1 // SPDX-License-Identifier: GPL-2.0+
3 * drivers/usb/class/usbtmc.c - USB Test & Measurement class driver
5 * Copyright (C) 2007 Stefan Kopp, Gechingen, Germany
6 * Copyright (C) 2008 Novell, Inc.
7 * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
12 #include <linux/module.h>
13 #include <linux/kernel.h>
15 #include <linux/uaccess.h>
16 #include <linux/kref.h>
17 #include <linux/slab.h>
18 #include <linux/poll.h>
19 #include <linux/mutex.h>
20 #include <linux/usb.h>
21 #include <linux/usb/tmc.h>
25 #define USBTMC_HEADER_SIZE 12
26 #define USBTMC_MINOR_BASE 176
29 * Size of driver internal IO buffer. Must be multiple of 4 and at least as
30 * large as wMaxPacketSize (which is usually 512 bytes).
32 #define USBTMC_SIZE_IOBUFFER 2048
34 /* Default USB timeout (in milliseconds) */
35 #define USBTMC_TIMEOUT 5000
38 * Maximum number of read cycles to empty bulk in endpoint during CLEAR and
39 * ABORT_BULK_IN requests. Ends the loop if (for whatever reason) a short
40 * packet is never read.
42 #define USBTMC_MAX_READS_TO_CLEAR_BULK_IN 100
44 static const struct usb_device_id usbtmc_devices
[] = {
45 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC
, 3, 0), },
46 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC
, 3, 1), },
47 { 0, } /* terminating entry */
49 MODULE_DEVICE_TABLE(usb
, usbtmc_devices
);
52 * This structure is the capabilities for the device
53 * See section 4.2.1.8 of the USBTMC specification,
54 * and section 4.2.2 of the USBTMC usb488 subclass
55 * specification for details.
57 struct usbtmc_dev_capabilities
{
58 __u8 interface_capabilities
;
59 __u8 device_capabilities
;
60 __u8 usb488_interface_capabilities
;
61 __u8 usb488_device_capabilities
;
64 /* This structure holds private data for each USBTMC device. One copy is
65 * allocated for each USBTMC device in the driver's probe function.
67 struct usbtmc_device_data
{
68 const struct usb_device_id
*id
;
69 struct usb_device
*usb_dev
;
70 struct usb_interface
*intf
;
73 unsigned int bulk_out
;
76 u8 bTag_last_write
; /* needed for abort */
77 u8 bTag_last_read
; /* needed for abort */
79 /* data for interrupt in endpoint handling */
85 atomic_t iin_data_valid
;
90 u16 iin_wMaxPacketSize
;
91 atomic_t srq_asserted
;
93 /* coalesced usb488_caps from usbtmc_dev_capabilities */
98 /* attributes from the USB TMC spec for this device */
100 bool TermCharEnabled
;
103 bool zombie
; /* fd of disconnected device */
105 struct usbtmc_dev_capabilities capabilities
;
107 struct mutex io_mutex
; /* only one i/o function running at a time */
108 wait_queue_head_t waitq
;
109 struct fasync_struct
*fasync
;
111 #define to_usbtmc_data(d) container_of(d, struct usbtmc_device_data, kref)
113 struct usbtmc_ID_rigol_quirk
{
118 static const struct usbtmc_ID_rigol_quirk usbtmc_id_quirk
[] = {
124 /* Forward declarations */
125 static struct usb_driver usbtmc_driver
;
127 static void usbtmc_delete(struct kref
*kref
)
129 struct usbtmc_device_data
*data
= to_usbtmc_data(kref
);
131 usb_put_dev(data
->usb_dev
);
135 static int usbtmc_open(struct inode
*inode
, struct file
*filp
)
137 struct usb_interface
*intf
;
138 struct usbtmc_device_data
*data
;
141 intf
= usb_find_interface(&usbtmc_driver
, iminor(inode
));
143 pr_err("can not find device for minor %d", iminor(inode
));
147 data
= usb_get_intfdata(intf
);
148 /* Protect reference to data from file structure until release */
149 kref_get(&data
->kref
);
151 /* Store pointer in file structure's private data field */
152 filp
->private_data
= data
;
157 static int usbtmc_release(struct inode
*inode
, struct file
*file
)
159 struct usbtmc_device_data
*data
= file
->private_data
;
161 kref_put(&data
->kref
, usbtmc_delete
);
165 static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data
*data
)
172 struct usb_host_interface
*current_setting
;
175 dev
= &data
->intf
->dev
;
176 buffer
= kmalloc(USBTMC_SIZE_IOBUFFER
, GFP_KERNEL
);
180 rv
= usb_control_msg(data
->usb_dev
,
181 usb_rcvctrlpipe(data
->usb_dev
, 0),
182 USBTMC_REQUEST_INITIATE_ABORT_BULK_IN
,
183 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_ENDPOINT
,
184 data
->bTag_last_read
, data
->bulk_in
,
185 buffer
, 2, USBTMC_TIMEOUT
);
188 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
192 dev_dbg(dev
, "INITIATE_ABORT_BULK_IN returned %x\n", buffer
[0]);
194 if (buffer
[0] == USBTMC_STATUS_FAILED
) {
199 if (buffer
[0] != USBTMC_STATUS_SUCCESS
) {
200 dev_err(dev
, "INITIATE_ABORT_BULK_IN returned %x\n",
207 current_setting
= data
->intf
->cur_altsetting
;
208 for (n
= 0; n
< current_setting
->desc
.bNumEndpoints
; n
++)
209 if (current_setting
->endpoint
[n
].desc
.bEndpointAddress
==
211 max_size
= usb_endpoint_maxp(¤t_setting
->endpoint
[n
].desc
);
214 dev_err(dev
, "Couldn't get wMaxPacketSize\n");
219 dev_dbg(&data
->intf
->dev
, "wMaxPacketSize is %d\n", max_size
);
224 dev_dbg(dev
, "Reading from bulk in EP\n");
226 rv
= usb_bulk_msg(data
->usb_dev
,
227 usb_rcvbulkpipe(data
->usb_dev
,
229 buffer
, USBTMC_SIZE_IOBUFFER
,
230 &actual
, USBTMC_TIMEOUT
);
235 dev_err(dev
, "usb_bulk_msg returned %d\n", rv
);
238 } while ((actual
== max_size
) &&
239 (n
< USBTMC_MAX_READS_TO_CLEAR_BULK_IN
));
241 if (actual
== max_size
) {
242 dev_err(dev
, "Couldn't clear device buffer within %d cycles\n",
243 USBTMC_MAX_READS_TO_CLEAR_BULK_IN
);
250 usbtmc_abort_bulk_in_status
:
251 rv
= usb_control_msg(data
->usb_dev
,
252 usb_rcvctrlpipe(data
->usb_dev
, 0),
253 USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS
,
254 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_ENDPOINT
,
255 0, data
->bulk_in
, buffer
, 0x08,
259 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
263 dev_dbg(dev
, "INITIATE_ABORT_BULK_IN returned %x\n", buffer
[0]);
265 if (buffer
[0] == USBTMC_STATUS_SUCCESS
) {
270 if (buffer
[0] != USBTMC_STATUS_PENDING
) {
271 dev_err(dev
, "INITIATE_ABORT_BULK_IN returned %x\n", buffer
[0]);
278 dev_dbg(dev
, "Reading from bulk in EP\n");
280 rv
= usb_bulk_msg(data
->usb_dev
,
281 usb_rcvbulkpipe(data
->usb_dev
,
283 buffer
, USBTMC_SIZE_IOBUFFER
,
284 &actual
, USBTMC_TIMEOUT
);
289 dev_err(dev
, "usb_bulk_msg returned %d\n", rv
);
292 } while ((actual
== max_size
) &&
293 (n
< USBTMC_MAX_READS_TO_CLEAR_BULK_IN
));
295 if (actual
== max_size
) {
296 dev_err(dev
, "Couldn't clear device buffer within %d cycles\n",
297 USBTMC_MAX_READS_TO_CLEAR_BULK_IN
);
302 goto usbtmc_abort_bulk_in_status
;
310 static int usbtmc_ioctl_abort_bulk_out(struct usbtmc_device_data
*data
)
317 dev
= &data
->intf
->dev
;
319 buffer
= kmalloc(8, GFP_KERNEL
);
323 rv
= usb_control_msg(data
->usb_dev
,
324 usb_rcvctrlpipe(data
->usb_dev
, 0),
325 USBTMC_REQUEST_INITIATE_ABORT_BULK_OUT
,
326 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_ENDPOINT
,
327 data
->bTag_last_write
, data
->bulk_out
,
328 buffer
, 2, USBTMC_TIMEOUT
);
331 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
335 dev_dbg(dev
, "INITIATE_ABORT_BULK_OUT returned %x\n", buffer
[0]);
337 if (buffer
[0] != USBTMC_STATUS_SUCCESS
) {
338 dev_err(dev
, "INITIATE_ABORT_BULK_OUT returned %x\n",
346 usbtmc_abort_bulk_out_check_status
:
347 rv
= usb_control_msg(data
->usb_dev
,
348 usb_rcvctrlpipe(data
->usb_dev
, 0),
349 USBTMC_REQUEST_CHECK_ABORT_BULK_OUT_STATUS
,
350 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_ENDPOINT
,
351 0, data
->bulk_out
, buffer
, 0x08,
355 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
359 dev_dbg(dev
, "CHECK_ABORT_BULK_OUT returned %x\n", buffer
[0]);
361 if (buffer
[0] == USBTMC_STATUS_SUCCESS
)
362 goto usbtmc_abort_bulk_out_clear_halt
;
364 if ((buffer
[0] == USBTMC_STATUS_PENDING
) &&
365 (n
< USBTMC_MAX_READS_TO_CLEAR_BULK_IN
))
366 goto usbtmc_abort_bulk_out_check_status
;
371 usbtmc_abort_bulk_out_clear_halt
:
372 rv
= usb_clear_halt(data
->usb_dev
,
373 usb_sndbulkpipe(data
->usb_dev
, data
->bulk_out
));
376 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
386 static int usbtmc488_ioctl_read_stb(struct usbtmc_device_data
*data
,
389 struct device
*dev
= &data
->intf
->dev
;
395 dev_dbg(dev
, "Enter ioctl_read_stb iin_ep_present: %d\n",
396 data
->iin_ep_present
);
398 buffer
= kmalloc(8, GFP_KERNEL
);
402 atomic_set(&data
->iin_data_valid
, 0);
404 /* must issue read_stb before using poll or select */
405 atomic_set(&data
->srq_asserted
, 0);
407 rv
= usb_control_msg(data
->usb_dev
,
408 usb_rcvctrlpipe(data
->usb_dev
, 0),
409 USBTMC488_REQUEST_READ_STATUS_BYTE
,
410 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
413 buffer
, 0x03, USBTMC_TIMEOUT
);
415 dev_err(dev
, "stb usb_control_msg returned %d\n", rv
);
419 if (buffer
[0] != USBTMC_STATUS_SUCCESS
) {
420 dev_err(dev
, "control status returned %x\n", buffer
[0]);
425 if (data
->iin_ep_present
) {
426 rv
= wait_event_interruptible_timeout(
428 atomic_read(&data
->iin_data_valid
) != 0,
431 dev_dbg(dev
, "wait interrupted %d\n", rv
);
436 dev_dbg(dev
, "wait timed out\n");
441 tag
= data
->bNotify1
& 0x7f;
442 if (tag
!= data
->iin_bTag
) {
443 dev_err(dev
, "expected bTag %x got %x\n",
444 data
->iin_bTag
, tag
);
447 stb
= data
->bNotify2
;
452 rv
= copy_to_user(arg
, &stb
, sizeof(stb
));
457 /* bump interrupt bTag */
459 if (data
->iin_bTag
> 127)
460 /* 1 is for SRQ see USBTMC-USB488 subclass spec section 4.3.1 */
467 static int usbtmc488_ioctl_simple(struct usbtmc_device_data
*data
,
468 void __user
*arg
, unsigned int cmd
)
470 struct device
*dev
= &data
->intf
->dev
;
476 if (!(data
->usb488_caps
& USBTMC488_CAPABILITY_SIMPLE
))
479 buffer
= kmalloc(8, GFP_KERNEL
);
483 if (cmd
== USBTMC488_REQUEST_REN_CONTROL
) {
484 rv
= copy_from_user(&val
, arg
, sizeof(val
));
489 wValue
= val
? 1 : 0;
494 rv
= usb_control_msg(data
->usb_dev
,
495 usb_rcvctrlpipe(data
->usb_dev
, 0),
497 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
500 buffer
, 0x01, USBTMC_TIMEOUT
);
502 dev_err(dev
, "simple usb_control_msg failed %d\n", rv
);
504 } else if (rv
!= 1) {
505 dev_warn(dev
, "simple usb_control_msg returned %d\n", rv
);
510 if (buffer
[0] != USBTMC_STATUS_SUCCESS
) {
511 dev_err(dev
, "simple control status returned %x\n", buffer
[0]);
523 * Sends a REQUEST_DEV_DEP_MSG_IN message on the Bulk-OUT endpoint.
524 * @transfer_size: number of bytes to request from the device.
526 * See the USBTMC specification, Table 4.
528 * Also updates bTag_last_write.
530 static int send_request_dev_dep_msg_in(struct usbtmc_device_data
*data
, size_t transfer_size
)
536 buffer
= kmalloc(USBTMC_HEADER_SIZE
, GFP_KERNEL
);
539 /* Setup IO buffer for REQUEST_DEV_DEP_MSG_IN message
540 * Refer to class specs for details
543 buffer
[1] = data
->bTag
;
544 buffer
[2] = ~data
->bTag
;
545 buffer
[3] = 0; /* Reserved */
546 buffer
[4] = transfer_size
>> 0;
547 buffer
[5] = transfer_size
>> 8;
548 buffer
[6] = transfer_size
>> 16;
549 buffer
[7] = transfer_size
>> 24;
550 buffer
[8] = data
->TermCharEnabled
* 2;
551 /* Use term character? */
552 buffer
[9] = data
->TermChar
;
553 buffer
[10] = 0; /* Reserved */
554 buffer
[11] = 0; /* Reserved */
557 retval
= usb_bulk_msg(data
->usb_dev
,
558 usb_sndbulkpipe(data
->usb_dev
,
560 buffer
, USBTMC_HEADER_SIZE
, &actual
, USBTMC_TIMEOUT
);
562 /* Store bTag (in case we need to abort) */
563 data
->bTag_last_write
= data
->bTag
;
565 /* Increment bTag -- and increment again if zero */
572 dev_err(&data
->intf
->dev
, "usb_bulk_msg in send_request_dev_dep_msg_in() returned %d\n", retval
);
579 static ssize_t
usbtmc_read(struct file
*filp
, char __user
*buf
,
580 size_t count
, loff_t
*f_pos
)
582 struct usbtmc_device_data
*data
;
592 /* Get pointer to private data structure */
593 data
= filp
->private_data
;
594 dev
= &data
->intf
->dev
;
596 buffer
= kmalloc(USBTMC_SIZE_IOBUFFER
, GFP_KERNEL
);
600 mutex_lock(&data
->io_mutex
);
606 if (data
->rigol_quirk
) {
607 dev_dbg(dev
, "usb_bulk_msg_in: count(%zu)\n", count
);
609 retval
= send_request_dev_dep_msg_in(data
, count
);
612 if (data
->auto_abort
)
613 usbtmc_ioctl_abort_bulk_out(data
);
618 /* Loop until we have fetched everything we requested */
620 this_part
= remaining
;
623 while (remaining
> 0) {
624 if (!data
->rigol_quirk
) {
625 dev_dbg(dev
, "usb_bulk_msg_in: remaining(%zu), count(%zu)\n", remaining
, count
);
627 if (remaining
> USBTMC_SIZE_IOBUFFER
- USBTMC_HEADER_SIZE
- 3)
628 this_part
= USBTMC_SIZE_IOBUFFER
- USBTMC_HEADER_SIZE
- 3;
630 this_part
= remaining
;
632 retval
= send_request_dev_dep_msg_in(data
, this_part
);
634 dev_err(dev
, "usb_bulk_msg returned %d\n", retval
);
635 if (data
->auto_abort
)
636 usbtmc_ioctl_abort_bulk_out(data
);
642 retval
= usb_bulk_msg(data
->usb_dev
,
643 usb_rcvbulkpipe(data
->usb_dev
,
645 buffer
, USBTMC_SIZE_IOBUFFER
, &actual
,
648 dev_dbg(dev
, "usb_bulk_msg: retval(%u), done(%zu), remaining(%zu), actual(%d)\n", retval
, done
, remaining
, actual
);
650 /* Store bTag (in case we need to abort) */
651 data
->bTag_last_read
= data
->bTag
;
654 dev_dbg(dev
, "Unable to read data, error %d\n", retval
);
655 if (data
->auto_abort
)
656 usbtmc_ioctl_abort_bulk_in(data
);
660 /* Parse header in first packet */
661 if ((done
== 0) || !data
->rigol_quirk
) {
662 /* Sanity checks for the header */
663 if (actual
< USBTMC_HEADER_SIZE
) {
664 dev_err(dev
, "Device sent too small first packet: %u < %u\n", actual
, USBTMC_HEADER_SIZE
);
665 if (data
->auto_abort
)
666 usbtmc_ioctl_abort_bulk_in(data
);
670 if (buffer
[0] != 2) {
671 dev_err(dev
, "Device sent reply with wrong MsgID: %u != 2\n", buffer
[0]);
672 if (data
->auto_abort
)
673 usbtmc_ioctl_abort_bulk_in(data
);
677 if (buffer
[1] != data
->bTag_last_write
) {
678 dev_err(dev
, "Device sent reply with wrong bTag: %u != %u\n", buffer
[1], data
->bTag_last_write
);
679 if (data
->auto_abort
)
680 usbtmc_ioctl_abort_bulk_in(data
);
684 /* How many characters did the instrument send? */
685 n_characters
= buffer
[4] +
690 if (n_characters
> this_part
) {
691 dev_err(dev
, "Device wants to return more data than requested: %u > %zu\n", n_characters
, count
);
692 if (data
->auto_abort
)
693 usbtmc_ioctl_abort_bulk_in(data
);
697 /* Remove the USBTMC header */
698 actual
-= USBTMC_HEADER_SIZE
;
700 /* Check if the message is smaller than requested */
701 if (data
->rigol_quirk
) {
702 if (remaining
> n_characters
)
703 remaining
= n_characters
;
704 /* Remove padding if it exists */
705 if (actual
> remaining
)
709 if (this_part
> n_characters
)
710 this_part
= n_characters
;
711 /* Remove padding if it exists */
712 if (actual
> this_part
)
716 dev_dbg(dev
, "Bulk-IN header: N_characters(%u), bTransAttr(%u)\n", n_characters
, buffer
[8]);
720 /* Terminate if end-of-message bit received from device */
721 if ((buffer
[8] & 0x01) && (actual
>= n_characters
))
724 dev_dbg(dev
, "Bulk-IN header: remaining(%zu), buf(%p), buffer(%p) done(%zu)\n", remaining
,buf
,buffer
,done
);
727 /* Copy buffer to user space */
728 if (copy_to_user(buf
+ done
, &buffer
[USBTMC_HEADER_SIZE
], actual
)) {
729 /* There must have been an addressing problem */
736 if (actual
> remaining
)
741 dev_dbg(dev
, "Bulk-IN header cont: actual(%u), done(%zu), remaining(%zu), buf(%p), buffer(%p)\n", actual
, done
, remaining
,buf
,buffer
);
743 /* Copy buffer to user space */
744 if (copy_to_user(buf
+ done
, buffer
, actual
)) {
745 /* There must have been an addressing problem */
753 /* Update file position value */
754 *f_pos
= *f_pos
+ done
;
758 mutex_unlock(&data
->io_mutex
);
763 static ssize_t
usbtmc_write(struct file
*filp
, const char __user
*buf
,
764 size_t count
, loff_t
*f_pos
)
766 struct usbtmc_device_data
*data
;
770 unsigned long int n_bytes
;
775 data
= filp
->private_data
;
777 buffer
= kmalloc(USBTMC_SIZE_IOBUFFER
, GFP_KERNEL
);
781 mutex_lock(&data
->io_mutex
);
790 while (remaining
> 0) {
791 if (remaining
> USBTMC_SIZE_IOBUFFER
- USBTMC_HEADER_SIZE
) {
792 this_part
= USBTMC_SIZE_IOBUFFER
- USBTMC_HEADER_SIZE
;
795 this_part
= remaining
;
799 /* Setup IO buffer for DEV_DEP_MSG_OUT message */
801 buffer
[1] = data
->bTag
;
802 buffer
[2] = ~data
->bTag
;
803 buffer
[3] = 0; /* Reserved */
804 buffer
[4] = this_part
>> 0;
805 buffer
[5] = this_part
>> 8;
806 buffer
[6] = this_part
>> 16;
807 buffer
[7] = this_part
>> 24;
808 /* buffer[8] is set above... */
809 buffer
[9] = 0; /* Reserved */
810 buffer
[10] = 0; /* Reserved */
811 buffer
[11] = 0; /* Reserved */
813 if (copy_from_user(&buffer
[USBTMC_HEADER_SIZE
], buf
+ done
, this_part
)) {
818 n_bytes
= roundup(USBTMC_HEADER_SIZE
+ this_part
, 4);
819 memset(buffer
+ USBTMC_HEADER_SIZE
+ this_part
, 0, n_bytes
- (USBTMC_HEADER_SIZE
+ this_part
));
822 retval
= usb_bulk_msg(data
->usb_dev
,
823 usb_sndbulkpipe(data
->usb_dev
,
826 &actual
, USBTMC_TIMEOUT
);
832 data
->bTag_last_write
= data
->bTag
;
839 dev_err(&data
->intf
->dev
,
840 "Unable to send data, error %d\n", retval
);
841 if (data
->auto_abort
)
842 usbtmc_ioctl_abort_bulk_out(data
);
846 remaining
-= this_part
;
852 mutex_unlock(&data
->io_mutex
);
857 static int usbtmc_ioctl_clear(struct usbtmc_device_data
*data
)
859 struct usb_host_interface
*current_setting
;
860 struct usb_endpoint_descriptor
*desc
;
868 dev
= &data
->intf
->dev
;
870 dev_dbg(dev
, "Sending INITIATE_CLEAR request\n");
872 buffer
= kmalloc(USBTMC_SIZE_IOBUFFER
, GFP_KERNEL
);
876 rv
= usb_control_msg(data
->usb_dev
,
877 usb_rcvctrlpipe(data
->usb_dev
, 0),
878 USBTMC_REQUEST_INITIATE_CLEAR
,
879 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
880 0, 0, buffer
, 1, USBTMC_TIMEOUT
);
882 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
886 dev_dbg(dev
, "INITIATE_CLEAR returned %x\n", buffer
[0]);
888 if (buffer
[0] != USBTMC_STATUS_SUCCESS
) {
889 dev_err(dev
, "INITIATE_CLEAR returned %x\n", buffer
[0]);
895 current_setting
= data
->intf
->cur_altsetting
;
896 for (n
= 0; n
< current_setting
->desc
.bNumEndpoints
; n
++) {
897 desc
= ¤t_setting
->endpoint
[n
].desc
;
898 if (desc
->bEndpointAddress
== data
->bulk_in
)
899 max_size
= usb_endpoint_maxp(desc
);
903 dev_err(dev
, "Couldn't get wMaxPacketSize\n");
908 dev_dbg(dev
, "wMaxPacketSize is %d\n", max_size
);
912 usbtmc_clear_check_status
:
914 dev_dbg(dev
, "Sending CHECK_CLEAR_STATUS request\n");
916 rv
= usb_control_msg(data
->usb_dev
,
917 usb_rcvctrlpipe(data
->usb_dev
, 0),
918 USBTMC_REQUEST_CHECK_CLEAR_STATUS
,
919 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
920 0, 0, buffer
, 2, USBTMC_TIMEOUT
);
922 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
926 dev_dbg(dev
, "CHECK_CLEAR_STATUS returned %x\n", buffer
[0]);
928 if (buffer
[0] == USBTMC_STATUS_SUCCESS
)
929 goto usbtmc_clear_bulk_out_halt
;
931 if (buffer
[0] != USBTMC_STATUS_PENDING
) {
932 dev_err(dev
, "CHECK_CLEAR_STATUS returned %x\n", buffer
[0]);
939 dev_dbg(dev
, "Reading from bulk in EP\n");
941 rv
= usb_bulk_msg(data
->usb_dev
,
942 usb_rcvbulkpipe(data
->usb_dev
,
944 buffer
, USBTMC_SIZE_IOBUFFER
,
945 &actual
, USBTMC_TIMEOUT
);
949 dev_err(dev
, "usb_control_msg returned %d\n",
953 } while ((actual
== max_size
) &&
954 (n
< USBTMC_MAX_READS_TO_CLEAR_BULK_IN
));
956 if (actual
== max_size
) {
957 dev_err(dev
, "Couldn't clear device buffer within %d cycles\n",
958 USBTMC_MAX_READS_TO_CLEAR_BULK_IN
);
963 goto usbtmc_clear_check_status
;
965 usbtmc_clear_bulk_out_halt
:
967 rv
= usb_clear_halt(data
->usb_dev
,
968 usb_sndbulkpipe(data
->usb_dev
, data
->bulk_out
));
970 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
980 static int usbtmc_ioctl_clear_out_halt(struct usbtmc_device_data
*data
)
984 rv
= usb_clear_halt(data
->usb_dev
,
985 usb_sndbulkpipe(data
->usb_dev
, data
->bulk_out
));
988 dev_err(&data
->usb_dev
->dev
, "usb_control_msg returned %d\n",
995 static int usbtmc_ioctl_clear_in_halt(struct usbtmc_device_data
*data
)
999 rv
= usb_clear_halt(data
->usb_dev
,
1000 usb_rcvbulkpipe(data
->usb_dev
, data
->bulk_in
));
1003 dev_err(&data
->usb_dev
->dev
, "usb_control_msg returned %d\n",
1010 static int get_capabilities(struct usbtmc_device_data
*data
)
1012 struct device
*dev
= &data
->usb_dev
->dev
;
1016 buffer
= kmalloc(0x18, GFP_KERNEL
);
1020 rv
= usb_control_msg(data
->usb_dev
, usb_rcvctrlpipe(data
->usb_dev
, 0),
1021 USBTMC_REQUEST_GET_CAPABILITIES
,
1022 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
1023 0, 0, buffer
, 0x18, USBTMC_TIMEOUT
);
1025 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
1029 dev_dbg(dev
, "GET_CAPABILITIES returned %x\n", buffer
[0]);
1030 if (buffer
[0] != USBTMC_STATUS_SUCCESS
) {
1031 dev_err(dev
, "GET_CAPABILITIES returned %x\n", buffer
[0]);
1035 dev_dbg(dev
, "Interface capabilities are %x\n", buffer
[4]);
1036 dev_dbg(dev
, "Device capabilities are %x\n", buffer
[5]);
1037 dev_dbg(dev
, "USB488 interface capabilities are %x\n", buffer
[14]);
1038 dev_dbg(dev
, "USB488 device capabilities are %x\n", buffer
[15]);
1040 data
->capabilities
.interface_capabilities
= buffer
[4];
1041 data
->capabilities
.device_capabilities
= buffer
[5];
1042 data
->capabilities
.usb488_interface_capabilities
= buffer
[14];
1043 data
->capabilities
.usb488_device_capabilities
= buffer
[15];
1044 data
->usb488_caps
= (buffer
[14] & 0x07) | ((buffer
[15] & 0x0f) << 4);
1052 #define capability_attribute(name) \
1053 static ssize_t name##_show(struct device *dev, \
1054 struct device_attribute *attr, char *buf) \
1056 struct usb_interface *intf = to_usb_interface(dev); \
1057 struct usbtmc_device_data *data = usb_get_intfdata(intf); \
1059 return sprintf(buf, "%d\n", data->capabilities.name); \
1061 static DEVICE_ATTR_RO(name)
1063 capability_attribute(interface_capabilities
);
1064 capability_attribute(device_capabilities
);
1065 capability_attribute(usb488_interface_capabilities
);
1066 capability_attribute(usb488_device_capabilities
);
1068 static struct attribute
*capability_attrs
[] = {
1069 &dev_attr_interface_capabilities
.attr
,
1070 &dev_attr_device_capabilities
.attr
,
1071 &dev_attr_usb488_interface_capabilities
.attr
,
1072 &dev_attr_usb488_device_capabilities
.attr
,
1076 static const struct attribute_group capability_attr_grp
= {
1077 .attrs
= capability_attrs
,
1080 static ssize_t
TermChar_show(struct device
*dev
,
1081 struct device_attribute
*attr
, char *buf
)
1083 struct usb_interface
*intf
= to_usb_interface(dev
);
1084 struct usbtmc_device_data
*data
= usb_get_intfdata(intf
);
1086 return sprintf(buf
, "%c\n", data
->TermChar
);
1089 static ssize_t
TermChar_store(struct device
*dev
,
1090 struct device_attribute
*attr
,
1091 const char *buf
, size_t count
)
1093 struct usb_interface
*intf
= to_usb_interface(dev
);
1094 struct usbtmc_device_data
*data
= usb_get_intfdata(intf
);
1098 data
->TermChar
= buf
[0];
1101 static DEVICE_ATTR_RW(TermChar
);
1103 #define data_attribute(name) \
1104 static ssize_t name##_show(struct device *dev, \
1105 struct device_attribute *attr, char *buf) \
1107 struct usb_interface *intf = to_usb_interface(dev); \
1108 struct usbtmc_device_data *data = usb_get_intfdata(intf); \
1110 return sprintf(buf, "%d\n", data->name); \
1112 static ssize_t name##_store(struct device *dev, \
1113 struct device_attribute *attr, \
1114 const char *buf, size_t count) \
1116 struct usb_interface *intf = to_usb_interface(dev); \
1117 struct usbtmc_device_data *data = usb_get_intfdata(intf); \
1121 result = sscanf(buf, "%u\n", &val); \
1130 static DEVICE_ATTR_RW(name)
1132 data_attribute(TermCharEnabled
);
1133 data_attribute(auto_abort
);
1135 static struct attribute
*data_attrs
[] = {
1136 &dev_attr_TermChar
.attr
,
1137 &dev_attr_TermCharEnabled
.attr
,
1138 &dev_attr_auto_abort
.attr
,
1142 static const struct attribute_group data_attr_grp
= {
1143 .attrs
= data_attrs
,
1146 static int usbtmc_ioctl_indicator_pulse(struct usbtmc_device_data
*data
)
1152 dev
= &data
->intf
->dev
;
1154 buffer
= kmalloc(2, GFP_KERNEL
);
1158 rv
= usb_control_msg(data
->usb_dev
,
1159 usb_rcvctrlpipe(data
->usb_dev
, 0),
1160 USBTMC_REQUEST_INDICATOR_PULSE
,
1161 USB_DIR_IN
| USB_TYPE_CLASS
| USB_RECIP_INTERFACE
,
1162 0, 0, buffer
, 0x01, USBTMC_TIMEOUT
);
1165 dev_err(dev
, "usb_control_msg returned %d\n", rv
);
1169 dev_dbg(dev
, "INDICATOR_PULSE returned %x\n", buffer
[0]);
1171 if (buffer
[0] != USBTMC_STATUS_SUCCESS
) {
1172 dev_err(dev
, "INDICATOR_PULSE returned %x\n", buffer
[0]);
1183 static long usbtmc_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
1185 struct usbtmc_device_data
*data
;
1186 int retval
= -EBADRQC
;
1188 data
= file
->private_data
;
1189 mutex_lock(&data
->io_mutex
);
1192 goto skip_io_on_zombie
;
1196 case USBTMC_IOCTL_CLEAR_OUT_HALT
:
1197 retval
= usbtmc_ioctl_clear_out_halt(data
);
1200 case USBTMC_IOCTL_CLEAR_IN_HALT
:
1201 retval
= usbtmc_ioctl_clear_in_halt(data
);
1204 case USBTMC_IOCTL_INDICATOR_PULSE
:
1205 retval
= usbtmc_ioctl_indicator_pulse(data
);
1208 case USBTMC_IOCTL_CLEAR
:
1209 retval
= usbtmc_ioctl_clear(data
);
1212 case USBTMC_IOCTL_ABORT_BULK_OUT
:
1213 retval
= usbtmc_ioctl_abort_bulk_out(data
);
1216 case USBTMC_IOCTL_ABORT_BULK_IN
:
1217 retval
= usbtmc_ioctl_abort_bulk_in(data
);
1220 case USBTMC488_IOCTL_GET_CAPS
:
1221 retval
= copy_to_user((void __user
*)arg
,
1223 sizeof(data
->usb488_caps
));
1228 case USBTMC488_IOCTL_READ_STB
:
1229 retval
= usbtmc488_ioctl_read_stb(data
, (void __user
*)arg
);
1232 case USBTMC488_IOCTL_REN_CONTROL
:
1233 retval
= usbtmc488_ioctl_simple(data
, (void __user
*)arg
,
1234 USBTMC488_REQUEST_REN_CONTROL
);
1237 case USBTMC488_IOCTL_GOTO_LOCAL
:
1238 retval
= usbtmc488_ioctl_simple(data
, (void __user
*)arg
,
1239 USBTMC488_REQUEST_GOTO_LOCAL
);
1242 case USBTMC488_IOCTL_LOCAL_LOCKOUT
:
1243 retval
= usbtmc488_ioctl_simple(data
, (void __user
*)arg
,
1244 USBTMC488_REQUEST_LOCAL_LOCKOUT
);
1249 mutex_unlock(&data
->io_mutex
);
1253 static int usbtmc_fasync(int fd
, struct file
*file
, int on
)
1255 struct usbtmc_device_data
*data
= file
->private_data
;
1257 return fasync_helper(fd
, file
, on
, &data
->fasync
);
1260 static unsigned int usbtmc_poll(struct file
*file
, poll_table
*wait
)
1262 struct usbtmc_device_data
*data
= file
->private_data
;
1265 mutex_lock(&data
->io_mutex
);
1268 mask
= POLLHUP
| POLLERR
;
1272 poll_wait(file
, &data
->waitq
, wait
);
1274 mask
= (atomic_read(&data
->srq_asserted
)) ? POLLIN
| POLLRDNORM
: 0;
1277 mutex_unlock(&data
->io_mutex
);
1281 static const struct file_operations fops
= {
1282 .owner
= THIS_MODULE
,
1283 .read
= usbtmc_read
,
1284 .write
= usbtmc_write
,
1285 .open
= usbtmc_open
,
1286 .release
= usbtmc_release
,
1287 .unlocked_ioctl
= usbtmc_ioctl
,
1288 .fasync
= usbtmc_fasync
,
1289 .poll
= usbtmc_poll
,
1290 .llseek
= default_llseek
,
1293 static struct usb_class_driver usbtmc_class
= {
1296 .minor_base
= USBTMC_MINOR_BASE
,
1299 static void usbtmc_interrupt(struct urb
*urb
)
1301 struct usbtmc_device_data
*data
= urb
->context
;
1302 struct device
*dev
= &data
->intf
->dev
;
1303 int status
= urb
->status
;
1306 dev_dbg(&data
->intf
->dev
, "int status: %d len %d\n",
1307 status
, urb
->actual_length
);
1310 case 0: /* SUCCESS */
1311 /* check for valid STB notification */
1312 if (data
->iin_buffer
[0] > 0x81) {
1313 data
->bNotify1
= data
->iin_buffer
[0];
1314 data
->bNotify2
= data
->iin_buffer
[1];
1315 atomic_set(&data
->iin_data_valid
, 1);
1316 wake_up_interruptible(&data
->waitq
);
1319 /* check for SRQ notification */
1320 if (data
->iin_buffer
[0] == 0x81) {
1322 kill_fasync(&data
->fasync
,
1325 atomic_set(&data
->srq_asserted
, 1);
1326 wake_up_interruptible(&data
->waitq
);
1329 dev_warn(dev
, "invalid notification: %x\n", data
->iin_buffer
[0]);
1332 dev_err(dev
, "overflow with length %d, actual length is %d\n",
1333 data
->iin_wMaxPacketSize
, urb
->actual_length
);
1340 /* urb terminated, clean up */
1341 dev_dbg(dev
, "urb terminated, status: %d\n", status
);
1344 dev_err(dev
, "unknown status received: %d\n", status
);
1347 rv
= usb_submit_urb(urb
, GFP_ATOMIC
);
1349 dev_err(dev
, "usb_submit_urb failed: %d\n", rv
);
1352 static void usbtmc_free_int(struct usbtmc_device_data
*data
)
1354 if (!data
->iin_ep_present
|| !data
->iin_urb
)
1356 usb_kill_urb(data
->iin_urb
);
1357 kfree(data
->iin_buffer
);
1358 usb_free_urb(data
->iin_urb
);
1359 kref_put(&data
->kref
, usbtmc_delete
);
1362 static int usbtmc_probe(struct usb_interface
*intf
,
1363 const struct usb_device_id
*id
)
1365 struct usbtmc_device_data
*data
;
1366 struct usb_host_interface
*iface_desc
;
1367 struct usb_endpoint_descriptor
*bulk_in
, *bulk_out
, *int_in
;
1371 dev_dbg(&intf
->dev
, "%s called\n", __func__
);
1373 data
= kzalloc(sizeof(*data
), GFP_KERNEL
);
1379 data
->usb_dev
= usb_get_dev(interface_to_usbdev(intf
));
1380 usb_set_intfdata(intf
, data
);
1381 kref_init(&data
->kref
);
1382 mutex_init(&data
->io_mutex
);
1383 init_waitqueue_head(&data
->waitq
);
1384 atomic_set(&data
->iin_data_valid
, 0);
1385 atomic_set(&data
->srq_asserted
, 0);
1388 /* Determine if it is a Rigol or not */
1389 data
->rigol_quirk
= 0;
1390 dev_dbg(&intf
->dev
, "Trying to find if device Vendor 0x%04X Product 0x%04X has the RIGOL quirk\n",
1391 le16_to_cpu(data
->usb_dev
->descriptor
.idVendor
),
1392 le16_to_cpu(data
->usb_dev
->descriptor
.idProduct
));
1393 for(n
= 0; usbtmc_id_quirk
[n
].idVendor
> 0; n
++) {
1394 if ((usbtmc_id_quirk
[n
].idVendor
== le16_to_cpu(data
->usb_dev
->descriptor
.idVendor
)) &&
1395 (usbtmc_id_quirk
[n
].idProduct
== le16_to_cpu(data
->usb_dev
->descriptor
.idProduct
))) {
1396 dev_dbg(&intf
->dev
, "Setting this device as having the RIGOL quirk\n");
1397 data
->rigol_quirk
= 1;
1402 /* Initialize USBTMC bTag and other fields */
1404 data
->TermCharEnabled
= 0;
1405 data
->TermChar
= '\n';
1406 /* 2 <= bTag <= 127 USBTMC-USB488 subclass specification 4.3.1 */
1409 /* USBTMC devices have only one setting, so use that */
1410 iface_desc
= data
->intf
->cur_altsetting
;
1411 data
->ifnum
= iface_desc
->desc
.bInterfaceNumber
;
1413 /* Find bulk endpoints */
1414 retcode
= usb_find_common_endpoints(iface_desc
,
1415 &bulk_in
, &bulk_out
, NULL
, NULL
);
1417 dev_err(&intf
->dev
, "bulk endpoints not found\n");
1421 data
->bulk_in
= bulk_in
->bEndpointAddress
;
1422 dev_dbg(&intf
->dev
, "Found bulk in endpoint at %u\n", data
->bulk_in
);
1424 data
->bulk_out
= bulk_out
->bEndpointAddress
;
1425 dev_dbg(&intf
->dev
, "Found Bulk out endpoint at %u\n", data
->bulk_out
);
1427 /* Find int endpoint */
1428 retcode
= usb_find_int_in_endpoint(iface_desc
, &int_in
);
1430 data
->iin_ep_present
= 1;
1431 data
->iin_ep
= int_in
->bEndpointAddress
;
1432 data
->iin_wMaxPacketSize
= usb_endpoint_maxp(int_in
);
1433 data
->iin_interval
= int_in
->bInterval
;
1434 dev_dbg(&intf
->dev
, "Found Int in endpoint at %u\n",
1438 retcode
= get_capabilities(data
);
1440 dev_err(&intf
->dev
, "can't read capabilities\n");
1442 retcode
= sysfs_create_group(&intf
->dev
.kobj
,
1443 &capability_attr_grp
);
1445 if (data
->iin_ep_present
) {
1446 /* allocate int urb */
1447 data
->iin_urb
= usb_alloc_urb(0, GFP_KERNEL
);
1448 if (!data
->iin_urb
) {
1450 goto error_register
;
1453 /* Protect interrupt in endpoint data until iin_urb is freed */
1454 kref_get(&data
->kref
);
1456 /* allocate buffer for interrupt in */
1457 data
->iin_buffer
= kmalloc(data
->iin_wMaxPacketSize
,
1459 if (!data
->iin_buffer
) {
1461 goto error_register
;
1464 /* fill interrupt urb */
1465 usb_fill_int_urb(data
->iin_urb
, data
->usb_dev
,
1466 usb_rcvintpipe(data
->usb_dev
, data
->iin_ep
),
1467 data
->iin_buffer
, data
->iin_wMaxPacketSize
,
1469 data
, data
->iin_interval
);
1471 retcode
= usb_submit_urb(data
->iin_urb
, GFP_KERNEL
);
1473 dev_err(&intf
->dev
, "Failed to submit iin_urb\n");
1474 goto error_register
;
1478 retcode
= sysfs_create_group(&intf
->dev
.kobj
, &data_attr_grp
);
1480 retcode
= usb_register_dev(intf
, &usbtmc_class
);
1482 dev_err(&intf
->dev
, "Not able to get a minor"
1483 " (base %u, slice default): %d\n", USBTMC_MINOR_BASE
,
1485 goto error_register
;
1487 dev_dbg(&intf
->dev
, "Using minor number %d\n", intf
->minor
);
1492 sysfs_remove_group(&intf
->dev
.kobj
, &capability_attr_grp
);
1493 sysfs_remove_group(&intf
->dev
.kobj
, &data_attr_grp
);
1494 usbtmc_free_int(data
);
1496 kref_put(&data
->kref
, usbtmc_delete
);
1500 static void usbtmc_disconnect(struct usb_interface
*intf
)
1502 struct usbtmc_device_data
*data
;
1504 dev_dbg(&intf
->dev
, "usbtmc_disconnect called\n");
1506 data
= usb_get_intfdata(intf
);
1507 usb_deregister_dev(intf
, &usbtmc_class
);
1508 sysfs_remove_group(&intf
->dev
.kobj
, &capability_attr_grp
);
1509 sysfs_remove_group(&intf
->dev
.kobj
, &data_attr_grp
);
1510 mutex_lock(&data
->io_mutex
);
1512 wake_up_all(&data
->waitq
);
1513 mutex_unlock(&data
->io_mutex
);
1514 usbtmc_free_int(data
);
1515 kref_put(&data
->kref
, usbtmc_delete
);
1518 static int usbtmc_suspend(struct usb_interface
*intf
, pm_message_t message
)
1520 /* this driver does not have pending URBs */
1524 static int usbtmc_resume(struct usb_interface
*intf
)
1529 static struct usb_driver usbtmc_driver
= {
1531 .id_table
= usbtmc_devices
,
1532 .probe
= usbtmc_probe
,
1533 .disconnect
= usbtmc_disconnect
,
1534 .suspend
= usbtmc_suspend
,
1535 .resume
= usbtmc_resume
,
1538 module_usb_driver(usbtmc_driver
);
1540 MODULE_LICENSE("GPL");