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");
160 	__le16 size;		/* little-endian */
166 	__le16 size;		/* little-endian */
171 	__le16 build_no;		/* little-endian */
246 	.poll =		tower_poll,
283 	dev_dbg(dev, "%s - length = %d, data = %*ph\n",  in lego_usb_tower_debug_data()
294 	usb_free_urb(dev->interrupt_in_urb);  in tower_delete()
295 	usb_free_urb(dev->interrupt_out_urb);  in tower_delete()
296 	kfree (dev->read_buffer);  in tower_delete()
297 	kfree (dev->interrupt_in_buffer);  in tower_delete()
298 	kfree (dev->interrupt_out_buffer);  in tower_delete()
299 	usb_put_dev(dev->udev);  in tower_delete()
319 		retval = -ENOMEM;  in tower_open()
330 		retval = -ENODEV;  in tower_open()
336 		retval = -ENODEV;  in tower_open()
341 	if (mutex_lock_interruptible(&dev->lock)) {  in tower_open()
342 	        retval = -ERESTARTSYS;  in tower_open()
348 	if (dev->open_count) {  in tower_open()
349 		retval = -EBUSY;  in tower_open()
354 	result = usb_control_msg (dev->udev,  in tower_open()
355 				  usb_rcvctrlpipe(dev->udev, 0),  in tower_open()
364 		dev_err(&dev->udev->dev,  in tower_open()
371 	dev->read_buffer_length = 0;  in tower_open()
372 	dev->read_packet_length = 0;  in tower_open()
373 	usb_fill_int_urb (dev->interrupt_in_urb,  in tower_open()
374 			  dev->udev,  in tower_open()
375 			  usb_rcvintpipe(dev->udev, dev->interrupt_in_endpoint->bEndpointAddress),  in tower_open()
376 			  dev->interrupt_in_buffer,  in tower_open()
377 			  usb_endpoint_maxp(dev->interrupt_in_endpoint),  in tower_open()
380 			  dev->interrupt_in_interval);  in tower_open()
382 	dev->interrupt_in_running = 1;  in tower_open()
383 	dev->interrupt_in_done = 0;  in tower_open()
386 	retval = usb_submit_urb (dev->interrupt_in_urb, GFP_KERNEL);  in tower_open()
388 		dev_err(&dev->udev->dev,  in tower_open()
390 		dev->interrupt_in_running = 0;  in tower_open()
395 	file->private_data = dev;  in tower_open()
397 	dev->open_count = 1;  in tower_open()
400 	mutex_unlock(&dev->lock);  in tower_open()
415 	dev = file->private_data;  in tower_release()
418 		retval = -ENODEV;  in tower_release()
422 	mutex_lock(&dev->lock);  in tower_release()
424 	if (dev->open_count != 1) {  in tower_release()
425 		dev_dbg(&dev->udev->dev, "%s: device not opened exactly once\n",  in tower_release()
427 		retval = -ENODEV;  in tower_release()
431 	if (dev->disconnected) {  in tower_release()
435 		mutex_unlock(&dev->lock);  in tower_release()
441 	if (dev->interrupt_out_busy) {  in tower_release()
442 		wait_event_interruptible_timeout (dev->write_wait, !dev->interrupt_out_busy, 2 * HZ);  in tower_release()
445 	dev->open_count = 0;  in tower_release()
448 	mutex_unlock(&dev->lock);  in tower_release()
464 	if (dev->interrupt_in_running) {  in tower_abort_transfers()
465 		dev->interrupt_in_running = 0;  in tower_abort_transfers()
467 		usb_kill_urb(dev->interrupt_in_urb);  in tower_abort_transfers()
469 	if (dev->interrupt_out_busy)  in tower_abort_transfers()
470 		usb_kill_urb(dev->interrupt_out_urb);  in tower_abort_transfers()
477  *      To get correct semantics for signals and non-blocking I/O
480  *      dev->packet_timeout_jiffies, or until the buffer is full.
484 	spin_lock_irq (&dev->read_buffer_lock);  in tower_check_for_read_packet()
486 	    || time_after(jiffies, dev->read_last_arrival + dev->packet_timeout_jiffies)  in tower_check_for_read_packet()
487 	    || dev->read_buffer_length == read_buffer_size) {  in tower_check_for_read_packet()
488 		dev->read_packet_length = dev->read_buffer_length;  in tower_check_for_read_packet()
490 	dev->interrupt_in_done = 0;  in tower_check_for_read_packet()
491 	spin_unlock_irq (&dev->read_buffer_lock);  in tower_check_for_read_packet()
503 	dev = file->private_data;  in tower_poll()
505 	if (dev->disconnected)  in tower_poll()
508 	poll_wait(file, &dev->read_wait, wait);  in tower_poll()
509 	poll_wait(file, &dev->write_wait, wait);  in tower_poll()
512 	if (dev->read_packet_length > 0) {  in tower_poll()
515 	if (!dev->interrupt_out_busy) {  in tower_poll()
528 	return -ESPIPE;		/* unseekable */  in tower_llseek()
541 	unsigned long timeout = 0;  in tower_read()  local
543 	dev = file->private_data;  in tower_read()
546 	if (mutex_lock_interruptible(&dev->lock)) {  in tower_read()
547 		retval = -ERESTARTSYS;  in tower_read()
552 	if (dev->disconnected) {  in tower_read()
553 		retval = -ENODEV;  in tower_read()
560 		dev_dbg(&dev->udev->dev, "read request of 0 bytes\n");  in tower_read()
565 		timeout = jiffies + msecs_to_jiffies(read_timeout);  in tower_read()
570 	while (dev->read_packet_length == 0) {  in tower_read()
571 		if (file->f_flags & O_NONBLOCK) {  in tower_read()
572 			retval = -EAGAIN;  in tower_read()
575 …retval = wait_event_interruptible_timeout(dev->read_wait, dev->interrupt_in_done, dev->packet_time…  in tower_read()
580 		/* reset read timeout during read or write activity */  in tower_read()
582 		    && (dev->read_buffer_length || dev->interrupt_out_busy)) {  in tower_read()
583 			timeout = jiffies + msecs_to_jiffies(read_timeout);  in tower_read()
585 		/* check for read timeout */  in tower_read()
586 		if (read_timeout && time_after (jiffies, timeout)) {  in tower_read()
587 			retval = -ETIMEDOUT;  in tower_read()
594 	bytes_to_read = min(count, dev->read_packet_length);  in tower_read()
596 	if (copy_to_user (buffer, dev->read_buffer, bytes_to_read)) {  in tower_read()
597 		retval = -EFAULT;  in tower_read()
601 	spin_lock_irq (&dev->read_buffer_lock);  in tower_read()
602 	dev->read_buffer_length -= bytes_to_read;  in tower_read()
603 	dev->read_packet_length -= bytes_to_read;  in tower_read()
604 	for (i=0; i<dev->read_buffer_length; i++) {  in tower_read()
605 		dev->read_buffer[i] = dev->read_buffer[i+bytes_to_read];  in tower_read()
607 	spin_unlock_irq (&dev->read_buffer_lock);  in tower_read()
613 	mutex_unlock(&dev->lock);  in tower_read()
629 	dev = file->private_data;  in tower_write()
632 	if (mutex_lock_interruptible(&dev->lock)) {  in tower_write()
633 		retval = -ERESTARTSYS;  in tower_write()
638 	if (dev->disconnected) {  in tower_write()
639 		retval = -ENODEV;  in tower_write()
646 		dev_dbg(&dev->udev->dev, "write request of 0 bytes\n");  in tower_write()
651 	while (dev->interrupt_out_busy) {  in tower_write()
652 		if (file->f_flags & O_NONBLOCK) {  in tower_write()
653 			retval = -EAGAIN;  in tower_write()
656 		retval = wait_event_interruptible (dev->write_wait, !dev->interrupt_out_busy);  in tower_write()
664 	dev_dbg(&dev->udev->dev, "%s: count = %zd, bytes_to_write = %zd\n",  in tower_write()
667 	if (copy_from_user (dev->interrupt_out_buffer, buffer, bytes_to_write)) {  in tower_write()
668 		retval = -EFAULT;  in tower_write()
673 	usb_fill_int_urb(dev->interrupt_out_urb,  in tower_write()
674 			 dev->udev,  in tower_write()
675 			 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress),  in tower_write()
676 			 dev->interrupt_out_buffer,  in tower_write()
680 			 dev->interrupt_out_interval);  in tower_write()
682 	dev->interrupt_out_busy = 1;  in tower_write()
685 	retval = usb_submit_urb (dev->interrupt_out_urb, GFP_KERNEL);  in tower_write()
687 		dev->interrupt_out_busy = 0;  in tower_write()
688 		dev_err(&dev->udev->dev,  in tower_write()
696 	mutex_unlock(&dev->lock);  in tower_write()
708 	struct lego_usb_tower *dev = urb->context;  in tower_interrupt_in_callback()
709 	int status = urb->status;  in tower_interrupt_in_callback()
713 	lego_usb_tower_debug_data(&dev->udev->dev, __func__,  in tower_interrupt_in_callback()
714 				  urb->actual_length, urb->transfer_buffer);  in tower_interrupt_in_callback()
717 		if (status == -ENOENT ||  in tower_interrupt_in_callback()
718 		    status == -ECONNRESET ||  in tower_interrupt_in_callback()
719 		    status == -ESHUTDOWN) {  in tower_interrupt_in_callback()
722 			dev_dbg(&dev->udev->dev,  in tower_interrupt_in_callback()
729 	if (urb->actual_length > 0) {  in tower_interrupt_in_callback()
730 		spin_lock_irqsave(&dev->read_buffer_lock, flags);  in tower_interrupt_in_callback()
731 		if (dev->read_buffer_length + urb->actual_length < read_buffer_size) {  in tower_interrupt_in_callback()
732 			memcpy (dev->read_buffer + dev->read_buffer_length,  in tower_interrupt_in_callback()
733 				dev->interrupt_in_buffer,  in tower_interrupt_in_callback()
734 				urb->actual_length);  in tower_interrupt_in_callback()
735 			dev->read_buffer_length += urb->actual_length;  in tower_interrupt_in_callback()
736 			dev->read_last_arrival = jiffies;  in tower_interrupt_in_callback()
737 			dev_dbg(&dev->udev->dev, "%s: received %d bytes\n",  in tower_interrupt_in_callback()
738 				__func__, urb->actual_length);  in tower_interrupt_in_callback()
741 				urb->actual_length);  in tower_interrupt_in_callback()
743 		spin_unlock_irqrestore(&dev->read_buffer_lock, flags);  in tower_interrupt_in_callback()
748 	if (dev->interrupt_in_running) {  in tower_interrupt_in_callback()
749 		retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);  in tower_interrupt_in_callback()
751 			dev_err(&dev->udev->dev,  in tower_interrupt_in_callback()
757 	dev->interrupt_in_done = 1;  in tower_interrupt_in_callback()
758 	wake_up_interruptible (&dev->read_wait);  in tower_interrupt_in_callback()
767 	struct lego_usb_tower *dev = urb->context;  in tower_interrupt_out_callback()
768 	int status = urb->status;  in tower_interrupt_out_callback()
770 	lego_usb_tower_debug_data(&dev->udev->dev, __func__,  in tower_interrupt_out_callback()
771 				  urb->actual_length, urb->transfer_buffer);  in tower_interrupt_out_callback()
774 	if (status && !(status == -ENOENT ||  in tower_interrupt_out_callback()
775 			status == -ECONNRESET ||  in tower_interrupt_out_callback()
776 			status == -ESHUTDOWN)) {  in tower_interrupt_out_callback()
777 		dev_dbg(&dev->udev->dev,  in tower_interrupt_out_callback()
782 	dev->interrupt_out_busy = 0;  in tower_interrupt_out_callback()
783 	wake_up_interruptible(&dev->write_wait);  in tower_interrupt_out_callback()
795 	struct device *idev = &interface->dev;  in tower_probe()
799 	int retval = -ENOMEM;  in tower_probe()
809 	mutex_init(&dev->lock);  in tower_probe()
811 	dev->udev = usb_get_dev(udev);  in tower_probe()
812 	dev->open_count = 0;  in tower_probe()
813 	dev->disconnected = 0;  in tower_probe()
815 	dev->read_buffer = NULL;  in tower_probe()
816 	dev->read_buffer_length = 0;  in tower_probe()
817 	dev->read_packet_length = 0;  in tower_probe()
818 	spin_lock_init (&dev->read_buffer_lock);  in tower_probe()
819 	dev->packet_timeout_jiffies = msecs_to_jiffies(packet_timeout);  in tower_probe()
820 	dev->read_last_arrival = jiffies;  in tower_probe()
822 	init_waitqueue_head (&dev->read_wait);  in tower_probe()
823 	init_waitqueue_head (&dev->write_wait);  in tower_probe()
825 	dev->interrupt_in_buffer = NULL;  in tower_probe()
826 	dev->interrupt_in_endpoint = NULL;  in tower_probe()
827 	dev->interrupt_in_urb = NULL;  in tower_probe()
828 	dev->interrupt_in_running = 0;  in tower_probe()
829 	dev->interrupt_in_done = 0;  in tower_probe()
831 	dev->interrupt_out_buffer = NULL;  in tower_probe()
832 	dev->interrupt_out_endpoint = NULL;  in tower_probe()
833 	dev->interrupt_out_urb = NULL;  in tower_probe()
834 	dev->interrupt_out_busy = 0;  in tower_probe()
836 	result = usb_find_common_endpoints_reverse(interface->cur_altsetting,  in tower_probe()
838 			&dev->interrupt_in_endpoint,  in tower_probe()
839 			&dev->interrupt_out_endpoint);  in tower_probe()
846 	dev->read_buffer = kmalloc (read_buffer_size, GFP_KERNEL);  in tower_probe()
847 	if (!dev->read_buffer)  in tower_probe()
849 	dev->interrupt_in_buffer = kmalloc (usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);  in tower_probe()
850 	if (!dev->interrupt_in_buffer)  in tower_probe()
852 	dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);  in tower_probe()
853 	if (!dev->interrupt_in_urb)  in tower_probe()
855 	dev->interrupt_out_buffer = kmalloc (write_buffer_size, GFP_KERNEL);  in tower_probe()
856 	if (!dev->interrupt_out_buffer)  in tower_probe()
858 	dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);  in tower_probe()
859 	if (!dev->interrupt_out_urb)  in tower_probe()
861 …dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_end…  in tower_probe()
862 …dev->interrupt_out_interval = interrupt_out_interval ? interrupt_out_interval : dev->interrupt_out…  in tower_probe()
867 		retval = -ENOMEM;  in tower_probe()
883 			result = -EIO;  in tower_probe()
888 	dev_info(&interface->dev,  in tower_probe()
890 		 get_version_reply->major,  in tower_probe()
891 		 get_version_reply->minor,  in tower_probe()
892 		 le16_to_cpu(get_version_reply->build_no));  in tower_probe()
904 	dev->minor = interface->minor;  in tower_probe()
907 	dev_info(&interface->dev, "LEGO USB Tower #%d now attached to major "  in tower_probe()
908 		 "%d minor %d\n", (dev->minor - LEGO_USB_TOWER_MINOR_BASE),  in tower_probe()
909 		 USB_MAJOR, dev->minor);  in tower_probe()
934 	minor = dev->minor;  in tower_disconnect()
940 	usb_poison_urb(dev->interrupt_in_urb);  in tower_disconnect()
941 	usb_poison_urb(dev->interrupt_out_urb);  in tower_disconnect()
943 	mutex_lock(&dev->lock);  in tower_disconnect()
946 	if (!dev->open_count) {  in tower_disconnect()
947 		mutex_unlock(&dev->lock);  in tower_disconnect()
950 		dev->disconnected = 1;  in tower_disconnect()
952 		wake_up_interruptible_all(&dev->read_wait);  in tower_disconnect()
953 		wake_up_interruptible_all(&dev->write_wait);  in tower_disconnect()
954 		mutex_unlock(&dev->lock);  in tower_disconnect()
957 	dev_info(&interface->dev, "LEGO USB Tower #%d now disconnected\n",  in tower_disconnect()
958 		 (minor - LEGO_USB_TOWER_MINOR_BASE));  in tower_disconnect()