?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: vboxvideo: Add vbox_bo_k[un]map helper functions
[linux/fpc-iii.git] / drivers / usb / class / usbtmc.c
blob83ffa5a14c3dbbc53e8b964a4101e6e4a19c57a5
1 // SPDX-License-Identifier: GPL-2.0+
2 /**
3 * drivers/usb/class/usbtmc.c - USB Test & Measurement class driver
4 *
5 * Copyright (C) 2007 Stefan Kopp, Gechingen, Germany
6 * Copyright (C) 2008 Novell, Inc.
7 * Copyright (C) 2008 Greg Kroah-Hartman <gregkh@suse.de>
8 */
9
10 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/fs.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/compat.h>
22 #include <linux/usb/tmc.h>
23
24
25 #define USBTMC_HEADER_SIZE 12
26 #define USBTMC_MINOR_BASE 176
27
28 /*
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).
31 */
32 #define USBTMC_SIZE_IOBUFFER 2048
33
34 /* Minimum USB timeout (in milliseconds) */
35 #define USBTMC_MIN_TIMEOUT 100
36 /* Default USB timeout (in milliseconds) */
37 #define USBTMC_TIMEOUT 5000
38
39 /*
40 * Maximum number of read cycles to empty bulk in endpoint during CLEAR and
41 * ABORT_BULK_IN requests. Ends the loop if (for whatever reason) a short
42 * packet is never read.
43 */
44 #define USBTMC_MAX_READS_TO_CLEAR_BULK_IN 100
45
46 static const struct usb_device_id usbtmc_devices[] = {
47 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 0), },
48 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 1), },
49 { 0, } /* terminating entry */
50 };
51 MODULE_DEVICE_TABLE(usb, usbtmc_devices);
52
53 /*
54 * This structure is the capabilities for the device
55 * See section 4.2.1.8 of the USBTMC specification,
56 * and section 4.2.2 of the USBTMC usb488 subclass
57 * specification for details.
58 */
59 struct usbtmc_dev_capabilities {
60 __u8 interface_capabilities;
61 __u8 device_capabilities;
62 __u8 usb488_interface_capabilities;
63 __u8 usb488_device_capabilities;
64 };
65
66 /* This structure holds private data for each USBTMC device. One copy is
67 * allocated for each USBTMC device in the driver's probe function.
68 */
69 struct usbtmc_device_data {
70 const struct usb_device_id *id;
71 struct usb_device *usb_dev;
72 struct usb_interface *intf;
73 struct list_head file_list;
74
75 unsigned int bulk_in;
76 unsigned int bulk_out;
77
78 u8 bTag;
79 u8 bTag_last_write; /* needed for abort */
80 u8 bTag_last_read; /* needed for abort */
81
82 /* data for interrupt in endpoint handling */
83 u8 bNotify1;
84 u8 bNotify2;
85 u16 ifnum;
86 u8 iin_bTag;
87 u8 *iin_buffer;
88 atomic_t iin_data_valid;
89 unsigned int iin_ep;
90 int iin_ep_present;
91 int iin_interval;
92 struct urb *iin_urb;
93 u16 iin_wMaxPacketSize;
94
95 /* coalesced usb488_caps from usbtmc_dev_capabilities */
96 __u8 usb488_caps;
97
98 /* attributes from the USB TMC spec for this device */
99 u8 TermChar;
100 bool TermCharEnabled;
101 bool auto_abort;
102
103 bool zombie; /* fd of disconnected device */
104
105 struct usbtmc_dev_capabilities capabilities;
106 struct kref kref;
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;
110 spinlock_t dev_lock; /* lock for file_list */
111 };
112 #define to_usbtmc_data(d) container_of(d, struct usbtmc_device_data, kref)
113
114 /*
115 * This structure holds private data for each USBTMC file handle.
116 */
117 struct usbtmc_file_data {
118 struct usbtmc_device_data *data;
119 struct list_head file_elem;
120
121 u32 timeout;
122 u8 srq_byte;
123 atomic_t srq_asserted;
124 u8 eom_val;
125 u8 term_char;
126 bool term_char_enabled;
127 };
128
129 /* Forward declarations */
130 static struct usb_driver usbtmc_driver;
131
132 static void usbtmc_delete(struct kref *kref)
133 {
134 struct usbtmc_device_data *data = to_usbtmc_data(kref);
135
136 usb_put_dev(data->usb_dev);
137 kfree(data);
138 }
139
140 static int usbtmc_open(struct inode *inode, struct file *filp)
141 {
142 struct usb_interface *intf;
143 struct usbtmc_device_data *data;
144 struct usbtmc_file_data *file_data;
145
146 intf = usb_find_interface(&usbtmc_driver, iminor(inode));
147 if (!intf) {
148 pr_err("can not find device for minor %d", iminor(inode));
149 return -ENODEV;
150 }
151
152 file_data = kzalloc(sizeof(*file_data), GFP_KERNEL);
153 if (!file_data)
154 return -ENOMEM;
155
156 data = usb_get_intfdata(intf);
157 /* Protect reference to data from file structure until release */
158 kref_get(&data->kref);
159
160 mutex_lock(&data->io_mutex);
161 file_data->data = data;
162
163 /* copy default values from device settings */
164 file_data->timeout = USBTMC_TIMEOUT;
165 file_data->term_char = data->TermChar;
166 file_data->term_char_enabled = data->TermCharEnabled;
167 file_data->eom_val = 1;
168
169 INIT_LIST_HEAD(&file_data->file_elem);
170 spin_lock_irq(&data->dev_lock);
171 list_add_tail(&file_data->file_elem, &data->file_list);
172 spin_unlock_irq(&data->dev_lock);
173 mutex_unlock(&data->io_mutex);
174
175 /* Store pointer in file structure's private data field */
176 filp->private_data = file_data;
177
178 return 0;
179 }
180
181 static int usbtmc_release(struct inode *inode, struct file *file)
182 {
183 struct usbtmc_file_data *file_data = file->private_data;
184
185 /* prevent IO _AND_ usbtmc_interrupt */
186 mutex_lock(&file_data->data->io_mutex);
187 spin_lock_irq(&file_data->data->dev_lock);
188
189 list_del(&file_data->file_elem);
190
191 spin_unlock_irq(&file_data->data->dev_lock);
192 mutex_unlock(&file_data->data->io_mutex);
193
194 kref_put(&file_data->data->kref, usbtmc_delete);
195 file_data->data = NULL;
196 kfree(file_data);
197 return 0;
198 }
199
200 static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data *data)
201 {
202 u8 *buffer;
203 struct device *dev;
204 int rv;
205 int n;
206 int actual;
207 struct usb_host_interface *current_setting;
208 int max_size;
209
210 dev = &data->intf->dev;
211 buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
212 if (!buffer)
213 return -ENOMEM;
214
215 rv = usb_control_msg(data->usb_dev,
216 usb_rcvctrlpipe(data->usb_dev, 0),
217 USBTMC_REQUEST_INITIATE_ABORT_BULK_IN,
218 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
219 data->bTag_last_read, data->bulk_in,
220 buffer, 2, USBTMC_TIMEOUT);
221
222 if (rv < 0) {
223 dev_err(dev, "usb_control_msg returned %d\n", rv);
224 goto exit;
225 }
226
227 dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x\n", buffer[0]);
228
229 if (buffer[0] == USBTMC_STATUS_FAILED) {
230 rv = 0;
231 goto exit;
232 }
233
234 if (buffer[0] != USBTMC_STATUS_SUCCESS) {
235 dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x\n",
236 buffer[0]);
237 rv = -EPERM;
238 goto exit;
239 }
240
241 max_size = 0;
242 current_setting = data->intf->cur_altsetting;
243 for (n = 0; n < current_setting->desc.bNumEndpoints; n++)
244 if (current_setting->endpoint[n].desc.bEndpointAddress ==
245 data->bulk_in)
246 max_size = usb_endpoint_maxp(&current_setting->endpoint[n].desc);
247
248 if (max_size == 0) {
249 dev_err(dev, "Couldn't get wMaxPacketSize\n");
250 rv = -EPERM;
251 goto exit;
252 }
253
254 dev_dbg(&data->intf->dev, "wMaxPacketSize is %d\n", max_size);
255
256 n = 0;
257
258 do {
259 dev_dbg(dev, "Reading from bulk in EP\n");
260
261 rv = usb_bulk_msg(data->usb_dev,
262 usb_rcvbulkpipe(data->usb_dev,
263 data->bulk_in),
264 buffer, USBTMC_SIZE_IOBUFFER,
265 &actual, USBTMC_TIMEOUT);
266
267 n++;
268
269 if (rv < 0) {
270 dev_err(dev, "usb_bulk_msg returned %d\n", rv);
271 goto exit;
272 }
273 } while ((actual == max_size) &&
274 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
275
276 if (actual == max_size) {
277 dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
278 USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
279 rv = -EPERM;
280 goto exit;
281 }
282
283 n = 0;
284
285 usbtmc_abort_bulk_in_status:
286 rv = usb_control_msg(data->usb_dev,
287 usb_rcvctrlpipe(data->usb_dev, 0),
288 USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS,
289 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
290 0, data->bulk_in, buffer, 0x08,
291 USBTMC_TIMEOUT);
292
293 if (rv < 0) {
294 dev_err(dev, "usb_control_msg returned %d\n", rv);
295 goto exit;
296 }
297
298 dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x\n", buffer[0]);
299
300 if (buffer[0] == USBTMC_STATUS_SUCCESS) {
301 rv = 0;
302 goto exit;
303 }
304
305 if (buffer[0] != USBTMC_STATUS_PENDING) {
306 dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x\n", buffer[0]);
307 rv = -EPERM;
308 goto exit;
309 }
310
311 if (buffer[1] == 1)
312 do {
313 dev_dbg(dev, "Reading from bulk in EP\n");
314
315 rv = usb_bulk_msg(data->usb_dev,
316 usb_rcvbulkpipe(data->usb_dev,
317 data->bulk_in),
318 buffer, USBTMC_SIZE_IOBUFFER,
319 &actual, USBTMC_TIMEOUT);
320
321 n++;
322
323 if (rv < 0) {
324 dev_err(dev, "usb_bulk_msg returned %d\n", rv);
325 goto exit;
326 }
327 } while ((actual == max_size) &&
328 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
329
330 if (actual == max_size) {
331 dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
332 USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
333 rv = -EPERM;
334 goto exit;
335 }
336
337 goto usbtmc_abort_bulk_in_status;
338
339 exit:
340 kfree(buffer);
341 return rv;
342
343 }
344
345 static int usbtmc_ioctl_abort_bulk_out(struct usbtmc_device_data *data)
346 {
347 struct device *dev;
348 u8 *buffer;
349 int rv;
350 int n;
351
352 dev = &data->intf->dev;
353
354 buffer = kmalloc(8, GFP_KERNEL);
355 if (!buffer)
356 return -ENOMEM;
357
358 rv = usb_control_msg(data->usb_dev,
359 usb_rcvctrlpipe(data->usb_dev, 0),
360 USBTMC_REQUEST_INITIATE_ABORT_BULK_OUT,
361 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
362 data->bTag_last_write, data->bulk_out,
363 buffer, 2, USBTMC_TIMEOUT);
364
365 if (rv < 0) {
366 dev_err(dev, "usb_control_msg returned %d\n", rv);
367 goto exit;
368 }
369
370 dev_dbg(dev, "INITIATE_ABORT_BULK_OUT returned %x\n", buffer[0]);
371
372 if (buffer[0] != USBTMC_STATUS_SUCCESS) {
373 dev_err(dev, "INITIATE_ABORT_BULK_OUT returned %x\n",
374 buffer[0]);
375 rv = -EPERM;
376 goto exit;
377 }
378
379 n = 0;
380
381 usbtmc_abort_bulk_out_check_status:
382 rv = usb_control_msg(data->usb_dev,
383 usb_rcvctrlpipe(data->usb_dev, 0),
384 USBTMC_REQUEST_CHECK_ABORT_BULK_OUT_STATUS,
385 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT,
386 0, data->bulk_out, buffer, 0x08,
387 USBTMC_TIMEOUT);
388 n++;
389 if (rv < 0) {
390 dev_err(dev, "usb_control_msg returned %d\n", rv);
391 goto exit;
392 }
393
394 dev_dbg(dev, "CHECK_ABORT_BULK_OUT returned %x\n", buffer[0]);
395
396 if (buffer[0] == USBTMC_STATUS_SUCCESS)
397 goto usbtmc_abort_bulk_out_clear_halt;
398
399 if ((buffer[0] == USBTMC_STATUS_PENDING) &&
400 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN))
401 goto usbtmc_abort_bulk_out_check_status;
402
403 rv = -EPERM;
404 goto exit;
405
406 usbtmc_abort_bulk_out_clear_halt:
407 rv = usb_clear_halt(data->usb_dev,
408 usb_sndbulkpipe(data->usb_dev, data->bulk_out));
409
410 if (rv < 0) {
411 dev_err(dev, "usb_control_msg returned %d\n", rv);
412 goto exit;
413 }
414 rv = 0;
415
416 exit:
417 kfree(buffer);
418 return rv;
419 }
420
421 static int usbtmc488_ioctl_read_stb(struct usbtmc_file_data *file_data,
422 void __user *arg)
423 {
424 struct usbtmc_device_data *data = file_data->data;
425 struct device *dev = &data->intf->dev;
426 int srq_asserted = 0;
427 u8 *buffer;
428 u8 tag;
429 __u8 stb;
430 int rv;
431
432 dev_dbg(dev, "Enter ioctl_read_stb iin_ep_present: %d\n",
433 data->iin_ep_present);
434
435 spin_lock_irq(&data->dev_lock);
436 srq_asserted = atomic_xchg(&file_data->srq_asserted, srq_asserted);
437 if (srq_asserted) {
438 /* a STB with SRQ is already received */
439 stb = file_data->srq_byte;
440 spin_unlock_irq(&data->dev_lock);
441 rv = put_user(stb, (__u8 __user *)arg);
442 dev_dbg(dev, "stb:0x%02x with srq received %d\n",
443 (unsigned int)stb, rv);
444 return rv;
445 }
446 spin_unlock_irq(&data->dev_lock);
447
448 buffer = kmalloc(8, GFP_KERNEL);
449 if (!buffer)
450 return -ENOMEM;
451
452 atomic_set(&data->iin_data_valid, 0);
453
454 rv = usb_control_msg(data->usb_dev,
455 usb_rcvctrlpipe(data->usb_dev, 0),
456 USBTMC488_REQUEST_READ_STATUS_BYTE,
457 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
458 data->iin_bTag,
459 data->ifnum,
460 buffer, 0x03, USBTMC_TIMEOUT);
461 if (rv < 0) {
462 dev_err(dev, "stb usb_control_msg returned %d\n", rv);
463 goto exit;
464 }
465
466 if (buffer[0] != USBTMC_STATUS_SUCCESS) {
467 dev_err(dev, "control status returned %x\n", buffer[0]);
468 rv = -EIO;
469 goto exit;
470 }
471
472 if (data->iin_ep_present) {
473 rv = wait_event_interruptible_timeout(
474 data->waitq,
475 atomic_read(&data->iin_data_valid) != 0,
476 file_data->timeout);
477 if (rv < 0) {
478 dev_dbg(dev, "wait interrupted %d\n", rv);
479 goto exit;
480 }
481
482 if (rv == 0) {
483 dev_dbg(dev, "wait timed out\n");
484 rv = -ETIMEDOUT;
485 goto exit;
486 }
487
488 tag = data->bNotify1 & 0x7f;
489 if (tag != data->iin_bTag) {
490 dev_err(dev, "expected bTag %x got %x\n",
491 data->iin_bTag, tag);
492 }
493
494 stb = data->bNotify2;
495 } else {
496 stb = buffer[2];
497 }
498
499 rv = put_user(stb, (__u8 __user *)arg);
500 dev_dbg(dev, "stb:0x%02x received %d\n", (unsigned int)stb, rv);
501
502 exit:
503 /* bump interrupt bTag */
504 data->iin_bTag += 1;
505 if (data->iin_bTag > 127)
506 /* 1 is for SRQ see USBTMC-USB488 subclass spec section 4.3.1 */
507 data->iin_bTag = 2;
508
509 kfree(buffer);
510 return rv;
511 }
512
513 static int usbtmc488_ioctl_simple(struct usbtmc_device_data *data,
514 void __user *arg, unsigned int cmd)
515 {
516 struct device *dev = &data->intf->dev;
517 __u8 val;
518 u8 *buffer;
519 u16 wValue;
520 int rv;
521
522 if (!(data->usb488_caps & USBTMC488_CAPABILITY_SIMPLE))
523 return -EINVAL;
524
525 buffer = kmalloc(8, GFP_KERNEL);
526 if (!buffer)
527 return -ENOMEM;
528
529 if (cmd == USBTMC488_REQUEST_REN_CONTROL) {
530 rv = copy_from_user(&val, arg, sizeof(val));
531 if (rv) {
532 rv = -EFAULT;
533 goto exit;
534 }
535 wValue = val ? 1 : 0;
536 } else {
537 wValue = 0;
538 }
539
540 rv = usb_control_msg(data->usb_dev,
541 usb_rcvctrlpipe(data->usb_dev, 0),
542 cmd,
543 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
544 wValue,
545 data->ifnum,
546 buffer, 0x01, USBTMC_TIMEOUT);
547 if (rv < 0) {
548 dev_err(dev, "simple usb_control_msg failed %d\n", rv);
549 goto exit;
550 } else if (rv != 1) {
551 dev_warn(dev, "simple usb_control_msg returned %d\n", rv);
552 rv = -EIO;
553 goto exit;
554 }
555
556 if (buffer[0] != USBTMC_STATUS_SUCCESS) {
557 dev_err(dev, "simple control status returned %x\n", buffer[0]);
558 rv = -EIO;
559 goto exit;
560 }
561 rv = 0;
562
563 exit:
564 kfree(buffer);
565 return rv;
566 }
567
568 /*
569 * Sends a TRIGGER Bulk-OUT command message
570 * See the USBTMC-USB488 specification, Table 2.
571 *
572 * Also updates bTag_last_write.
573 */
574 static int usbtmc488_ioctl_trigger(struct usbtmc_file_data *file_data)
575 {
576 struct usbtmc_device_data *data = file_data->data;
577 int retval;
578 u8 *buffer;
579 int actual;
580
581 buffer = kzalloc(USBTMC_HEADER_SIZE, GFP_KERNEL);
582 if (!buffer)
583 return -ENOMEM;
584
585 buffer[0] = 128;
586 buffer[1] = data->bTag;
587 buffer[2] = ~data->bTag;
588
589 retval = usb_bulk_msg(data->usb_dev,
590 usb_sndbulkpipe(data->usb_dev,
591 data->bulk_out),
592 buffer, USBTMC_HEADER_SIZE,
593 &actual, file_data->timeout);
594
595 /* Store bTag (in case we need to abort) */
596 data->bTag_last_write = data->bTag;
597
598 /* Increment bTag -- and increment again if zero */
599 data->bTag++;
600 if (!data->bTag)
601 data->bTag++;
602
603 kfree(buffer);
604 if (retval < 0) {
605 dev_err(&data->intf->dev, "%s returned %d\n",
606 __func__, retval);
607 return retval;
608 }
609
610 return 0;
611 }
612
613 /*
614 * Sends a REQUEST_DEV_DEP_MSG_IN message on the Bulk-OUT endpoint.
615 * @transfer_size: number of bytes to request from the device.
616 *
617 * See the USBTMC specification, Table 4.
618 *
619 * Also updates bTag_last_write.
620 */
621 static int send_request_dev_dep_msg_in(struct usbtmc_file_data *file_data,
622 size_t transfer_size)
623 {
624 struct usbtmc_device_data *data = file_data->data;
625 int retval;
626 u8 *buffer;
627 int actual;
628
629 buffer = kmalloc(USBTMC_HEADER_SIZE, GFP_KERNEL);
630 if (!buffer)
631 return -ENOMEM;
632 /* Setup IO buffer for REQUEST_DEV_DEP_MSG_IN message
633 * Refer to class specs for details
634 */
635 buffer[0] = 2;
636 buffer[1] = data->bTag;
637 buffer[2] = ~data->bTag;
638 buffer[3] = 0; /* Reserved */
639 buffer[4] = transfer_size >> 0;
640 buffer[5] = transfer_size >> 8;
641 buffer[6] = transfer_size >> 16;
642 buffer[7] = transfer_size >> 24;
643 buffer[8] = file_data->term_char_enabled * 2;
644 /* Use term character? */
645 buffer[9] = file_data->term_char;
646 buffer[10] = 0; /* Reserved */
647 buffer[11] = 0; /* Reserved */
648
649 /* Send bulk URB */
650 retval = usb_bulk_msg(data->usb_dev,
651 usb_sndbulkpipe(data->usb_dev,
652 data->bulk_out),
653 buffer, USBTMC_HEADER_SIZE,
654 &actual, file_data->timeout);
655
656 /* Store bTag (in case we need to abort) */
657 data->bTag_last_write = data->bTag;
658
659 /* Increment bTag -- and increment again if zero */
660 data->bTag++;
661 if (!data->bTag)
662 data->bTag++;
663
664 kfree(buffer);
665 if (retval < 0) {
666 dev_err(&data->intf->dev, "usb_bulk_msg in send_request_dev_dep_msg_in() returned %d\n", retval);
667 return retval;
668 }
669
670 return 0;
671 }
672
673 static ssize_t usbtmc_read(struct file *filp, char __user *buf,
674 size_t count, loff_t *f_pos)
675 {
676 struct usbtmc_file_data *file_data;
677 struct usbtmc_device_data *data;
678 struct device *dev;
679 u32 n_characters;
680 u8 *buffer;
681 int actual;
682 size_t done;
683 size_t remaining;
684 int retval;
685 size_t this_part;
686
687 /* Get pointer to private data structure */
688 file_data = filp->private_data;
689 data = file_data->data;
690 dev = &data->intf->dev;
691
692 buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
693 if (!buffer)
694 return -ENOMEM;
695
696 mutex_lock(&data->io_mutex);
697 if (data->zombie) {
698 retval = -ENODEV;
699 goto exit;
700 }
701
702 dev_dbg(dev, "usb_bulk_msg_in: count(%zu)\n", count);
703
704 retval = send_request_dev_dep_msg_in(file_data, count);
705
706 if (retval < 0) {
707 if (data->auto_abort)
708 usbtmc_ioctl_abort_bulk_out(data);
709 goto exit;
710 }
711
712 /* Loop until we have fetched everything we requested */
713 remaining = count;
714 this_part = remaining;
715 done = 0;
716
717 while (remaining > 0) {
718 /* Send bulk URB */
719 retval = usb_bulk_msg(data->usb_dev,
720 usb_rcvbulkpipe(data->usb_dev,
721 data->bulk_in),
722 buffer, USBTMC_SIZE_IOBUFFER, &actual,
723 file_data->timeout);
724
725 dev_dbg(dev, "usb_bulk_msg: retval(%u), done(%zu), remaining(%zu), actual(%d)\n", retval, done, remaining, actual);
726
727 /* Store bTag (in case we need to abort) */
728 data->bTag_last_read = data->bTag;
729
730 if (retval < 0) {
731 dev_dbg(dev, "Unable to read data, error %d\n", retval);
732 if (data->auto_abort)
733 usbtmc_ioctl_abort_bulk_in(data);
734 goto exit;
735 }
736
737 /* Parse header in first packet */
738 if (done == 0) {
739 /* Sanity checks for the header */
740 if (actual < USBTMC_HEADER_SIZE) {
741 dev_err(dev, "Device sent too small first packet: %u < %u\n", actual, USBTMC_HEADER_SIZE);
742 if (data->auto_abort)
743 usbtmc_ioctl_abort_bulk_in(data);
744 goto exit;
745 }
746
747 if (buffer[0] != 2) {
748 dev_err(dev, "Device sent reply with wrong MsgID: %u != 2\n", buffer[0]);
749 if (data->auto_abort)
750 usbtmc_ioctl_abort_bulk_in(data);
751 goto exit;
752 }
753
754 if (buffer[1] != data->bTag_last_write) {
755 dev_err(dev, "Device sent reply with wrong bTag: %u != %u\n", buffer[1], data->bTag_last_write);
756 if (data->auto_abort)
757 usbtmc_ioctl_abort_bulk_in(data);
758 goto exit;
759 }
760
761 /* How many characters did the instrument send? */
762 n_characters = buffer[4] +
763 (buffer[5] << 8) +
764 (buffer[6] << 16) +
765 (buffer[7] << 24);
766
767 if (n_characters > this_part) {
768 dev_err(dev, "Device wants to return more data than requested: %u > %zu\n", n_characters, count);
769 if (data->auto_abort)
770 usbtmc_ioctl_abort_bulk_in(data);
771 goto exit;
772 }
773
774 /* Remove the USBTMC header */
775 actual -= USBTMC_HEADER_SIZE;
776
777 /* Check if the message is smaller than requested */
778 if (remaining > n_characters)
779 remaining = n_characters;
780 /* Remove padding if it exists */
781 if (actual > remaining)
782 actual = remaining;
783
784 dev_dbg(dev, "Bulk-IN header: N_characters(%u), bTransAttr(%u)\n", n_characters, buffer[8]);
785
786 remaining -= actual;
787
788 /* Terminate if end-of-message bit received from device */
789 if ((buffer[8] & 0x01) && (actual >= n_characters))
790 remaining = 0;
791
792 dev_dbg(dev, "Bulk-IN header: remaining(%zu), buf(%p), buffer(%p) done(%zu)\n", remaining,buf,buffer,done);
793
794
795 /* Copy buffer to user space */
796 if (copy_to_user(buf + done, &buffer[USBTMC_HEADER_SIZE], actual)) {
797 /* There must have been an addressing problem */
798 retval = -EFAULT;
799 goto exit;
800 }
801 done += actual;
802 }
803 else {
804 if (actual > remaining)
805 actual = remaining;
806
807 remaining -= actual;
808
809 dev_dbg(dev, "Bulk-IN header cont: actual(%u), done(%zu), remaining(%zu), buf(%p), buffer(%p)\n", actual, done, remaining,buf,buffer);
810
811 /* Copy buffer to user space */
812 if (copy_to_user(buf + done, buffer, actual)) {
813 /* There must have been an addressing problem */
814 retval = -EFAULT;
815 goto exit;
816 }
817 done += actual;
818 }
819 }
820
821 /* Update file position value */
822 *f_pos = *f_pos + done;
823 retval = done;
824
825 exit:
826 mutex_unlock(&data->io_mutex);
827 kfree(buffer);
828 return retval;
829 }
830
831 static ssize_t usbtmc_write(struct file *filp, const char __user *buf,
832 size_t count, loff_t *f_pos)
833 {
834 struct usbtmc_file_data *file_data;
835 struct usbtmc_device_data *data;
836 u8 *buffer;
837 int retval;
838 int actual;
839 unsigned long int n_bytes;
840 int remaining;
841 int done;
842 int this_part;
843
844 file_data = filp->private_data;
845 data = file_data->data;
846
847 buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
848 if (!buffer)
849 return -ENOMEM;
850
851 mutex_lock(&data->io_mutex);
852 if (data->zombie) {
853 retval = -ENODEV;
854 goto exit;
855 }
856
857 remaining = count;
858 done = 0;
859
860 while (remaining > 0) {
861 if (remaining > USBTMC_SIZE_IOBUFFER - USBTMC_HEADER_SIZE) {
862 this_part = USBTMC_SIZE_IOBUFFER - USBTMC_HEADER_SIZE;
863 buffer[8] = 0;
864 } else {
865 this_part = remaining;
866 buffer[8] = file_data->eom_val;
867 }
868
869 /* Setup IO buffer for DEV_DEP_MSG_OUT message */
870 buffer[0] = 1;
871 buffer[1] = data->bTag;
872 buffer[2] = ~data->bTag;
873 buffer[3] = 0; /* Reserved */
874 buffer[4] = this_part >> 0;
875 buffer[5] = this_part >> 8;
876 buffer[6] = this_part >> 16;
877 buffer[7] = this_part >> 24;
878 /* buffer[8] is set above... */
879 buffer[9] = 0; /* Reserved */
880 buffer[10] = 0; /* Reserved */
881 buffer[11] = 0; /* Reserved */
882
883 if (copy_from_user(&buffer[USBTMC_HEADER_SIZE], buf + done, this_part)) {
884 retval = -EFAULT;
885 goto exit;
886 }
887
888 n_bytes = roundup(USBTMC_HEADER_SIZE + this_part, 4);
889 memset(buffer + USBTMC_HEADER_SIZE + this_part, 0, n_bytes - (USBTMC_HEADER_SIZE + this_part));
890
891 do {
892 retval = usb_bulk_msg(data->usb_dev,
893 usb_sndbulkpipe(data->usb_dev,
894 data->bulk_out),
895 buffer, n_bytes,
896 &actual, file_data->timeout);
897 if (retval != 0)
898 break;
899 n_bytes -= actual;
900 } while (n_bytes);
901
902 data->bTag_last_write = data->bTag;
903 data->bTag++;
904
905 if (!data->bTag)
906 data->bTag++;
907
908 if (retval < 0) {
909 dev_err(&data->intf->dev,
910 "Unable to send data, error %d\n", retval);
911 if (data->auto_abort)
912 usbtmc_ioctl_abort_bulk_out(data);
913 goto exit;
914 }
915
916 remaining -= this_part;
917 done += this_part;
918 }
919
920 retval = count;
921 exit:
922 mutex_unlock(&data->io_mutex);
923 kfree(buffer);
924 return retval;
925 }
926
927 static int usbtmc_ioctl_clear(struct usbtmc_device_data *data)
928 {
929 struct usb_host_interface *current_setting;
930 struct usb_endpoint_descriptor *desc;
931 struct device *dev;
932 u8 *buffer;
933 int rv;
934 int n;
935 int actual = 0;
936 int max_size;
937
938 dev = &data->intf->dev;
939
940 dev_dbg(dev, "Sending INITIATE_CLEAR request\n");
941
942 buffer = kmalloc(USBTMC_SIZE_IOBUFFER, GFP_KERNEL);
943 if (!buffer)
944 return -ENOMEM;
945
946 rv = usb_control_msg(data->usb_dev,
947 usb_rcvctrlpipe(data->usb_dev, 0),
948 USBTMC_REQUEST_INITIATE_CLEAR,
949 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
950 0, 0, buffer, 1, USBTMC_TIMEOUT);
951 if (rv < 0) {
952 dev_err(dev, "usb_control_msg returned %d\n", rv);
953 goto exit;
954 }
955
956 dev_dbg(dev, "INITIATE_CLEAR returned %x\n", buffer[0]);
957
958 if (buffer[0] != USBTMC_STATUS_SUCCESS) {
959 dev_err(dev, "INITIATE_CLEAR returned %x\n", buffer[0]);
960 rv = -EPERM;
961 goto exit;
962 }
963
964 max_size = 0;
965 current_setting = data->intf->cur_altsetting;
966 for (n = 0; n < current_setting->desc.bNumEndpoints; n++) {
967 desc = &current_setting->endpoint[n].desc;
968 if (desc->bEndpointAddress == data->bulk_in)
969 max_size = usb_endpoint_maxp(desc);
970 }
971
972 if (max_size == 0) {
973 dev_err(dev, "Couldn't get wMaxPacketSize\n");
974 rv = -EPERM;
975 goto exit;
976 }
977
978 dev_dbg(dev, "wMaxPacketSize is %d\n", max_size);
979
980 n = 0;
981
982 usbtmc_clear_check_status:
983
984 dev_dbg(dev, "Sending CHECK_CLEAR_STATUS request\n");
985
986 rv = usb_control_msg(data->usb_dev,
987 usb_rcvctrlpipe(data->usb_dev, 0),
988 USBTMC_REQUEST_CHECK_CLEAR_STATUS,
989 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
990 0, 0, buffer, 2, USBTMC_TIMEOUT);
991 if (rv < 0) {
992 dev_err(dev, "usb_control_msg returned %d\n", rv);
993 goto exit;
994 }
995
996 dev_dbg(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]);
997
998 if (buffer[0] == USBTMC_STATUS_SUCCESS)
999 goto usbtmc_clear_bulk_out_halt;
1000
1001 if (buffer[0] != USBTMC_STATUS_PENDING) {
1002 dev_err(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]);
1003 rv = -EPERM;
1004 goto exit;
1005 }
1006
1007 if (buffer[1] == 1)
1008 do {
1009 dev_dbg(dev, "Reading from bulk in EP\n");
1010
1011 rv = usb_bulk_msg(data->usb_dev,
1012 usb_rcvbulkpipe(data->usb_dev,
1013 data->bulk_in),
1014 buffer, USBTMC_SIZE_IOBUFFER,
1015 &actual, USBTMC_TIMEOUT);
1016 n++;
1017
1018 if (rv < 0) {
1019 dev_err(dev, "usb_control_msg returned %d\n",
1020 rv);
1021 goto exit;
1022 }
1023 } while ((actual == max_size) &&
1024 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN));
1025
1026 if (actual == max_size) {
1027 dev_err(dev, "Couldn't clear device buffer within %d cycles\n",
1028 USBTMC_MAX_READS_TO_CLEAR_BULK_IN);
1029 rv = -EPERM;
1030 goto exit;
1031 }
1032
1033 goto usbtmc_clear_check_status;
1034
1035 usbtmc_clear_bulk_out_halt:
1036
1037 rv = usb_clear_halt(data->usb_dev,
1038 usb_sndbulkpipe(data->usb_dev, data->bulk_out));
1039 if (rv < 0) {
1040 dev_err(dev, "usb_control_msg returned %d\n", rv);
1041 goto exit;
1042 }
1043 rv = 0;
1044
1045 exit:
1046 kfree(buffer);
1047 return rv;
1048 }
1049
1050 static int usbtmc_ioctl_clear_out_halt(struct usbtmc_device_data *data)
1051 {
1052 int rv;
1053
1054 rv = usb_clear_halt(data->usb_dev,
1055 usb_sndbulkpipe(data->usb_dev, data->bulk_out));
1056
1057 if (rv < 0) {
1058 dev_err(&data->usb_dev->dev, "usb_control_msg returned %d\n",
1059 rv);
1060 return rv;
1061 }
1062 return 0;
1063 }
1064
1065 static int usbtmc_ioctl_clear_in_halt(struct usbtmc_device_data *data)
1066 {
1067 int rv;
1068
1069 rv = usb_clear_halt(data->usb_dev,
1070 usb_rcvbulkpipe(data->usb_dev, data->bulk_in));
1071
1072 if (rv < 0) {
1073 dev_err(&data->usb_dev->dev, "usb_control_msg returned %d\n",
1074 rv);
1075 return rv;
1076 }
1077 return 0;
1078 }
1079
1080 static int get_capabilities(struct usbtmc_device_data *data)
1081 {
1082 struct device *dev = &data->usb_dev->dev;
1083 char *buffer;
1084 int rv = 0;
1085
1086 buffer = kmalloc(0x18, GFP_KERNEL);
1087 if (!buffer)
1088 return -ENOMEM;
1089
1090 rv = usb_control_msg(data->usb_dev, usb_rcvctrlpipe(data->usb_dev, 0),
1091 USBTMC_REQUEST_GET_CAPABILITIES,
1092 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1093 0, 0, buffer, 0x18, USBTMC_TIMEOUT);
1094 if (rv < 0) {
1095 dev_err(dev, "usb_control_msg returned %d\n", rv);
1096 goto err_out;
1097 }
1098
1099 dev_dbg(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
1100 if (buffer[0] != USBTMC_STATUS_SUCCESS) {
1101 dev_err(dev, "GET_CAPABILITIES returned %x\n", buffer[0]);
1102 rv = -EPERM;
1103 goto err_out;
1104 }
1105 dev_dbg(dev, "Interface capabilities are %x\n", buffer[4]);
1106 dev_dbg(dev, "Device capabilities are %x\n", buffer[5]);
1107 dev_dbg(dev, "USB488 interface capabilities are %x\n", buffer[14]);
1108 dev_dbg(dev, "USB488 device capabilities are %x\n", buffer[15]);
1109
1110 data->capabilities.interface_capabilities = buffer[4];
1111 data->capabilities.device_capabilities = buffer[5];
1112 data->capabilities.usb488_interface_capabilities = buffer[14];
1113 data->capabilities.usb488_device_capabilities = buffer[15];
1114 data->usb488_caps = (buffer[14] & 0x07) | ((buffer[15] & 0x0f) << 4);
1115 rv = 0;
1116
1117 err_out:
1118 kfree(buffer);
1119 return rv;
1120 }
1121
1122 #define capability_attribute(name) \
1123 static ssize_t name##_show(struct device *dev, \
1124 struct device_attribute *attr, char *buf) \
1125 { \
1126 struct usb_interface *intf = to_usb_interface(dev); \
1127 struct usbtmc_device_data *data = usb_get_intfdata(intf); \
1128 \
1129 return sprintf(buf, "%d\n", data->capabilities.name); \
1130 } \
1131 static DEVICE_ATTR_RO(name)
1132
1133 capability_attribute(interface_capabilities);
1134 capability_attribute(device_capabilities);
1135 capability_attribute(usb488_interface_capabilities);
1136 capability_attribute(usb488_device_capabilities);
1137
1138 static struct attribute *capability_attrs[] = {
1139 &dev_attr_interface_capabilities.attr,
1140 &dev_attr_device_capabilities.attr,
1141 &dev_attr_usb488_interface_capabilities.attr,
1142 &dev_attr_usb488_device_capabilities.attr,
1143 NULL,
1144 };
1145
1146 static const struct attribute_group capability_attr_grp = {
1147 .attrs = capability_attrs,
1148 };
1149
1150 static ssize_t TermChar_show(struct device *dev,
1151 struct device_attribute *attr, char *buf)
1152 {
1153 struct usb_interface *intf = to_usb_interface(dev);
1154 struct usbtmc_device_data *data = usb_get_intfdata(intf);
1155
1156 return sprintf(buf, "%c\n", data->TermChar);
1157 }
1158
1159 static ssize_t TermChar_store(struct device *dev,
1160 struct device_attribute *attr,
1161 const char *buf, size_t count)
1162 {
1163 struct usb_interface *intf = to_usb_interface(dev);
1164 struct usbtmc_device_data *data = usb_get_intfdata(intf);
1165
1166 if (count < 1)
1167 return -EINVAL;
1168 data->TermChar = buf[0];
1169 return count;
1170 }
1171 static DEVICE_ATTR_RW(TermChar);
1172
1173 #define data_attribute(name) \
1174 static ssize_t name##_show(struct device *dev, \
1175 struct device_attribute *attr, char *buf) \
1176 { \
1177 struct usb_interface *intf = to_usb_interface(dev); \
1178 struct usbtmc_device_data *data = usb_get_intfdata(intf); \
1179 \
1180 return sprintf(buf, "%d\n", data->name); \
1181 } \
1182 static ssize_t name##_store(struct device *dev, \
1183 struct device_attribute *attr, \
1184 const char *buf, size_t count) \
1185 { \
1186 struct usb_interface *intf = to_usb_interface(dev); \
1187 struct usbtmc_device_data *data = usb_get_intfdata(intf); \
1188 ssize_t result; \
1189 unsigned val; \
1190 \
1191 result = sscanf(buf, "%u\n", &val); \
1192 if (result != 1) \
1193 result = -EINVAL; \
1194 data->name = val; \
1195 if (result < 0) \
1196 return result; \
1197 else \
1198 return count; \
1199 } \
1200 static DEVICE_ATTR_RW(name)
1201
1202 data_attribute(TermCharEnabled);
1203 data_attribute(auto_abort);
1204
1205 static struct attribute *data_attrs[] = {
1206 &dev_attr_TermChar.attr,
1207 &dev_attr_TermCharEnabled.attr,
1208 &dev_attr_auto_abort.attr,
1209 NULL,
1210 };
1211
1212 static const struct attribute_group data_attr_grp = {
1213 .attrs = data_attrs,
1214 };
1215
1216 static int usbtmc_ioctl_indicator_pulse(struct usbtmc_device_data *data)
1217 {
1218 struct device *dev;
1219 u8 *buffer;
1220 int rv;
1221
1222 dev = &data->intf->dev;
1223
1224 buffer = kmalloc(2, GFP_KERNEL);
1225 if (!buffer)
1226 return -ENOMEM;
1227
1228 rv = usb_control_msg(data->usb_dev,
1229 usb_rcvctrlpipe(data->usb_dev, 0),
1230 USBTMC_REQUEST_INDICATOR_PULSE,
1231 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
1232 0, 0, buffer, 0x01, USBTMC_TIMEOUT);
1233
1234 if (rv < 0) {
1235 dev_err(dev, "usb_control_msg returned %d\n", rv);
1236 goto exit;
1237 }
1238
1239 dev_dbg(dev, "INDICATOR_PULSE returned %x\n", buffer[0]);
1240
1241 if (buffer[0] != USBTMC_STATUS_SUCCESS) {
1242 dev_err(dev, "INDICATOR_PULSE returned %x\n", buffer[0]);
1243 rv = -EPERM;
1244 goto exit;
1245 }
1246 rv = 0;
1247
1248 exit:
1249 kfree(buffer);
1250 return rv;
1251 }
1252
1253 /*
1254 * Get the usb timeout value
1255 */
1256 static int usbtmc_ioctl_get_timeout(struct usbtmc_file_data *file_data,
1257 void __user *arg)
1258 {
1259 u32 timeout;
1260
1261 timeout = file_data->timeout;
1262
1263 return put_user(timeout, (__u32 __user *)arg);
1264 }
1265
1266 /*
1267 * Set the usb timeout value
1268 */
1269 static int usbtmc_ioctl_set_timeout(struct usbtmc_file_data *file_data,
1270 void __user *arg)
1271 {
1272 u32 timeout;
1273
1274 if (get_user(timeout, (__u32 __user *)arg))
1275 return -EFAULT;
1276
1277 /* Note that timeout = 0 means
1278 * MAX_SCHEDULE_TIMEOUT in usb_control_msg
1279 */
1280 if (timeout < USBTMC_MIN_TIMEOUT)
1281 return -EINVAL;
1282
1283 file_data->timeout = timeout;
1284
1285 return 0;
1286 }
1287
1288 /*
1289 * enables/disables sending EOM on write
1290 */
1291 static int usbtmc_ioctl_eom_enable(struct usbtmc_file_data *file_data,
1292 void __user *arg)
1293 {
1294 u8 eom_enable;
1295
1296 if (copy_from_user(&eom_enable, arg, sizeof(eom_enable)))
1297 return -EFAULT;
1298
1299 if (eom_enable > 1)
1300 return -EINVAL;
1301
1302 file_data->eom_val = eom_enable;
1303
1304 return 0;
1305 }
1306
1307 /*
1308 * Configure termination character for read()
1309 */
1310 static int usbtmc_ioctl_config_termc(struct usbtmc_file_data *file_data,
1311 void __user *arg)
1312 {
1313 struct usbtmc_termchar termc;
1314
1315 if (copy_from_user(&termc, arg, sizeof(termc)))
1316 return -EFAULT;
1317
1318 if ((termc.term_char_enabled > 1) ||
1319 (termc.term_char_enabled &&
1320 !(file_data->data->capabilities.device_capabilities & 1)))
1321 return -EINVAL;
1322
1323 file_data->term_char = termc.term_char;
1324 file_data->term_char_enabled = termc.term_char_enabled;
1325
1326 return 0;
1327 }
1328
1329 static long usbtmc_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1330 {
1331 struct usbtmc_file_data *file_data;
1332 struct usbtmc_device_data *data;
1333 int retval = -EBADRQC;
1334
1335 file_data = file->private_data;
1336 data = file_data->data;
1337
1338 mutex_lock(&data->io_mutex);
1339 if (data->zombie) {
1340 retval = -ENODEV;
1341 goto skip_io_on_zombie;
1342 }
1343
1344 switch (cmd) {
1345 case USBTMC_IOCTL_CLEAR_OUT_HALT:
1346 retval = usbtmc_ioctl_clear_out_halt(data);
1347 break;
1348
1349 case USBTMC_IOCTL_CLEAR_IN_HALT:
1350 retval = usbtmc_ioctl_clear_in_halt(data);
1351 break;
1352
1353 case USBTMC_IOCTL_INDICATOR_PULSE:
1354 retval = usbtmc_ioctl_indicator_pulse(data);
1355 break;
1356
1357 case USBTMC_IOCTL_CLEAR:
1358 retval = usbtmc_ioctl_clear(data);
1359 break;
1360
1361 case USBTMC_IOCTL_ABORT_BULK_OUT:
1362 retval = usbtmc_ioctl_abort_bulk_out(data);
1363 break;
1364
1365 case USBTMC_IOCTL_ABORT_BULK_IN:
1366 retval = usbtmc_ioctl_abort_bulk_in(data);
1367 break;
1368
1369 case USBTMC_IOCTL_GET_TIMEOUT:
1370 retval = usbtmc_ioctl_get_timeout(file_data,
1371 (void __user *)arg);
1372 break;
1373
1374 case USBTMC_IOCTL_SET_TIMEOUT:
1375 retval = usbtmc_ioctl_set_timeout(file_data,
1376 (void __user *)arg);
1377 break;
1378
1379 case USBTMC_IOCTL_EOM_ENABLE:
1380 retval = usbtmc_ioctl_eom_enable(file_data,
1381 (void __user *)arg);
1382 break;
1383
1384 case USBTMC_IOCTL_CONFIG_TERMCHAR:
1385 retval = usbtmc_ioctl_config_termc(file_data,
1386 (void __user *)arg);
1387 break;
1388
1389 case USBTMC488_IOCTL_GET_CAPS:
1390 retval = copy_to_user((void __user *)arg,
1391 &data->usb488_caps,
1392 sizeof(data->usb488_caps));
1393 if (retval)
1394 retval = -EFAULT;
1395 break;
1396
1397 case USBTMC488_IOCTL_READ_STB:
1398 retval = usbtmc488_ioctl_read_stb(file_data,
1399 (void __user *)arg);
1400 break;
1401
1402 case USBTMC488_IOCTL_REN_CONTROL:
1403 retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
1404 USBTMC488_REQUEST_REN_CONTROL);
1405 break;
1406
1407 case USBTMC488_IOCTL_GOTO_LOCAL:
1408 retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
1409 USBTMC488_REQUEST_GOTO_LOCAL);
1410 break;
1411
1412 case USBTMC488_IOCTL_LOCAL_LOCKOUT:
1413 retval = usbtmc488_ioctl_simple(data, (void __user *)arg,
1414 USBTMC488_REQUEST_LOCAL_LOCKOUT);
1415 break;
1416
1417 case USBTMC488_IOCTL_TRIGGER:
1418 retval = usbtmc488_ioctl_trigger(file_data);
1419 break;
1420 }
1421
1422 skip_io_on_zombie:
1423 mutex_unlock(&data->io_mutex);
1424 return retval;
1425 }
1426
1427 static int usbtmc_fasync(int fd, struct file *file, int on)
1428 {
1429 struct usbtmc_file_data *file_data = file->private_data;
1430
1431 return fasync_helper(fd, file, on, &file_data->data->fasync);
1432 }
1433
1434 static __poll_t usbtmc_poll(struct file *file, poll_table *wait)
1435 {
1436 struct usbtmc_file_data *file_data = file->private_data;
1437 struct usbtmc_device_data *data = file_data->data;
1438 __poll_t mask;
1439
1440 mutex_lock(&data->io_mutex);
1441
1442 if (data->zombie) {
1443 mask = EPOLLHUP | EPOLLERR;
1444 goto no_poll;
1445 }
1446
1447 poll_wait(file, &data->waitq, wait);
1448
1449 mask = (atomic_read(&file_data->srq_asserted)) ? EPOLLPRI : 0;
1450
1451 no_poll:
1452 mutex_unlock(&data->io_mutex);
1453 return mask;
1454 }
1455
1456 static const struct file_operations fops = {
1457 .owner = THIS_MODULE,
1458 .read = usbtmc_read,
1459 .write = usbtmc_write,
1460 .open = usbtmc_open,
1461 .release = usbtmc_release,
1462 .unlocked_ioctl = usbtmc_ioctl,
1463 #ifdef CONFIG_COMPAT
1464 .compat_ioctl = usbtmc_ioctl,
1465 #endif
1466 .fasync = usbtmc_fasync,
1467 .poll = usbtmc_poll,
1468 .llseek = default_llseek,
1469 };
1470
1471 static struct usb_class_driver usbtmc_class = {
1472 .name = "usbtmc%d",
1473 .fops = &fops,
1474 .minor_base = USBTMC_MINOR_BASE,
1475 };
1476
1477 static void usbtmc_interrupt(struct urb *urb)
1478 {
1479 struct usbtmc_device_data *data = urb->context;
1480 struct device *dev = &data->intf->dev;
1481 int status = urb->status;
1482 int rv;
1483
1484 dev_dbg(&data->intf->dev, "int status: %d len %d\n",
1485 status, urb->actual_length);
1486
1487 switch (status) {
1488 case 0: /* SUCCESS */
1489 /* check for valid STB notification */
1490 if (data->iin_buffer[0] > 0x81) {
1491 data->bNotify1 = data->iin_buffer[0];
1492 data->bNotify2 = data->iin_buffer[1];
1493 atomic_set(&data->iin_data_valid, 1);
1494 wake_up_interruptible(&data->waitq);
1495 goto exit;
1496 }
1497 /* check for SRQ notification */
1498 if (data->iin_buffer[0] == 0x81) {
1499 unsigned long flags;
1500 struct list_head *elem;
1501
1502 if (data->fasync)
1503 kill_fasync(&data->fasync,
1504 SIGIO, POLL_PRI);
1505
1506 spin_lock_irqsave(&data->dev_lock, flags);
1507 list_for_each(elem, &data->file_list) {
1508 struct usbtmc_file_data *file_data;
1509
1510 file_data = list_entry(elem,
1511 struct usbtmc_file_data,
1512 file_elem);
1513 file_data->srq_byte = data->iin_buffer[1];
1514 atomic_set(&file_data->srq_asserted, 1);
1515 }
1516 spin_unlock_irqrestore(&data->dev_lock, flags);
1517
1518 dev_dbg(dev, "srq received bTag %x stb %x\n",
1519 (unsigned int)data->iin_buffer[0],
1520 (unsigned int)data->iin_buffer[1]);
1521 wake_up_interruptible_all(&data->waitq);
1522 goto exit;
1523 }
1524 dev_warn(dev, "invalid notification: %x\n",
1525 data->iin_buffer[0]);
1526 break;
1527 case -EOVERFLOW:
1528 dev_err(dev, "overflow with length %d, actual length is %d\n",
1529 data->iin_wMaxPacketSize, urb->actual_length);
1530 /* fall through */
1531 case -ECONNRESET:
1532 case -ENOENT:
1533 case -ESHUTDOWN:
1534 case -EILSEQ:
1535 case -ETIME:
1536 case -EPIPE:
1537 /* urb terminated, clean up */
1538 dev_dbg(dev, "urb terminated, status: %d\n", status);
1539 return;
1540 default:
1541 dev_err(dev, "unknown status received: %d\n", status);
1542 }
1543 exit:
1544 rv = usb_submit_urb(urb, GFP_ATOMIC);
1545 if (rv)
1546 dev_err(dev, "usb_submit_urb failed: %d\n", rv);
1547 }
1548
1549 static void usbtmc_free_int(struct usbtmc_device_data *data)
1550 {
1551 if (!data->iin_ep_present || !data->iin_urb)
1552 return;
1553 usb_kill_urb(data->iin_urb);
1554 kfree(data->iin_buffer);
1555 usb_free_urb(data->iin_urb);
1556 kref_put(&data->kref, usbtmc_delete);
1557 }
1558
1559 static int usbtmc_probe(struct usb_interface *intf,
1560 const struct usb_device_id *id)
1561 {
1562 struct usbtmc_device_data *data;
1563 struct usb_host_interface *iface_desc;
1564 struct usb_endpoint_descriptor *bulk_in, *bulk_out, *int_in;
1565 int retcode;
1566
1567 dev_dbg(&intf->dev, "%s called\n", __func__);
1568
1569 data = kzalloc(sizeof(*data), GFP_KERNEL);
1570 if (!data)
1571 return -ENOMEM;
1572
1573 data->intf = intf;
1574 data->id = id;
1575 data->usb_dev = usb_get_dev(interface_to_usbdev(intf));
1576 usb_set_intfdata(intf, data);
1577 kref_init(&data->kref);
1578 mutex_init(&data->io_mutex);
1579 init_waitqueue_head(&data->waitq);
1580 atomic_set(&data->iin_data_valid, 0);
1581 INIT_LIST_HEAD(&data->file_list);
1582 spin_lock_init(&data->dev_lock);
1583
1584 data->zombie = 0;
1585
1586 /* Initialize USBTMC bTag and other fields */
1587 data->bTag = 1;
1588 data->TermCharEnabled = 0;
1589 data->TermChar = '\n';
1590 /* 2 <= bTag <= 127 USBTMC-USB488 subclass specification 4.3.1 */
1591 data->iin_bTag = 2;
1592
1593 /* USBTMC devices have only one setting, so use that */
1594 iface_desc = data->intf->cur_altsetting;
1595 data->ifnum = iface_desc->desc.bInterfaceNumber;
1596
1597 /* Find bulk endpoints */
1598 retcode = usb_find_common_endpoints(iface_desc,
1599 &bulk_in, &bulk_out, NULL, NULL);
1600 if (retcode) {
1601 dev_err(&intf->dev, "bulk endpoints not found\n");
1602 goto err_put;
1603 }
1604
1605 data->bulk_in = bulk_in->bEndpointAddress;
1606 dev_dbg(&intf->dev, "Found bulk in endpoint at %u\n", data->bulk_in);
1607
1608 data->bulk_out = bulk_out->bEndpointAddress;
1609 dev_dbg(&intf->dev, "Found Bulk out endpoint at %u\n", data->bulk_out);
1610
1611 /* Find int endpoint */
1612 retcode = usb_find_int_in_endpoint(iface_desc, &int_in);
1613 if (!retcode) {
1614 data->iin_ep_present = 1;
1615 data->iin_ep = int_in->bEndpointAddress;
1616 data->iin_wMaxPacketSize = usb_endpoint_maxp(int_in);
1617 data->iin_interval = int_in->bInterval;
1618 dev_dbg(&intf->dev, "Found Int in endpoint at %u\n",
1619 data->iin_ep);
1620 }
1621
1622 retcode = get_capabilities(data);
1623 if (retcode)
1624 dev_err(&intf->dev, "can't read capabilities\n");
1625 else
1626 retcode = sysfs_create_group(&intf->dev.kobj,
1627 &capability_attr_grp);
1628
1629 if (data->iin_ep_present) {
1630 /* allocate int urb */
1631 data->iin_urb = usb_alloc_urb(0, GFP_KERNEL);
1632 if (!data->iin_urb) {
1633 retcode = -ENOMEM;
1634 goto error_register;
1635 }
1636
1637 /* Protect interrupt in endpoint data until iin_urb is freed */
1638 kref_get(&data->kref);
1639
1640 /* allocate buffer for interrupt in */
1641 data->iin_buffer = kmalloc(data->iin_wMaxPacketSize,
1642 GFP_KERNEL);
1643 if (!data->iin_buffer) {
1644 retcode = -ENOMEM;
1645 goto error_register;
1646 }
1647
1648 /* fill interrupt urb */
1649 usb_fill_int_urb(data->iin_urb, data->usb_dev,
1650 usb_rcvintpipe(data->usb_dev, data->iin_ep),
1651 data->iin_buffer, data->iin_wMaxPacketSize,
1652 usbtmc_interrupt,
1653 data, data->iin_interval);
1654
1655 retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL);
1656 if (retcode) {
1657 dev_err(&intf->dev, "Failed to submit iin_urb\n");
1658 goto error_register;
1659 }
1660 }
1661
1662 retcode = sysfs_create_group(&intf->dev.kobj, &data_attr_grp);
1663
1664 retcode = usb_register_dev(intf, &usbtmc_class);
1665 if (retcode) {
1666 dev_err(&intf->dev, "Not able to get a minor"
1667 " (base %u, slice default): %d\n", USBTMC_MINOR_BASE,
1668 retcode);
1669 goto error_register;
1670 }
1671 dev_dbg(&intf->dev, "Using minor number %d\n", intf->minor);
1672
1673 return 0;
1674
1675 error_register:
1676 sysfs_remove_group(&intf->dev.kobj, &capability_attr_grp);
1677 sysfs_remove_group(&intf->dev.kobj, &data_attr_grp);
1678 usbtmc_free_int(data);
1679 err_put:
1680 kref_put(&data->kref, usbtmc_delete);
1681 return retcode;
1682 }
1683
1684 static void usbtmc_disconnect(struct usb_interface *intf)
1685 {
1686 struct usbtmc_device_data *data = usb_get_intfdata(intf);
1687
1688 usb_deregister_dev(intf, &usbtmc_class);
1689 sysfs_remove_group(&intf->dev.kobj, &capability_attr_grp);
1690 sysfs_remove_group(&intf->dev.kobj, &data_attr_grp);
1691 mutex_lock(&data->io_mutex);
1692 data->zombie = 1;
1693 wake_up_interruptible_all(&data->waitq);
1694 mutex_unlock(&data->io_mutex);
1695 usbtmc_free_int(data);
1696 kref_put(&data->kref, usbtmc_delete);
1697 }
1698
1699 static int usbtmc_suspend(struct usb_interface *intf, pm_message_t message)
1700 {
1701 /* this driver does not have pending URBs */
1702 return 0;
1703 }
1704
1705 static int usbtmc_resume(struct usb_interface *intf)
1706 {
1707 return 0;
1708 }
1709
1710 static struct usb_driver usbtmc_driver = {
1711 .name = "usbtmc",
1712 .id_table = usbtmc_devices,
1713 .probe = usbtmc_probe,
1714 .disconnect = usbtmc_disconnect,
1715 .suspend = usbtmc_suspend,
1716 .resume = usbtmc_resume,
1717 };
1718
1719 module_usb_driver(usbtmc_driver);
1720
1721 MODULE_LICENSE("GPL");
Linux with added FPC-III support