15fd54aceSGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0+
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * LEGO USB Tower driver
41da177e4SLinus Torvalds *
51da177e4SLinus Torvalds * Copyright (C) 2003 David Glance <davidgsf@sourceforge.net>
61da177e4SLinus Torvalds * 2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
71da177e4SLinus Torvalds *
81da177e4SLinus Torvalds * derived from USB Skeleton driver - 0.5
91da177e4SLinus Torvalds * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
101da177e4SLinus Torvalds *
111da177e4SLinus Torvalds * History:
121da177e4SLinus Torvalds *
131da177e4SLinus Torvalds * 2001-10-13 - 0.1 js
141da177e4SLinus Torvalds * - first version
151da177e4SLinus Torvalds * 2001-11-03 - 0.2 js
161da177e4SLinus Torvalds * - simplified buffering, one-shot URBs for writing
171da177e4SLinus Torvalds * 2001-11-10 - 0.3 js
181da177e4SLinus Torvalds * - removed IOCTL (setting power/mode is more complicated, postponed)
191da177e4SLinus Torvalds * 2001-11-28 - 0.4 js
201da177e4SLinus Torvalds * - added vendor commands for mode of operation and power level in open
211da177e4SLinus Torvalds * 2001-12-04 - 0.5 js
221da177e4SLinus Torvalds * - set IR mode by default (by oversight 0.4 set VLL mode)
231da177e4SLinus Torvalds * 2002-01-11 - 0.5? pcchan
241da177e4SLinus Torvalds * - make read buffer reusable and work around bytes_to_write issue between
251da177e4SLinus Torvalds * uhci and legusbtower
261da177e4SLinus Torvalds * 2002-09-23 - 0.52 david (david@csse.uwa.edu.au)
271da177e4SLinus Torvalds * - imported into lejos project
281da177e4SLinus Torvalds * - changed wake_up to wake_up_interruptible
291da177e4SLinus Torvalds * - changed to use lego0 rather than tower0
30441b62c1SHarvey Harrison * - changed dbg() to use __func__ rather than deprecated __func__
311da177e4SLinus Torvalds * 2003-01-12 - 0.53 david (david@csse.uwa.edu.au)
321da177e4SLinus Torvalds * - changed read and write to write everything or
331da177e4SLinus Torvalds * timeout (from a patch by Chris Riesen and Brett Thaeler driver)
341da177e4SLinus Torvalds * - added ioctl functionality to set timeouts
351da177e4SLinus Torvalds * 2003-07-18 - 0.54 davidgsf (david@csse.uwa.edu.au)
361da177e4SLinus Torvalds * - initial import into LegoUSB project
371da177e4SLinus Torvalds * - merge of existing LegoUSB.c driver
381da177e4SLinus Torvalds * 2003-07-18 - 0.56 davidgsf (david@csse.uwa.edu.au)
391da177e4SLinus Torvalds * - port to 2.6 style driver
401da177e4SLinus Torvalds * 2004-02-29 - 0.6 Juergen Stuber <starblue@users.sourceforge.net>
411da177e4SLinus Torvalds * - fix locking
421da177e4SLinus Torvalds * - unlink read URBs which are no longer needed
431da177e4SLinus Torvalds * - allow increased buffer size, eliminates need for timeout on write
441da177e4SLinus Torvalds * - have read URB running continuously
451da177e4SLinus Torvalds * - added poll
461da177e4SLinus Torvalds * - forbid seeking
471da177e4SLinus Torvalds * - added nonblocking I/O
48441b62c1SHarvey Harrison * - changed back __func__ to __func__
491da177e4SLinus Torvalds * - read and log tower firmware version
501da177e4SLinus Torvalds * - reset tower on probe, avoids failure of first write
511da177e4SLinus Torvalds * 2004-03-09 - 0.7 Juergen Stuber <starblue@users.sourceforge.net>
521da177e4SLinus Torvalds * - timeout read now only after inactivity, shorten default accordingly
531da177e4SLinus Torvalds * 2004-03-11 - 0.8 Juergen Stuber <starblue@users.sourceforge.net>
541da177e4SLinus Torvalds * - log major, minor instead of possibly confusing device filename
551da177e4SLinus Torvalds * - whitespace cleanup
561da177e4SLinus Torvalds * 2004-03-12 - 0.9 Juergen Stuber <starblue@users.sourceforge.net>
571da177e4SLinus Torvalds * - normalize whitespace in debug messages
581da177e4SLinus Torvalds * - take care about endianness in control message responses
591da177e4SLinus Torvalds * 2004-03-13 - 0.91 Juergen Stuber <starblue@users.sourceforge.net>
601da177e4SLinus Torvalds * - make default intervals longer to accommodate current EHCI driver
611da177e4SLinus Torvalds * 2004-03-19 - 0.92 Juergen Stuber <starblue@users.sourceforge.net>
621da177e4SLinus Torvalds * - replaced atomic_t by memory barriers
631da177e4SLinus Torvalds * 2004-04-21 - 0.93 Juergen Stuber <starblue@users.sourceforge.net>
641da177e4SLinus Torvalds * - wait for completion of write urb in release (needed for remotecontrol)
651da177e4SLinus Torvalds * - corrected poll for write direction (missing negation)
661da177e4SLinus Torvalds * 2004-04-22 - 0.94 Juergen Stuber <starblue@users.sourceforge.net>
671da177e4SLinus Torvalds * - make device locking interruptible
681da177e4SLinus Torvalds * 2004-04-30 - 0.95 Juergen Stuber <starblue@users.sourceforge.net>
691da177e4SLinus Torvalds * - check for valid udev on resubmitting and unlinking urbs
701da177e4SLinus Torvalds * 2004-08-03 - 0.96 Juergen Stuber <starblue@users.sourceforge.net>
711da177e4SLinus Torvalds * - move reset into open to clean out spurious data
721da177e4SLinus Torvalds */
731da177e4SLinus Torvalds
7438726bf5SGreg Kroah-Hartman #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7538726bf5SGreg Kroah-Hartman
761da177e4SLinus Torvalds #include <linux/kernel.h>
771da177e4SLinus Torvalds #include <linux/errno.h>
781da177e4SLinus Torvalds #include <linux/slab.h>
791da177e4SLinus Torvalds #include <linux/module.h>
801da177e4SLinus Torvalds #include <linux/completion.h>
814186ecf8SArjan van de Ven #include <linux/mutex.h>
827c0f6ba6SLinus Torvalds #include <linux/uaccess.h>
831da177e4SLinus Torvalds #include <linux/usb.h>
841da177e4SLinus Torvalds #include <linux/poll.h>
851da177e4SLinus Torvalds
861da177e4SLinus Torvalds
871da177e4SLinus Torvalds #define DRIVER_AUTHOR "Juergen Stuber <starblue@sourceforge.net>"
881da177e4SLinus Torvalds #define DRIVER_DESC "LEGO USB Tower Driver"
891da177e4SLinus Torvalds
901da177e4SLinus Torvalds
911da177e4SLinus Torvalds /* The defaults are chosen to work with the latest versions of leJOS and NQC.
921da177e4SLinus Torvalds */
931da177e4SLinus Torvalds
941da177e4SLinus Torvalds /* Some legacy software likes to receive packets in one piece.
951da177e4SLinus Torvalds * In this case read_buffer_size should exceed the maximal packet length
961da177e4SLinus Torvalds * (417 for datalog uploads), and packet_timeout should be set.
971da177e4SLinus Torvalds */
981da177e4SLinus Torvalds static int read_buffer_size = 480;
991da177e4SLinus Torvalds module_param(read_buffer_size, int, 0);
1001da177e4SLinus Torvalds MODULE_PARM_DESC(read_buffer_size, "Read buffer size");
1011da177e4SLinus Torvalds
1021da177e4SLinus Torvalds /* Some legacy software likes to send packets in one piece.
1031da177e4SLinus Torvalds * In this case write_buffer_size should exceed the maximal packet length
1041da177e4SLinus Torvalds * (417 for firmware and program downloads).
1051da177e4SLinus Torvalds * A problem with long writes is that the following read may time out
1061da177e4SLinus Torvalds * if the software is not prepared to wait long enough.
1071da177e4SLinus Torvalds */
1081da177e4SLinus Torvalds static int write_buffer_size = 480;
1091da177e4SLinus Torvalds module_param(write_buffer_size, int, 0);
1101da177e4SLinus Torvalds MODULE_PARM_DESC(write_buffer_size, "Write buffer size");
1111da177e4SLinus Torvalds
1121da177e4SLinus Torvalds /* Some legacy software expects reads to contain whole LASM packets.
1131da177e4SLinus Torvalds * To achieve this, characters which arrive before a packet timeout
1141da177e4SLinus Torvalds * occurs will be returned in a single read operation.
1151da177e4SLinus Torvalds * A problem with long reads is that the software may time out
1161da177e4SLinus Torvalds * if it is not prepared to wait long enough.
1171da177e4SLinus Torvalds * The packet timeout should be greater than the time between the
1181da177e4SLinus Torvalds * reception of subsequent characters, which should arrive about
1191da177e4SLinus Torvalds * every 5ms for the standard 2400 baud.
1201da177e4SLinus Torvalds * Set it to 0 to disable.
1211da177e4SLinus Torvalds */
1221da177e4SLinus Torvalds static int packet_timeout = 50;
1231da177e4SLinus Torvalds module_param(packet_timeout, int, 0);
1241da177e4SLinus Torvalds MODULE_PARM_DESC(packet_timeout, "Packet timeout in ms");
1251da177e4SLinus Torvalds
1261da177e4SLinus Torvalds /* Some legacy software expects blocking reads to time out.
1271da177e4SLinus Torvalds * Timeout occurs after the specified time of read and write inactivity.
1281da177e4SLinus Torvalds * Set it to 0 to disable.
1291da177e4SLinus Torvalds */
1301da177e4SLinus Torvalds static int read_timeout = 200;
1311da177e4SLinus Torvalds module_param(read_timeout, int, 0);
1321da177e4SLinus Torvalds MODULE_PARM_DESC(read_timeout, "Read timeout in ms");
1331da177e4SLinus Torvalds
1341da177e4SLinus Torvalds /* As of kernel version 2.6.4 ehci-hcd uses an
1351da177e4SLinus Torvalds * "only one interrupt transfer per frame" shortcut
1361da177e4SLinus Torvalds * to simplify the scheduling of periodic transfers.
1371da177e4SLinus Torvalds * This conflicts with our standard 1ms intervals for in and out URBs.
1381da177e4SLinus Torvalds * We use default intervals of 2ms for in and 8ms for out transfers,
1391da177e4SLinus Torvalds * which is fast enough for 2400 baud and allows a small additional load.
1401da177e4SLinus Torvalds * Increase the interval to allow more devices that do interrupt transfers,
1411da177e4SLinus Torvalds * or set to 0 to use the standard interval from the endpoint descriptors.
1421da177e4SLinus Torvalds */
1431da177e4SLinus Torvalds static int interrupt_in_interval = 2;
1441da177e4SLinus Torvalds module_param(interrupt_in_interval, int, 0);
1451da177e4SLinus Torvalds MODULE_PARM_DESC(interrupt_in_interval, "Interrupt in interval in ms");
1461da177e4SLinus Torvalds
1471da177e4SLinus Torvalds static int interrupt_out_interval = 8;
1481da177e4SLinus Torvalds module_param(interrupt_out_interval, int, 0);
1491da177e4SLinus Torvalds MODULE_PARM_DESC(interrupt_out_interval, "Interrupt out interval in ms");
1501da177e4SLinus Torvalds
1511da177e4SLinus Torvalds /* Define these values to match your device */
1521da177e4SLinus Torvalds #define LEGO_USB_TOWER_VENDOR_ID 0x0694
1531da177e4SLinus Torvalds #define LEGO_USB_TOWER_PRODUCT_ID 0x0001
1541da177e4SLinus Torvalds
1551da177e4SLinus Torvalds /* Vendor requests */
1561da177e4SLinus Torvalds #define LEGO_USB_TOWER_REQUEST_RESET 0x04
1571da177e4SLinus Torvalds #define LEGO_USB_TOWER_REQUEST_GET_VERSION 0xFD
1581da177e4SLinus Torvalds
1591da177e4SLinus Torvalds struct tower_reset_reply {
16072877248SJohan Hovold __le16 size;
1611da177e4SLinus Torvalds __u8 err_code;
1621da177e4SLinus Torvalds __u8 spare;
163a76c234fSJohan Hovold };
1641da177e4SLinus Torvalds
1651da177e4SLinus Torvalds struct tower_get_version_reply {
16672877248SJohan Hovold __le16 size;
1671da177e4SLinus Torvalds __u8 err_code;
1681da177e4SLinus Torvalds __u8 spare;
1691da177e4SLinus Torvalds __u8 major;
1701da177e4SLinus Torvalds __u8 minor;
17172877248SJohan Hovold __le16 build_no;
172a76c234fSJohan Hovold };
1731da177e4SLinus Torvalds
1741da177e4SLinus Torvalds
1751da177e4SLinus Torvalds /* table of devices that work with this driver */
17633b9e162SNémeth Márton static const struct usb_device_id tower_table[] = {
1771da177e4SLinus Torvalds { USB_DEVICE(LEGO_USB_TOWER_VENDOR_ID, LEGO_USB_TOWER_PRODUCT_ID) },
1781da177e4SLinus Torvalds { } /* Terminating entry */
1791da177e4SLinus Torvalds };
1801da177e4SLinus Torvalds
1811da177e4SLinus Torvalds MODULE_DEVICE_TABLE(usb, tower_table);
1821da177e4SLinus Torvalds
1831da177e4SLinus Torvalds #define LEGO_USB_TOWER_MINOR_BASE 160
1841da177e4SLinus Torvalds
1851da177e4SLinus Torvalds
1861da177e4SLinus Torvalds /* Structure to hold all of our device specific stuff */
1871da177e4SLinus Torvalds struct lego_usb_tower {
18818bcbcfeSDaniel Walker struct mutex lock; /* locks this structure */
1891da177e4SLinus Torvalds struct usb_device *udev; /* save off the usb device pointer */
1901da177e4SLinus Torvalds unsigned char minor; /* the starting minor number for this device */
1911da177e4SLinus Torvalds
1921da177e4SLinus Torvalds int open_count; /* number of times this port has been opened */
193cd81e6faSJohan Hovold unsigned long disconnected:1;
1941da177e4SLinus Torvalds
1951da177e4SLinus Torvalds char *read_buffer;
1961da177e4SLinus Torvalds size_t read_buffer_length; /* this much came in */
1971da177e4SLinus Torvalds size_t read_packet_length; /* this much will be returned on read */
1981da177e4SLinus Torvalds spinlock_t read_buffer_lock;
1991da177e4SLinus Torvalds int packet_timeout_jiffies;
2001da177e4SLinus Torvalds unsigned long read_last_arrival;
2011da177e4SLinus Torvalds
2021da177e4SLinus Torvalds wait_queue_head_t read_wait;
2031da177e4SLinus Torvalds wait_queue_head_t write_wait;
2041da177e4SLinus Torvalds
2051da177e4SLinus Torvalds char *interrupt_in_buffer;
2061da177e4SLinus Torvalds struct usb_endpoint_descriptor *interrupt_in_endpoint;
2071da177e4SLinus Torvalds struct urb *interrupt_in_urb;
2081da177e4SLinus Torvalds int interrupt_in_interval;
2091da177e4SLinus Torvalds int interrupt_in_done;
2101da177e4SLinus Torvalds
2111da177e4SLinus Torvalds char *interrupt_out_buffer;
2121da177e4SLinus Torvalds struct usb_endpoint_descriptor *interrupt_out_endpoint;
2131da177e4SLinus Torvalds struct urb *interrupt_out_urb;
2141da177e4SLinus Torvalds int interrupt_out_interval;
2151da177e4SLinus Torvalds int interrupt_out_busy;
2161da177e4SLinus Torvalds
2171da177e4SLinus Torvalds };
2181da177e4SLinus Torvalds
2191da177e4SLinus Torvalds
2201da177e4SLinus Torvalds /* local function prototypes */
2211da177e4SLinus Torvalds static ssize_t tower_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos);
2221da177e4SLinus Torvalds static ssize_t tower_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
2231da177e4SLinus Torvalds static inline void tower_delete(struct lego_usb_tower *dev);
2241da177e4SLinus Torvalds static int tower_open(struct inode *inode, struct file *file);
2251da177e4SLinus Torvalds static int tower_release(struct inode *inode, struct file *file);
226afc9a42bSAl Viro static __poll_t tower_poll(struct file *file, poll_table *wait);
2271da177e4SLinus Torvalds static loff_t tower_llseek(struct file *file, loff_t off, int whence);
2281da177e4SLinus Torvalds
2291da177e4SLinus Torvalds static void tower_check_for_read_packet(struct lego_usb_tower *dev);
2307d12e780SDavid Howells static void tower_interrupt_in_callback(struct urb *urb);
2317d12e780SDavid Howells static void tower_interrupt_out_callback(struct urb *urb);
2321da177e4SLinus Torvalds
2331da177e4SLinus Torvalds static int tower_probe(struct usb_interface *interface, const struct usb_device_id *id);
2341da177e4SLinus Torvalds static void tower_disconnect(struct usb_interface *interface);
2351da177e4SLinus Torvalds
2361da177e4SLinus Torvalds
2371da177e4SLinus Torvalds /* file operations needed when we register this driver */
238066202ddSLuiz Fernando N. Capitulino static const struct file_operations tower_fops = {
2391da177e4SLinus Torvalds .owner = THIS_MODULE,
2401da177e4SLinus Torvalds .read = tower_read,
2411da177e4SLinus Torvalds .write = tower_write,
2421da177e4SLinus Torvalds .open = tower_open,
2431da177e4SLinus Torvalds .release = tower_release,
2441da177e4SLinus Torvalds .poll = tower_poll,
2451da177e4SLinus Torvalds .llseek = tower_llseek,
2461da177e4SLinus Torvalds };
2471da177e4SLinus Torvalds
legousbtower_devnode(const struct device * dev,umode_t * mode)248*5033ac5cSGreg Kroah-Hartman static char *legousbtower_devnode(const struct device *dev, umode_t *mode)
249f7a386c5SKay Sievers {
250f7a386c5SKay Sievers return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
251f7a386c5SKay Sievers }
252f7a386c5SKay Sievers
2531da177e4SLinus Torvalds /*
2541da177e4SLinus Torvalds * usb class driver info in order to get a minor number from the usb core,
255d6e5bcf4SGreg Kroah-Hartman * and to have the device registered with the driver core
2561da177e4SLinus Torvalds */
2571da177e4SLinus Torvalds static struct usb_class_driver tower_class = {
258d6e5bcf4SGreg Kroah-Hartman .name = "legousbtower%d",
259e454cea2SKay Sievers .devnode = legousbtower_devnode,
2601da177e4SLinus Torvalds .fops = &tower_fops,
2611da177e4SLinus Torvalds .minor_base = LEGO_USB_TOWER_MINOR_BASE,
2621da177e4SLinus Torvalds };
2631da177e4SLinus Torvalds
2641da177e4SLinus Torvalds
2651da177e4SLinus Torvalds /* usb specific object needed to register this driver with the usb subsystem */
2661da177e4SLinus Torvalds static struct usb_driver tower_driver = {
2671da177e4SLinus Torvalds .name = "legousbtower",
2681da177e4SLinus Torvalds .probe = tower_probe,
2691da177e4SLinus Torvalds .disconnect = tower_disconnect,
2701da177e4SLinus Torvalds .id_table = tower_table,
2711da177e4SLinus Torvalds };
2721da177e4SLinus Torvalds
2731da177e4SLinus Torvalds
2744ac2c460SLee Jones /*
2751da177e4SLinus Torvalds * lego_usb_tower_debug_data
2761da177e4SLinus Torvalds */
lego_usb_tower_debug_data(struct device * dev,const char * function,int size,const unsigned char * data)2774dae9963SGreg Kroah-Hartman static inline void lego_usb_tower_debug_data(struct device *dev,
2784dae9963SGreg Kroah-Hartman const char *function, int size,
2794dae9963SGreg Kroah-Hartman const unsigned char *data)
2801da177e4SLinus Torvalds {
2814dae9963SGreg Kroah-Hartman dev_dbg(dev, "%s - length = %d, data = %*ph\n",
2824dae9963SGreg Kroah-Hartman function, size, size, data);
2831da177e4SLinus Torvalds }
2841da177e4SLinus Torvalds
2851da177e4SLinus Torvalds
286464b7d0eSLee Jones /*
2871da177e4SLinus Torvalds * tower_delete
2881da177e4SLinus Torvalds */
tower_delete(struct lego_usb_tower * dev)2891da177e4SLinus Torvalds static inline void tower_delete(struct lego_usb_tower *dev)
2901da177e4SLinus Torvalds {
2911da177e4SLinus Torvalds /* free data structures */
2921da177e4SLinus Torvalds usb_free_urb(dev->interrupt_in_urb);
2931da177e4SLinus Torvalds usb_free_urb(dev->interrupt_out_urb);
2941da177e4SLinus Torvalds kfree(dev->read_buffer);
2951da177e4SLinus Torvalds kfree(dev->interrupt_in_buffer);
2961da177e4SLinus Torvalds kfree(dev->interrupt_out_buffer);
297726b55d0SJohan Hovold usb_put_dev(dev->udev);
2981da177e4SLinus Torvalds kfree(dev);
2991da177e4SLinus Torvalds }
3001da177e4SLinus Torvalds
3011da177e4SLinus Torvalds
302464b7d0eSLee Jones /*
3031da177e4SLinus Torvalds * tower_open
3041da177e4SLinus Torvalds */
tower_open(struct inode * inode,struct file * file)3051da177e4SLinus Torvalds static int tower_open(struct inode *inode, struct file *file)
3061da177e4SLinus Torvalds {
3071da177e4SLinus Torvalds struct lego_usb_tower *dev = NULL;
3081da177e4SLinus Torvalds int subminor;
3091da177e4SLinus Torvalds int retval = 0;
3101da177e4SLinus Torvalds struct usb_interface *interface;
311d9f0d82fSGreg Kroah-Hartman struct tower_reset_reply reset_reply;
3121da177e4SLinus Torvalds int result;
3131da177e4SLinus Torvalds
3141da177e4SLinus Torvalds nonseekable_open(inode, file);
3151da177e4SLinus Torvalds subminor = iminor(inode);
3161da177e4SLinus Torvalds
3171da177e4SLinus Torvalds interface = usb_find_interface(&tower_driver, subminor);
3181da177e4SLinus Torvalds if (!interface) {
31938726bf5SGreg Kroah-Hartman pr_err("error, can't find device for minor %d\n", subminor);
3201da177e4SLinus Torvalds retval = -ENODEV;
321d4ead16fSAlan Stern goto exit;
3221da177e4SLinus Torvalds }
3231da177e4SLinus Torvalds
3241da177e4SLinus Torvalds dev = usb_get_intfdata(interface);
3251da177e4SLinus Torvalds if (!dev) {
3261da177e4SLinus Torvalds retval = -ENODEV;
327d4ead16fSAlan Stern goto exit;
3281da177e4SLinus Torvalds }
3291da177e4SLinus Torvalds
3301da177e4SLinus Torvalds /* lock this device */
33118bcbcfeSDaniel Walker if (mutex_lock_interruptible(&dev->lock)) {
3321da177e4SLinus Torvalds retval = -ERESTARTSYS;
333d4ead16fSAlan Stern goto exit;
3341da177e4SLinus Torvalds }
3351da177e4SLinus Torvalds
33678663eccSOliver Neukum
3371da177e4SLinus Torvalds /* allow opening only once */
3381da177e4SLinus Torvalds if (dev->open_count) {
3391da177e4SLinus Torvalds retval = -EBUSY;
3401da177e4SLinus Torvalds goto unlock_exit;
3411da177e4SLinus Torvalds }
3421da177e4SLinus Torvalds
3431da177e4SLinus Torvalds /* reset the tower */
344d9f0d82fSGreg Kroah-Hartman result = usb_control_msg_recv(dev->udev, 0,
3451da177e4SLinus Torvalds LEGO_USB_TOWER_REQUEST_RESET,
3461da177e4SLinus Torvalds USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
347d9f0d82fSGreg Kroah-Hartman 0, 0,
348d9f0d82fSGreg Kroah-Hartman &reset_reply, sizeof(reset_reply), 1000,
349d9f0d82fSGreg Kroah-Hartman GFP_KERNEL);
3501da177e4SLinus Torvalds if (result < 0) {
3519d974b2aSGreg Kroah-Hartman dev_err(&dev->udev->dev,
3529d974b2aSGreg Kroah-Hartman "LEGO USB Tower reset control request failed\n");
3531da177e4SLinus Torvalds retval = result;
3541da177e4SLinus Torvalds goto unlock_exit;
3551da177e4SLinus Torvalds }
3561da177e4SLinus Torvalds
3571da177e4SLinus Torvalds /* initialize in direction */
3581da177e4SLinus Torvalds dev->read_buffer_length = 0;
3591da177e4SLinus Torvalds dev->read_packet_length = 0;
3601da177e4SLinus Torvalds usb_fill_int_urb(dev->interrupt_in_urb,
3611da177e4SLinus Torvalds dev->udev,
3621da177e4SLinus Torvalds usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),
3631da177e4SLinus Torvalds dev->interrupt_in_buffer,
36429cc8897SKuninori Morimoto usb_endpoint_maxp(dev->interrupt_in_endpoint),
3651da177e4SLinus Torvalds tower_interrupt_in_callback,
3661da177e4SLinus Torvalds dev,
3671da177e4SLinus Torvalds dev->interrupt_in_interval);
3681da177e4SLinus Torvalds
3691da177e4SLinus Torvalds dev->interrupt_in_done = 0;
3701da177e4SLinus Torvalds mb();
3711da177e4SLinus Torvalds
3721da177e4SLinus Torvalds retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);
3731da177e4SLinus Torvalds if (retval) {
3749d974b2aSGreg Kroah-Hartman dev_err(&dev->udev->dev,
3759d974b2aSGreg Kroah-Hartman "Couldn't submit interrupt_in_urb %d\n", retval);
3761da177e4SLinus Torvalds goto unlock_exit;
3771da177e4SLinus Torvalds }
3781da177e4SLinus Torvalds
3791da177e4SLinus Torvalds /* save device in the file's private structure */
3801da177e4SLinus Torvalds file->private_data = dev;
3811da177e4SLinus Torvalds
3820b074f69SJohan Hovold dev->open_count = 1;
3830b074f69SJohan Hovold
3841da177e4SLinus Torvalds unlock_exit:
38518bcbcfeSDaniel Walker mutex_unlock(&dev->lock);
3861da177e4SLinus Torvalds
387d4ead16fSAlan Stern exit:
3881da177e4SLinus Torvalds return retval;
3891da177e4SLinus Torvalds }
3901da177e4SLinus Torvalds
391464b7d0eSLee Jones /*
3921da177e4SLinus Torvalds * tower_release
3931da177e4SLinus Torvalds */
tower_release(struct inode * inode,struct file * file)3941da177e4SLinus Torvalds static int tower_release(struct inode *inode, struct file *file)
3951da177e4SLinus Torvalds {
3961da177e4SLinus Torvalds struct lego_usb_tower *dev;
3971da177e4SLinus Torvalds int retval = 0;
3981da177e4SLinus Torvalds
3995bd6e8b3SJoe Perches dev = file->private_data;
4001da177e4SLinus Torvalds if (dev == NULL) {
4011da177e4SLinus Torvalds retval = -ENODEV;
40233a78132SJohan Hovold goto exit;
4031da177e4SLinus Torvalds }
4041da177e4SLinus Torvalds
405b6c03e5fSJohan Hovold mutex_lock(&dev->lock);
4061da177e4SLinus Torvalds
407cd81e6faSJohan Hovold if (dev->disconnected) {
4081da177e4SLinus Torvalds /* the device was unplugged before the file was released */
40918bcbcfeSDaniel Walker
41018bcbcfeSDaniel Walker /* unlock here as tower_delete frees dev */
41118bcbcfeSDaniel Walker mutex_unlock(&dev->lock);
4121da177e4SLinus Torvalds tower_delete(dev);
4131da177e4SLinus Torvalds goto exit;
4141da177e4SLinus Torvalds }
4151da177e4SLinus Torvalds
4161da177e4SLinus Torvalds /* wait until write transfer is finished */
4171da177e4SLinus Torvalds if (dev->interrupt_out_busy) {
418a0cd1df9SJohan Hovold wait_event_interruptible_timeout(dev->write_wait, !dev->interrupt_out_busy,
419a0cd1df9SJohan Hovold 2 * HZ);
4201da177e4SLinus Torvalds }
421aa6f3832SJohan Hovold
422aa6f3832SJohan Hovold /* shutdown transfers */
423aa6f3832SJohan Hovold usb_kill_urb(dev->interrupt_in_urb);
424aa6f3832SJohan Hovold usb_kill_urb(dev->interrupt_out_urb);
425aa6f3832SJohan Hovold
4261da177e4SLinus Torvalds dev->open_count = 0;
4271da177e4SLinus Torvalds
42818bcbcfeSDaniel Walker mutex_unlock(&dev->lock);
4291da177e4SLinus Torvalds exit:
4301da177e4SLinus Torvalds return retval;
4311da177e4SLinus Torvalds }
4321da177e4SLinus Torvalds
433464b7d0eSLee Jones /*
4341da177e4SLinus Torvalds * tower_check_for_read_packet
4351da177e4SLinus Torvalds *
4361da177e4SLinus Torvalds * To get correct semantics for signals and non-blocking I/O
4371da177e4SLinus Torvalds * with packetizing we pretend not to see any data in the read buffer
4381da177e4SLinus Torvalds * until it has been there unchanged for at least
4391da177e4SLinus Torvalds * dev->packet_timeout_jiffies, or until the buffer is full.
4401da177e4SLinus Torvalds */
tower_check_for_read_packet(struct lego_usb_tower * dev)4411da177e4SLinus Torvalds static void tower_check_for_read_packet(struct lego_usb_tower *dev)
4421da177e4SLinus Torvalds {
4431da177e4SLinus Torvalds spin_lock_irq(&dev->read_buffer_lock);
4441da177e4SLinus Torvalds if (!packet_timeout
4451da177e4SLinus Torvalds || time_after(jiffies, dev->read_last_arrival + dev->packet_timeout_jiffies)
4461da177e4SLinus Torvalds || dev->read_buffer_length == read_buffer_size) {
4471da177e4SLinus Torvalds dev->read_packet_length = dev->read_buffer_length;
4481da177e4SLinus Torvalds }
4491da177e4SLinus Torvalds dev->interrupt_in_done = 0;
4501da177e4SLinus Torvalds spin_unlock_irq(&dev->read_buffer_lock);
4511da177e4SLinus Torvalds }
4521da177e4SLinus Torvalds
4531da177e4SLinus Torvalds
454464b7d0eSLee Jones /*
4551da177e4SLinus Torvalds * tower_poll
4561da177e4SLinus Torvalds */
tower_poll(struct file * file,poll_table * wait)457afc9a42bSAl Viro static __poll_t tower_poll(struct file *file, poll_table *wait)
4581da177e4SLinus Torvalds {
4591da177e4SLinus Torvalds struct lego_usb_tower *dev;
460afc9a42bSAl Viro __poll_t mask = 0;
4611da177e4SLinus Torvalds
4621da177e4SLinus Torvalds dev = file->private_data;
4631da177e4SLinus Torvalds
464cd81e6faSJohan Hovold if (dev->disconnected)
465a9a08845SLinus Torvalds return EPOLLERR | EPOLLHUP;
466d35b4ce1SOliver Neukum
4671da177e4SLinus Torvalds poll_wait(file, &dev->read_wait, wait);
4681da177e4SLinus Torvalds poll_wait(file, &dev->write_wait, wait);
4691da177e4SLinus Torvalds
4701da177e4SLinus Torvalds tower_check_for_read_packet(dev);
4713c84f4bbSJohan Hovold if (dev->read_packet_length > 0)
472a9a08845SLinus Torvalds mask |= EPOLLIN | EPOLLRDNORM;
4733c84f4bbSJohan Hovold if (!dev->interrupt_out_busy)
474a9a08845SLinus Torvalds mask |= EPOLLOUT | EPOLLWRNORM;
4751da177e4SLinus Torvalds
4761da177e4SLinus Torvalds return mask;
4771da177e4SLinus Torvalds }
4781da177e4SLinus Torvalds
4791da177e4SLinus Torvalds
480464b7d0eSLee Jones /*
4811da177e4SLinus Torvalds * tower_llseek
4821da177e4SLinus Torvalds */
tower_llseek(struct file * file,loff_t off,int whence)4831da177e4SLinus Torvalds static loff_t tower_llseek(struct file *file, loff_t off, int whence)
4841da177e4SLinus Torvalds {
4851da177e4SLinus Torvalds return -ESPIPE; /* unseekable */
4861da177e4SLinus Torvalds }
4871da177e4SLinus Torvalds
4881da177e4SLinus Torvalds
489464b7d0eSLee Jones /*
4901da177e4SLinus Torvalds * tower_read
4911da177e4SLinus Torvalds */
tower_read(struct file * file,char __user * buffer,size_t count,loff_t * ppos)4921da177e4SLinus Torvalds static ssize_t tower_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
4931da177e4SLinus Torvalds {
4941da177e4SLinus Torvalds struct lego_usb_tower *dev;
4951da177e4SLinus Torvalds size_t bytes_to_read;
4961da177e4SLinus Torvalds int i;
4971da177e4SLinus Torvalds int retval = 0;
4981da177e4SLinus Torvalds unsigned long timeout = 0;
4991da177e4SLinus Torvalds
5005bd6e8b3SJoe Perches dev = file->private_data;
5011da177e4SLinus Torvalds
5021da177e4SLinus Torvalds /* lock this object */
50318bcbcfeSDaniel Walker if (mutex_lock_interruptible(&dev->lock)) {
5041da177e4SLinus Torvalds retval = -ERESTARTSYS;
5051da177e4SLinus Torvalds goto exit;
5061da177e4SLinus Torvalds }
5071da177e4SLinus Torvalds
5081da177e4SLinus Torvalds /* verify that the device wasn't unplugged */
509cd81e6faSJohan Hovold if (dev->disconnected) {
5101da177e4SLinus Torvalds retval = -ENODEV;
5111da177e4SLinus Torvalds goto unlock_exit;
5121da177e4SLinus Torvalds }
5131da177e4SLinus Torvalds
5141da177e4SLinus Torvalds /* verify that we actually have some data to read */
5151da177e4SLinus Torvalds if (count == 0) {
516fef526caSGreg Kroah-Hartman dev_dbg(&dev->udev->dev, "read request of 0 bytes\n");
5171da177e4SLinus Torvalds goto unlock_exit;
5181da177e4SLinus Torvalds }
5191da177e4SLinus Torvalds
5203c84f4bbSJohan Hovold if (read_timeout)
5218f7e9473SNicholas Mc Guire timeout = jiffies + msecs_to_jiffies(read_timeout);
5221da177e4SLinus Torvalds
5231da177e4SLinus Torvalds /* wait for data */
5241da177e4SLinus Torvalds tower_check_for_read_packet(dev);
5251da177e4SLinus Torvalds while (dev->read_packet_length == 0) {
5261da177e4SLinus Torvalds if (file->f_flags & O_NONBLOCK) {
5271da177e4SLinus Torvalds retval = -EAGAIN;
5281da177e4SLinus Torvalds goto unlock_exit;
5291da177e4SLinus Torvalds }
5301da177e4SLinus Torvalds retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_timeout_jiffies);
5313c84f4bbSJohan Hovold if (retval < 0)
5321da177e4SLinus Torvalds goto unlock_exit;
5331da177e4SLinus Torvalds
5341da177e4SLinus Torvalds /* reset read timeout during read or write activity */
5351da177e4SLinus Torvalds if (read_timeout
5361da177e4SLinus Torvalds && (dev->read_buffer_length || dev->interrupt_out_busy)) {
5378f7e9473SNicholas Mc Guire timeout = jiffies + msecs_to_jiffies(read_timeout);
5381da177e4SLinus Torvalds }
5391da177e4SLinus Torvalds /* check for read timeout */
5401da177e4SLinus Torvalds if (read_timeout && time_after(jiffies, timeout)) {
5411da177e4SLinus Torvalds retval = -ETIMEDOUT;
5421da177e4SLinus Torvalds goto unlock_exit;
5431da177e4SLinus Torvalds }
5441da177e4SLinus Torvalds tower_check_for_read_packet(dev);
5451da177e4SLinus Torvalds }
5461da177e4SLinus Torvalds
5471da177e4SLinus Torvalds /* copy the data from read_buffer into userspace */
5481da177e4SLinus Torvalds bytes_to_read = min(count, dev->read_packet_length);
5491da177e4SLinus Torvalds
5501da177e4SLinus Torvalds if (copy_to_user(buffer, dev->read_buffer, bytes_to_read)) {
5511da177e4SLinus Torvalds retval = -EFAULT;
5521da177e4SLinus Torvalds goto unlock_exit;
5531da177e4SLinus Torvalds }
5541da177e4SLinus Torvalds
5551da177e4SLinus Torvalds spin_lock_irq(&dev->read_buffer_lock);
5561da177e4SLinus Torvalds dev->read_buffer_length -= bytes_to_read;
5571da177e4SLinus Torvalds dev->read_packet_length -= bytes_to_read;
5583c84f4bbSJohan Hovold for (i = 0; i < dev->read_buffer_length; i++)
5591da177e4SLinus Torvalds dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];
5601da177e4SLinus Torvalds spin_unlock_irq(&dev->read_buffer_lock);
5611da177e4SLinus Torvalds
5621da177e4SLinus Torvalds retval = bytes_to_read;
5631da177e4SLinus Torvalds
5641da177e4SLinus Torvalds unlock_exit:
5651da177e4SLinus Torvalds /* unlock the device */
56618bcbcfeSDaniel Walker mutex_unlock(&dev->lock);
5671da177e4SLinus Torvalds
5681da177e4SLinus Torvalds exit:
5691da177e4SLinus Torvalds return retval;
5701da177e4SLinus Torvalds }
5711da177e4SLinus Torvalds
5721da177e4SLinus Torvalds
573464b7d0eSLee Jones /*
5741da177e4SLinus Torvalds * tower_write
5751da177e4SLinus Torvalds */
tower_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)5761da177e4SLinus Torvalds static ssize_t tower_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
5771da177e4SLinus Torvalds {
5781da177e4SLinus Torvalds struct lego_usb_tower *dev;
5791da177e4SLinus Torvalds size_t bytes_to_write;
5801da177e4SLinus Torvalds int retval = 0;
5811da177e4SLinus Torvalds
5825bd6e8b3SJoe Perches dev = file->private_data;
5831da177e4SLinus Torvalds
5841da177e4SLinus Torvalds /* lock this object */
58518bcbcfeSDaniel Walker if (mutex_lock_interruptible(&dev->lock)) {
5861da177e4SLinus Torvalds retval = -ERESTARTSYS;
5871da177e4SLinus Torvalds goto exit;
5881da177e4SLinus Torvalds }
5891da177e4SLinus Torvalds
5901da177e4SLinus Torvalds /* verify that the device wasn't unplugged */
591cd81e6faSJohan Hovold if (dev->disconnected) {
5921da177e4SLinus Torvalds retval = -ENODEV;
5931da177e4SLinus Torvalds goto unlock_exit;
5941da177e4SLinus Torvalds }
5951da177e4SLinus Torvalds
5961da177e4SLinus Torvalds /* verify that we actually have some data to write */
5971da177e4SLinus Torvalds if (count == 0) {
598fef526caSGreg Kroah-Hartman dev_dbg(&dev->udev->dev, "write request of 0 bytes\n");
5991da177e4SLinus Torvalds goto unlock_exit;
6001da177e4SLinus Torvalds }
6011da177e4SLinus Torvalds
6021da177e4SLinus Torvalds /* wait until previous transfer is finished */
6031da177e4SLinus Torvalds while (dev->interrupt_out_busy) {
6041da177e4SLinus Torvalds if (file->f_flags & O_NONBLOCK) {
6051da177e4SLinus Torvalds retval = -EAGAIN;
6061da177e4SLinus Torvalds goto unlock_exit;
6071da177e4SLinus Torvalds }
608a0cd1df9SJohan Hovold retval = wait_event_interruptible(dev->write_wait,
609a0cd1df9SJohan Hovold !dev->interrupt_out_busy);
6103c84f4bbSJohan Hovold if (retval)
6111da177e4SLinus Torvalds goto unlock_exit;
6121da177e4SLinus Torvalds }
6131da177e4SLinus Torvalds
6141da177e4SLinus Torvalds /* write the data into interrupt_out_buffer from userspace */
6151da177e4SLinus Torvalds bytes_to_write = min_t(int, count, write_buffer_size);
6165b5e0928SAlexey Dobriyan dev_dbg(&dev->udev->dev, "%s: count = %zd, bytes_to_write = %zd\n",
617fef526caSGreg Kroah-Hartman __func__, count, bytes_to_write);
6181da177e4SLinus Torvalds
6191da177e4SLinus Torvalds if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {
6201da177e4SLinus Torvalds retval = -EFAULT;
6211da177e4SLinus Torvalds goto unlock_exit;
6221da177e4SLinus Torvalds }
6231da177e4SLinus Torvalds
6241da177e4SLinus Torvalds /* send off the urb */
6251da177e4SLinus Torvalds usb_fill_int_urb(dev->interrupt_out_urb,
6261da177e4SLinus Torvalds dev->udev,
6271da177e4SLinus Torvalds usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
6281da177e4SLinus Torvalds dev->interrupt_out_buffer,
6291da177e4SLinus Torvalds bytes_to_write,
6301da177e4SLinus Torvalds tower_interrupt_out_callback,
6311da177e4SLinus Torvalds dev,
6321da177e4SLinus Torvalds dev->interrupt_out_interval);
6331da177e4SLinus Torvalds
6341da177e4SLinus Torvalds dev->interrupt_out_busy = 1;
6351da177e4SLinus Torvalds wmb();
6361da177e4SLinus Torvalds
6371da177e4SLinus Torvalds retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
6381da177e4SLinus Torvalds if (retval) {
6391da177e4SLinus Torvalds dev->interrupt_out_busy = 0;
6409d974b2aSGreg Kroah-Hartman dev_err(&dev->udev->dev,
6419d974b2aSGreg Kroah-Hartman "Couldn't submit interrupt_out_urb %d\n", retval);
6421da177e4SLinus Torvalds goto unlock_exit;
6431da177e4SLinus Torvalds }
6441da177e4SLinus Torvalds retval = bytes_to_write;
6451da177e4SLinus Torvalds
6461da177e4SLinus Torvalds unlock_exit:
6471da177e4SLinus Torvalds /* unlock the device */
64818bcbcfeSDaniel Walker mutex_unlock(&dev->lock);
6491da177e4SLinus Torvalds
6501da177e4SLinus Torvalds exit:
6511da177e4SLinus Torvalds return retval;
6521da177e4SLinus Torvalds }
6531da177e4SLinus Torvalds
6541da177e4SLinus Torvalds
655464b7d0eSLee Jones /*
6561da177e4SLinus Torvalds * tower_interrupt_in_callback
6571da177e4SLinus Torvalds */
tower_interrupt_in_callback(struct urb * urb)6587d12e780SDavid Howells static void tower_interrupt_in_callback(struct urb *urb)
6591da177e4SLinus Torvalds {
660cdc97792SMing Lei struct lego_usb_tower *dev = urb->context;
66164771a0fSGreg Kroah-Hartman int status = urb->status;
6621da177e4SLinus Torvalds int retval;
6634327059aSSebastian Andrzej Siewior unsigned long flags;
6641da177e4SLinus Torvalds
6654dae9963SGreg Kroah-Hartman lego_usb_tower_debug_data(&dev->udev->dev, __func__,
6664dae9963SGreg Kroah-Hartman urb->actual_length, urb->transfer_buffer);
6671da177e4SLinus Torvalds
66864771a0fSGreg Kroah-Hartman if (status) {
66964771a0fSGreg Kroah-Hartman if (status == -ENOENT ||
67064771a0fSGreg Kroah-Hartman status == -ECONNRESET ||
67164771a0fSGreg Kroah-Hartman status == -ESHUTDOWN) {
6721da177e4SLinus Torvalds goto exit;
6731da177e4SLinus Torvalds } else {
674fef526caSGreg Kroah-Hartman dev_dbg(&dev->udev->dev,
675fef526caSGreg Kroah-Hartman "%s: nonzero status received: %d\n", __func__,
676fef526caSGreg Kroah-Hartman status);
6771da177e4SLinus Torvalds goto resubmit; /* maybe we can recover */
6781da177e4SLinus Torvalds }
6791da177e4SLinus Torvalds }
6801da177e4SLinus Torvalds
6811da177e4SLinus Torvalds if (urb->actual_length > 0) {
6824327059aSSebastian Andrzej Siewior spin_lock_irqsave(&dev->read_buffer_lock, flags);
6831da177e4SLinus Torvalds if (dev->read_buffer_length + urb->actual_length < read_buffer_size) {
6841da177e4SLinus Torvalds memcpy(dev->read_buffer + dev->read_buffer_length,
6851da177e4SLinus Torvalds dev->interrupt_in_buffer,
6861da177e4SLinus Torvalds urb->actual_length);
6871da177e4SLinus Torvalds dev->read_buffer_length += urb->actual_length;
6881da177e4SLinus Torvalds dev->read_last_arrival = jiffies;
689fef526caSGreg Kroah-Hartman dev_dbg(&dev->udev->dev, "%s: received %d bytes\n",
690fef526caSGreg Kroah-Hartman __func__, urb->actual_length);
6911da177e4SLinus Torvalds } else {
69238726bf5SGreg Kroah-Hartman pr_warn("read_buffer overflow, %d bytes dropped\n",
69338726bf5SGreg Kroah-Hartman urb->actual_length);
6941da177e4SLinus Torvalds }
6954327059aSSebastian Andrzej Siewior spin_unlock_irqrestore(&dev->read_buffer_lock, flags);
6961da177e4SLinus Torvalds }
6971da177e4SLinus Torvalds
6981da177e4SLinus Torvalds resubmit:
6991da177e4SLinus Torvalds retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);
700728fcd55SJohan Hovold if (retval) {
701728fcd55SJohan Hovold dev_err(&dev->udev->dev, "%s: usb_submit_urb failed (%d)\n",
7029d974b2aSGreg Kroah-Hartman __func__, retval);
7031da177e4SLinus Torvalds }
7041da177e4SLinus Torvalds exit:
7051da177e4SLinus Torvalds dev->interrupt_in_done = 1;
7061da177e4SLinus Torvalds wake_up_interruptible(&dev->read_wait);
7071da177e4SLinus Torvalds }
7081da177e4SLinus Torvalds
7091da177e4SLinus Torvalds
710464b7d0eSLee Jones /*
7111da177e4SLinus Torvalds * tower_interrupt_out_callback
7121da177e4SLinus Torvalds */
tower_interrupt_out_callback(struct urb * urb)7137d12e780SDavid Howells static void tower_interrupt_out_callback(struct urb *urb)
7141da177e4SLinus Torvalds {
715cdc97792SMing Lei struct lego_usb_tower *dev = urb->context;
71664771a0fSGreg Kroah-Hartman int status = urb->status;
7171da177e4SLinus Torvalds
7184dae9963SGreg Kroah-Hartman lego_usb_tower_debug_data(&dev->udev->dev, __func__,
7194dae9963SGreg Kroah-Hartman urb->actual_length, urb->transfer_buffer);
7201da177e4SLinus Torvalds
7211da177e4SLinus Torvalds /* sync/async unlink faults aren't errors */
72264771a0fSGreg Kroah-Hartman if (status && !(status == -ENOENT ||
72364771a0fSGreg Kroah-Hartman status == -ECONNRESET ||
72464771a0fSGreg Kroah-Hartman status == -ESHUTDOWN)) {
725fef526caSGreg Kroah-Hartman dev_dbg(&dev->udev->dev,
726fef526caSGreg Kroah-Hartman "%s: nonzero write bulk status received: %d\n", __func__,
727fef526caSGreg Kroah-Hartman status);
7281da177e4SLinus Torvalds }
7291da177e4SLinus Torvalds
7301da177e4SLinus Torvalds dev->interrupt_out_busy = 0;
7311da177e4SLinus Torvalds wake_up_interruptible(&dev->write_wait);
7321da177e4SLinus Torvalds }
7331da177e4SLinus Torvalds
7341da177e4SLinus Torvalds
735464b7d0eSLee Jones /*
7361da177e4SLinus Torvalds * tower_probe
7371da177e4SLinus Torvalds *
7381da177e4SLinus Torvalds * Called by the usb core when a new device is connected that it thinks
7391da177e4SLinus Torvalds * this driver might be interested in.
7401da177e4SLinus Torvalds */
tower_probe(struct usb_interface * interface,const struct usb_device_id * id)7411da177e4SLinus Torvalds static int tower_probe(struct usb_interface *interface, const struct usb_device_id *id)
7421da177e4SLinus Torvalds {
7439d974b2aSGreg Kroah-Hartman struct device *idev = &interface->dev;
7441da177e4SLinus Torvalds struct usb_device *udev = interface_to_usbdev(interface);
74530da837aSJohan Hovold struct lego_usb_tower *dev;
746d9f0d82fSGreg Kroah-Hartman struct tower_get_version_reply get_version_reply;
7471da177e4SLinus Torvalds int retval = -ENOMEM;
7481da177e4SLinus Torvalds int result;
7491da177e4SLinus Torvalds
750093cf723SSteven Cole /* allocate memory for our device state and initialize it */
75130da837aSJohan Hovold dev = kzalloc(sizeof(*dev), GFP_KERNEL);
75249d8ffabSWolfram Sang if (!dev)
7531da177e4SLinus Torvalds goto exit;
7541da177e4SLinus Torvalds
75518bcbcfeSDaniel Walker mutex_init(&dev->lock);
756726b55d0SJohan Hovold dev->udev = usb_get_dev(udev);
7571da177e4SLinus Torvalds spin_lock_init(&dev->read_buffer_lock);
7588f7e9473SNicholas Mc Guire dev->packet_timeout_jiffies = msecs_to_jiffies(packet_timeout);
7591da177e4SLinus Torvalds dev->read_last_arrival = jiffies;
7601da177e4SLinus Torvalds init_waitqueue_head(&dev->read_wait);
7611da177e4SLinus Torvalds init_waitqueue_head(&dev->write_wait);
7621da177e4SLinus Torvalds
7639b181166SJohan Hovold result = usb_find_common_endpoints_reverse(interface->cur_altsetting,
7649b181166SJohan Hovold NULL, NULL,
7659b181166SJohan Hovold &dev->interrupt_in_endpoint,
7669b181166SJohan Hovold &dev->interrupt_out_endpoint);
7679b181166SJohan Hovold if (result) {
7689b181166SJohan Hovold dev_err(idev, "interrupt endpoints not found\n");
7699b181166SJohan Hovold retval = result;
7701da177e4SLinus Torvalds goto error;
7711da177e4SLinus Torvalds }
7721da177e4SLinus Torvalds
7731da177e4SLinus Torvalds dev->read_buffer = kmalloc(read_buffer_size, GFP_KERNEL);
77449d8ffabSWolfram Sang if (!dev->read_buffer)
7751da177e4SLinus Torvalds goto error;
77629cc8897SKuninori Morimoto dev->interrupt_in_buffer = kmalloc(usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);
77749d8ffabSWolfram Sang if (!dev->interrupt_in_buffer)
7781da177e4SLinus Torvalds goto error;
7791da177e4SLinus Torvalds dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
780a131f41fSWolfram Sang if (!dev->interrupt_in_urb)
7811da177e4SLinus Torvalds goto error;
7821da177e4SLinus Torvalds dev->interrupt_out_buffer = kmalloc(write_buffer_size, GFP_KERNEL);
78349d8ffabSWolfram Sang if (!dev->interrupt_out_buffer)
7841da177e4SLinus Torvalds goto error;
7851da177e4SLinus Torvalds dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
786a131f41fSWolfram Sang if (!dev->interrupt_out_urb)
7871da177e4SLinus Torvalds goto error;
7881da177e4SLinus Torvalds dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_endpoint->bInterval;
7891da177e4SLinus Torvalds dev->interrupt_out_interval = interrupt_out_interval ? interrupt_out_interval : dev->interrupt_out_endpoint->bInterval;
7901da177e4SLinus Torvalds
7911da177e4SLinus Torvalds /* get the firmware version and log it */
792d9f0d82fSGreg Kroah-Hartman result = usb_control_msg_recv(udev, 0,
7931da177e4SLinus Torvalds LEGO_USB_TOWER_REQUEST_GET_VERSION,
7941da177e4SLinus Torvalds USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
7951da177e4SLinus Torvalds 0,
7961da177e4SLinus Torvalds 0,
797d9f0d82fSGreg Kroah-Hartman &get_version_reply,
798d9f0d82fSGreg Kroah-Hartman sizeof(get_version_reply),
799d9f0d82fSGreg Kroah-Hartman 1000, GFP_KERNEL);
800b175d273SAlan Stern if (result) {
8011d427be4SJohan Hovold dev_err(idev, "get version request failed: %d\n", result);
8021da177e4SLinus Torvalds retval = result;
8031da177e4SLinus Torvalds goto error;
8041da177e4SLinus Torvalds }
805942a4873SMaksim Salau dev_info(&interface->dev,
806942a4873SMaksim Salau "LEGO USB Tower firmware version is %d.%d build %d\n",
807d9f0d82fSGreg Kroah-Hartman get_version_reply.major,
808d9f0d82fSGreg Kroah-Hartman get_version_reply.minor,
809d9f0d82fSGreg Kroah-Hartman le16_to_cpu(get_version_reply.build_no));
8101da177e4SLinus Torvalds
8112fae9e5aSGreg Kroah-Hartman /* we can register the device now, as it is ready */
8122fae9e5aSGreg Kroah-Hartman usb_set_intfdata(interface, dev);
8132fae9e5aSGreg Kroah-Hartman
8142fae9e5aSGreg Kroah-Hartman retval = usb_register_dev(interface, &tower_class);
8152fae9e5aSGreg Kroah-Hartman if (retval) {
8162fae9e5aSGreg Kroah-Hartman /* something prevented us from registering this driver */
8172fae9e5aSGreg Kroah-Hartman dev_err(idev, "Not able to get a minor for this device.\n");
8182fae9e5aSGreg Kroah-Hartman goto error;
8192fae9e5aSGreg Kroah-Hartman }
8202fae9e5aSGreg Kroah-Hartman dev->minor = interface->minor;
8212fae9e5aSGreg Kroah-Hartman
8222fae9e5aSGreg Kroah-Hartman /* let the user know what node this device is now attached to */
8232fae9e5aSGreg Kroah-Hartman dev_info(&interface->dev, "LEGO USB Tower #%d now attached to major "
8242fae9e5aSGreg Kroah-Hartman "%d minor %d\n", (dev->minor - LEGO_USB_TOWER_MINOR_BASE),
8252fae9e5aSGreg Kroah-Hartman USB_MAJOR, dev->minor);
8261da177e4SLinus Torvalds
8271da177e4SLinus Torvalds exit:
8281da177e4SLinus Torvalds return retval;
8291da177e4SLinus Torvalds
8301da177e4SLinus Torvalds error:
8311da177e4SLinus Torvalds tower_delete(dev);
8321da177e4SLinus Torvalds return retval;
8331da177e4SLinus Torvalds }
8341da177e4SLinus Torvalds
8351da177e4SLinus Torvalds
836464b7d0eSLee Jones /*
8371da177e4SLinus Torvalds * tower_disconnect
8381da177e4SLinus Torvalds *
8391da177e4SLinus Torvalds * Called by the usb core when the device is removed from the system.
8401da177e4SLinus Torvalds */
tower_disconnect(struct usb_interface * interface)8411da177e4SLinus Torvalds static void tower_disconnect(struct usb_interface *interface)
8421da177e4SLinus Torvalds {
8431da177e4SLinus Torvalds struct lego_usb_tower *dev;
8441da177e4SLinus Torvalds int minor;
8451da177e4SLinus Torvalds
8461da177e4SLinus Torvalds dev = usb_get_intfdata(interface);
8471da177e4SLinus Torvalds
8481da177e4SLinus Torvalds minor = dev->minor;
8491da177e4SLinus Torvalds
85033a78132SJohan Hovold /* give back our minor and prevent further open() */
8511da177e4SLinus Torvalds usb_deregister_dev(interface, &tower_class);
8521da177e4SLinus Torvalds
853cd81e6faSJohan Hovold /* stop I/O */
854cd81e6faSJohan Hovold usb_poison_urb(dev->interrupt_in_urb);
855cd81e6faSJohan Hovold usb_poison_urb(dev->interrupt_out_urb);
856cd81e6faSJohan Hovold
85718bcbcfeSDaniel Walker mutex_lock(&dev->lock);
858d4ead16fSAlan Stern
8591da177e4SLinus Torvalds /* if the device is not opened, then we clean up right now */
8601da177e4SLinus Torvalds if (!dev->open_count) {
86118bcbcfeSDaniel Walker mutex_unlock(&dev->lock);
8621da177e4SLinus Torvalds tower_delete(dev);
8631da177e4SLinus Torvalds } else {
864cd81e6faSJohan Hovold dev->disconnected = 1;
865d35b4ce1SOliver Neukum /* wake up pollers */
866d35b4ce1SOliver Neukum wake_up_interruptible_all(&dev->read_wait);
867d35b4ce1SOliver Neukum wake_up_interruptible_all(&dev->write_wait);
86818bcbcfeSDaniel Walker mutex_unlock(&dev->lock);
8691da177e4SLinus Torvalds }
8701da177e4SLinus Torvalds
8711b29a375SGreg Kroah-Hartman dev_info(&interface->dev, "LEGO USB Tower #%d now disconnected\n",
8721b29a375SGreg Kroah-Hartman (minor - LEGO_USB_TOWER_MINOR_BASE));
8731da177e4SLinus Torvalds }
8741da177e4SLinus Torvalds
87565db4305SGreg Kroah-Hartman module_usb_driver(tower_driver);
8761da177e4SLinus Torvalds
8771da177e4SLinus Torvalds MODULE_AUTHOR(DRIVER_AUTHOR);
8781da177e4SLinus Torvalds MODULE_DESCRIPTION(DRIVER_DESC);
8791da177e4SLinus Torvalds MODULE_LICENSE("GPL");
880