1 // SPDX-License-Identifier: GPL-2.0+
6  *               2001-2004 Juergen Stuber <starblue@users.sourceforge.net>
8  * derived from USB Skeleton driver - 0.5
9  * Copyright (C) 2001 Greg Kroah-Hartman (greg@kroah.com)
13  * 2001-10-13 - 0.1 js
14  *   - first version
15  * 2001-11-03 - 0.2 js
16  *   - simplified buffering, one-shot URBs for writing
17  * 2001-11-10 - 0.3 js
18  *   - removed IOCTL (setting power/mode is more complicated, postponed)
19  * 2001-11-28 - 0.4 js
20  *   - added vendor commands for mode of operation and power level in open
21  * 2001-12-04 - 0.5 js
22  *   - set IR mode by default (by oversight 0.4 set VLL mode)
23  * 2002-01-11 - 0.5? pcchan
24  *   - make read buffer reusable and work around bytes_to_write issue between
26  * 2002-09-23 - 0.52 david (david@csse.uwa.edu.au)
27  *   - imported into lejos project
28  *   - changed wake_up to wake_up_interruptible
29  *   - changed to use lego0 rather than tower0
30  *   - changed dbg() to use __func__ rather than deprecated __func__
31  * 2003-01-12 - 0.53 david (david@csse.uwa.edu.au)
32  *   - changed read and write to write everything or
33  *     timeout (from a patch by Chris Riesen and Brett Thaeler driver)
34  *   - added ioctl functionality to set timeouts
35  * 2003-07-18 - 0.54 davidgsf (david@csse.uwa.edu.au)
36  *   - initial import into LegoUSB project
37  *   - merge of existing LegoUSB.c driver
38  * 2003-07-18 - 0.56 davidgsf (david@csse.uwa.edu.au)
39  *   - port to 2.6 style driver
40  * 2004-02-29 - 0.6 Juergen Stuber <starblue@users.sourceforge.net>
41  *   - fix locking
42  *   - unlink read URBs which are no longer needed
43  *   - allow increased buffer size, eliminates need for timeout on write
44  *   - have read URB running continuously
45  *   - added poll
46  *   - forbid seeking
47  *   - added nonblocking I/O
48  *   - changed back __func__ to __func__
49  *   - read and log tower firmware version
50  *   - reset tower on probe, avoids failure of first write
51  * 2004-03-09 - 0.7 Juergen Stuber <starblue@users.sourceforge.net>
52  *   - timeout read now only after inactivity, shorten default accordingly
53  * 2004-03-11 - 0.8 Juergen Stuber <starblue@users.sourceforge.net>
54  *   - log major, minor instead of possibly confusing device filename
55  *   - whitespace cleanup
56  * 2004-03-12 - 0.9 Juergen Stuber <starblue@users.sourceforge.net>
57  *   - normalize whitespace in debug messages
58  *   - take care about endianness in control message responses
59  * 2004-03-13 - 0.91 Juergen Stuber <starblue@users.sourceforge.net>
60  *   - make default intervals longer to accommodate current EHCI driver
61  * 2004-03-19 - 0.92 Juergen Stuber <starblue@users.sourceforge.net>
62  *   - replaced atomic_t by memory barriers
63  * 2004-04-21 - 0.93 Juergen Stuber <starblue@users.sourceforge.net>
64  *   - wait for completion of write urb in release (needed for remotecontrol)
65  *   - corrected poll for write direction (missing negation)
66  * 2004-04-22 - 0.94 Juergen Stuber <starblue@users.sourceforge.net>
67  *   - make device locking interruptible
68  * 2004-04-30 - 0.95 Juergen Stuber <starblue@users.sourceforge.net>
69  *   - check for valid udev on resubmitting and unlinking urbs
70  * 2004-08-03 - 0.96 Juergen Stuber <starblue@users.sourceforge.net>
71  *   - move reset into open to clean out spurious data
84 #include <linux/poll.h>
113  * To achieve this, characters which arrive before a packet timeout
117  * The packet timeout should be greater than the time between the
119  * every 5ms for the standard 2400 baud.
124 MODULE_PARM_DESC(packet_timeout, "Packet timeout in ms");
127  * Timeout occurs after the specified time of read and write inactivity.
132 MODULE_PARM_DESC(read_timeout, "Read timeout in ms");
134 /* As of kernel version 2.6.4 ehci-hcd uses an
137  * This conflicts with our standard 1ms intervals for in and out URBs.
138  * We use default intervals of 2ms for in and 8ms for out transfers,
145 MODULE_PARM_DESC(interrupt_in_interval, "Interrupt in interval in ms");
149 MODULE_PARM_DESC(interrupt_out_interval, "Interrupt out interval in ms");
244 	.poll =		tower_poll,
281 	dev_dbg(dev, "%s - length = %d, data = %*ph\n",  in lego_usb_tower_debug_data()
292 	usb_free_urb(dev->interrupt_in_urb);  in tower_delete()
293 	usb_free_urb(dev->interrupt_out_urb);  in tower_delete()
294 	kfree(dev->read_buffer);  in tower_delete()
295 	kfree(dev->interrupt_in_buffer);  in tower_delete()
296 	kfree(dev->interrupt_out_buffer);  in tower_delete()
297 	usb_put_dev(dev->udev);  in tower_delete()
320 		retval = -ENODEV;  in tower_open()
326 		retval = -ENODEV;  in tower_open()
331 	if (mutex_lock_interruptible(&dev->lock)) {  in tower_open()
332 	        retval = -ERESTARTSYS;  in tower_open()
338 	if (dev->open_count) {  in tower_open()
339 		retval = -EBUSY;  in tower_open()
344 	result = usb_control_msg_recv(dev->udev, 0,  in tower_open()
351 		dev_err(&dev->udev->dev,  in tower_open()
358 	dev->read_buffer_length = 0;  in tower_open()
359 	dev->read_packet_length = 0;  in tower_open()
360 	usb_fill_int_urb(dev->interrupt_in_urb,  in tower_open()
361 			 dev->udev,  in tower_open()
362 			 usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),  in tower_open()
363 			 dev->interrupt_in_buffer,  in tower_open()
364 			 usb_endpoint_maxp(dev->interrupt_in_endpoint),  in tower_open()
367 			 dev->interrupt_in_interval);  in tower_open()
369 	dev->interrupt_in_done = 0;  in tower_open()
372 	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL);  in tower_open()
374 		dev_err(&dev->udev->dev,  in tower_open()
380 	file->private_data = dev;  in tower_open()
382 	dev->open_count = 1;  in tower_open()
385 	mutex_unlock(&dev->lock);  in tower_open()
399 	dev = file->private_data;  in tower_release()
401 		retval = -ENODEV;  in tower_release()
405 	mutex_lock(&dev->lock);  in tower_release()
407 	if (dev->disconnected) {  in tower_release()
411 		mutex_unlock(&dev->lock);  in tower_release()
417 	if (dev->interrupt_out_busy) {  in tower_release()
418 		wait_event_interruptible_timeout(dev->write_wait, !dev->interrupt_out_busy,  in tower_release()
423 	usb_kill_urb(dev->interrupt_in_urb);  in tower_release()
424 	usb_kill_urb(dev->interrupt_out_urb);  in tower_release()
426 	dev->open_count = 0;  in tower_release()
428 	mutex_unlock(&dev->lock);  in tower_release()
436  *      To get correct semantics for signals and non-blocking I/O
439  *      dev->packet_timeout_jiffies, or until the buffer is full.
443 	spin_lock_irq(&dev->read_buffer_lock);  in tower_check_for_read_packet()
445 	    || time_after(jiffies, dev->read_last_arrival + dev->packet_timeout_jiffies)  in tower_check_for_read_packet()
446 	    || dev->read_buffer_length == read_buffer_size) {  in tower_check_for_read_packet()
447 		dev->read_packet_length = dev->read_buffer_length;  in tower_check_for_read_packet()
449 	dev->interrupt_in_done = 0;  in tower_check_for_read_packet()
450 	spin_unlock_irq(&dev->read_buffer_lock);  in tower_check_for_read_packet()
462 	dev = file->private_data;  in tower_poll()
464 	if (dev->disconnected)  in tower_poll()
467 	poll_wait(file, &dev->read_wait, wait);  in tower_poll()
468 	poll_wait(file, &dev->write_wait, wait);  in tower_poll()
471 	if (dev->read_packet_length > 0)  in tower_poll()
473 	if (!dev->interrupt_out_busy)  in tower_poll()
485 	return -ESPIPE;		/* unseekable */  in tower_llseek()
498 	unsigned long timeout = 0;  in tower_read()  local
500 	dev = file->private_data;  in tower_read()
503 	if (mutex_lock_interruptible(&dev->lock)) {  in tower_read()
504 		retval = -ERESTARTSYS;  in tower_read()
509 	if (dev->disconnected) {  in tower_read()
510 		retval = -ENODEV;  in tower_read()
516 		dev_dbg(&dev->udev->dev, "read request of 0 bytes\n");  in tower_read()
521 		timeout = jiffies + msecs_to_jiffies(read_timeout);  in tower_read()
525 	while (dev->read_packet_length == 0) {  in tower_read()
526 		if (file->f_flags & O_NONBLOCK) {  in tower_read()
527 			retval = -EAGAIN;  in tower_read()
530 …retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_time…  in tower_read()
534 		/* reset read timeout during read or write activity */  in tower_read()
536 		    && (dev->read_buffer_length || dev->interrupt_out_busy)) {  in tower_read()
537 			timeout = jiffies + msecs_to_jiffies(read_timeout);  in tower_read()
539 		/* check for read timeout */  in tower_read()
540 		if (read_timeout && time_after(jiffies, timeout)) {  in tower_read()
541 			retval = -ETIMEDOUT;  in tower_read()
548 	bytes_to_read = min(count, dev->read_packet_length);  in tower_read()
550 	if (copy_to_user(buffer, dev->read_buffer, bytes_to_read)) {  in tower_read()
551 		retval = -EFAULT;  in tower_read()
555 	spin_lock_irq(&dev->read_buffer_lock);  in tower_read()
556 	dev->read_buffer_length -= bytes_to_read;  in tower_read()
557 	dev->read_packet_length -= bytes_to_read;  in tower_read()
558 	for (i = 0; i < dev->read_buffer_length; i++)  in tower_read()
559 		dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];  in tower_read()
560 	spin_unlock_irq(&dev->read_buffer_lock);  in tower_read()
566 	mutex_unlock(&dev->lock);  in tower_read()
582 	dev = file->private_data;  in tower_write()
585 	if (mutex_lock_interruptible(&dev->lock)) {  in tower_write()
586 		retval = -ERESTARTSYS;  in tower_write()
591 	if (dev->disconnected) {  in tower_write()
592 		retval = -ENODEV;  in tower_write()
598 		dev_dbg(&dev->udev->dev, "write request of 0 bytes\n");  in tower_write()
603 	while (dev->interrupt_out_busy) {  in tower_write()
604 		if (file->f_flags & O_NONBLOCK) {  in tower_write()
605 			retval = -EAGAIN;  in tower_write()
608 		retval = wait_event_interruptible(dev->write_wait,  in tower_write()
609 						  !dev->interrupt_out_busy);  in tower_write()
616 	dev_dbg(&dev->udev->dev, "%s: count = %zd, bytes_to_write = %zd\n",  in tower_write()
619 	if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write)) {  in tower_write()
620 		retval = -EFAULT;  in tower_write()
625 	usb_fill_int_urb(dev->interrupt_out_urb,  in tower_write()
626 			 dev->udev,  in tower_write()
627 			 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),  in tower_write()
628 			 dev->interrupt_out_buffer,  in tower_write()
632 			 dev->interrupt_out_interval);  in tower_write()
634 	dev->interrupt_out_busy = 1;  in tower_write()
637 	retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);  in tower_write()
639 		dev->interrupt_out_busy = 0;  in tower_write()
640 		dev_err(&dev->udev->dev,  in tower_write()
648 	mutex_unlock(&dev->lock);  in tower_write()
660 	struct lego_usb_tower *dev = urb->context;  in tower_interrupt_in_callback()
661 	int status = urb->status;  in tower_interrupt_in_callback()
665 	lego_usb_tower_debug_data(&dev->udev->dev, __func__,  in tower_interrupt_in_callback()
666 				  urb->actual_length, urb->transfer_buffer);  in tower_interrupt_in_callback()
669 		if (status == -ENOENT ||  in tower_interrupt_in_callback()
670 		    status == -ECONNRESET ||  in tower_interrupt_in_callback()
671 		    status == -ESHUTDOWN) {  in tower_interrupt_in_callback()
674 			dev_dbg(&dev->udev->dev,  in tower_interrupt_in_callback()
681 	if (urb->actual_length > 0) {  in tower_interrupt_in_callback()
682 		spin_lock_irqsave(&dev->read_buffer_lock, flags);  in tower_interrupt_in_callback()
683 		if (dev->read_buffer_length + urb->actual_length < read_buffer_size) {  in tower_interrupt_in_callback()
684 			memcpy(dev->read_buffer + dev->read_buffer_length,  in tower_interrupt_in_callback()
685 			       dev->interrupt_in_buffer,  in tower_interrupt_in_callback()
686 			       urb->actual_length);  in tower_interrupt_in_callback()
687 			dev->read_buffer_length += urb->actual_length;  in tower_interrupt_in_callback()
688 			dev->read_last_arrival = jiffies;  in tower_interrupt_in_callback()
689 			dev_dbg(&dev->udev->dev, "%s: received %d bytes\n",  in tower_interrupt_in_callback()
690 				__func__, urb->actual_length);  in tower_interrupt_in_callback()
693 				urb->actual_length);  in tower_interrupt_in_callback()
695 		spin_unlock_irqrestore(&dev->read_buffer_lock, flags);  in tower_interrupt_in_callback()
699 	retval = usb_submit_urb(dev->interrupt_in_urb, GFP_ATOMIC);  in tower_interrupt_in_callback()
701 		dev_err(&dev->udev->dev, "%s: usb_submit_urb failed (%d)\n",  in tower_interrupt_in_callback()
705 	dev->interrupt_in_done = 1;  in tower_interrupt_in_callback()
706 	wake_up_interruptible(&dev->read_wait);  in tower_interrupt_in_callback()
715 	struct lego_usb_tower *dev = urb->context;  in tower_interrupt_out_callback()
716 	int status = urb->status;  in tower_interrupt_out_callback()
718 	lego_usb_tower_debug_data(&dev->udev->dev, __func__,  in tower_interrupt_out_callback()
719 				  urb->actual_length, urb->transfer_buffer);  in tower_interrupt_out_callback()
722 	if (status && !(status == -ENOENT ||  in tower_interrupt_out_callback()
723 			status == -ECONNRESET ||  in tower_interrupt_out_callback()
724 			status == -ESHUTDOWN)) {  in tower_interrupt_out_callback()
725 		dev_dbg(&dev->udev->dev,  in tower_interrupt_out_callback()
730 	dev->interrupt_out_busy = 0;  in tower_interrupt_out_callback()
731 	wake_up_interruptible(&dev->write_wait);  in tower_interrupt_out_callback()
743 	struct device *idev = &interface->dev;  in tower_probe()
747 	int retval = -ENOMEM;  in tower_probe()
755 	mutex_init(&dev->lock);  in tower_probe()
756 	dev->udev = usb_get_dev(udev);  in tower_probe()
757 	spin_lock_init(&dev->read_buffer_lock);  in tower_probe()
758 	dev->packet_timeout_jiffies = msecs_to_jiffies(packet_timeout);  in tower_probe()
759 	dev->read_last_arrival = jiffies;  in tower_probe()
760 	init_waitqueue_head(&dev->read_wait);  in tower_probe()
761 	init_waitqueue_head(&dev->write_wait);  in tower_probe()
763 	result = usb_find_common_endpoints_reverse(interface->cur_altsetting,  in tower_probe()
765 			&dev->interrupt_in_endpoint,  in tower_probe()
766 			&dev->interrupt_out_endpoint);  in tower_probe()
773 	dev->read_buffer = kmalloc(read_buffer_size, GFP_KERNEL);  in tower_probe()
774 	if (!dev->read_buffer)  in tower_probe()
776 	dev->interrupt_in_buffer = kmalloc(usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);  in tower_probe()
777 	if (!dev->interrupt_in_buffer)  in tower_probe()
779 	dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);  in tower_probe()
780 	if (!dev->interrupt_in_urb)  in tower_probe()
782 	dev->interrupt_out_buffer = kmalloc(write_buffer_size, GFP_KERNEL);  in tower_probe()
783 	if (!dev->interrupt_out_buffer)  in tower_probe()
785 	dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);  in tower_probe()
786 	if (!dev->interrupt_out_urb)  in tower_probe()
788 …dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_end…  in tower_probe()
789 …dev->interrupt_out_interval = interrupt_out_interval ? interrupt_out_interval : dev->interrupt_out…  in tower_probe()
805 	dev_info(&interface->dev,  in tower_probe()
820 	dev->minor = interface->minor;  in tower_probe()
823 	dev_info(&interface->dev, "LEGO USB Tower #%d now attached to major "  in tower_probe()
824 		 "%d minor %d\n", (dev->minor - LEGO_USB_TOWER_MINOR_BASE),  in tower_probe()
825 		 USB_MAJOR, dev->minor);  in tower_probe()
848 	minor = dev->minor;  in tower_disconnect()
854 	usb_poison_urb(dev->interrupt_in_urb);  in tower_disconnect()
855 	usb_poison_urb(dev->interrupt_out_urb);  in tower_disconnect()
857 	mutex_lock(&dev->lock);  in tower_disconnect()
860 	if (!dev->open_count) {  in tower_disconnect()
861 		mutex_unlock(&dev->lock);  in tower_disconnect()
864 		dev->disconnected = 1;  in tower_disconnect()
866 		wake_up_interruptible_all(&dev->read_wait);  in tower_disconnect()
867 		wake_up_interruptible_all(&dev->write_wait);  in tower_disconnect()
868 		mutex_unlock(&dev->lock);  in tower_disconnect()
871 	dev_info(&interface->dev, "LEGO USB Tower #%d now disconnected\n",  in tower_disconnect()
872 		 (minor - LEGO_USB_TOWER_MINOR_BASE));  in tower_disconnect()