2623 lines · 61.7 KB · C
RawDownload
// SPDX-License-Identifier: GPL-2.0+/* * drivers/usb/class/usbtmc.c - USB Test & Measurement class driver * * Copyright (C) 2007 Stefan Kopp, Gechingen, Germany * Copyright (C) 2008 Novell, Inc. * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de> * Copyright (C) 2018 IVI Foundation, Inc. */ #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/module.h>#include <linux/kernel.h>#include <linux/fs.h>#include <linux/uaccess.h>#include <linux/kref.h>#include <linux/slab.h>#include <linux/poll.h>#include <linux/mutex.h>#include <linux/usb.h>#include <linux/compat.h>#include <linux/usb/tmc.h> /* Increment API VERSION when changing tmc.h with new flags or ioctls * or when changing a significant behavior of the driver. */#define USBTMC_API_VERSION (3) #define USBTMC_HEADER_SIZE	12#define USBTMC_MINOR_BASE	176 /* Minimum USB timeout (in milliseconds) */#define USBTMC_MIN_TIMEOUT	100/* Default USB timeout (in milliseconds) */#define USBTMC_TIMEOUT		5000 /* Max number of urbs used in write transfers */#define MAX_URBS_IN_FLIGHT	16/* I/O buffer size used in generic read/write functions */#define USBTMC_BUFSIZE		(4096) /* * Maximum number of read cycles to empty bulk in endpoint during CLEAR and * ABORT_BULK_IN requests. Ends the loop if (for whatever reason) a short * packet is never read. */#define USBTMC_MAX_READS_TO_CLEAR_BULK_IN	100 static const struct usb_device_id usbtmc_devices[] = {	{ USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 0), },	{ USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 1), },	{ 0, } /* terminating entry */};MODULE_DEVICE_TABLE(usb, usbtmc_devices); /* * This structure is the capabilities for the device * See section 4.2.1.8 of the USBTMC specification, * and section 4.2.2 of the USBTMC usb488 subclass * specification for details. */struct usbtmc_dev_capabilities {	__u8 interface_capabilities;	__u8 device_capabilities;	__u8 usb488_interface_capabilities;	__u8 usb488_device_capabilities;}; /* This structure holds private data for each USBTMC device. One copy is * allocated for each USBTMC device in the driver's probe function. */struct usbtmc_device_data {	struct usb_device *usb_dev;	struct usb_interface *intf;	struct list_head file_list; 	unsigned int bulk_in;	unsigned int bulk_out; 	u8 bTag;	u8 bTag_last_write;	/* needed for abort */	u8 bTag_last_read;	/* needed for abort */ 	/* packet size of IN bulk */	u16            wMaxPacketSize; 	/* data for interrupt in endpoint handling */	u8             bNotify1;	u8             bNotify2;	u16            ifnum;	u8             iin_bTag;	u8            *iin_buffer;	atomic_t       iin_data_valid;	unsigned int   iin_ep;	int            iin_ep_present;	int            iin_interval;	struct urb    *iin_urb;	u16            iin_wMaxPacketSize; 	/* coalesced usb488_caps from usbtmc_dev_capabilities */	__u8 usb488_caps; 	bool zombie; /* fd of disconnected device */ 	struct usbtmc_dev_capabilities	capabilities;	struct kref kref;	struct mutex io_mutex;	/* only one i/o function running at a time */	wait_queue_head_t waitq;	struct fasync_struct *fasync;	spinlock_t dev_lock; /* lock for file_list */};#define to_usbtmc_data(d) container_of(d, struct usbtmc_device_data, kref) /* * This structure holds private data for each USBTMC file handle. */struct usbtmc_file_data {	struct usbtmc_device_data *data;	struct list_head file_elem; 	u32            timeout;	u8             srq_byte;	atomic_t       srq_asserted;	atomic_t       closing;	u8             bmTransferAttributes; /* member of DEV_DEP_MSG_IN */ 	u8             eom_val;	u8             term_char;	bool           term_char_enabled;	bool           auto_abort; 	spinlock_t     err_lock; /* lock for errors */ 	struct usb_anchor submitted; 	/* data for generic_write */	struct semaphore limit_write_sem;	u32 out_transfer_size;	int out_status; 	/* data for generic_read */	u32 in_transfer_size;	int in_status;	int in_urbs_used;	struct usb_anchor in_anchor;	wait_queue_head_t wait_bulk_in;}; /* Forward declarations */static struct usb_driver usbtmc_driver;static void usbtmc_draw_down(struct usbtmc_file_data *file_data); static void usbtmc_delete(struct kref *kref){	struct usbtmc_device_data *data = to_usbtmc_data(kref); 	usb_put_dev(data->usb_dev);	kfree(data);} static int usbtmc_open(struct inode *inode, struct file *filp){	struct usb_interface *intf;	struct usbtmc_device_data *data;	struct usbtmc_file_data *file_data; 	intf = usb_find_interface(&usbtmc_driver, iminor(inode));	if (!intf) {		pr_err("can not find device for minor %d", iminor(inode));		return -ENODEV;	} 	file_data = kzalloc_obj(*file_data);	if (!file_data)		return -ENOMEM; 	spin_lock_init(&file_data->err_lock);	sema_init(&file_data->limit_write_sem, MAX_URBS_IN_FLIGHT);	init_usb_anchor(&file_data->submitted);	init_usb_anchor(&file_data->in_anchor);	init_waitqueue_head(&file_data->wait_bulk_in); 	data = usb_get_intfdata(intf);	/* Protect reference to data from file structure until release */	kref_get(&data->kref); 	mutex_lock(&data->io_mutex);	file_data->data = data; 	atomic_set(&file_data->closing, 0); 	file_data->timeout = USBTMC_TIMEOUT;	file_data->term_char = '\n';	file_data->term_char_enabled = 0;	file_data->auto_abort = 0;	file_data->eom_val = 1; 	INIT_LIST_HEAD(&file_data->file_elem);	spin_lock_irq(&data->dev_lock);	list_add_tail(&file_data->file_elem, &data->file_list);	spin_unlock_irq(&data->dev_lock);	mutex_unlock(&data->io_mutex); 	/* Store pointer in file structure's private data field */	filp->private_data = file_data; 	return 0;} /* * usbtmc_flush - called before file handle is closed */static int usbtmc_flush(struct file *file, fl_owner_t id){	struct usbtmc_file_data *file_data;	struct usbtmc_device_data *data; 	file_data = file->private_data;	if (file_data == NULL)		return -ENODEV; 	atomic_set(&file_data->closing, 1);	data = file_data->data; 	/* wait for io to stop */	mutex_lock(&data->io_mutex); 	usbtmc_draw_down(file_data); 	spin_lock_irq(&file_data->err_lock);	file_data->in_status = 0;	file_data->in_transfer_size = 0;	file_data->in_urbs_used = 0;	file_data->out_status = 0;	file_data->out_transfer_size = 0;	spin_unlock_irq(&file_data->err_lock); 	wake_up_interruptible_all(&data->waitq);	mutex_unlock(&data->io_mutex); 	return 0;} static int usbtmc_release(struct inode *inode, struct file *file){	struct usbtmc_file_data *file_data = file->private_data; 	/* prevent IO _AND_ usbtmc_interrupt */	mutex_lock(&file_data->data->io_mutex);	spin_lock_irq(&file_data->data->dev_lock); 	list_del(&file_data->file_elem); 	spin_unlock_irq(&file_data->data->dev_lock); 	/* flush anchored URBs */	usbtmc_draw_down(file_data);	mutex_unlock(&file_data->data->io_mutex); 	kref_put(&file_data->data->kref, usbtmc_delete);	file_data->data = NULL;	kfree(file_data);	return 0;} static int usbtmc_ioctl_abort_bulk_in_tag(struct usbtmc_device_data *data,					  u8 tag){	u8 *buffer;	struct device *dev;	int rv;	int n;	int actual; 	dev = &data->intf->dev;	buffer = kmalloc(USBTMC_BUFSIZE, GFP_KERNEL);	if (!buffer)		return -ENOMEM; 	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_INITIATE_ABORT_BULK_IN,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,			     tag, data->bulk_in,			     buffer, 2, USB_CTRL_GET_TIMEOUT); 	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d\n", rv);		goto exit;	} 	dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x with tag %02x\n",		buffer[0], buffer[1]); 	if (buffer[0] == USBTMC_STATUS_FAILED) {		/* No transfer in progress and the Bulk-OUT FIFO is empty. */		rv = 0;		goto exit;	} 	if (buffer[0] == USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS) {		/* The device returns this status if either:		 * - There is a transfer in progress, but the specified bTag		 *   does not match.		 * - There is no transfer in progress, but the Bulk-OUT FIFO		 *   is not empty.		 */		rv = -ENOMSG;		goto exit;	} 	if (buffer[0] != USBTMC_STATUS_SUCCESS) {		dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x\n",			buffer[0]);		rv = -EPERM;		goto exit;	} 	n = 0; usbtmc_abort_bulk_in_status:	dev_dbg(dev, "Reading from bulk in EP\n"); 	/* Data must be present. So use low timeout 300 ms */	actual = 0;	rv = usb_bulk_msg(data->usb_dev,			  usb_rcvbulkpipe(data->usb_dev,					  data->bulk_in),			  buffer, USBTMC_BUFSIZE,			  &actual, 300); 	print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 16, 1,			     buffer, actual, true); 	n++; 	if (rv < 0) {		dev_err(dev, "usb_bulk_msg returned %d\n", rv);		if (rv != -ETIMEDOUT)			goto exit;	} 	if (actual == USBTMC_BUFSIZE)		goto usbtmc_abort_bulk_in_status; 	if (n >= USBTMC_MAX_READS_TO_CLEAR_BULK_IN) {		dev_err(dev, "Couldn't clear device buffer within %d cycles\n",			USBTMC_MAX_READS_TO_CLEAR_BULK_IN);		rv = -EPERM;		goto exit;	} 	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,			     0, data->bulk_in, buffer, 0x08,			     USB_CTRL_GET_TIMEOUT); 	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d\n", rv);		goto exit;	} 	dev_dbg(dev, "CHECK_ABORT_BULK_IN returned %x\n", buffer[0]); 	if (buffer[0] == USBTMC_STATUS_SUCCESS) {		rv = 0;		goto exit;	} 	if (buffer[0] != USBTMC_STATUS_PENDING) {		dev_err(dev, "CHECK_ABORT_BULK_IN returned %x\n", buffer[0]);		rv = -EPERM;		goto exit;	} 	if ((buffer[1] & 1) > 0) {		/* The device has 1 or more queued packets the Host can read */		goto usbtmc_abort_bulk_in_status;	} 	/* The Host must send CHECK_ABORT_BULK_IN_STATUS at a later time. */	rv = -EAGAIN;exit:	kfree(buffer);	return rv;} static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data *data){	return usbtmc_ioctl_abort_bulk_in_tag(data, data->bTag_last_read);} static int usbtmc_ioctl_abort_bulk_out_tag(struct usbtmc_device_data *data,					   u8 tag){	struct device *dev;	u8 *buffer;	int rv;	int n; 	dev = &data->intf->dev; 	buffer = kmalloc(8, GFP_KERNEL);	if (!buffer)		return -ENOMEM; 	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_INITIATE_ABORT_BULK_OUT,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,			     tag, data->bulk_out,			     buffer, 2, USB_CTRL_GET_TIMEOUT); 	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d\n", rv);		goto exit;	} 	dev_dbg(dev, "INITIATE_ABORT_BULK_OUT returned %x\n", buffer[0]); 	if (buffer[0] != USBTMC_STATUS_SUCCESS) {		dev_err(dev, "INITIATE_ABORT_BULK_OUT returned %x\n",			buffer[0]);		rv = -EPERM;		goto exit;	} 	n = 0; usbtmc_abort_bulk_out_check_status:	/* do not stress device with subsequent requests */	msleep(50);	rv = usb_control_msg(data->usb_dev,			     usb_rcvctrlpipe(data->usb_dev, 0),			     USBTMC_REQUEST_CHECK_ABORT_BULK_OUT_STATUS,			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,			     0, data->bulk_out, buffer, 0x08,			     USB_CTRL_GET_TIMEOUT);	n++;	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d\n", rv);		goto exit;	} 	dev_dbg(dev, "CHECK_ABORT_BULK_OUT returned %x\n", buffer[0]); 	if (buffer[0] == USBTMC_STATUS_SUCCESS)		goto usbtmc_abort_bulk_out_clear_halt; 	if ((buffer[0] == USBTMC_STATUS_PENDING) &&	    (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN))		goto usbtmc_abort_bulk_out_check_status; 	rv = -EPERM;	goto exit; usbtmc_abort_bulk_out_clear_halt:	rv = usb_clear_halt(data->usb_dev,			    usb_sndbulkpipe(data->usb_dev, data->bulk_out)); 	if (rv < 0) {		dev_err(dev, "usb_control_msg returned %d\n", rv);		goto exit;	}	rv = 0; exit:	kfree(buffer);	return rv;} static int usbtmc_ioctl_abort_bulk_out(struct usbtmc_device_data *data){	return usbtmc_ioctl_abort_bulk_out_tag(data, data->bTag_last_write);} static int usbtmc_get_stb(struct usbtmc_file_data *file_data, __u8 *stb){	struct usbtmc_device_data *data = file_data->data;	struct device *dev = &data->intf->dev;	u8 *buffer;	u8 tag;	int rv;	long wait_rv;	unsigned long expire; 	dev_dbg(dev, "Enter ioctl_read_stb iin_ep_present: %d\n",		data->iin_ep_present); 	buffer = kmalloc(8, GFP_KERNEL);	if (!buffer)		return -ENOMEM; 	atomic_set(&data->iin_data_valid, 0); 	rv = usb_control_msg(data->usb_dev,			usb_rcvctrlpipe(data->usb_dev, 0),

Lines 1–500 of 2623.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t