2017-11-03 18:28:30 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2005-05-07 01:05:39 +08:00
|
|
|
/* Siemens ID Mouse driver v0.6
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
Copyright (C) 2004-5 by Florian 'Floe' Echtler <echtler@fs.tum.de>
|
|
|
|
and Andreas 'ad' Deresch <aderesch@fs.tum.de>
|
|
|
|
|
|
|
|
Derived from the USB Skeleton driver 1.1,
|
|
|
|
Copyright (C) 2003 Greg Kroah-Hartman (greg@kroah.com)
|
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
Additional information provided by Martin Reising
|
|
|
|
<Martin.Reising@natural-computing.de>
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
2017-02-03 02:15:33 +08:00
|
|
|
#include <linux/sched/signal.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/completion.h>
|
2006-01-11 22:55:29 +08:00
|
|
|
#include <linux/mutex.h>
|
2016-12-25 03:46:01 +08:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/usb.h>
|
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* image constants */
|
2005-04-17 06:20:36 +08:00
|
|
|
#define WIDTH 225
|
2005-05-07 01:05:39 +08:00
|
|
|
#define HEIGHT 289
|
|
|
|
#define HEADER "P5 225 289 255 "
|
2005-04-17 06:20:36 +08:00
|
|
|
#define IMGSIZE ((WIDTH * HEIGHT) + sizeof(HEADER)-1)
|
|
|
|
|
|
|
|
#define DRIVER_SHORT "idmouse"
|
|
|
|
#define DRIVER_AUTHOR "Florian 'Floe' Echtler <echtler@fs.tum.de>"
|
|
|
|
#define DRIVER_DESC "Siemens ID Mouse FingerTIP Sensor Driver"
|
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* minor number for misc USB devices */
|
2005-04-17 06:20:36 +08:00
|
|
|
#define USB_IDMOUSE_MINOR_BASE 132
|
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* vendor and device IDs */
|
|
|
|
#define ID_SIEMENS 0x0681
|
|
|
|
#define ID_IDMOUSE 0x0005
|
|
|
|
#define ID_CHERRY 0x0010
|
|
|
|
|
|
|
|
/* device ID table */
|
2010-01-10 22:34:45 +08:00
|
|
|
static const struct usb_device_id idmouse_table[] = {
|
2005-05-07 01:05:39 +08:00
|
|
|
{USB_DEVICE(ID_SIEMENS, ID_IDMOUSE)}, /* Siemens ID Mouse (Professional) */
|
|
|
|
{USB_DEVICE(ID_SIEMENS, ID_CHERRY )}, /* Cherry FingerTIP ID Board */
|
|
|
|
{} /* terminating null entry */
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* sensor commands */
|
|
|
|
#define FTIP_RESET 0x20
|
|
|
|
#define FTIP_ACQUIRE 0x21
|
|
|
|
#define FTIP_RELEASE 0x22
|
|
|
|
#define FTIP_BLINK 0x23 /* LSB of value = blink pulse width */
|
|
|
|
#define FTIP_SCROLL 0x24
|
|
|
|
|
|
|
|
#define ftip_command(dev, command, value, index) \
|
2019-11-05 18:36:38 +08:00
|
|
|
usb_control_msg(dev->udev, usb_sndctrlpipe(dev->udev, 0), command, \
|
2005-05-07 01:05:39 +08:00
|
|
|
USB_TYPE_VENDOR | USB_RECIP_ENDPOINT | USB_DIR_OUT, value, index, NULL, 0, 1000)
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
MODULE_DEVICE_TABLE(usb, idmouse_table);
|
|
|
|
|
|
|
|
/* structure to hold all of our device specific stuff */
|
|
|
|
struct usb_idmouse {
|
|
|
|
|
|
|
|
struct usb_device *udev; /* save off the usb device pointer */
|
|
|
|
struct usb_interface *interface; /* the interface for this device */
|
|
|
|
|
|
|
|
unsigned char *bulk_in_buffer; /* the buffer to receive data */
|
2005-05-07 01:05:39 +08:00
|
|
|
size_t bulk_in_size; /* the maximum bulk packet size */
|
|
|
|
size_t orig_bi_size; /* same as above, but reported by the device */
|
2005-04-17 06:20:36 +08:00
|
|
|
__u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */
|
|
|
|
|
|
|
|
int open; /* if the port is open or not */
|
|
|
|
int present; /* if the device is not disconnected */
|
2007-10-23 20:23:13 +08:00
|
|
|
struct mutex lock; /* locks this structure */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
};
|
|
|
|
|
|
|
|
/* local function prototypes */
|
|
|
|
static ssize_t idmouse_read(struct file *file, char __user *buffer,
|
|
|
|
size_t count, loff_t * ppos);
|
|
|
|
|
|
|
|
static int idmouse_open(struct inode *inode, struct file *file);
|
|
|
|
static int idmouse_release(struct inode *inode, struct file *file);
|
|
|
|
|
|
|
|
static int idmouse_probe(struct usb_interface *interface,
|
|
|
|
const struct usb_device_id *id);
|
|
|
|
|
|
|
|
static void idmouse_disconnect(struct usb_interface *interface);
|
2009-07-13 05:58:23 +08:00
|
|
|
static int idmouse_suspend(struct usb_interface *intf, pm_message_t message);
|
|
|
|
static int idmouse_resume(struct usb_interface *intf);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* file operation pointers */
|
2006-08-06 07:37:11 +08:00
|
|
|
static const struct file_operations idmouse_fops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.read = idmouse_read,
|
|
|
|
.open = idmouse_open,
|
|
|
|
.release = idmouse_release,
|
llseek: automatically add .llseek fop
All file_operations should get a .llseek operation so we can make
nonseekable_open the default for future file operations without a
.llseek pointer.
The three cases that we can automatically detect are no_llseek, seq_lseek
and default_llseek. For cases where we can we can automatically prove that
the file offset is always ignored, we use noop_llseek, which maintains
the current behavior of not returning an error from a seek.
New drivers should normally not use noop_llseek but instead use no_llseek
and call nonseekable_open at open time. Existing drivers can be converted
to do the same when the maintainer knows for certain that no user code
relies on calling seek on the device file.
The generated code is often incorrectly indented and right now contains
comments that clarify for each added line why a specific variant was
chosen. In the version that gets submitted upstream, the comments will
be gone and I will manually fix the indentation, because there does not
seem to be a way to do that using coccinelle.
Some amount of new code is currently sitting in linux-next that should get
the same modifications, which I will do at the end of the merge window.
Many thanks to Julia Lawall for helping me learn to write a semantic
patch that does all this.
===== begin semantic patch =====
// This adds an llseek= method to all file operations,
// as a preparation for making no_llseek the default.
//
// The rules are
// - use no_llseek explicitly if we do nonseekable_open
// - use seq_lseek for sequential files
// - use default_llseek if we know we access f_pos
// - use noop_llseek if we know we don't access f_pos,
// but we still want to allow users to call lseek
//
@ open1 exists @
identifier nested_open;
@@
nested_open(...)
{
<+...
nonseekable_open(...)
...+>
}
@ open exists@
identifier open_f;
identifier i, f;
identifier open1.nested_open;
@@
int open_f(struct inode *i, struct file *f)
{
<+...
(
nonseekable_open(...)
|
nested_open(...)
)
...+>
}
@ read disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ read_no_fpos disable optional_qualifier exists @
identifier read_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t read_f(struct file *f, char *p, size_t s, loff_t *off)
{
... when != off
}
@ write @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
expression E;
identifier func;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
<+...
(
*off = E
|
*off += E
|
func(..., off, ...)
|
E = *off
)
...+>
}
@ write_no_fpos @
identifier write_f;
identifier f, p, s, off;
type ssize_t, size_t, loff_t;
@@
ssize_t write_f(struct file *f, const char *p, size_t s, loff_t *off)
{
... when != off
}
@ fops0 @
identifier fops;
@@
struct file_operations fops = {
...
};
@ has_llseek depends on fops0 @
identifier fops0.fops;
identifier llseek_f;
@@
struct file_operations fops = {
...
.llseek = llseek_f,
...
};
@ has_read depends on fops0 @
identifier fops0.fops;
identifier read_f;
@@
struct file_operations fops = {
...
.read = read_f,
...
};
@ has_write depends on fops0 @
identifier fops0.fops;
identifier write_f;
@@
struct file_operations fops = {
...
.write = write_f,
...
};
@ has_open depends on fops0 @
identifier fops0.fops;
identifier open_f;
@@
struct file_operations fops = {
...
.open = open_f,
...
};
// use no_llseek if we call nonseekable_open
////////////////////////////////////////////
@ nonseekable1 depends on !has_llseek && has_open @
identifier fops0.fops;
identifier nso ~= "nonseekable_open";
@@
struct file_operations fops = {
... .open = nso, ...
+.llseek = no_llseek, /* nonseekable */
};
@ nonseekable2 depends on !has_llseek @
identifier fops0.fops;
identifier open.open_f;
@@
struct file_operations fops = {
... .open = open_f, ...
+.llseek = no_llseek, /* open uses nonseekable */
};
// use seq_lseek for sequential files
/////////////////////////////////////
@ seq depends on !has_llseek @
identifier fops0.fops;
identifier sr ~= "seq_read";
@@
struct file_operations fops = {
... .read = sr, ...
+.llseek = seq_lseek, /* we have seq_read */
};
// use default_llseek if there is a readdir
///////////////////////////////////////////
@ fops1 depends on !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier readdir_e;
@@
// any other fop is used that changes pos
struct file_operations fops = {
... .readdir = readdir_e, ...
+.llseek = default_llseek, /* readdir is present */
};
// use default_llseek if at least one of read/write touches f_pos
/////////////////////////////////////////////////////////////////
@ fops2 depends on !fops1 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read.read_f;
@@
// read fops use offset
struct file_operations fops = {
... .read = read_f, ...
+.llseek = default_llseek, /* read accesses f_pos */
};
@ fops3 depends on !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write.write_f;
@@
// write fops use offset
struct file_operations fops = {
... .write = write_f, ...
+ .llseek = default_llseek, /* write accesses f_pos */
};
// Use noop_llseek if neither read nor write accesses f_pos
///////////////////////////////////////////////////////////
@ fops4 depends on !fops1 && !fops2 && !fops3 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
identifier write_no_fpos.write_f;
@@
// write fops use offset
struct file_operations fops = {
...
.write = write_f,
.read = read_f,
...
+.llseek = noop_llseek, /* read and write both use no f_pos */
};
@ depends on has_write && !has_read && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier write_no_fpos.write_f;
@@
struct file_operations fops = {
... .write = write_f, ...
+.llseek = noop_llseek, /* write uses no f_pos */
};
@ depends on has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
identifier read_no_fpos.read_f;
@@
struct file_operations fops = {
... .read = read_f, ...
+.llseek = noop_llseek, /* read uses no f_pos */
};
@ depends on !has_read && !has_write && !fops1 && !fops2 && !has_llseek && !nonseekable1 && !nonseekable2 && !seq @
identifier fops0.fops;
@@
struct file_operations fops = {
...
+.llseek = noop_llseek, /* no read or write fn */
};
===== End semantic patch =====
Signed-off-by: Arnd Bergmann <arnd@arndb.de>
Cc: Julia Lawall <julia@diku.dk>
Cc: Christoph Hellwig <hch@infradead.org>
2010-08-16 00:52:59 +08:00
|
|
|
.llseek = default_llseek,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2005-06-21 12:15:16 +08:00
|
|
|
/* class driver information */
|
2005-04-17 06:20:36 +08:00
|
|
|
static struct usb_class_driver idmouse_class = {
|
2005-06-21 12:15:16 +08:00
|
|
|
.name = "idmouse%d",
|
2005-04-17 06:20:36 +08:00
|
|
|
.fops = &idmouse_fops,
|
|
|
|
.minor_base = USB_IDMOUSE_MINOR_BASE,
|
|
|
|
};
|
|
|
|
|
|
|
|
/* usb specific object needed to register this driver with the usb subsystem */
|
|
|
|
static struct usb_driver idmouse_driver = {
|
|
|
|
.name = DRIVER_SHORT,
|
|
|
|
.probe = idmouse_probe,
|
|
|
|
.disconnect = idmouse_disconnect,
|
2009-07-13 05:58:23 +08:00
|
|
|
.suspend = idmouse_suspend,
|
|
|
|
.resume = idmouse_resume,
|
|
|
|
.reset_resume = idmouse_resume,
|
2005-04-17 06:20:36 +08:00
|
|
|
.id_table = idmouse_table,
|
2009-07-13 05:58:23 +08:00
|
|
|
.supports_autosuspend = 1,
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static int idmouse_create_image(struct usb_idmouse *dev)
|
|
|
|
{
|
2006-11-07 00:37:20 +08:00
|
|
|
int bytes_read;
|
|
|
|
int bulk_read;
|
|
|
|
int result;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
memcpy(dev->bulk_in_buffer, HEADER, sizeof(HEADER)-1);
|
2006-11-07 00:37:20 +08:00
|
|
|
bytes_read = sizeof(HEADER)-1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* reset the device and set a fast blink rate */
|
|
|
|
result = ftip_command(dev, FTIP_RELEASE, 0, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result < 0)
|
2005-05-07 01:05:39 +08:00
|
|
|
goto reset;
|
|
|
|
result = ftip_command(dev, FTIP_BLINK, 1, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result < 0)
|
2005-05-07 01:05:39 +08:00
|
|
|
goto reset;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* initialize the sensor - sending this command twice */
|
|
|
|
/* significantly reduces the rate of failed reads */
|
|
|
|
result = ftip_command(dev, FTIP_ACQUIRE, 0, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result < 0)
|
2005-05-07 01:05:39 +08:00
|
|
|
goto reset;
|
|
|
|
result = ftip_command(dev, FTIP_ACQUIRE, 0, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result < 0)
|
2005-05-07 01:05:39 +08:00
|
|
|
goto reset;
|
|
|
|
|
|
|
|
/* start the readout - sending this command twice */
|
|
|
|
/* presumably enables the high dynamic range mode */
|
|
|
|
result = ftip_command(dev, FTIP_RESET, 0, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result < 0)
|
2005-05-07 01:05:39 +08:00
|
|
|
goto reset;
|
|
|
|
result = ftip_command(dev, FTIP_RESET, 0, 0);
|
|
|
|
if (result < 0)
|
|
|
|
goto reset;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* loop over a blocking bulk read to get data from the device */
|
|
|
|
while (bytes_read < IMGSIZE) {
|
2019-11-05 18:36:38 +08:00
|
|
|
result = usb_bulk_msg(dev->udev,
|
|
|
|
usb_rcvbulkpipe(dev->udev, dev->bulk_in_endpointAddr),
|
2005-04-17 06:20:36 +08:00
|
|
|
dev->bulk_in_buffer + bytes_read,
|
|
|
|
dev->bulk_in_size, &bulk_read, 5000);
|
2005-05-07 01:05:39 +08:00
|
|
|
if (result < 0) {
|
|
|
|
/* Maybe this error was caused by the increased packet size? */
|
|
|
|
/* Reset to the original value and tell userspace to retry. */
|
|
|
|
if (dev->bulk_in_size != dev->orig_bi_size) {
|
|
|
|
dev->bulk_in_size = dev->orig_bi_size;
|
|
|
|
result = -EAGAIN;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
result = -EINTR;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
bytes_read += bulk_read;
|
|
|
|
}
|
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* check for valid image */
|
|
|
|
/* right border should be black (0x00) */
|
|
|
|
for (bytes_read = sizeof(HEADER)-1 + WIDTH-1; bytes_read < IMGSIZE; bytes_read += WIDTH)
|
|
|
|
if (dev->bulk_in_buffer[bytes_read] != 0x00)
|
|
|
|
return -EAGAIN;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* lower border should be white (0xFF) */
|
|
|
|
for (bytes_read = IMGSIZE-WIDTH; bytes_read < IMGSIZE-1; bytes_read++)
|
|
|
|
if (dev->bulk_in_buffer[bytes_read] != 0xFF)
|
|
|
|
return -EAGAIN;
|
|
|
|
|
2022-09-22 21:48:44 +08:00
|
|
|
/* reset the device */
|
|
|
|
reset:
|
|
|
|
ftip_command(dev, FTIP_RELEASE, 0, 0);
|
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* should be IMGSIZE == 65040 */
|
2012-05-02 12:33:58 +08:00
|
|
|
dev_dbg(&dev->interface->dev, "read %d bytes fingerprint data\n",
|
|
|
|
bytes_read);
|
2005-05-07 01:05:39 +08:00
|
|
|
return result;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-07-13 05:58:23 +08:00
|
|
|
/* PM operations are nops as this driver does IO only during open() */
|
|
|
|
static int idmouse_suspend(struct usb_interface *intf, pm_message_t message)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int idmouse_resume(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static inline void idmouse_delete(struct usb_idmouse *dev)
|
|
|
|
{
|
|
|
|
kfree(dev->bulk_in_buffer);
|
|
|
|
kfree(dev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int idmouse_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2006-11-07 00:37:20 +08:00
|
|
|
struct usb_idmouse *dev;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct usb_interface *interface;
|
2006-11-07 00:37:20 +08:00
|
|
|
int result;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* get the interface from minor number and driver information */
|
2019-11-05 18:36:38 +08:00
|
|
|
interface = usb_find_interface(&idmouse_driver, iminor(inode));
|
2010-01-14 23:11:03 +08:00
|
|
|
if (!interface)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* get the device information block from the interface */
|
|
|
|
dev = usb_get_intfdata(interface);
|
2019-11-05 18:36:36 +08:00
|
|
|
if (!dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* lock this device */
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_lock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* check if already open */
|
|
|
|
if (dev->open) {
|
|
|
|
|
|
|
|
/* already open, so fail */
|
|
|
|
result = -EBUSY;
|
|
|
|
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* create a new image and check for success */
|
2009-07-13 05:58:23 +08:00
|
|
|
result = usb_autopm_get_interface(interface);
|
|
|
|
if (result)
|
|
|
|
goto error;
|
2019-11-05 18:36:38 +08:00
|
|
|
result = idmouse_create_image(dev);
|
2016-02-22 10:48:45 +08:00
|
|
|
usb_autopm_put_interface(interface);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (result)
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
/* increment our usage count for the driver */
|
|
|
|
++dev->open;
|
|
|
|
|
|
|
|
/* save our object in the file's private structure */
|
|
|
|
file->private_data = dev;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
|
|
|
/* unlock this device */
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_unlock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int idmouse_release(struct inode *inode, struct file *file)
|
|
|
|
{
|
|
|
|
struct usb_idmouse *dev;
|
|
|
|
|
2006-12-20 18:42:12 +08:00
|
|
|
dev = file->private_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
if (dev == NULL)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* lock our device */
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_lock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
--dev->open;
|
|
|
|
|
|
|
|
if (!dev->present) {
|
|
|
|
/* the device was unplugged before the file was released */
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_unlock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
idmouse_delete(dev);
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
} else {
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_unlock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t idmouse_read(struct file *file, char __user *buffer, size_t count,
|
|
|
|
loff_t * ppos)
|
|
|
|
{
|
2006-12-20 18:42:12 +08:00
|
|
|
struct usb_idmouse *dev = file->private_data;
|
2006-11-07 00:37:20 +08:00
|
|
|
int result;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* lock this object */
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_lock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-05-07 01:05:39 +08:00
|
|
|
/* verify that the device wasn't unplugged */
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!dev->present) {
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_unlock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2005-10-29 18:56:13 +08:00
|
|
|
result = simple_read_from_buffer(buffer, count, ppos,
|
|
|
|
dev->bulk_in_buffer, IMGSIZE);
|
2005-05-07 01:05:39 +08:00
|
|
|
/* unlock the device */
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_unlock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int idmouse_probe(struct usb_interface *interface,
|
|
|
|
const struct usb_device_id *id)
|
|
|
|
{
|
|
|
|
struct usb_device *udev = interface_to_usbdev(interface);
|
2006-11-07 00:37:20 +08:00
|
|
|
struct usb_idmouse *dev;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct usb_host_interface *iface_desc;
|
|
|
|
struct usb_endpoint_descriptor *endpoint;
|
|
|
|
int result;
|
|
|
|
|
|
|
|
/* check if we have gotten the data or the hid interface */
|
2019-12-10 19:26:00 +08:00
|
|
|
iface_desc = interface->cur_altsetting;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (iface_desc->desc.bInterfaceClass != 0x0A)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2017-03-13 20:47:48 +08:00
|
|
|
if (iface_desc->desc.bNumEndpoints < 1)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* allocate memory for our device state and initialize it */
|
2006-01-07 05:36:27 +08:00
|
|
|
dev = kzalloc(sizeof(*dev), GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (dev == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_init(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
dev->udev = udev;
|
|
|
|
dev->interface = interface;
|
|
|
|
|
|
|
|
/* set up the endpoint information - use only the first bulk-in endpoint */
|
2017-03-17 18:35:38 +08:00
|
|
|
result = usb_find_bulk_in_endpoint(iface_desc, &endpoint);
|
|
|
|
if (result) {
|
|
|
|
dev_err(&interface->dev, "Unable to find bulk-in endpoint.\n");
|
|
|
|
idmouse_delete(dev);
|
|
|
|
return result;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2017-03-17 18:35:38 +08:00
|
|
|
dev->orig_bi_size = usb_endpoint_maxp(endpoint);
|
|
|
|
dev->bulk_in_size = 0x200; /* works _much_ faster */
|
|
|
|
dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
|
|
|
|
dev->bulk_in_buffer = kmalloc(IMGSIZE + dev->bulk_in_size, GFP_KERNEL);
|
|
|
|
if (!dev->bulk_in_buffer) {
|
2005-04-17 06:20:36 +08:00
|
|
|
idmouse_delete(dev);
|
2017-03-17 18:35:38 +08:00
|
|
|
return -ENOMEM;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2017-03-17 18:35:38 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* allow device read, write and ioctl */
|
|
|
|
dev->present = 1;
|
|
|
|
|
|
|
|
/* we can register the device now, as it is ready */
|
|
|
|
usb_set_intfdata(interface, dev);
|
|
|
|
result = usb_register_dev(interface, &idmouse_class);
|
|
|
|
if (result) {
|
|
|
|
/* something prevented us from registering this device */
|
2014-01-02 21:55:50 +08:00
|
|
|
dev_err(&interface->dev, "Unable to allocate minor number.\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
idmouse_delete(dev);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* be noisy */
|
|
|
|
dev_info(&interface->dev,"%s now attached\n",DRIVER_DESC);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void idmouse_disconnect(struct usb_interface *interface)
|
|
|
|
{
|
2019-11-05 18:36:36 +08:00
|
|
|
struct usb_idmouse *dev = usb_get_intfdata(interface);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* give back our minor */
|
|
|
|
usb_deregister_dev(interface, &idmouse_class);
|
|
|
|
|
2007-10-23 20:23:13 +08:00
|
|
|
/* lock the device */
|
|
|
|
mutex_lock(&dev->lock);
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* prevent device read, write and ioctl */
|
|
|
|
dev->present = 0;
|
|
|
|
|
|
|
|
/* if the device is opened, idmouse_release will clean this up */
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
if (!dev->open) {
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_unlock(&dev->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
idmouse_delete(dev);
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
} else {
|
|
|
|
/* unlock */
|
2007-10-23 20:23:13 +08:00
|
|
|
mutex_unlock(&dev->lock);
|
USB: prevent char device open/deregister race
This patch (as908) adds central protection in usbcore for the
prototypical race between opening and unregistering a char device.
The spinlock used to protect the minor-numbers array is replaced with
an rwsem, which can remain locked across a call to a driver's open()
method. This guarantees that open() and deregister() will be mutually
exclusive.
The private locks currently used in several individual drivers for
this purpose are no longer necessary, and the patch removes them. The
following USB drivers are affected: usblcd, idmouse, auerswald,
legousbtower, sisusbvga/sisusb, ldusb, adutux, iowarrior, and
usb-skeleton.
As a side effect of this change, usb_deregister_dev() must not be
called while holding a lock that is acquired by open(). Unfortunately
a number of drivers do this, but luckily the solution is simple: call
usb_deregister_dev() before acquiring the lock.
In addition to these changes (and their consequent code
simplifications), the patch fixes a use-after-free bug in adutux and a
race between open() and release() in iowarrior.
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2007-05-22 23:46:41 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-08-19 04:21:04 +08:00
|
|
|
dev_info(&interface->dev, "disconnected\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2011-11-19 01:34:02 +08:00
|
|
|
module_usb_driver(idmouse_driver);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|