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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
79
80 #include <linux/kernel.h>
81 #include <linux/errno.h>
82 #include <linux/slab.h>
83 #include <linux/module.h>
84 #include <linux/completion.h>
85 #include <linux/mutex.h>
86 #include <asm/uaccess.h>
87 #include <linux/usb.h>
88 #include <linux/poll.h>
89
90
91 /* Version Information */
92 #define DRIVER_VERSION "v0.96"
93 #define DRIVER_AUTHOR "Juergen Stuber <starblue@sourceforge.net>"
94 #define DRIVER_DESC "LEGO USB Tower Driver"
95
96
97 /* The defaults are chosen to work with the latest versions of leJOS and NQC.
98 */
99
100 /* Some legacy software likes to receive packets in one piece.
101 * In this case read_buffer_size should exceed the maximal packet length
102 * (417 for datalog uploads), and packet_timeout should be set.
103 */
104 static int read_buffer_size = 480;
105 module_param(read_buffer_size, int, 0);
106 MODULE_PARM_DESC(read_buffer_size, "Read buffer size");
107
108 /* Some legacy software likes to send packets in one piece.
109 * In this case write_buffer_size should exceed the maximal packet length
110 * (417 for firmware and program downloads).
111 * A problem with long writes is that the following read may time out
112 * if the software is not prepared to wait long enough.
113 */
114 static int write_buffer_size = 480;
115 module_param(write_buffer_size, int, 0);
116 MODULE_PARM_DESC(write_buffer_size, "Write buffer size");
117
118 /* Some legacy software expects reads to contain whole LASM packets.
119 * To achieve this, characters which arrive before a packet timeout
120 * occurs will be returned in a single read operation.
121 * A problem with long reads is that the software may time out
122 * if it is not prepared to wait long enough.
123 * The packet timeout should be greater than the time between the
124 * reception of subsequent characters, which should arrive about
125 * every 5ms for the standard 2400 baud.
126 * Set it to 0 to disable.
127 */
128 static int packet_timeout = 50;
129 module_param(packet_timeout, int, 0);
130 MODULE_PARM_DESC(packet_timeout, "Packet timeout in ms");
131
132 /* Some legacy software expects blocking reads to time out.
133 * Timeout occurs after the specified time of read and write inactivity.
134 * Set it to 0 to disable.
135 */
136 static int read_timeout = 200;
137 module_param(read_timeout, int, 0);
138 MODULE_PARM_DESC(read_timeout, "Read timeout in ms");
139
140 /* As of kernel version 2.6.4 ehci-hcd uses an
141 * "only one interrupt transfer per frame" shortcut
142 * to simplify the scheduling of periodic transfers.
143 * This conflicts with our standard 1ms intervals for in and out URBs.
144 * We use default intervals of 2ms for in and 8ms for out transfers,
145 * which is fast enough for 2400 baud and allows a small additional load.
146 * Increase the interval to allow more devices that do interrupt transfers,
147 * or set to 0 to use the standard interval from the endpoint descriptors.
148 */
149 static int interrupt_in_interval = 2;
150 module_param(interrupt_in_interval, int, 0);
151 MODULE_PARM_DESC(interrupt_in_interval, "Interrupt in interval in ms");
152
153 static int interrupt_out_interval = 8;
154 module_param(interrupt_out_interval, int, 0);
155 MODULE_PARM_DESC(interrupt_out_interval, "Interrupt out interval in ms");
156
157 /* Define these values to match your device */
158 #define LEGO_USB_TOWER_VENDOR_ID 0x0694
159 #define LEGO_USB_TOWER_PRODUCT_ID 0x0001
160
161 /* Vendor requests */
162 #define LEGO_USB_TOWER_REQUEST_RESET 0x04
163 #define LEGO_USB_TOWER_REQUEST_GET_VERSION 0xFD
164
165 struct tower_reset_reply {
166 __le16 size; /* little-endian */
167 __u8 err_code;
168 __u8 spare;
169 } __attribute__ ((packed));
170
171 struct tower_get_version_reply {
172 __le16 size; /* little-endian */
173 __u8 err_code;
174 __u8 spare;
175 __u8 major;
176 __u8 minor;
177 __le16 build_no; /* little-endian */
178 } __attribute__ ((packed));
179
180
181 /* table of devices that work with this driver */
182 static const struct usb_device_id tower_table[] = {
183 { USB_DEVICE(LEGO_USB_TOWER_VENDOR_ID, LEGO_USB_TOWER_PRODUCT_ID) },
184 { } /* Terminating entry */
185 };
186
187 MODULE_DEVICE_TABLE (usb, tower_table);
188 static DEFINE_MUTEX(open_disc_mutex);
189
190 #define LEGO_USB_TOWER_MINOR_BASE 160
191
192
193 /* Structure to hold all of our device specific stuff */
194 struct lego_usb_tower {
195 struct mutex lock; /* locks this structure */
196 struct usb_device* udev; /* save off the usb device pointer */
197 unsigned char minor; /* the starting minor number for this device */
198
199 int open_count; /* number of times this port has been opened */
200
201 char* read_buffer;
202 size_t read_buffer_length; /* this much came in */
203 size_t read_packet_length; /* this much will be returned on read */
204 spinlock_t read_buffer_lock;
205 int packet_timeout_jiffies;
206 unsigned long read_last_arrival;
207
208 wait_queue_head_t read_wait;
209 wait_queue_head_t write_wait;
210
211 char* interrupt_in_buffer;
212 struct usb_endpoint_descriptor* interrupt_in_endpoint;
213 struct urb* interrupt_in_urb;
214 int interrupt_in_interval;
215 int interrupt_in_running;
216 int interrupt_in_done;
217
218 char* interrupt_out_buffer;
219 struct usb_endpoint_descriptor* interrupt_out_endpoint;
220 struct urb* interrupt_out_urb;
221 int interrupt_out_interval;
222 int interrupt_out_busy;
223
224 };
225
226
227 /* local function prototypes */
228 static ssize_t tower_read (struct file *file, char __user *buffer, size_t count, loff_t *ppos);
229 static ssize_t tower_write (struct file *file, const char __user *buffer, size_t count, loff_t *ppos);
230 static inline void tower_delete (struct lego_usb_tower *dev);
231 static int tower_open (struct inode *inode, struct file *file);
232 static int tower_release (struct inode *inode, struct file *file);
233 static unsigned int tower_poll (struct file *file, poll_table *wait);
234 static loff_t tower_llseek (struct file *file, loff_t off, int whence);
235
236 static void tower_abort_transfers (struct lego_usb_tower *dev);
237 static void tower_check_for_read_packet (struct lego_usb_tower *dev);
238 static void tower_interrupt_in_callback (struct urb *urb);
239 static void tower_interrupt_out_callback (struct urb *urb);
240
241 static int tower_probe (struct usb_interface *interface, const struct usb_device_id *id);
242 static void tower_disconnect (struct usb_interface *interface);
243
244
245 /* file operations needed when we register this driver */
246 static const struct file_operations tower_fops = {
247 .owner = THIS_MODULE,
248 .read = tower_read,
249 .write = tower_write,
250 .open = tower_open,
251 .release = tower_release,
252 .poll = tower_poll,
253 .llseek = tower_llseek,
254 };
255
legousbtower_devnode(struct device * dev,umode_t * mode)256 static char *legousbtower_devnode(struct device *dev, umode_t *mode)
257 {
258 return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
259 }
260
261 /*
262 * usb class driver info in order to get a minor number from the usb core,
263 * and to have the device registered with the driver core
264 */
265 static struct usb_class_driver tower_class = {
266 .name = "legousbtower%d",
267 .devnode = legousbtower_devnode,
268 .fops = &tower_fops,
269 .minor_base = LEGO_USB_TOWER_MINOR_BASE,
270 };
271
272
273 /* usb specific object needed to register this driver with the usb subsystem */
274 static struct usb_driver tower_driver = {
275 .name = "legousbtower",
276 .probe = tower_probe,
277 .disconnect = tower_disconnect,
278 .id_table = tower_table,
279 };
280
281
282 /**
283 * lego_usb_tower_debug_data
284 */
lego_usb_tower_debug_data(struct device * dev,const char * function,int size,const unsigned char * data)285 static inline void lego_usb_tower_debug_data(struct device *dev,
286 const char *function, int size,
287 const unsigned char *data)
288 {
289 dev_dbg(dev, "%s - length = %d, data = %*ph\n",
290 function, size, size, data);
291 }
292
293
294 /**
295 * tower_delete
296 */
tower_delete(struct lego_usb_tower * dev)297 static inline void tower_delete (struct lego_usb_tower *dev)
298 {
299 tower_abort_transfers (dev);
300
301 /* free data structures */
302 usb_free_urb(dev->interrupt_in_urb);
303 usb_free_urb(dev->interrupt_out_urb);
304 kfree (dev->read_buffer);
305 kfree (dev->interrupt_in_buffer);
306 kfree (dev->interrupt_out_buffer);
307 kfree (dev);
308 }
309
310
311 /**
312 * tower_open
313 */
tower_open(struct inode * inode,struct file * file)314 static int tower_open (struct inode *inode, struct file *file)
315 {
316 struct lego_usb_tower *dev = NULL;
317 int subminor;
318 int retval = 0;
319 struct usb_interface *interface;
320 struct tower_reset_reply *reset_reply;
321 int result;
322
323 reset_reply = kmalloc(sizeof(*reset_reply), GFP_KERNEL);
324
325 if (!reset_reply) {
326 retval = -ENOMEM;
327 goto exit;
328 }
329
330 nonseekable_open(inode, file);
331 subminor = iminor(inode);
332
333 interface = usb_find_interface (&tower_driver, subminor);
334
335 if (!interface) {
336 pr_err("error, can't find device for minor %d\n", subminor);
337 retval = -ENODEV;
338 goto exit;
339 }
340
341 mutex_lock(&open_disc_mutex);
342 dev = usb_get_intfdata(interface);
343
344 if (!dev) {
345 mutex_unlock(&open_disc_mutex);
346 retval = -ENODEV;
347 goto exit;
348 }
349
350 /* lock this device */
351 if (mutex_lock_interruptible(&dev->lock)) {
352 mutex_unlock(&open_disc_mutex);
353 retval = -ERESTARTSYS;
354 goto exit;
355 }
356
357
358 /* allow opening only once */
359 if (dev->open_count) {
360 mutex_unlock(&open_disc_mutex);
361 retval = -EBUSY;
362 goto unlock_exit;
363 }
364 dev->open_count = 1;
365 mutex_unlock(&open_disc_mutex);
366
367 /* reset the tower */
368 result = usb_control_msg (dev->udev,
369 usb_rcvctrlpipe(dev->udev, 0),
370 LEGO_USB_TOWER_REQUEST_RESET,
371 USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
372 0,
373 0,
374 reset_reply,
375 sizeof(*reset_reply),
376 1000);
377 if (result < 0) {
378 dev_err(&dev->udev->dev,
379 "LEGO USB Tower reset control request failed\n");
380 retval = result;
381 goto unlock_exit;
382 }
383
384 /* initialize in direction */
385 dev->read_buffer_length = 0;
386 dev->read_packet_length = 0;
387 usb_fill_int_urb (dev->interrupt_in_urb,
388 dev->udev,
389 usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),
390 dev->interrupt_in_buffer,
391 usb_endpoint_maxp(dev->interrupt_in_endpoint),
392 tower_interrupt_in_callback,
393 dev,
394 dev->interrupt_in_interval);
395
396 dev->interrupt_in_running = 1;
397 dev->interrupt_in_done = 0;
398 mb();
399
400 retval = usb_submit_urb (dev->interrupt_in_urb, GFP_KERNEL);
401 if (retval) {
402 dev_err(&dev->udev->dev,
403 "Couldn't submit interrupt_in_urb %d\n", retval);
404 dev->interrupt_in_running = 0;
405 dev->open_count = 0;
406 goto unlock_exit;
407 }
408
409 /* save device in the file's private structure */
410 file->private_data = dev;
411
412 unlock_exit:
413 mutex_unlock(&dev->lock);
414
415 exit:
416 kfree(reset_reply);
417 return retval;
418 }
419
420 /**
421 * tower_release
422 */
tower_release(struct inode * inode,struct file * file)423 static int tower_release (struct inode *inode, struct file *file)
424 {
425 struct lego_usb_tower *dev;
426 int retval = 0;
427
428 dev = file->private_data;
429
430 if (dev == NULL) {
431 retval = -ENODEV;
432 goto exit_nolock;
433 }
434
435 mutex_lock(&open_disc_mutex);
436 if (mutex_lock_interruptible(&dev->lock)) {
437 retval = -ERESTARTSYS;
438 goto exit;
439 }
440
441 if (dev->open_count != 1) {
442 dev_dbg(&dev->udev->dev, "%s: device not opened exactly once\n",
443 __func__);
444 retval = -ENODEV;
445 goto unlock_exit;
446 }
447 if (dev->udev == NULL) {
448 /* the device was unplugged before the file was released */
449
450 /* unlock here as tower_delete frees dev */
451 mutex_unlock(&dev->lock);
452 tower_delete (dev);
453 goto exit;
454 }
455
456 /* wait until write transfer is finished */
457 if (dev->interrupt_out_busy) {
458 wait_event_interruptible_timeout (dev->write_wait, !dev->interrupt_out_busy, 2 * HZ);
459 }
460 tower_abort_transfers (dev);
461 dev->open_count = 0;
462
463 unlock_exit:
464 mutex_unlock(&dev->lock);
465
466 exit:
467 mutex_unlock(&open_disc_mutex);
468 exit_nolock:
469 return retval;
470 }
471
472
473 /**
474 * tower_abort_transfers
475 * aborts transfers and frees associated data structures
476 */
tower_abort_transfers(struct lego_usb_tower * dev)477 static void tower_abort_transfers (struct lego_usb_tower *dev)
478 {
479 if (dev == NULL)
480 return;
481
482 /* shutdown transfer */
483 if (dev->interrupt_in_running) {
484 dev->interrupt_in_running = 0;
485 mb();
486 if (dev->udev)
487 usb_kill_urb (dev->interrupt_in_urb);
488 }
489 if (dev->interrupt_out_busy && dev->udev)
490 usb_kill_urb(dev->interrupt_out_urb);
491 }
492
493
494 /**
495 * tower_check_for_read_packet
496 *
497 * To get correct semantics for signals and non-blocking I/O
498 * with packetizing we pretend not to see any data in the read buffer
499 * until it has been there unchanged for at least
500 * dev->packet_timeout_jiffies, or until the buffer is full.
501 */
tower_check_for_read_packet(struct lego_usb_tower * dev)502 static void tower_check_for_read_packet (struct lego_usb_tower *dev)
503 {
504 spin_lock_irq (&dev->read_buffer_lock);
505 if (!packet_timeout
506 || time_after(jiffies, dev->read_last_arrival + dev->packet_timeout_jiffies)
507 || dev->read_buffer_length == read_buffer_size) {
508 dev->read_packet_length = dev->read_buffer_length;
509 }
510 dev->interrupt_in_done = 0;
511 spin_unlock_irq (&dev->read_buffer_lock);
512 }
513
514
515 /**
516 * tower_poll
517 */
tower_poll(struct file * file,poll_table * wait)518 static unsigned int tower_poll (struct file *file, poll_table *wait)
519 {
520 struct lego_usb_tower *dev;
521 unsigned int mask = 0;
522
523 dev = file->private_data;
524
525 if (!dev->udev)
526 return POLLERR | POLLHUP;
527
528 poll_wait(file, &dev->read_wait, wait);
529 poll_wait(file, &dev->write_wait, wait);
530
531 tower_check_for_read_packet(dev);
532 if (dev->read_packet_length > 0) {
533 mask |= POLLIN | POLLRDNORM;
534 }
535 if (!dev->interrupt_out_busy) {
536 mask |= POLLOUT | POLLWRNORM;
537 }
538
539 return mask;
540 }
541
542
543 /**
544 * tower_llseek
545 */
tower_llseek(struct file * file,loff_t off,int whence)546 static loff_t tower_llseek (struct file *file, loff_t off, int whence)
547 {
548 return -ESPIPE; /* unseekable */
549 }
550
551
552 /**
553 * tower_read
554 */
tower_read(struct file * file,char __user * buffer,size_t count,loff_t * ppos)555 static ssize_t tower_read (struct file *file, char __user *buffer, size_t count, loff_t *ppos)
556 {
557 struct lego_usb_tower *dev;
558 size_t bytes_to_read;
559 int i;
560 int retval = 0;
561 unsigned long timeout = 0;
562
563 dev = file->private_data;
564
565 /* lock this object */
566 if (mutex_lock_interruptible(&dev->lock)) {
567 retval = -ERESTARTSYS;
568 goto exit;
569 }
570
571 /* verify that the device wasn't unplugged */
572 if (dev->udev == NULL) {
573 retval = -ENODEV;
574 pr_err("No device or device unplugged %d\n", retval);
575 goto unlock_exit;
576 }
577
578 /* verify that we actually have some data to read */
579 if (count == 0) {
580 dev_dbg(&dev->udev->dev, "read request of 0 bytes\n");
581 goto unlock_exit;
582 }
583
584 if (read_timeout) {
585 timeout = jiffies + msecs_to_jiffies(read_timeout);
586 }
587
588 /* wait for data */
589 tower_check_for_read_packet (dev);
590 while (dev->read_packet_length == 0) {
591 if (file->f_flags & O_NONBLOCK) {
592 retval = -EAGAIN;
593 goto unlock_exit;
594 }
595 retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_timeout_jiffies);
596 if (retval < 0) {
597 goto unlock_exit;
598 }
599
600 /* reset read timeout during read or write activity */
601 if (read_timeout
602 && (dev->read_buffer_length || dev->interrupt_out_busy)) {
603 timeout = jiffies + msecs_to_jiffies(read_timeout);
604 }
605 /* check for read timeout */
606 if (read_timeout && time_after (jiffies, timeout)) {
607 retval = -ETIMEDOUT;
608 goto unlock_exit;
609 }
610 tower_check_for_read_packet (dev);
611 }
612
613 /* copy the data from read_buffer into userspace */
614 bytes_to_read = min(count, dev->read_packet_length);
615
616 if (copy_to_user (buffer, dev->read_buffer, bytes_to_read)) {
617 retval = -EFAULT;
618 goto unlock_exit;
619 }
620
621 spin_lock_irq (&dev->read_buffer_lock);
622 dev->read_buffer_length -= bytes_to_read;
623 dev->read_packet_length -= bytes_to_read;
624 for (i=0; i<dev->read_buffer_length; i++) {
625 dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];
626 }
627 spin_unlock_irq (&dev->read_buffer_lock);
628
629 retval = bytes_to_read;
630
631 unlock_exit:
632 /* unlock the device */
633 mutex_unlock(&dev->lock);
634
635 exit:
636 return retval;
637 }
638
639
640 /**
641 * tower_write
642 */
tower_write(struct file * file,const char __user * buffer,size_t count,loff_t * ppos)643 static ssize_t tower_write (struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
644 {
645 struct lego_usb_tower *dev;
646 size_t bytes_to_write;
647 int retval = 0;
648
649 dev = file->private_data;
650
651 /* lock this object */
652 if (mutex_lock_interruptible(&dev->lock)) {
653 retval = -ERESTARTSYS;
654 goto exit;
655 }
656
657 /* verify that the device wasn't unplugged */
658 if (dev->udev == NULL) {
659 retval = -ENODEV;
660 pr_err("No device or device unplugged %d\n", retval);
661 goto unlock_exit;
662 }
663
664 /* verify that we actually have some data to write */
665 if (count == 0) {
666 dev_dbg(&dev->udev->dev, "write request of 0 bytes\n");
667 goto unlock_exit;
668 }
669
670 /* wait until previous transfer is finished */
671 while (dev->interrupt_out_busy) {
672 if (file->f_flags & O_NONBLOCK) {
673 retval = -EAGAIN;
674 goto unlock_exit;
675 }
676 retval = wait_event_interruptible (dev->write_wait, !dev->interrupt_out_busy);
677 if (retval) {
678 goto unlock_exit;
679 }
680 }
681
682 /* write the data into interrupt_out_buffer from userspace */
683 bytes_to_write = min_t(int, count, write_buffer_size);
684 dev_dbg(&dev->udev->dev, "%s: count = %Zd, bytes_to_write = %Zd\n",
685 __func__, count, bytes_to_write);
686
687 if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {
688 retval = -EFAULT;
689 goto unlock_exit;
690 }
691
692 /* send off the urb */
693 usb_fill_int_urb(dev->interrupt_out_urb,
694 dev->udev,
695 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),
696 dev->interrupt_out_buffer,
697 bytes_to_write,
698 tower_interrupt_out_callback,
699 dev,
700 dev->interrupt_out_interval);
701
702 dev->interrupt_out_busy = 1;
703 wmb();
704
705 retval = usb_submit_urb (dev->interrupt_out_urb, GFP_KERNEL);
706 if (retval) {
707 dev->interrupt_out_busy = 0;
708 dev_err(&dev->udev->dev,
709 "Couldn't submit interrupt_out_urb %d\n", retval);
710 goto unlock_exit;
711 }
712 retval = bytes_to_write;
713
714 unlock_exit:
715 /* unlock the device */
716 mutex_unlock(&dev->lock);
717
718 exit:
719 return retval;
720 }
721
722
723 /**
724 * tower_interrupt_in_callback
725 */
tower_interrupt_in_callback(struct urb * urb)726 static void tower_interrupt_in_callback (struct urb *urb)
727 {
728 struct lego_usb_tower *dev = urb->context;
729 int status = urb->status;
730 int retval;
731
732 lego_usb_tower_debug_data(&dev->udev->dev, __func__,
733 urb->actual_length, urb->transfer_buffer);
734
735 if (status) {
736 if (status == -ENOENT ||
737 status == -ECONNRESET ||
738 status == -ESHUTDOWN) {
739 goto exit;
740 } else {
741 dev_dbg(&dev->udev->dev,
742 "%s: nonzero status received: %d\n", __func__,
743 status);
744 goto resubmit; /* maybe we can recover */
745 }
746 }
747
748 if (urb->actual_length > 0) {
749 spin_lock (&dev->read_buffer_lock);
750 if (dev->read_buffer_length + urb->actual_length < read_buffer_size) {
751 memcpy (dev->read_buffer + dev->read_buffer_length,
752 dev->interrupt_in_buffer,
753 urb->actual_length);
754 dev->read_buffer_length += urb->actual_length;
755 dev->read_last_arrival = jiffies;
756 dev_dbg(&dev->udev->dev, "%s: received %d bytes\n",
757 __func__, urb->actual_length);
758 } else {
759 pr_warn("read_buffer overflow, %d bytes dropped\n",
760 urb->actual_length);
761 }
762 spin_unlock (&dev->read_buffer_lock);
763 }
764
765 resubmit:
766 /* resubmit if we're still running */
767 if (dev->interrupt_in_running && dev->udev) {
768 retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
769 if (retval)
770 dev_err(&dev->udev->dev,
771 "%s: usb_submit_urb failed (%d)\n",
772 __func__, retval);
773 }
774
775 exit:
776 dev->interrupt_in_done = 1;
777 wake_up_interruptible (&dev->read_wait);
778 }
779
780
781 /**
782 * tower_interrupt_out_callback
783 */
tower_interrupt_out_callback(struct urb * urb)784 static void tower_interrupt_out_callback (struct urb *urb)
785 {
786 struct lego_usb_tower *dev = urb->context;
787 int status = urb->status;
788
789 lego_usb_tower_debug_data(&dev->udev->dev, __func__,
790 urb->actual_length, urb->transfer_buffer);
791
792 /* sync/async unlink faults aren't errors */
793 if (status && !(status == -ENOENT ||
794 status == -ECONNRESET ||
795 status == -ESHUTDOWN)) {
796 dev_dbg(&dev->udev->dev,
797 "%s: nonzero write bulk status received: %d\n", __func__,
798 status);
799 }
800
801 dev->interrupt_out_busy = 0;
802 wake_up_interruptible(&dev->write_wait);
803 }
804
805
806 /**
807 * tower_probe
808 *
809 * Called by the usb core when a new device is connected that it thinks
810 * this driver might be interested in.
811 */
tower_probe(struct usb_interface * interface,const struct usb_device_id * id)812 static int tower_probe (struct usb_interface *interface, const struct usb_device_id *id)
813 {
814 struct device *idev = &interface->dev;
815 struct usb_device *udev = interface_to_usbdev(interface);
816 struct lego_usb_tower *dev = NULL;
817 struct usb_host_interface *iface_desc;
818 struct usb_endpoint_descriptor* endpoint;
819 struct tower_get_version_reply *get_version_reply = NULL;
820 int i;
821 int retval = -ENOMEM;
822 int result;
823
824 /* allocate memory for our device state and initialize it */
825
826 dev = kmalloc (sizeof(struct lego_usb_tower), GFP_KERNEL);
827
828 if (!dev)
829 goto exit;
830
831 mutex_init(&dev->lock);
832
833 dev->udev = udev;
834 dev->open_count = 0;
835
836 dev->read_buffer = NULL;
837 dev->read_buffer_length = 0;
838 dev->read_packet_length = 0;
839 spin_lock_init (&dev->read_buffer_lock);
840 dev->packet_timeout_jiffies = msecs_to_jiffies(packet_timeout);
841 dev->read_last_arrival = jiffies;
842
843 init_waitqueue_head (&dev->read_wait);
844 init_waitqueue_head (&dev->write_wait);
845
846 dev->interrupt_in_buffer = NULL;
847 dev->interrupt_in_endpoint = NULL;
848 dev->interrupt_in_urb = NULL;
849 dev->interrupt_in_running = 0;
850 dev->interrupt_in_done = 0;
851
852 dev->interrupt_out_buffer = NULL;
853 dev->interrupt_out_endpoint = NULL;
854 dev->interrupt_out_urb = NULL;
855 dev->interrupt_out_busy = 0;
856
857 iface_desc = interface->cur_altsetting;
858
859 /* set up the endpoint information */
860 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
861 endpoint = &iface_desc->endpoint[i].desc;
862
863 if (usb_endpoint_xfer_int(endpoint)) {
864 if (usb_endpoint_dir_in(endpoint))
865 dev->interrupt_in_endpoint = endpoint;
866 else
867 dev->interrupt_out_endpoint = endpoint;
868 }
869 }
870 if(dev->interrupt_in_endpoint == NULL) {
871 dev_err(idev, "interrupt in endpoint not found\n");
872 goto error;
873 }
874 if (dev->interrupt_out_endpoint == NULL) {
875 dev_err(idev, "interrupt out endpoint not found\n");
876 goto error;
877 }
878
879 dev->read_buffer = kmalloc (read_buffer_size, GFP_KERNEL);
880 if (!dev->read_buffer)
881 goto error;
882 dev->interrupt_in_buffer = kmalloc (usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);
883 if (!dev->interrupt_in_buffer)
884 goto error;
885 dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
886 if (!dev->interrupt_in_urb)
887 goto error;
888 dev->interrupt_out_buffer = kmalloc (write_buffer_size, GFP_KERNEL);
889 if (!dev->interrupt_out_buffer)
890 goto error;
891 dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
892 if (!dev->interrupt_out_urb)
893 goto error;
894 dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_endpoint->bInterval;
895 dev->interrupt_out_interval = interrupt_out_interval ? interrupt_out_interval : dev->interrupt_out_endpoint->bInterval;
896
897 get_version_reply = kmalloc(sizeof(*get_version_reply), GFP_KERNEL);
898
899 if (!get_version_reply) {
900 retval = -ENOMEM;
901 goto error;
902 }
903
904 /* get the firmware version and log it */
905 result = usb_control_msg (udev,
906 usb_rcvctrlpipe(udev, 0),
907 LEGO_USB_TOWER_REQUEST_GET_VERSION,
908 USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
909 0,
910 0,
911 get_version_reply,
912 sizeof(*get_version_reply),
913 1000);
914 if (result < 0) {
915 dev_err(idev, "LEGO USB Tower get version control request failed\n");
916 retval = result;
917 goto error;
918 }
919 dev_info(&interface->dev,
920 "LEGO USB Tower firmware version is %d.%d build %d\n",
921 get_version_reply->major,
922 get_version_reply->minor,
923 le16_to_cpu(get_version_reply->build_no));
924
925 /* we can register the device now, as it is ready */
926 usb_set_intfdata (interface, dev);
927
928 retval = usb_register_dev (interface, &tower_class);
929
930 if (retval) {
931 /* something prevented us from registering this driver */
932 dev_err(idev, "Not able to get a minor for this device.\n");
933 usb_set_intfdata (interface, NULL);
934 goto error;
935 }
936 dev->minor = interface->minor;
937
938 /* let the user know what node this device is now attached to */
939 dev_info(&interface->dev, "LEGO USB Tower #%d now attached to major "
940 "%d minor %d\n", (dev->minor - LEGO_USB_TOWER_MINOR_BASE),
941 USB_MAJOR, dev->minor);
942
943 exit:
944 kfree(get_version_reply);
945 return retval;
946
947 error:
948 kfree(get_version_reply);
949 tower_delete(dev);
950 return retval;
951 }
952
953
954 /**
955 * tower_disconnect
956 *
957 * Called by the usb core when the device is removed from the system.
958 */
tower_disconnect(struct usb_interface * interface)959 static void tower_disconnect (struct usb_interface *interface)
960 {
961 struct lego_usb_tower *dev;
962 int minor;
963
964 dev = usb_get_intfdata (interface);
965 mutex_lock(&open_disc_mutex);
966 usb_set_intfdata (interface, NULL);
967
968 minor = dev->minor;
969
970 /* give back our minor */
971 usb_deregister_dev (interface, &tower_class);
972
973 mutex_lock(&dev->lock);
974 mutex_unlock(&open_disc_mutex);
975
976 /* if the device is not opened, then we clean up right now */
977 if (!dev->open_count) {
978 mutex_unlock(&dev->lock);
979 tower_delete (dev);
980 } else {
981 dev->udev = NULL;
982 /* wake up pollers */
983 wake_up_interruptible_all(&dev->read_wait);
984 wake_up_interruptible_all(&dev->write_wait);
985 mutex_unlock(&dev->lock);
986 }
987
988 dev_info(&interface->dev, "LEGO USB Tower #%d now disconnected\n",
989 (minor - LEGO_USB_TOWER_MINOR_BASE));
990 }
991
992 module_usb_driver(tower_driver);
993
994 MODULE_AUTHOR(DRIVER_AUTHOR);
995 MODULE_DESCRIPTION(DRIVER_DESC);
996 #ifdef MODULE_LICENSE
997 MODULE_LICENSE("GPL");
998 #endif
999