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