usbtmc.c revision ca157c4a51fa6209f28c316f4a63d594adb79518 
1/**
2 * drivers/usb/class/usbtmc.c - USB Test & Measurment class driver
3 *
4 * Copyright (C) 2007 Stefan Kopp, Gechingen, Germany
5 * Copyright (C) 2008 Novell, Inc.
6 * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License
10 * as published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 * GNU General Public License for more details.
17 *
18 * The GNU General Public License is available at
19 * http://www.gnu.org/copyleft/gpl.html.
20 */
21
22#include <linux/init.h>
23#include <linux/module.h>
24#include <linux/kernel.h>
25#include <linux/fs.h>
26#include <linux/uaccess.h>
27#include <linux/kref.h>
28#include <linux/mutex.h>
29#include <linux/usb.h>
30#include <linux/usb/tmc.h>
31
32
33#define USBTMC_MINOR_BASE	176
34
35/*
36 * Size of driver internal IO buffer. Must be multiple of 4 and at least as
37 * large as wMaxPacketSize (which is usually 512 bytes).
38 */
39#define USBTMC_SIZE_IOBUFFER	2048
40
41/* Default USB timeout (in milliseconds) */
42#define USBTMC_TIMEOUT		10
43
44/*
45 * Maximum number of read cycles to empty bulk in endpoint during CLEAR and
46 * ABORT_BULK_IN requests. Ends the loop if (for whatever reason) a short
47 * packet is never read.
48 */
49#define USBTMC_MAX_READS_TO_CLEAR_BULK_IN	100
50
51static struct usb_device_id usbtmc_devices[] = {
52	{ USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 0), },
53	{ USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 1), },
54	{ 0, } /* terminating entry */
55};
56MODULE_DEVICE_TABLE(usb, usbtmc_devices);
57
58/*
59 * This structure is the capabilities for the device
60 * See section 4.2.1.8 of the USBTMC specification for details.
61 */
62struct usbtmc_dev_capabilities {
63	__u8 interface_capabilities;
64	__u8 device_capabilities;
65	__u8 usb488_interface_capabilities;
66	__u8 usb488_device_capabilities;
67};
68
69/* This structure holds private data for each USBTMC device. One copy is
70 * allocated for each USBTMC device in the driver's probe function.
71 */
72struct usbtmc_device_data {
73	const struct usb_device_id *id;
74	struct usb_device *usb_dev;
75	struct usb_interface *intf;
76
77	unsigned int bulk_in;
78	unsigned int bulk_out;
79
80	u8 bTag;
81	u8 bTag_last_write;	/* needed for abort */
82	u8 bTag_last_read;	/* needed for abort */
83
84	/* attributes from the USB TMC spec for this device */
85	u8 TermChar;
86	bool TermCharEnabled;
87	bool auto_abort;
88
89	struct usbtmc_dev_capabilities	capabilities;
90	struct kref kref;
91	struct mutex io_mutex;	/* only one i/o function running at a time */
92};
93#define to_usbtmc_data(d) container_of(d, struct usbtmc_device_data, kref)
94
95/* Forward declarations */
96static struct usb_driver usbtmc_driver;
97
98static void usbtmc_delete(struct kref *kref)
99{
100	struct usbtmc_device_data *data = to_usbtmc_data(kref);
101
102	usb_put_dev(data->usb_dev);
103	kfree(data);
104}
105
106static int usbtmc_open(struct inode *inode, struct file *filp)
107{
108	struct usb_interface *intf;
109	struct usbtmc_device_data *data;
110	int retval = 0;
111
112	intf = usb_find_interface(&usbtmc_driver, iminor(inode));
113	if (!intf) {
114		printk(KERN_ERR KBUILD_MODNAME
115		       ": can not find device for minor %d", iminor(inode));
116		retval = -ENODEV;
117		goto exit;
118	}
119
120	data = usb_get_intfdata(intf);
121	kref_get(&data->kref);
122
123	/* Store pointer in file structure's private data field */
124	filp->private_data = data;
125
126exit:
127	return retval;
128}
129
130static int usbtmc_release(struct inode *inode, struct file *file)
131{
132	struct usbtmc_device_data *data = file->private_data;
133
134	kref_put(&data->kref, usbtmc_delete);
135	return 0;
136}
137
138static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data *data)
139{
140	u8 *buffer;
141	struct device *dev;
142	int rv;
143	int n;
144	int actual;
145	struct usb_host_interface *current_setting;
146	int max_size;
147
148	dev = &data->intf->dev;
149	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
150	if (!buffer)
151		return -ENOMEM;
152
153	rv = usb_control_msg(data->usb_dev,
154			     usb_rcvctrlpipe(data->usb_dev, 0),
155			     USBTMC_REQUEST_INITIATE_ABORT_BULK_IN,
156			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
157			     data->bTag_last_read, data->bulk_in,
158			     buffer, 2, USBTMC_TIMEOUT);
159
160	if (rv < 0) {
161		dev_err(dev, "usb_control_msg returned %d\n", rv);
162		goto exit;
163	}
164
165	dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x\n", buffer[0]);
166
167	if (buffer[0] == USBTMC_STATUS_FAILED) {
168		rv = 0;
169		goto exit;
170	}
171
172	if (buffer[0] != USBTMC_STATUS_SUCCESS) {
173		dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x\n",
174			buffer[0]);
175		rv = -EPERM;
176		goto exit;
177	}
178
179	max_size = 0;
180	current_setting = data->intf->cur_altsetting;
181	for (n = 0; n < current_setting->desc.bNumEndpoints; n++)
182		if (current_setting->endpoint[n].desc.bEndpointAddress ==
183			data->bulk_in)
184			max_size = le16_to_cpu(current_setting->endpoint[n].
185						desc.wMaxPacketSize);
186
187	if (max_size == 0) {
188		dev_err(dev, "Couldn't get wMaxPacketSize\n");
189		rv = -EPERM;
190		goto exit;
191	}
192
193	dev_dbg(&data->intf->dev, "wMaxPacketSize is %d\n", max_size);
194
195	n = 0;
196
197	do {
198		dev_dbg(dev, "Reading from bulk in EP\n");
199
200		rv = usb_bulk_msg(data->usb_dev,
201				  usb_rcvbulkpipe(data->usb_dev,
202						  data->bulk_in),
203				  buffer, USBTMC_SIZE_IOBUFFER,
204				  &actual, USBTMC_TIMEOUT);
205
206		n++;
207
208		if (rv < 0) {
209			dev_err(dev, "usb_bulk_msg returned %d\n", rv);
210			goto exit;
211		}
212	} while ((actual == max_size) &&
213		 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
214
215	if (actual == max_size) {
216		dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
217			USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
218		rv = -EPERM;
219		goto exit;
220	}
221
222	n = 0;
223
224usbtmc_abort_bulk_in_status:
225	rv = usb_control_msg(data->usb_dev,
226			     usb_rcvctrlpipe(data->usb_dev, 0),
227			     USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS,
228			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
229			     0, data->bulk_in, buffer, 0x08,
230			     USBTMC_TIMEOUT);
231
232	if (rv < 0) {
233		dev_err(dev, "usb_control_msg returned %d\n", rv);
234		goto exit;
235	}
236
237	dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x\n", buffer[0]);
238
239	if (buffer[0] == USBTMC_STATUS_SUCCESS) {
240		rv = 0;
241		goto exit;
242	}
243
244	if (buffer[0] != USBTMC_STATUS_PENDING) {
245		dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x\n", buffer[0]);
246		rv = -EPERM;
247		goto exit;
248	}
249
250	if (buffer[1] == 1)
251		do {
252			dev_dbg(dev, "Reading from bulk in EP\n");
253
254			rv = usb_bulk_msg(data->usb_dev,
255					  usb_rcvbulkpipe(data->usb_dev,
256							  data->bulk_in),
257					  buffer, USBTMC_SIZE_IOBUFFER,
258					  &actual, USBTMC_TIMEOUT);
259
260			n++;
261
262			if (rv < 0) {
263				dev_err(dev, "usb_bulk_msg returned %d\n", rv);
264				goto exit;
265			}
266		} while ((actual = max_size) &&
267			 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
268
269	if (actual == max_size) {
270		dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
271			USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
272		rv = -EPERM;
273		goto exit;
274	}
275
276	goto usbtmc_abort_bulk_in_status;
277
278exit:
279	kfree(buffer);
280	return rv;
281
282}
283
284static int usbtmc_ioctl_abort_bulk_out(struct usbtmc_device_data *data)
285{
286	struct device *dev;
287	u8 *buffer;
288	int rv;
289	int n;
290
291	dev = &data->intf->dev;
292
293	buffer = kmalloc(8, GFP_KERNEL);
294	if (!buffer)
295		return -ENOMEM;
296
297	rv = usb_control_msg(data->usb_dev,
298			     usb_rcvctrlpipe(data->usb_dev, 0),
299			     USBTMC_REQUEST_INITIATE_ABORT_BULK_OUT,
300			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
301			     data->bTag_last_write, data->bulk_out,
302			     buffer, 2, USBTMC_TIMEOUT);
303
304	if (rv < 0) {
305		dev_err(dev, "usb_control_msg returned %d\n", rv);
306		goto exit;
307	}
308
309	dev_dbg(dev, "INITIATE_ABORT_BULK_OUT returned %x\n", buffer[0]);
310
311	if (buffer[0] != USBTMC_STATUS_SUCCESS) {
312		dev_err(dev, "INITIATE_ABORT_BULK_OUT returned %x\n",
313			buffer[0]);
314		rv = -EPERM;
315		goto exit;
316	}
317
318	n = 0;
319
320usbtmc_abort_bulk_out_check_status:
321	rv = usb_control_msg(data->usb_dev,
322			     usb_rcvctrlpipe(data->usb_dev, 0),
323			     USBTMC_REQUEST_CHECK_ABORT_BULK_OUT_STATUS,
324			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
325			     0, data->bulk_out, buffer, 0x08,
326			     USBTMC_TIMEOUT);
327	n++;
328	if (rv < 0) {
329		dev_err(dev, "usb_control_msg returned %d\n", rv);
330		goto exit;
331	}
332
333	dev_dbg(dev, "CHECK_ABORT_BULK_OUT returned %x\n", buffer[0]);
334
335	if (buffer[0] == USBTMC_STATUS_SUCCESS)
336		goto usbtmc_abort_bulk_out_clear_halt;
337
338	if ((buffer[0] == USBTMC_STATUS_PENDING) &&
339	    (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN))
340		goto usbtmc_abort_bulk_out_check_status;
341
342	rv = -EPERM;
343	goto exit;
344
345usbtmc_abort_bulk_out_clear_halt:
346	rv = usb_control_msg(data->usb_dev,
347			     usb_sndctrlpipe(data->usb_dev, 0),
348			     USB_REQ_CLEAR_FEATURE,
349			     USB_DIR_OUT | USB_TYPE_STANDARD |
350			     USB_RECIP_ENDPOINT,
351			     USB_ENDPOINT_HALT, data->bulk_out, buffer,
352			     0, USBTMC_TIMEOUT);
353
354	if (rv < 0) {
355		dev_err(dev, "usb_control_msg returned %d\n", rv);
356		goto exit;
357	}
358	rv = 0;
359
360exit:
361	kfree(buffer);
362	return rv;
363}
364
365static ssize_t usbtmc_read(struct file *filp, char __user *buf,
366			   size_t count, loff_t *f_pos)
367{
368	struct usbtmc_device_data *data;
369	struct device *dev;
370	unsigned long int n_characters;
371	u8 *buffer;
372	int actual;
373	int done;
374	int remaining;
375	int retval;
376	int this_part;
377
378	/* Get pointer to private data structure */
379	data = filp->private_data;
380	dev = &data->intf->dev;
381
382	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
383	if (!buffer)
384		return -ENOMEM;
385
386	mutex_lock(&data->io_mutex);
387
388	remaining = count;
389	done = 0;
390
391	while (remaining > 0) {
392		if (remaining > USBTMC_SIZE_IOBUFFER - 12 - 3)
393			this_part = USBTMC_SIZE_IOBUFFER - 12 - 3;
394		else
395			this_part = remaining;
396
397		/* Setup IO buffer for DEV_DEP_MSG_IN message
398		 * Refer to class specs for details
399		 */
400		buffer[0] = 2;
401		buffer[1] = data->bTag;
402		buffer[2] = ~(data->bTag);
403		buffer[3] = 0; /* Reserved */
404		buffer[4] = (this_part - 12 - 3) & 255;
405		buffer[5] = ((this_part - 12 - 3) >> 8) & 255;
406		buffer[6] = ((this_part - 12 - 3) >> 16) & 255;
407		buffer[7] = ((this_part - 12 - 3) >> 24) & 255;
408		buffer[8] = data->TermCharEnabled * 2;
409		/* Use term character? */
410		buffer[9] = data->TermChar;
411		buffer[10] = 0; /* Reserved */
412		buffer[11] = 0; /* Reserved */
413
414		/* Send bulk URB */
415		retval = usb_bulk_msg(data->usb_dev,
416				      usb_sndbulkpipe(data->usb_dev,
417						      data->bulk_out),
418				      buffer, 12, &actual, USBTMC_TIMEOUT);
419
420		/* Store bTag (in case we need to abort) */
421		data->bTag_last_write = data->bTag;
422
423		/* Increment bTag -- and increment again if zero */
424		data->bTag++;
425		if (!data->bTag)
426			(data->bTag)++;
427
428		if (retval < 0) {
429			dev_err(dev, "usb_bulk_msg returned %d\n", retval);
430			if (data->auto_abort)
431				usbtmc_ioctl_abort_bulk_out(data);
432			goto exit;
433		}
434
435		/* Send bulk URB */
436		retval = usb_bulk_msg(data->usb_dev,
437				      usb_rcvbulkpipe(data->usb_dev,
438						      data->bulk_in),
439				      buffer, USBTMC_SIZE_IOBUFFER, &actual,
440				      USBTMC_TIMEOUT);
441
442		/* Store bTag (in case we need to abort) */
443		data->bTag_last_read = data->bTag;
444
445		if (retval < 0) {
446			dev_err(dev, "Unable to read data, error %d\n", retval);
447			if (data->auto_abort)
448				usbtmc_ioctl_abort_bulk_in(data);
449			goto exit;
450		}
451
452		/* How many characters did the instrument send? */
453		n_characters = buffer[4] +
454			       (buffer[5] << 8) +
455			       (buffer[6] << 16) +
456			       (buffer[7] << 24);
457
458		/* Copy buffer to user space */
459		if (copy_to_user(buf + done, &buffer[12], n_characters)) {
460			/* There must have been an addressing problem */
461			retval = -EFAULT;
462			goto exit;
463		}
464
465		done += n_characters;
466		if (n_characters < USBTMC_SIZE_IOBUFFER)
467			remaining = 0;
468	}
469
470	/* Update file position value */
471	*f_pos = *f_pos + done;
472	retval = done;
473
474exit:
475	mutex_unlock(&data->io_mutex);
476	kfree(buffer);
477	return retval;
478}
479
480static ssize_t usbtmc_write(struct file *filp, const char __user *buf,
481			    size_t count, loff_t *f_pos)
482{
483	struct usbtmc_device_data *data;
484	u8 *buffer;
485	int retval;
486	int actual;
487	unsigned long int n_bytes;
488	int remaining;
489	int done;
490	int this_part;
491
492	data = filp->private_data;
493
494	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
495	if (!buffer)
496		return -ENOMEM;
497
498	mutex_lock(&data->io_mutex);
499
500	remaining = count;
501	done = 0;
502
503	while (remaining > 0) {
504		if (remaining > USBTMC_SIZE_IOBUFFER - 12) {
505			this_part = USBTMC_SIZE_IOBUFFER - 12;
506			buffer[8] = 0;
507		} else {
508			this_part = remaining;
509			buffer[8] = 1;
510		}
511
512		/* Setup IO buffer for DEV_DEP_MSG_OUT message */
513		buffer[0] = 1;
514		buffer[1] = data->bTag;
515		buffer[2] = ~(data->bTag);
516		buffer[3] = 0; /* Reserved */
517		buffer[4] = this_part & 255;
518		buffer[5] = (this_part >> 8) & 255;
519		buffer[6] = (this_part >> 16) & 255;
520		buffer[7] = (this_part >> 24) & 255;
521		/* buffer[8] is set above... */
522		buffer[9] = 0; /* Reserved */
523		buffer[10] = 0; /* Reserved */
524		buffer[11] = 0; /* Reserved */
525
526		if (copy_from_user(&buffer[12], buf + done, this_part)) {
527			retval = -EFAULT;
528			goto exit;
529		}
530
531		n_bytes = roundup(12 + this_part, 4);
532		memset(buffer + 12 + this_part, 0, n_bytes - (12 + this_part));
533
534		retval = usb_bulk_msg(data->usb_dev,
535				      usb_sndbulkpipe(data->usb_dev,
536						      data->bulk_out),
537				      buffer, n_bytes, &actual, USBTMC_TIMEOUT);
538
539		data->bTag_last_write = data->bTag;
540		data->bTag++;
541
542		if (!data->bTag)
543			data->bTag++;
544
545		if (retval < 0) {
546			dev_err(&data->intf->dev,
547				"Unable to send data, error %d\n", retval);
548			if (data->auto_abort)
549				usbtmc_ioctl_abort_bulk_out(data);
550			goto exit;
551		}
552
553		remaining -= this_part;
554		done += this_part;
555	}
556
557	retval = count;
558exit:
559	mutex_unlock(&data->io_mutex);
560	kfree(buffer);
561	return retval;
562}
563
564static int usbtmc_ioctl_clear(struct usbtmc_device_data *data)
565{
566	struct usb_host_interface *current_setting;
567	struct usb_endpoint_descriptor *desc;
568	struct device *dev;
569	u8 *buffer;
570	int rv;
571	int n;
572	int actual;
573	int max_size;
574
575	dev = &data->intf->dev;
576
577	dev_dbg(dev, "Sending INITIATE_CLEAR request\n");
578
579	buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
580	if (!buffer)
581		return -ENOMEM;
582
583	rv = usb_control_msg(data->usb_dev,
584			     usb_rcvctrlpipe(data->usb_dev, 0),
585			     USBTMC_REQUEST_INITIATE_CLEAR,
586			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
587			     0, 0, buffer, 1, USBTMC_TIMEOUT);
588	if (rv < 0) {
589		dev_err(dev, "usb_control_msg returned %d\n", rv);
590		goto exit;
591	}
592
593	dev_dbg(dev, "INITIATE_CLEAR returned %x\n", buffer[0]);
594
595	if (buffer[0] != USBTMC_STATUS_SUCCESS) {
596		dev_err(dev, "INITIATE_CLEAR returned %x\n", buffer[0]);
597		rv = -EPERM;
598		goto exit;
599	}
600
601	max_size = 0;
602	current_setting = data->intf->cur_altsetting;
603	for (n = 0; n < current_setting->desc.bNumEndpoints; n++) {
604		desc = &current_setting->endpoint[n].desc;
605		if (desc->bEndpointAddress == data->bulk_in)
606			max_size = le16_to_cpu(desc->wMaxPacketSize);
607	}
608
609	if (max_size == 0) {
610		dev_err(dev, "Couldn't get wMaxPacketSize\n");
611		rv = -EPERM;
612		goto exit;
613	}
614
615	dev_dbg(dev, "wMaxPacketSize is %d\n", max_size);
616
617	n = 0;
618
619usbtmc_clear_check_status:
620
621	dev_dbg(dev, "Sending CHECK_CLEAR_STATUS request\n");
622
623	rv = usb_control_msg(data->usb_dev,
624			     usb_rcvctrlpipe(data->usb_dev, 0),
625			     USBTMC_REQUEST_CHECK_CLEAR_STATUS,
626			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
627			     0, 0, buffer, 2, USBTMC_TIMEOUT);
628	if (rv < 0) {
629		dev_err(dev, "usb_control_msg returned %d\n", rv);
630		goto exit;
631	}
632
633	dev_dbg(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]);
634
635	if (buffer[0] == USBTMC_STATUS_SUCCESS)
636		goto usbtmc_clear_bulk_out_halt;
637
638	if (buffer[0] != USBTMC_STATUS_PENDING) {
639		dev_err(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]);
640		rv = -EPERM;
641		goto exit;
642	}
643
644	if (buffer[1] == 1)
645		do {
646			dev_dbg(dev, "Reading from bulk in EP\n");
647
648			rv = usb_bulk_msg(data->usb_dev,
649					  usb_rcvbulkpipe(data->usb_dev,
650							  data->bulk_in),
651					  buffer, USBTMC_SIZE_IOBUFFER,
652					  &actual, USBTMC_TIMEOUT);
653			n++;
654
655			if (rv < 0) {
656				dev_err(dev, "usb_control_msg returned %d\n",
657					rv);
658				goto exit;
659			}
660		} while ((actual == max_size) &&
661			  (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
662
663	if (actual == max_size) {
664		dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
665			USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
666		rv = -EPERM;
667		goto exit;
668	}
669
670	goto usbtmc_clear_check_status;
671
672usbtmc_clear_bulk_out_halt:
673
674	rv = usb_control_msg(data->usb_dev,
675			     usb_sndctrlpipe(data->usb_dev, 0),
676			     USB_REQ_CLEAR_FEATURE,
677			     USB_DIR_OUT | USB_TYPE_STANDARD |
678			     USB_RECIP_ENDPOINT,
679			     USB_ENDPOINT_HALT,
680			     data->bulk_out, buffer, 0,
681			     USBTMC_TIMEOUT);
682	if (rv < 0) {
683		dev_err(dev, "usb_control_msg returned %d\n", rv);
684		goto exit;
685	}
686	rv = 0;
687
688exit:
689	kfree(buffer);
690	return rv;
691}
692
693static int usbtmc_ioctl_clear_out_halt(struct usbtmc_device_data *data)
694{
695	u8 *buffer;
696	int rv;
697
698	buffer = kmalloc(2, GFP_KERNEL);
699	if (!buffer)
700		return -ENOMEM;
701
702	rv = usb_control_msg(data->usb_dev,
703			     usb_sndctrlpipe(data->usb_dev, 0),
704			     USB_REQ_CLEAR_FEATURE,
705			     USB_DIR_OUT | USB_TYPE_STANDARD |
706			     USB_RECIP_ENDPOINT,
707			     USB_ENDPOINT_HALT, data->bulk_out,
708			     buffer, 0, USBTMC_TIMEOUT);
709
710	if (rv < 0) {
711		dev_err(&data->usb_dev->dev, "usb_control_msg returned %d\n",
712			rv);
713		goto exit;
714	}
715	rv = 0;
716
717exit:
718	kfree(buffer);
719	return rv;
720}
721
722static int usbtmc_ioctl_clear_in_halt(struct usbtmc_device_data *data)
723{
724	u8 *buffer;
725	int rv;
726
727	buffer = kmalloc(2, GFP_KERNEL);
728	if (!buffer)
729		return -ENOMEM;
730
731	rv = usb_control_msg(data->usb_dev, usb_sndctrlpipe(data->usb_dev, 0),
732			     USB_REQ_CLEAR_FEATURE,
733			     USB_DIR_OUT | USB_TYPE_STANDARD |
734			     USB_RECIP_ENDPOINT,
735			     USB_ENDPOINT_HALT, data->bulk_in, buffer, 0,
736			     USBTMC_TIMEOUT);
737
738	if (rv < 0) {
739		dev_err(&data->usb_dev->dev, "usb_control_msg returned %d\n",
740			rv);
741		goto exit;
742	}
743	rv = 0;
744
745exit:
746	kfree(buffer);
747	return rv;
748}
749
750static int get_capabilities(struct usbtmc_device_data *data)
751{
752	struct device *dev = &data->usb_dev->dev;
753	char *buffer;
754	int rv = 0;
755
756	buffer = kmalloc(0x18, GFP_KERNEL);
757	if (!buffer)
758		return -ENOMEM;
759
760	rv = usb_control_msg(data->usb_dev, usb_rcvctrlpipe(data->usb_dev, 0),
761			     USBTMC_REQUEST_GET_CAPABILITIES,
762			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
763			     0, 0, buffer, 0x18, USBTMC_TIMEOUT);
764	if (rv < 0) {
765		dev_err(dev, "usb_control_msg returned %d\n", rv);
766		goto err_out;
767	}
768
769	dev_dbg(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
770	dev_dbg(dev, "Interface capabilities are %x\n", buffer[4]);
771	dev_dbg(dev, "Device capabilities are %x\n", buffer[5]);
772	dev_dbg(dev, "USB488 interface capabilities are %x\n", buffer[14]);
773	dev_dbg(dev, "USB488 device capabilities are %x\n", buffer[15]);
774	if (buffer[0] != USBTMC_STATUS_SUCCESS) {
775		dev_err(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
776		rv = -EPERM;
777		goto err_out;
778	}
779
780	data->capabilities.interface_capabilities = buffer[4];
781	data->capabilities.device_capabilities = buffer[5];
782	data->capabilities.usb488_interface_capabilities = buffer[14];
783	data->capabilities.usb488_device_capabilities = buffer[15];
784
785err_out:
786	kfree(buffer);
787	return rv;
788}
789
790#define capability_attribute(name)					\
791static ssize_t show_##name(struct device *dev,				\
792			   struct device_attribute *attr, char *buf)	\
793{									\
794	struct usb_interface *intf = to_usb_interface(dev);		\
795	struct usbtmc_device_data *data = usb_get_intfdata(intf);	\
796									\
797	return sprintf(buf, "%d\n", data->capabilities.name);		\
798}									\
799static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
800
801capability_attribute(interface_capabilities);
802capability_attribute(device_capabilities);
803capability_attribute(usb488_interface_capabilities);
804capability_attribute(usb488_device_capabilities);
805
806static struct attribute *capability_attrs[] = {
807	&dev_attr_interface_capabilities.attr,
808	&dev_attr_device_capabilities.attr,
809	&dev_attr_usb488_interface_capabilities.attr,
810	&dev_attr_usb488_device_capabilities.attr,
811	NULL,
812};
813
814static struct attribute_group capability_attr_grp = {
815	.attrs = capability_attrs,
816};
817
818static ssize_t show_TermChar(struct device *dev,
819			     struct device_attribute *attr, char *buf)
820{
821	struct usb_interface *intf = to_usb_interface(dev);
822	struct usbtmc_device_data *data = usb_get_intfdata(intf);
823
824	return sprintf(buf, "%c\n", data->TermChar);
825}
826
827static ssize_t store_TermChar(struct device *dev,
828			      struct device_attribute *attr,
829			      const char *buf, size_t count)
830{
831	struct usb_interface *intf = to_usb_interface(dev);
832	struct usbtmc_device_data *data = usb_get_intfdata(intf);
833
834	if (count < 1)
835		return -EINVAL;
836	data->TermChar = buf[0];
837	return count;
838}
839static DEVICE_ATTR(TermChar, S_IRUGO, show_TermChar, store_TermChar);
840
841#define data_attribute(name)						\
842static ssize_t show_##name(struct device *dev,				\
843			   struct device_attribute *attr, char *buf)	\
844{									\
845	struct usb_interface *intf = to_usb_interface(dev);		\
846	struct usbtmc_device_data *data = usb_get_intfdata(intf);	\
847									\
848	return sprintf(buf, "%d\n", data->name);			\
849}									\
850static ssize_t store_##name(struct device *dev,				\
851			    struct device_attribute *attr,		\
852			    const char *buf, size_t count)		\
853{									\
854	struct usb_interface *intf = to_usb_interface(dev);		\
855	struct usbtmc_device_data *data = usb_get_intfdata(intf);	\
856	ssize_t result;							\
857	unsigned val;							\
858									\
859	result = sscanf(buf, "%u\n", &val);				\
860	if (result != 1)						\
861		result = -EINVAL;					\
862	data->name = val;						\
863	if (result < 0)							\
864		return result;						\
865	else								\
866		return count;						\
867}									\
868static DEVICE_ATTR(name, S_IRUGO, show_##name, store_##name)
869
870data_attribute(TermCharEnabled);
871data_attribute(auto_abort);
872
873static struct attribute *data_attrs[] = {
874	&dev_attr_TermChar.attr,
875	&dev_attr_TermCharEnabled.attr,
876	&dev_attr_auto_abort.attr,
877	NULL,
878};
879
880static struct attribute_group data_attr_grp = {
881	.attrs = data_attrs,
882};
883
884static int usbtmc_ioctl_indicator_pulse(struct usbtmc_device_data *data)
885{
886	struct device *dev;
887	u8 *buffer;
888	int rv;
889
890	dev = &data->intf->dev;
891
892	buffer = kmalloc(2, GFP_KERNEL);
893	if (!buffer)
894		return -ENOMEM;
895
896	rv = usb_control_msg(data->usb_dev,
897			     usb_rcvctrlpipe(data->usb_dev, 0),
898			     USBTMC_REQUEST_INDICATOR_PULSE,
899			     USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
900			     0, 0, buffer, 0x01, USBTMC_TIMEOUT);
901
902	if (rv < 0) {
903		dev_err(dev, "usb_control_msg returned %d\n", rv);
904		goto exit;
905	}
906
907	dev_dbg(dev, "INDICATOR_PULSE returned %x\n", buffer[0]);
908
909	if (buffer[0] != USBTMC_STATUS_SUCCESS) {
910		dev_err(dev, "INDICATOR_PULSE returned %x\n", buffer[0]);
911		rv = -EPERM;
912		goto exit;
913	}
914	rv = 0;
915
916exit:
917	kfree(buffer);
918	return rv;
919}
920
921static long usbtmc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
922{
923	struct usbtmc_device_data *data;
924	int retval = -EBADRQC;
925
926	data = file->private_data;
927	mutex_lock(&data->io_mutex);
928
929	switch (cmd) {
930	case USBTMC_IOCTL_CLEAR_OUT_HALT:
931		retval = usbtmc_ioctl_clear_out_halt(data);
932		break;
933
934	case USBTMC_IOCTL_CLEAR_IN_HALT:
935		retval = usbtmc_ioctl_clear_in_halt(data);
936		break;
937
938	case USBTMC_IOCTL_INDICATOR_PULSE:
939		retval = usbtmc_ioctl_indicator_pulse(data);
940		break;
941
942	case USBTMC_IOCTL_CLEAR:
943		retval = usbtmc_ioctl_clear(data);
944		break;
945
946	case USBTMC_IOCTL_ABORT_BULK_OUT:
947		retval = usbtmc_ioctl_abort_bulk_out(data);
948		break;
949
950	case USBTMC_IOCTL_ABORT_BULK_IN:
951		retval = usbtmc_ioctl_abort_bulk_in(data);
952		break;
953	}
954
955	mutex_unlock(&data->io_mutex);
956	return retval;
957}
958
959static struct file_operations fops = {
960	.owner		= THIS_MODULE,
961	.read		= usbtmc_read,
962	.write		= usbtmc_write,
963	.open		= usbtmc_open,
964	.release	= usbtmc_release,
965	.unlocked_ioctl	= usbtmc_ioctl,
966};
967
968static struct usb_class_driver usbtmc_class = {
969	.name =		"usbtmc%d",
970	.fops =		&fops,
971	.minor_base =	USBTMC_MINOR_BASE,
972};
973
974
975static int usbtmc_probe(struct usb_interface *intf,
976			const struct usb_device_id *id)
977{
978	struct usbtmc_device_data *data;
979	struct usb_host_interface *iface_desc;
980	struct usb_endpoint_descriptor *endpoint;
981	int n;
982	int retcode;
983
984	dev_dbg(&intf->dev, "%s called\n", __func__);
985
986	data = kmalloc(sizeof(struct usbtmc_device_data), GFP_KERNEL);
987	if (!data) {
988		dev_err(&intf->dev, "Unable to allocate kernel memory\n");
989		return -ENOMEM;
990	}
991
992	data->intf = intf;
993	data->id = id;
994	data->usb_dev = usb_get_dev(interface_to_usbdev(intf));
995	usb_set_intfdata(intf, data);
996	kref_init(&data->kref);
997	mutex_init(&data->io_mutex);
998
999	/* Initialize USBTMC bTag and other fields */
1000	data->bTag	= 1;
1001	data->TermCharEnabled = 0;
1002	data->TermChar = '\n';
1003
1004	/* USBTMC devices have only one setting, so use that */
1005	iface_desc = data->intf->cur_altsetting;
1006
1007	/* Find bulk in endpoint */
1008	for (n = 0; n < iface_desc->desc.bNumEndpoints; n++) {
1009		endpoint = &iface_desc->endpoint[n].desc;
1010
1011		if (usb_endpoint_is_bulk_in(endpoint)) {
1012			data->bulk_in = endpoint->bEndpointAddress;
1013			dev_dbg(&intf->dev, "Found bulk in endpoint at %u\n",
1014				data->bulk_in);
1015			break;
1016		}
1017	}
1018
1019	/* Find bulk out endpoint */
1020	for (n = 0; n < iface_desc->desc.bNumEndpoints; n++) {
1021		endpoint = &iface_desc->endpoint[n].desc;
1022
1023		if (usb_endpoint_is_bulk_out(endpoint)) {
1024			data->bulk_out = endpoint->bEndpointAddress;
1025			dev_dbg(&intf->dev, "Found Bulk out endpoint at %u\n",
1026				data->bulk_out);
1027			break;
1028		}
1029	}
1030
1031	retcode = get_capabilities(data);
1032	if (retcode)
1033		dev_err(&intf->dev, "can't read capabilities\n");
1034	else
1035		retcode = sysfs_create_group(&intf->dev.kobj,
1036					     &capability_attr_grp);
1037
1038	retcode = sysfs_create_group(&intf->dev.kobj, &data_attr_grp);
1039
1040	retcode = usb_register_dev(intf, &usbtmc_class);
1041	if (retcode) {
1042		dev_err(&intf->dev, "Not able to get a minor"
1043			" (base %u, slice default): %d\n", USBTMC_MINOR_BASE,
1044			retcode);
1045		goto error_register;
1046	}
1047	dev_dbg(&intf->dev, "Using minor number %d\n", intf->minor);
1048
1049	return 0;
1050
1051error_register:
1052	sysfs_remove_group(&intf->dev.kobj, &capability_attr_grp);
1053	sysfs_remove_group(&intf->dev.kobj, &data_attr_grp);
1054	kref_put(&data->kref, usbtmc_delete);
1055	return retcode;
1056}
1057
1058static void usbtmc_disconnect(struct usb_interface *intf)
1059{
1060	struct usbtmc_device_data *data;
1061
1062	dev_dbg(&intf->dev, "usbtmc_disconnect called\n");
1063
1064	data = usb_get_intfdata(intf);
1065	usb_deregister_dev(intf, &usbtmc_class);
1066	sysfs_remove_group(&intf->dev.kobj, &capability_attr_grp);
1067	sysfs_remove_group(&intf->dev.kobj, &data_attr_grp);
1068	kref_put(&data->kref, usbtmc_delete);
1069}
1070
1071static struct usb_driver usbtmc_driver = {
1072	.name		= "usbtmc",
1073	.id_table	= usbtmc_devices,
1074	.probe		= usbtmc_probe,
1075	.disconnect	= usbtmc_disconnect
1076};
1077
1078static int __init usbtmc_init(void)
1079{
1080	int retcode;
1081
1082	retcode = usb_register(&usbtmc_driver);
1083	if (retcode)
1084		printk(KERN_ERR KBUILD_MODNAME": Unable to register driver\n");
1085	return retcode;
1086}
1087module_init(usbtmc_init);
1088
1089static void __exit usbtmc_exit(void)
1090{
1091	usb_deregister(&usbtmc_driver);
1092}
1093module_exit(usbtmc_exit);
1094
1095MODULE_LICENSE("GPL");
1096