cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

legousbtower.c (24782B)


      1// SPDX-License-Identifier: GPL-2.0+
      2/*
      3 * LEGO USB Tower driver
      4 *
      5 * Copyright (C) 2003 David Glance <davidgsf@sourceforge.net>
      6 *               2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
      7 *
      8 * derived from USB Skeleton driver - 0.5
      9 * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
     10 *
     11 * History:
     12 *
     13 * 2001-10-13 - 0.1 js
     14 *   - first version
     15 * 2001-11-03 - 0.2 js
     16 *   - simplified buffering, one-shot URBs for writing
     17 * 2001-11-10 - 0.3 js
     18 *   - removed IOCTL (setting power/mode is more complicated, postponed)
     19 * 2001-11-28 - 0.4 js
     20 *   - added vendor commands for mode of operation and power level in open
     21 * 2001-12-04 - 0.5 js
     22 *   - set IR mode by default (by oversight 0.4 set VLL mode)
     23 * 2002-01-11 - 0.5? pcchan
     24 *   - make read buffer reusable and work around bytes_to_write issue between
     25 *     uhci and legusbtower
     26 * 2002-09-23 - 0.52 david (david@csse.uwa.edu.au)
     27 *   - imported into lejos project
     28 *   - changed wake_up to wake_up_interruptible
     29 *   - changed to use lego0 rather than tower0
     30 *   - changed dbg() to use __func__ rather than deprecated __func__
     31 * 2003-01-12 - 0.53 david (david@csse.uwa.edu.au)
     32 *   - changed read and write to write everything or
     33 *     timeout (from a patch by Chris Riesen and Brett Thaeler driver)
     34 *   - added ioctl functionality to set timeouts
     35 * 2003-07-18 - 0.54 davidgsf (david@csse.uwa.edu.au)
     36 *   - initial import into LegoUSB project
     37 *   - merge of existing LegoUSB.c driver
     38 * 2003-07-18 - 0.56 davidgsf (david@csse.uwa.edu.au)
     39 *   - port to 2.6 style driver
     40 * 2004-02-29 - 0.6 Juergen Stuber <starblue@users.sourceforge.net>
     41 *   - fix locking
     42 *   - unlink read URBs which are no longer needed
     43 *   - allow increased buffer size, eliminates need for timeout on write
     44 *   - have read URB running continuously
     45 *   - added poll
     46 *   - forbid seeking
     47 *   - added nonblocking I/O
     48 *   - changed back __func__ to __func__
     49 *   - read and log tower firmware version
     50 *   - reset tower on probe, avoids failure of first write
     51 * 2004-03-09 - 0.7 Juergen Stuber <starblue@users.sourceforge.net>
     52 *   - timeout read now only after inactivity, shorten default accordingly
     53 * 2004-03-11 - 0.8 Juergen Stuber <starblue@users.sourceforge.net>
     54 *   - log major, minor instead of possibly confusing device filename
     55 *   - whitespace cleanup
     56 * 2004-03-12 - 0.9 Juergen Stuber <starblue@users.sourceforge.net>
     57 *   - normalize whitespace in debug messages
     58 *   - take care about endianness in control message responses
     59 * 2004-03-13 - 0.91 Juergen Stuber <starblue@users.sourceforge.net>
     60 *   - make default intervals longer to accommodate current EHCI driver
     61 * 2004-03-19 - 0.92 Juergen Stuber <starblue@users.sourceforge.net>
     62 *   - replaced atomic_t by memory barriers
     63 * 2004-04-21 - 0.93 Juergen Stuber <starblue@users.sourceforge.net>
     64 *   - wait for completion of write urb in release (needed for remotecontrol)
     65 *   - corrected poll for write direction (missing negation)
     66 * 2004-04-22 - 0.94 Juergen Stuber <starblue@users.sourceforge.net>
     67 *   - make device locking interruptible
     68 * 2004-04-30 - 0.95 Juergen Stuber <starblue@users.sourceforge.net>
     69 *   - check for valid udev on resubmitting and unlinking urbs
     70 * 2004-08-03 - 0.96 Juergen Stuber <starblue@users.sourceforge.net>
     71 *   - move reset into open to clean out spurious data
     72 */
     73
     74#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
     75
     76#include <linux/kernel.h>
     77#include <linux/errno.h>
     78#include <linux/slab.h>
     79#include <linux/module.h>
     80#include <linux/completion.h>
     81#include <linux/mutex.h>
     82#include <linux/uaccess.h>
     83#include <linux/usb.h>
     84#include <linux/poll.h>
     85
     86
     87#define DRIVER_AUTHOR "Juergen Stuber <starblue@sourceforge.net>"
     88#define DRIVER_DESC "LEGO USB Tower Driver"
     89
     90
     91/* The defaults are chosen to work with the latest versions of leJOS and NQC.
     92 */
     93
     94/* Some legacy software likes to receive packets in one piece.
     95 * In this case read_buffer_size should exceed the maximal packet length
     96 * (417 for datalog uploads), and packet_timeout should be set.
     97 */
     98static int read_buffer_size = 480;
     99module_param(read_buffer_size, int, 0);
    100MODULE_PARM_DESC(read_buffer_size, "Read buffer size");
    101
    102/* Some legacy software likes to send packets in one piece.
    103 * In this case write_buffer_size should exceed the maximal packet length
    104 * (417 for firmware and program downloads).
    105 * A problem with long writes is that the following read may time out
    106 * if the software is not prepared to wait long enough.
    107 */
    108static int write_buffer_size = 480;
    109module_param(write_buffer_size, int, 0);
    110MODULE_PARM_DESC(write_buffer_size, "Write buffer size");
    111
    112/* Some legacy software expects reads to contain whole LASM packets.
    113 * To achieve this, characters which arrive before a packet timeout
    114 * occurs will be returned in a single read operation.
    115 * A problem with long reads is that the software may time out
    116 * if it is not prepared to wait long enough.
    117 * The packet timeout should be greater than the time between the
    118 * reception of subsequent characters, which should arrive about
    119 * every 5ms for the standard 2400 baud.
    120 * Set it to 0 to disable.
    121 */
    122static int packet_timeout = 50;
    123module_param(packet_timeout, int, 0);
    124MODULE_PARM_DESC(packet_timeout, "Packet timeout in ms");
    125
    126/* Some legacy software expects blocking reads to time out.
    127 * Timeout occurs after the specified time of read and write inactivity.
    128 * Set it to 0 to disable.
    129 */
    130static int read_timeout = 200;
    131module_param(read_timeout, int, 0);
    132MODULE_PARM_DESC(read_timeout, "Read timeout in ms");
    133
    134/* As of kernel version 2.6.4 ehci-hcd uses an
    135 * "only one interrupt transfer per frame" shortcut
    136 * to simplify the scheduling of periodic transfers.
    137 * This conflicts with our standard 1ms intervals for in and out URBs.
    138 * We use default intervals of 2ms for in and 8ms for out transfers,
    139 * which is fast enough for 2400 baud and allows a small additional load.
    140 * Increase the interval to allow more devices that do interrupt transfers,
    141 * or set to 0 to use the standard interval from the endpoint descriptors.
    142 */
    143static int interrupt_in_interval = 2;
    144module_param(interrupt_in_interval, int, 0);
    145MODULE_PARM_DESC(interrupt_in_interval, "Interrupt in interval in ms");
    146
    147static int interrupt_out_interval = 8;
    148module_param(interrupt_out_interval, int, 0);
    149MODULE_PARM_DESC(interrupt_out_interval, "Interrupt out interval in ms");
    150
    151/* Define these values to match your device */
    152#define LEGO_USB_TOWER_VENDOR_ID	0x0694
    153#define LEGO_USB_TOWER_PRODUCT_ID	0x0001
    154
    155/* Vendor requests */
    156#define LEGO_USB_TOWER_REQUEST_RESET		0x04
    157#define LEGO_USB_TOWER_REQUEST_GET_VERSION	0xFD
    158
    159struct tower_reset_reply {
    160	__le16 size;
    161	__u8 err_code;
    162	__u8 spare;
    163};
    164
    165struct tower_get_version_reply {
    166	__le16 size;
    167	__u8 err_code;
    168	__u8 spare;
    169	__u8 major;
    170	__u8 minor;
    171	__le16 build_no;
    172};
    173
    174
    175/* table of devices that work with this driver */
    176static const struct usb_device_id tower_table[] = {
    177	{ USB_DEVICE(LEGO_USB_TOWER_VENDOR_ID, LEGO_USB_TOWER_PRODUCT_ID) },
    178	{ }					/* Terminating entry */
    179};
    180
    181MODULE_DEVICE_TABLE(usb, tower_table);
    182
    183#define LEGO_USB_TOWER_MINOR_BASE	160
    184
    185
    186/* Structure to hold all of our device specific stuff */
    187struct lego_usb_tower {
    188	struct mutex		lock;		/* locks this structure */
    189	struct usb_device	*udev;		/* save off the usb device pointer */
    190	unsigned char		minor;		/* the starting minor number for this device */
    191
    192	int			open_count;	/* number of times this port has been opened */
    193	unsigned long		disconnected:1;
    194
    195	char			*read_buffer;
    196	size_t			read_buffer_length; /* this much came in */
    197	size_t			read_packet_length; /* this much will be returned on read */
    198	spinlock_t		read_buffer_lock;
    199	int			packet_timeout_jiffies;
    200	unsigned long		read_last_arrival;
    201
    202	wait_queue_head_t	read_wait;
    203	wait_queue_head_t	write_wait;
    204
    205	char			*interrupt_in_buffer;
    206	struct usb_endpoint_descriptor *interrupt_in_endpoint;
    207	struct urb		*interrupt_in_urb;
    208	int			interrupt_in_interval;
    209	int			interrupt_in_done;
    210
    211	char			*interrupt_out_buffer;
    212	struct usb_endpoint_descriptor *interrupt_out_endpoint;
    213	struct urb		*interrupt_out_urb;
    214	int			interrupt_out_interval;
    215	int			interrupt_out_busy;
    216
    217};
    218
    219
    220/* local function prototypes */
    221static ssize_t tower_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos);
    222static ssize_t tower_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
    223static inline void tower_delete(struct lego_usb_tower *dev);
    224static int tower_open(struct inode *inode, struct file *file);
    225static int tower_release(struct inode *inode, struct file *file);
    226static __poll_t tower_poll(struct file *file, poll_table *wait);
    227static loff_t tower_llseek(struct file *file, loff_t off, int whence);
    228
    229static void tower_check_for_read_packet(struct lego_usb_tower *dev);
    230static void tower_interrupt_in_callback(struct urb *urb);
    231static void tower_interrupt_out_callback(struct urb *urb);
    232
    233static int  tower_probe(struct usb_interface *interface, const struct usb_device_id *id);
    234static void tower_disconnect(struct usb_interface *interface);
    235
    236
    237/* file operations needed when we register this driver */
    238static const struct file_operations tower_fops = {
    239	.owner =	THIS_MODULE,
    240	.read  =	tower_read,
    241	.write =	tower_write,
    242	.open =		tower_open,
    243	.release =	tower_release,
    244	.poll =		tower_poll,
    245	.llseek =	tower_llseek,
    246};
    247
    248static char *legousbtower_devnode(struct device *dev, umode_t *mode)
    249{
    250	return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
    251}
    252
    253/*
    254 * usb class driver info in order to get a minor number from the usb core,
    255 * and to have the device registered with the driver core
    256 */
    257static struct usb_class_driver tower_class = {
    258	.name =		"legousbtower%d",
    259	.devnode = 	legousbtower_devnode,
    260	.fops =		&tower_fops,
    261	.minor_base =	LEGO_USB_TOWER_MINOR_BASE,
    262};
    263
    264
    265/* usb specific object needed to register this driver with the usb subsystem */
    266static struct usb_driver tower_driver = {
    267	.name =		"legousbtower",
    268	.probe =	tower_probe,
    269	.disconnect =	tower_disconnect,
    270	.id_table =	tower_table,
    271};
    272
    273
    274/*
    275 *	lego_usb_tower_debug_data
    276 */
    277static inline void lego_usb_tower_debug_data(struct device *dev,
    278					     const char *function, int size,
    279					     const unsigned char *data)
    280{
    281	dev_dbg(dev, "%s - length = %d, data = %*ph\n",
    282		function, size, size, data);
    283}
    284
    285
    286/*
    287 *	tower_delete
    288 */
    289static inline void tower_delete(struct lego_usb_tower *dev)
    290{
    291	/* free data structures */
    292	usb_free_urb(dev->interrupt_in_urb);
    293	usb_free_urb(dev->interrupt_out_urb);
    294	kfree(dev->read_buffer);
    295	kfree(dev->interrupt_in_buffer);
    296	kfree(dev->interrupt_out_buffer);
    297	usb_put_dev(dev->udev);
    298	kfree(dev);
    299}
    300
    301
    302/*
    303 *	tower_open
    304 */
    305static int tower_open(struct inode *inode, struct file *file)
    306{
    307	struct lego_usb_tower *dev = NULL;
    308	int subminor;
    309	int retval = 0;
    310	struct usb_interface *interface;
    311	struct tower_reset_reply reset_reply;
    312	int result;
    313
    314	nonseekable_open(inode, file);
    315	subminor = iminor(inode);
    316
    317	interface = usb_find_interface(&tower_driver, subminor);
    318	if (!interface) {
    319		pr_err("error, can't find device for minor %d\n", subminor);
    320		retval = -ENODEV;
    321		goto exit;
    322	}
    323
    324	dev = usb_get_intfdata(interface);
    325	if (!dev) {
    326		retval = -ENODEV;
    327		goto exit;
    328	}
    329
    330	/* lock this device */
    331	if (mutex_lock_interruptible(&dev->lock)) {
    332	        retval = -ERESTARTSYS;
    333		goto exit;
    334	}
    335
    336
    337	/* allow opening only once */
    338	if (dev->open_count) {
    339		retval = -EBUSY;
    340		goto unlock_exit;
    341	}
    342
    343	/* reset the tower */
    344	result = usb_control_msg_recv(dev->udev, 0,
    345				      LEGO_USB_TOWER_REQUEST_RESET,
    346				      USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
    347				      0, 0,
    348				      &reset_reply, sizeof(reset_reply), 1000,
    349				      GFP_KERNEL);
    350	if (result < 0) {
    351		dev_err(&dev->udev->dev,
    352			"LEGO USB Tower reset control request failed\n");
    353		retval = result;
    354		goto unlock_exit;
    355	}
    356
    357	/* initialize in direction */
    358	dev->read_buffer_length = 0;
    359	dev->read_packet_length = 0;
    360	usb_fill_int_urb(dev->interrupt_in_urb,
    361			 dev->udev,
    362			 usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),
    363			 dev->interrupt_in_buffer,
    364			 usb_endpoint_maxp(dev->interrupt_in_endpoint),
    365			 tower_interrupt_in_callback,
    366			 dev,
    367			 dev->interrupt_in_interval);
    368
    369	dev->interrupt_in_done = 0;
    370	mb();
    371
    372	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
    373	if (retval) {
    374		dev_err(&dev->udev->dev,
    375			"Couldn't submit interrupt_in_urb %d\n", retval);
    376		goto unlock_exit;
    377	}
    378
    379	/* save device in the file's private structure */
    380	file->private_data = dev;
    381
    382	dev->open_count = 1;
    383
    384unlock_exit:
    385	mutex_unlock(&dev->lock);
    386
    387exit:
    388	return retval;
    389}
    390
    391/*
    392 *	tower_release
    393 */
    394static int tower_release(struct inode *inode, struct file *file)
    395{
    396	struct lego_usb_tower *dev;
    397	int retval = 0;
    398
    399	dev = file->private_data;
    400	if (dev == NULL) {
    401		retval = -ENODEV;
    402		goto exit;
    403	}
    404
    405	mutex_lock(&dev->lock);
    406
    407	if (dev->disconnected) {
    408		/* the device was unplugged before the file was released */
    409
    410		/* unlock here as tower_delete frees dev */
    411		mutex_unlock(&dev->lock);
    412		tower_delete(dev);
    413		goto exit;
    414	}
    415
    416	/* wait until write transfer is finished */
    417	if (dev->interrupt_out_busy) {
    418		wait_event_interruptible_timeout(dev->write_wait, !dev->interrupt_out_busy,
    419						 2 * HZ);
    420	}
    421
    422	/* shutdown transfers */
    423	usb_kill_urb(dev->interrupt_in_urb);
    424	usb_kill_urb(dev->interrupt_out_urb);
    425
    426	dev->open_count = 0;
    427
    428	mutex_unlock(&dev->lock);
    429exit:
    430	return retval;
    431}
    432
    433/*
    434 *	tower_check_for_read_packet
    435 *
    436 *      To get correct semantics for signals and non-blocking I/O
    437 *      with packetizing we pretend not to see any data in the read buffer
    438 *      until it has been there unchanged for at least
    439 *      dev->packet_timeout_jiffies, or until the buffer is full.
    440 */
    441static void tower_check_for_read_packet(struct lego_usb_tower *dev)
    442{
    443	spin_lock_irq(&dev->read_buffer_lock);
    444	if (!packet_timeout
    445	    || time_after(jiffies, dev->read_last_arrival + dev->packet_timeout_jiffies)
    446	    || dev->read_buffer_length == read_buffer_size) {
    447		dev->read_packet_length = dev->read_buffer_length;
    448	}
    449	dev->interrupt_in_done = 0;
    450	spin_unlock_irq(&dev->read_buffer_lock);
    451}
    452
    453
    454/*
    455 *	tower_poll
    456 */
    457static __poll_t tower_poll(struct file *file, poll_table *wait)
    458{
    459	struct lego_usb_tower *dev;
    460	__poll_t mask = 0;
    461
    462	dev = file->private_data;
    463
    464	if (dev->disconnected)
    465		return EPOLLERR | EPOLLHUP;
    466
    467	poll_wait(file, &dev->read_wait, wait);
    468	poll_wait(file, &dev->write_wait, wait);
    469
    470	tower_check_for_read_packet(dev);
    471	if (dev->read_packet_length > 0)
    472		mask |= EPOLLIN | EPOLLRDNORM;
    473	if (!dev->interrupt_out_busy)
    474		mask |= EPOLLOUT | EPOLLWRNORM;
    475
    476	return mask;
    477}
    478
    479
    480/*
    481 *	tower_llseek
    482 */
    483static loff_t tower_llseek(struct file *file, loff_t off, int whence)
    484{
    485	return -ESPIPE;		/* unseekable */
    486}
    487
    488
    489/*
    490 *	tower_read
    491 */
    492static ssize_t tower_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
    493{
    494	struct lego_usb_tower *dev;
    495	size_t bytes_to_read;
    496	int i;
    497	int retval = 0;
    498	unsigned long timeout = 0;
    499
    500	dev = file->private_data;
    501
    502	/* lock this object */
    503	if (mutex_lock_interruptible(&dev->lock)) {
    504		retval = -ERESTARTSYS;
    505		goto exit;
    506	}
    507
    508	/* verify that the device wasn't unplugged */
    509	if (dev->disconnected) {
    510		retval = -ENODEV;
    511		goto unlock_exit;
    512	}
    513
    514	/* verify that we actually have some data to read */
    515	if (count == 0) {
    516		dev_dbg(&dev->udev->dev, "read request of 0 bytes\n");
    517		goto unlock_exit;
    518	}
    519
    520	if (read_timeout)
    521		timeout = jiffies + msecs_to_jiffies(read_timeout);
    522
    523	/* wait for data */
    524	tower_check_for_read_packet(dev);
    525	while (dev->read_packet_length == 0) {
    526		if (file->f_flags & O_NONBLOCK) {
    527			retval = -EAGAIN;
    528			goto unlock_exit;
    529		}
    530		retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_timeout_jiffies);
    531		if (retval < 0)
    532			goto unlock_exit;
    533
    534		/* reset read timeout during read or write activity */
    535		if (read_timeout
    536		    && (dev->read_buffer_length || dev->interrupt_out_busy)) {
    537			timeout = jiffies + msecs_to_jiffies(read_timeout);
    538		}
    539		/* check for read timeout */
    540		if (read_timeout && time_after(jiffies, timeout)) {
    541			retval = -ETIMEDOUT;
    542			goto unlock_exit;
    543		}
    544		tower_check_for_read_packet(dev);
    545	}
    546
    547	/* copy the data from read_buffer into userspace */
    548	bytes_to_read = min(count, dev->read_packet_length);
    549
    550	if (copy_to_user(buffer, dev->read_buffer, bytes_to_read)) {
    551		retval = -EFAULT;
    552		goto unlock_exit;
    553	}
    554
    555	spin_lock_irq(&dev->read_buffer_lock);
    556	dev->read_buffer_length -= bytes_to_read;
    557	dev->read_packet_length -= bytes_to_read;
    558	for (i = 0; i < dev->read_buffer_length; i++)
    559		dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];
    560	spin_unlock_irq(&dev->read_buffer_lock);
    561
    562	retval = bytes_to_read;
    563
    564unlock_exit:
    565	/* unlock the device */
    566	mutex_unlock(&dev->lock);
    567
    568exit:
    569	return retval;
    570}
    571
    572
    573/*
    574 *	tower_write
    575 */
    576static ssize_t tower_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
    577{
    578	struct lego_usb_tower *dev;
    579	size_t bytes_to_write;
    580	int retval = 0;
    581
    582	dev = file->private_data;
    583
    584	/* lock this object */
    585	if (mutex_lock_interruptible(&dev->lock)) {
    586		retval = -ERESTARTSYS;
    587		goto exit;
    588	}
    589
    590	/* verify that the device wasn't unplugged */
    591	if (dev->disconnected) {
    592		retval = -ENODEV;
    593		goto unlock_exit;
    594	}
    595
    596	/* verify that we actually have some data to write */
    597	if (count == 0) {
    598		dev_dbg(&dev->udev->dev, "write request of 0 bytes\n");
    599		goto unlock_exit;
    600	}
    601
    602	/* wait until previous transfer is finished */
    603	while (dev->interrupt_out_busy) {
    604		if (file->f_flags & O_NONBLOCK) {
    605			retval = -EAGAIN;
    606			goto unlock_exit;
    607		}
    608		retval = wait_event_interruptible(dev->write_wait,
    609						  !dev->interrupt_out_busy);
    610		if (retval)
    611			goto unlock_exit;
    612	}
    613
    614	/* write the data into interrupt_out_buffer from userspace */
    615	bytes_to_write = min_t(int, count, write_buffer_size);
    616	dev_dbg(&dev->udev->dev, "%s: count = %zd, bytes_to_write = %zd\n",
    617		__func__, count, bytes_to_write);
    618
    619	if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
    620		retval = -EFAULT;
    621		goto unlock_exit;
    622	}
    623
    624	/* send off the urb */
    625	usb_fill_int_urb(dev->interrupt_out_urb,
    626			 dev->udev,
    627			 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
    628			 dev->interrupt_out_buffer,
    629			 bytes_to_write,
    630			 tower_interrupt_out_callback,
    631			 dev,
    632			 dev->interrupt_out_interval);
    633
    634	dev->interrupt_out_busy = 1;
    635	wmb();
    636
    637	retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
    638	if (retval) {
    639		dev->interrupt_out_busy = 0;
    640		dev_err(&dev->udev->dev,
    641			"Couldn't submit interrupt_out_urb %d\n", retval);
    642		goto unlock_exit;
    643	}
    644	retval = bytes_to_write;
    645
    646unlock_exit:
    647	/* unlock the device */
    648	mutex_unlock(&dev->lock);
    649
    650exit:
    651	return retval;
    652}
    653
    654
    655/*
    656 *	tower_interrupt_in_callback
    657 */
    658static void tower_interrupt_in_callback(struct urb *urb)
    659{
    660	struct lego_usb_tower *dev = urb->context;
    661	int status = urb->status;
    662	int retval;
    663	unsigned long flags;
    664
    665	lego_usb_tower_debug_data(&dev->udev->dev, __func__,
    666				  urb->actual_length, urb->transfer_buffer);
    667
    668	if (status) {
    669		if (status == -ENOENT ||
    670		    status == -ECONNRESET ||
    671		    status == -ESHUTDOWN) {
    672			goto exit;
    673		} else {
    674			dev_dbg(&dev->udev->dev,
    675				"%s: nonzero status received: %d\n", __func__,
    676				status);
    677			goto resubmit; /* maybe we can recover */
    678		}
    679	}
    680
    681	if (urb->actual_length > 0) {
    682		spin_lock_irqsave(&dev->read_buffer_lock, flags);
    683		if (dev->read_buffer_length + urb->actual_length < read_buffer_size) {
    684			memcpy(dev->read_buffer + dev->read_buffer_length,
    685			       dev->interrupt_in_buffer,
    686			       urb->actual_length);
    687			dev->read_buffer_length += urb->actual_length;
    688			dev->read_last_arrival = jiffies;
    689			dev_dbg(&dev->udev->dev, "%s: received %d bytes\n",
    690				__func__, urb->actual_length);
    691		} else {
    692			pr_warn("read_buffer overflow, %d bytes dropped\n",
    693				urb->actual_length);
    694		}
    695		spin_unlock_irqrestore(&dev->read_buffer_lock, flags);
    696	}
    697
    698resubmit:
    699	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
    700	if (retval) {
    701		dev_err(&dev->udev->dev, "%s: usb_submit_urb failed (%d)\n",
    702			__func__, retval);
    703	}
    704exit:
    705	dev->interrupt_in_done = 1;
    706	wake_up_interruptible(&dev->read_wait);
    707}
    708
    709
    710/*
    711 *	tower_interrupt_out_callback
    712 */
    713static void tower_interrupt_out_callback(struct urb *urb)
    714{
    715	struct lego_usb_tower *dev = urb->context;
    716	int status = urb->status;
    717
    718	lego_usb_tower_debug_data(&dev->udev->dev, __func__,
    719				  urb->actual_length, urb->transfer_buffer);
    720
    721	/* sync/async unlink faults aren't errors */
    722	if (status && !(status == -ENOENT ||
    723			status == -ECONNRESET ||
    724			status == -ESHUTDOWN)) {
    725		dev_dbg(&dev->udev->dev,
    726			"%s: nonzero write bulk status received: %d\n", __func__,
    727			status);
    728	}
    729
    730	dev->interrupt_out_busy = 0;
    731	wake_up_interruptible(&dev->write_wait);
    732}
    733
    734
    735/*
    736 *	tower_probe
    737 *
    738 *	Called by the usb core when a new device is connected that it thinks
    739 *	this driver might be interested in.
    740 */
    741static int tower_probe(struct usb_interface *interface, const struct usb_device_id *id)
    742{
    743	struct device *idev = &interface->dev;
    744	struct usb_device *udev = interface_to_usbdev(interface);
    745	struct lego_usb_tower *dev;
    746	struct tower_get_version_reply get_version_reply;
    747	int retval = -ENOMEM;
    748	int result;
    749
    750	/* allocate memory for our device state and initialize it */
    751	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
    752	if (!dev)
    753		goto exit;
    754
    755	mutex_init(&dev->lock);
    756	dev->udev = usb_get_dev(udev);
    757	spin_lock_init(&dev->read_buffer_lock);
    758	dev->packet_timeout_jiffies = msecs_to_jiffies(packet_timeout);
    759	dev->read_last_arrival = jiffies;
    760	init_waitqueue_head(&dev->read_wait);
    761	init_waitqueue_head(&dev->write_wait);
    762
    763	result = usb_find_common_endpoints_reverse(interface->cur_altsetting,
    764			NULL, NULL,
    765			&dev->interrupt_in_endpoint,
    766			&dev->interrupt_out_endpoint);
    767	if (result) {
    768		dev_err(idev, "interrupt endpoints not found\n");
    769		retval = result;
    770		goto error;
    771	}
    772
    773	dev->read_buffer = kmalloc(read_buffer_size, GFP_KERNEL);
    774	if (!dev->read_buffer)
    775		goto error;
    776	dev->interrupt_in_buffer = kmalloc(usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);
    777	if (!dev->interrupt_in_buffer)
    778		goto error;
    779	dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
    780	if (!dev->interrupt_in_urb)
    781		goto error;
    782	dev->interrupt_out_buffer = kmalloc(write_buffer_size, GFP_KERNEL);
    783	if (!dev->interrupt_out_buffer)
    784		goto error;
    785	dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
    786	if (!dev->interrupt_out_urb)
    787		goto error;
    788	dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_endpoint->bInterval;
    789	dev->interrupt_out_interval = interrupt_out_interval ? interrupt_out_interval : dev->interrupt_out_endpoint->bInterval;
    790
    791	/* get the firmware version and log it */
    792	result = usb_control_msg_recv(udev, 0,
    793				      LEGO_USB_TOWER_REQUEST_GET_VERSION,
    794				      USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
    795				      0,
    796				      0,
    797				      &get_version_reply,
    798				      sizeof(get_version_reply),
    799				      1000, GFP_KERNEL);
    800	if (result) {
    801		dev_err(idev, "get version request failed: %d\n", result);
    802		retval = result;
    803		goto error;
    804	}
    805	dev_info(&interface->dev,
    806		 "LEGO USB Tower firmware version is %d.%d build %d\n",
    807		 get_version_reply.major,
    808		 get_version_reply.minor,
    809		 le16_to_cpu(get_version_reply.build_no));
    810
    811	/* we can register the device now, as it is ready */
    812	usb_set_intfdata(interface, dev);
    813
    814	retval = usb_register_dev(interface, &tower_class);
    815	if (retval) {
    816		/* something prevented us from registering this driver */
    817		dev_err(idev, "Not able to get a minor for this device.\n");
    818		goto error;
    819	}
    820	dev->minor = interface->minor;
    821
    822	/* let the user know what node this device is now attached to */
    823	dev_info(&interface->dev, "LEGO USB Tower #%d now attached to major "
    824		 "%d minor %d\n", (dev->minor - LEGO_USB_TOWER_MINOR_BASE),
    825		 USB_MAJOR, dev->minor);
    826
    827exit:
    828	return retval;
    829
    830error:
    831	tower_delete(dev);
    832	return retval;
    833}
    834
    835
    836/*
    837 *	tower_disconnect
    838 *
    839 *	Called by the usb core when the device is removed from the system.
    840 */
    841static void tower_disconnect(struct usb_interface *interface)
    842{
    843	struct lego_usb_tower *dev;
    844	int minor;
    845
    846	dev = usb_get_intfdata(interface);
    847
    848	minor = dev->minor;
    849
    850	/* give back our minor and prevent further open() */
    851	usb_deregister_dev(interface, &tower_class);
    852
    853	/* stop I/O */
    854	usb_poison_urb(dev->interrupt_in_urb);
    855	usb_poison_urb(dev->interrupt_out_urb);
    856
    857	mutex_lock(&dev->lock);
    858
    859	/* if the device is not opened, then we clean up right now */
    860	if (!dev->open_count) {
    861		mutex_unlock(&dev->lock);
    862		tower_delete(dev);
    863	} else {
    864		dev->disconnected = 1;
    865		/* wake up pollers */
    866		wake_up_interruptible_all(&dev->read_wait);
    867		wake_up_interruptible_all(&dev->write_wait);
    868		mutex_unlock(&dev->lock);
    869	}
    870
    871	dev_info(&interface->dev, "LEGO USB Tower #%d now disconnected\n",
    872		 (minor - LEGO_USB_TOWER_MINOR_BASE));
    873}
    874
    875module_usb_driver(tower_driver);
    876
    877MODULE_AUTHOR(DRIVER_AUTHOR);
    878MODULE_DESCRIPTION(DRIVER_DESC);
    879MODULE_LICENSE("GPL");