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