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 * Copyright (C) 2018 IVI Foundation, Inc. 9 */ 10 11 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 12 13 #include <linux/module.h> 14 #include <linux/kernel.h> 15 #include <linux/fs.h> 16 #include <linux/uaccess.h> 17 #include <linux/kref.h> 18 #include <linux/slab.h> 19 #include <linux/poll.h> 20 #include <linux/mutex.h> 21 #include <linux/usb.h> 22 #include <linux/compat.h> 23 #include <linux/usb/tmc.h> 24 25 /* Increment API VERSION when changing tmc.h with new flags or ioctls 26 * or when changing a significant behavior of the driver. 27 */ 28 #define USBTMC_API_VERSION (3) 29 30 #define USBTMC_HEADER_SIZE 12 31 #define USBTMC_MINOR_BASE 176 32 33 /* Minimum USB timeout (in milliseconds) */ 34 #define USBTMC_MIN_TIMEOUT 100 35 /* Default USB timeout (in milliseconds) */ 36 #define USBTMC_TIMEOUT 5000 37 38 /* Max number of urbs used in write transfers */ 39 #define MAX_URBS_IN_FLIGHT 16 40 /* I/O buffer size used in generic read/write functions */ 41 #define USBTMC_BUFSIZE (4096) 42 43 /* 44 * Maximum number of read cycles to empty bulk in endpoint during CLEAR and 45 * ABORT_BULK_IN requests. Ends the loop if (for whatever reason) a short 46 * packet is never read. 47 */ 48 #define USBTMC_MAX_READS_TO_CLEAR_BULK_IN 100 49 50 static const struct usb_device_id usbtmc_devices[] = { 51 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 0), }, 52 { USB_INTERFACE_INFO(USB_CLASS_APP_SPEC, 3, 1), }, 53 { 0, } /* terminating entry */ 54 }; 55 MODULE_DEVICE_TABLE(usb, usbtmc_devices); 56 57 /* 58 * This structure is the capabilities for the device 59 * See section 4.2.1.8 of the USBTMC specification, 60 * and section 4.2.2 of the USBTMC usb488 subclass 61 * specification for details. 62 */ 63 struct usbtmc_dev_capabilities { 64 __u8 interface_capabilities; 65 __u8 device_capabilities; 66 __u8 usb488_interface_capabilities; 67 __u8 usb488_device_capabilities; 68 }; 69 70 /* This structure holds private data for each USBTMC device. One copy is 71 * allocated for each USBTMC device in the driver's probe function. 72 */ 73 struct usbtmc_device_data { 74 struct usb_device *usb_dev; 75 struct usb_interface *intf; 76 struct list_head file_list; 77 78 unsigned int bulk_in; 79 unsigned int bulk_out; 80 81 u8 bTag; 82 u8 bTag_last_write; /* needed for abort */ 83 u8 bTag_last_read; /* needed for abort */ 84 85 /* packet size of IN bulk */ 86 u16 wMaxPacketSize; 87 88 /* data for interrupt in endpoint handling */ 89 u8 bNotify1; 90 u8 bNotify2; 91 u16 ifnum; 92 u8 iin_bTag; 93 u8 *iin_buffer; 94 atomic_t iin_data_valid; 95 unsigned int iin_ep; 96 int iin_ep_present; 97 int iin_interval; 98 struct urb *iin_urb; 99 u16 iin_wMaxPacketSize; 100 101 /* coalesced usb488_caps from usbtmc_dev_capabilities */ 102 __u8 usb488_caps; 103 104 bool zombie; /* fd of disconnected device */ 105 106 struct usbtmc_dev_capabilities capabilities; 107 struct kref kref; 108 struct mutex io_mutex; /* only one i/o function running at a time */ 109 wait_queue_head_t waitq; 110 struct fasync_struct *fasync; 111 spinlock_t dev_lock; /* lock for file_list */ 112 }; 113 #define to_usbtmc_data(d) container_of(d, struct usbtmc_device_data, kref) 114 115 /* 116 * This structure holds private data for each USBTMC file handle. 117 */ 118 struct usbtmc_file_data { 119 struct usbtmc_device_data *data; 120 struct list_head file_elem; 121 122 u32 timeout; 123 u8 srq_byte; 124 atomic_t srq_asserted; 125 atomic_t closing; 126 u8 bmTransferAttributes; /* member of DEV_DEP_MSG_IN */ 127 128 u8 eom_val; 129 u8 term_char; 130 bool term_char_enabled; 131 bool auto_abort; 132 133 spinlock_t err_lock; /* lock for errors */ 134 135 struct usb_anchor submitted; 136 137 /* data for generic_write */ 138 struct semaphore limit_write_sem; 139 u32 out_transfer_size; 140 int out_status; 141 142 /* data for generic_read */ 143 u32 in_transfer_size; 144 int in_status; 145 int in_urbs_used; 146 struct usb_anchor in_anchor; 147 wait_queue_head_t wait_bulk_in; 148 }; 149 150 /* Forward declarations */ 151 static struct usb_driver usbtmc_driver; 152 static void usbtmc_draw_down(struct usbtmc_file_data *file_data); 153 154 static void usbtmc_delete(struct kref *kref) 155 { 156 struct usbtmc_device_data *data = to_usbtmc_data(kref); 157 158 usb_put_dev(data->usb_dev); 159 kfree(data); 160 } 161 162 static int usbtmc_open(struct inode *inode, struct file *filp) 163 { 164 struct usb_interface *intf; 165 struct usbtmc_device_data *data; 166 struct usbtmc_file_data *file_data; 167 168 intf = usb_find_interface(&usbtmc_driver, iminor(inode)); 169 if (!intf) { 170 pr_err("can not find device for minor %d", iminor(inode)); 171 return -ENODEV; 172 } 173 174 file_data = kzalloc_obj(*file_data); 175 if (!file_data) 176 return -ENOMEM; 177 178 spin_lock_init(&file_data->err_lock); 179 sema_init(&file_data->limit_write_sem, MAX_URBS_IN_FLIGHT); 180 init_usb_anchor(&file_data->submitted); 181 init_usb_anchor(&file_data->in_anchor); 182 init_waitqueue_head(&file_data->wait_bulk_in); 183 184 data = usb_get_intfdata(intf); 185 /* Protect reference to data from file structure until release */ 186 kref_get(&data->kref); 187 188 mutex_lock(&data->io_mutex); 189 file_data->data = data; 190 191 atomic_set(&file_data->closing, 0); 192 193 file_data->timeout = USBTMC_TIMEOUT; 194 file_data->term_char = '\n'; 195 file_data->term_char_enabled = 0; 196 file_data->auto_abort = 0; 197 file_data->eom_val = 1; 198 199 INIT_LIST_HEAD(&file_data->file_elem); 200 spin_lock_irq(&data->dev_lock); 201 list_add_tail(&file_data->file_elem, &data->file_list); 202 spin_unlock_irq(&data->dev_lock); 203 mutex_unlock(&data->io_mutex); 204 205 /* Store pointer in file structure's private data field */ 206 filp->private_data = file_data; 207 208 return 0; 209 } 210 211 /* 212 * usbtmc_flush - called before file handle is closed 213 */ 214 static int usbtmc_flush(struct file *file, fl_owner_t id) 215 { 216 struct usbtmc_file_data *file_data; 217 struct usbtmc_device_data *data; 218 219 file_data = file->private_data; 220 if (file_data == NULL) 221 return -ENODEV; 222 223 atomic_set(&file_data->closing, 1); 224 data = file_data->data; 225 226 /* wait for io to stop */ 227 mutex_lock(&data->io_mutex); 228 229 usbtmc_draw_down(file_data); 230 231 spin_lock_irq(&file_data->err_lock); 232 file_data->in_status = 0; 233 file_data->in_transfer_size = 0; 234 file_data->in_urbs_used = 0; 235 file_data->out_status = 0; 236 file_data->out_transfer_size = 0; 237 spin_unlock_irq(&file_data->err_lock); 238 239 wake_up_interruptible_all(&data->waitq); 240 mutex_unlock(&data->io_mutex); 241 242 return 0; 243 } 244 245 static int usbtmc_release(struct inode *inode, struct file *file) 246 { 247 struct usbtmc_file_data *file_data = file->private_data; 248 249 /* prevent IO _AND_ usbtmc_interrupt */ 250 mutex_lock(&file_data->data->io_mutex); 251 spin_lock_irq(&file_data->data->dev_lock); 252 253 list_del(&file_data->file_elem); 254 255 spin_unlock_irq(&file_data->data->dev_lock); 256 257 /* flush anchored URBs */ 258 usbtmc_draw_down(file_data); 259 mutex_unlock(&file_data->data->io_mutex); 260 261 kref_put(&file_data->data->kref, usbtmc_delete); 262 file_data->data = NULL; 263 kfree(file_data); 264 return 0; 265 } 266 267 static int usbtmc_ioctl_abort_bulk_in_tag(struct usbtmc_device_data *data, 268 u8 tag) 269 { 270 u8 *buffer; 271 struct device *dev; 272 int rv; 273 int n; 274 int actual; 275 276 dev = &data->intf->dev; 277 buffer = kmalloc(USBTMC_BUFSIZE, GFP_KERNEL); 278 if (!buffer) 279 return -ENOMEM; 280 281 rv = usb_control_msg(data->usb_dev, 282 usb_rcvctrlpipe(data->usb_dev, 0), 283 USBTMC_REQUEST_INITIATE_ABORT_BULK_IN, 284 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 285 tag, data->bulk_in, 286 buffer, 2, USB_CTRL_GET_TIMEOUT); 287 288 if (rv < 0) { 289 dev_err(dev, "usb_control_msg returned %d\n", rv); 290 goto exit; 291 } 292 293 dev_dbg(dev, "INITIATE_ABORT_BULK_IN returned %x with tag %02x\n", 294 buffer[0], buffer[1]); 295 296 if (buffer[0] == USBTMC_STATUS_FAILED) { 297 /* No transfer in progress and the Bulk-OUT FIFO is empty. */ 298 rv = 0; 299 goto exit; 300 } 301 302 if (buffer[0] == USBTMC_STATUS_TRANSFER_NOT_IN_PROGRESS) { 303 /* The device returns this status if either: 304 * - There is a transfer in progress, but the specified bTag 305 * does not match. 306 * - There is no transfer in progress, but the Bulk-OUT FIFO 307 * is not empty. 308 */ 309 rv = -ENOMSG; 310 goto exit; 311 } 312 313 if (buffer[0] != USBTMC_STATUS_SUCCESS) { 314 dev_err(dev, "INITIATE_ABORT_BULK_IN returned %x\n", 315 buffer[0]); 316 rv = -EPERM; 317 goto exit; 318 } 319 320 n = 0; 321 322 usbtmc_abort_bulk_in_status: 323 dev_dbg(dev, "Reading from bulk in EP\n"); 324 325 /* Data must be present. So use low timeout 300 ms */ 326 actual = 0; 327 rv = usb_bulk_msg(data->usb_dev, 328 usb_rcvbulkpipe(data->usb_dev, 329 data->bulk_in), 330 buffer, USBTMC_BUFSIZE, 331 &actual, 300); 332 333 print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 16, 1, 334 buffer, actual, true); 335 336 n++; 337 338 if (rv < 0) { 339 dev_err(dev, "usb_bulk_msg returned %d\n", rv); 340 if (rv != -ETIMEDOUT) 341 goto exit; 342 } 343 344 if (actual == USBTMC_BUFSIZE) 345 goto usbtmc_abort_bulk_in_status; 346 347 if (n >= USBTMC_MAX_READS_TO_CLEAR_BULK_IN) { 348 dev_err(dev, "Couldn't clear device buffer within %d cycles\n", 349 USBTMC_MAX_READS_TO_CLEAR_BULK_IN); 350 rv = -EPERM; 351 goto exit; 352 } 353 354 rv = usb_control_msg(data->usb_dev, 355 usb_rcvctrlpipe(data->usb_dev, 0), 356 USBTMC_REQUEST_CHECK_ABORT_BULK_IN_STATUS, 357 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 358 0, data->bulk_in, buffer, 0x08, 359 USB_CTRL_GET_TIMEOUT); 360 361 if (rv < 0) { 362 dev_err(dev, "usb_control_msg returned %d\n", rv); 363 goto exit; 364 } 365 366 dev_dbg(dev, "CHECK_ABORT_BULK_IN returned %x\n", buffer[0]); 367 368 if (buffer[0] == USBTMC_STATUS_SUCCESS) { 369 rv = 0; 370 goto exit; 371 } 372 373 if (buffer[0] != USBTMC_STATUS_PENDING) { 374 dev_err(dev, "CHECK_ABORT_BULK_IN returned %x\n", buffer[0]); 375 rv = -EPERM; 376 goto exit; 377 } 378 379 if ((buffer[1] & 1) > 0) { 380 /* The device has 1 or more queued packets the Host can read */ 381 goto usbtmc_abort_bulk_in_status; 382 } 383 384 /* The Host must send CHECK_ABORT_BULK_IN_STATUS at a later time. */ 385 rv = -EAGAIN; 386 exit: 387 kfree(buffer); 388 return rv; 389 } 390 391 static int usbtmc_ioctl_abort_bulk_in(struct usbtmc_device_data *data) 392 { 393 return usbtmc_ioctl_abort_bulk_in_tag(data, data->bTag_last_read); 394 } 395 396 static int usbtmc_ioctl_abort_bulk_out_tag(struct usbtmc_device_data *data, 397 u8 tag) 398 { 399 struct device *dev; 400 u8 *buffer; 401 int rv; 402 int n; 403 404 dev = &data->intf->dev; 405 406 buffer = kmalloc(8, GFP_KERNEL); 407 if (!buffer) 408 return -ENOMEM; 409 410 rv = usb_control_msg(data->usb_dev, 411 usb_rcvctrlpipe(data->usb_dev, 0), 412 USBTMC_REQUEST_INITIATE_ABORT_BULK_OUT, 413 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 414 tag, data->bulk_out, 415 buffer, 2, USB_CTRL_GET_TIMEOUT); 416 417 if (rv < 0) { 418 dev_err(dev, "usb_control_msg returned %d\n", rv); 419 goto exit; 420 } 421 422 dev_dbg(dev, "INITIATE_ABORT_BULK_OUT returned %x\n", buffer[0]); 423 424 if (buffer[0] != USBTMC_STATUS_SUCCESS) { 425 dev_err(dev, "INITIATE_ABORT_BULK_OUT returned %x\n", 426 buffer[0]); 427 rv = -EPERM; 428 goto exit; 429 } 430 431 n = 0; 432 433 usbtmc_abort_bulk_out_check_status: 434 /* do not stress device with subsequent requests */ 435 msleep(50); 436 rv = usb_control_msg(data->usb_dev, 437 usb_rcvctrlpipe(data->usb_dev, 0), 438 USBTMC_REQUEST_CHECK_ABORT_BULK_OUT_STATUS, 439 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT, 440 0, data->bulk_out, buffer, 0x08, 441 USB_CTRL_GET_TIMEOUT); 442 n++; 443 if (rv < 0) { 444 dev_err(dev, "usb_control_msg returned %d\n", rv); 445 goto exit; 446 } 447 448 dev_dbg(dev, "CHECK_ABORT_BULK_OUT returned %x\n", buffer[0]); 449 450 if (buffer[0] == USBTMC_STATUS_SUCCESS) 451 goto usbtmc_abort_bulk_out_clear_halt; 452 453 if ((buffer[0] == USBTMC_STATUS_PENDING) && 454 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN)) 455 goto usbtmc_abort_bulk_out_check_status; 456 457 rv = -EPERM; 458 goto exit; 459 460 usbtmc_abort_bulk_out_clear_halt: 461 rv = usb_clear_halt(data->usb_dev, 462 usb_sndbulkpipe(data->usb_dev, data->bulk_out)); 463 464 if (rv < 0) { 465 dev_err(dev, "usb_control_msg returned %d\n", rv); 466 goto exit; 467 } 468 rv = 0; 469 470 exit: 471 kfree(buffer); 472 return rv; 473 } 474 475 static int usbtmc_ioctl_abort_bulk_out(struct usbtmc_device_data *data) 476 { 477 return usbtmc_ioctl_abort_bulk_out_tag(data, data->bTag_last_write); 478 } 479 480 static int usbtmc_get_stb(struct usbtmc_file_data *file_data, __u8 *stb) 481 { 482 struct usbtmc_device_data *data = file_data->data; 483 struct device *dev = &data->intf->dev; 484 u8 *buffer; 485 u8 tag; 486 int rv; 487 long wait_rv; 488 unsigned long expire; 489 490 dev_dbg(dev, "Enter ioctl_read_stb iin_ep_present: %d\n", 491 data->iin_ep_present); 492 493 buffer = kmalloc(8, GFP_KERNEL); 494 if (!buffer) 495 return -ENOMEM; 496 497 atomic_set(&data->iin_data_valid, 0); 498 499 rv = usb_control_msg(data->usb_dev, 500 usb_rcvctrlpipe(data->usb_dev, 0), 501 USBTMC488_REQUEST_READ_STATUS_BYTE, 502 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 503 data->iin_bTag, 504 data->ifnum, 505 buffer, 0x03, USB_CTRL_GET_TIMEOUT); 506 if (rv < 0) { 507 dev_err(dev, "stb usb_control_msg returned %d\n", rv); 508 goto exit; 509 } 510 511 if (buffer[0] != USBTMC_STATUS_SUCCESS) { 512 dev_err(dev, "control status returned %x\n", buffer[0]); 513 rv = -EIO; 514 goto exit; 515 } 516 517 if (data->iin_ep_present) { 518 expire = msecs_to_jiffies(file_data->timeout); 519 wait_rv = wait_event_interruptible_timeout( 520 data->waitq, 521 atomic_read(&data->iin_data_valid) != 0, 522 expire); 523 if (wait_rv < 0) { 524 dev_dbg(dev, "wait interrupted %ld\n", wait_rv); 525 rv = wait_rv; 526 goto exit; 527 } 528 529 if (wait_rv == 0) { 530 dev_dbg(dev, "wait timed out\n"); 531 rv = -ETIMEDOUT; 532 goto exit; 533 } 534 535 tag = data->bNotify1 & 0x7f; 536 if (tag != data->iin_bTag) { 537 dev_err(dev, "expected bTag %x got %x\n", 538 data->iin_bTag, tag); 539 } 540 541 *stb = data->bNotify2; 542 } else { 543 *stb = buffer[2]; 544 } 545 546 dev_dbg(dev, "stb:0x%02x received %d\n", (unsigned int)*stb, rv); 547 548 rv = 0; 549 550 exit: 551 /* bump interrupt bTag */ 552 data->iin_bTag += 1; 553 if (data->iin_bTag > 127) 554 /* 1 is for SRQ see USBTMC-USB488 subclass spec section 4.3.1 */ 555 data->iin_bTag = 2; 556 557 kfree(buffer); 558 return rv; 559 } 560 561 static int usbtmc488_ioctl_read_stb(struct usbtmc_file_data *file_data, 562 void __user *arg) 563 { 564 int srq_asserted = 0; 565 __u8 stb; 566 int rv; 567 568 rv = usbtmc_get_stb(file_data, &stb); 569 570 if (rv < 0) 571 return rv; 572 573 srq_asserted = atomic_xchg(&file_data->srq_asserted, srq_asserted); 574 if (srq_asserted) 575 stb |= 0x40; /* Set RQS bit */ 576 577 rv = put_user(stb, (__u8 __user *)arg); 578 579 return rv; 580 581 } 582 583 static int usbtmc_ioctl_get_srq_stb(struct usbtmc_file_data *file_data, 584 void __user *arg) 585 { 586 struct usbtmc_device_data *data = file_data->data; 587 struct device *dev = &data->intf->dev; 588 int srq_asserted = 0; 589 __u8 stb = 0; 590 int rv; 591 592 spin_lock_irq(&data->dev_lock); 593 srq_asserted = atomic_xchg(&file_data->srq_asserted, srq_asserted); 594 595 if (srq_asserted) { 596 stb = file_data->srq_byte; 597 spin_unlock_irq(&data->dev_lock); 598 rv = put_user(stb, (__u8 __user *)arg); 599 } else { 600 spin_unlock_irq(&data->dev_lock); 601 rv = -ENOMSG; 602 } 603 604 dev_dbg(dev, "stb:0x%02x with srq received %d\n", (unsigned int)stb, rv); 605 606 return rv; 607 } 608 609 static int usbtmc488_ioctl_wait_srq(struct usbtmc_file_data *file_data, 610 __u32 __user *arg) 611 { 612 struct usbtmc_device_data *data = file_data->data; 613 struct device *dev = &data->intf->dev; 614 u32 timeout; 615 unsigned long expire; 616 long wait_rv; 617 618 if (!data->iin_ep_present) { 619 dev_dbg(dev, "no interrupt endpoint present\n"); 620 return -EFAULT; 621 } 622 623 if (get_user(timeout, arg)) 624 return -EFAULT; 625 626 expire = msecs_to_jiffies(timeout); 627 628 mutex_unlock(&data->io_mutex); 629 630 wait_rv = wait_event_interruptible_timeout( 631 data->waitq, 632 atomic_read(&file_data->srq_asserted) != 0 || 633 atomic_read(&file_data->closing), 634 expire); 635 636 mutex_lock(&data->io_mutex); 637 638 /* Note! disconnect or close could be called in the meantime */ 639 if (atomic_read(&file_data->closing) || data->zombie) 640 return -ENODEV; 641 642 if (wait_rv < 0) { 643 dev_dbg(dev, "%s - wait interrupted %ld\n", __func__, wait_rv); 644 return wait_rv; 645 } 646 647 if (wait_rv == 0) { 648 dev_dbg(dev, "%s - wait timed out\n", __func__); 649 return -ETIMEDOUT; 650 } 651 652 dev_dbg(dev, "%s - srq asserted\n", __func__); 653 return 0; 654 } 655 656 static int usbtmc488_ioctl_simple(struct usbtmc_device_data *data, 657 void __user *arg, unsigned int cmd) 658 { 659 struct device *dev = &data->intf->dev; 660 __u8 val; 661 u8 *buffer; 662 u16 wValue; 663 int rv; 664 665 if (!(data->usb488_caps & USBTMC488_CAPABILITY_SIMPLE)) 666 return -EINVAL; 667 668 buffer = kmalloc(8, GFP_KERNEL); 669 if (!buffer) 670 return -ENOMEM; 671 672 if (cmd == USBTMC488_REQUEST_REN_CONTROL) { 673 rv = copy_from_user(&val, arg, sizeof(val)); 674 if (rv) { 675 rv = -EFAULT; 676 goto exit; 677 } 678 wValue = val ? 1 : 0; 679 } else { 680 wValue = 0; 681 } 682 683 rv = usb_control_msg(data->usb_dev, 684 usb_rcvctrlpipe(data->usb_dev, 0), 685 cmd, 686 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 687 wValue, 688 data->ifnum, 689 buffer, 0x01, USB_CTRL_GET_TIMEOUT); 690 if (rv < 0) { 691 dev_err(dev, "simple usb_control_msg failed %d\n", rv); 692 goto exit; 693 } else if (rv != 1) { 694 dev_warn(dev, "simple usb_control_msg returned %d\n", rv); 695 rv = -EIO; 696 goto exit; 697 } 698 699 if (buffer[0] != USBTMC_STATUS_SUCCESS) { 700 dev_err(dev, "simple control status returned %x\n", buffer[0]); 701 rv = -EIO; 702 goto exit; 703 } 704 rv = 0; 705 706 exit: 707 kfree(buffer); 708 return rv; 709 } 710 711 /* 712 * Sends a TRIGGER Bulk-OUT command message 713 * See the USBTMC-USB488 specification, Table 2. 714 * 715 * Also updates bTag_last_write. 716 */ 717 static int usbtmc488_ioctl_trigger(struct usbtmc_file_data *file_data) 718 { 719 struct usbtmc_device_data *data = file_data->data; 720 int retval; 721 u8 *buffer; 722 int actual; 723 724 buffer = kzalloc(USBTMC_HEADER_SIZE, GFP_KERNEL); 725 if (!buffer) 726 return -ENOMEM; 727 728 buffer[0] = 128; 729 buffer[1] = data->bTag; 730 buffer[2] = ~data->bTag; 731 732 retval = usb_bulk_msg_killable(data->usb_dev, 733 usb_sndbulkpipe(data->usb_dev, 734 data->bulk_out), 735 buffer, USBTMC_HEADER_SIZE, 736 &actual, file_data->timeout); 737 738 /* Store bTag (in case we need to abort) */ 739 data->bTag_last_write = data->bTag; 740 741 /* Increment bTag -- and increment again if zero */ 742 data->bTag++; 743 if (!data->bTag) 744 data->bTag++; 745 746 kfree(buffer); 747 if (retval < 0) { 748 dev_err(&data->intf->dev, "%s returned %d\n", 749 __func__, retval); 750 return retval; 751 } 752 753 return 0; 754 } 755 756 static struct urb *usbtmc_create_urb(void) 757 { 758 const size_t bufsize = USBTMC_BUFSIZE; 759 u8 *dmabuf = NULL; 760 struct urb *urb = usb_alloc_urb(0, GFP_KERNEL); 761 762 if (!urb) 763 return NULL; 764 765 dmabuf = kzalloc(bufsize, GFP_KERNEL); 766 if (!dmabuf) { 767 usb_free_urb(urb); 768 return NULL; 769 } 770 771 urb->transfer_buffer = dmabuf; 772 urb->transfer_buffer_length = bufsize; 773 urb->transfer_flags |= URB_FREE_BUFFER; 774 return urb; 775 } 776 777 static void usbtmc_read_bulk_cb(struct urb *urb) 778 { 779 struct usbtmc_file_data *file_data = urb->context; 780 int status = urb->status; 781 unsigned long flags; 782 783 /* sync/async unlink faults aren't errors */ 784 if (status) { 785 if (!(/* status == -ENOENT || */ 786 status == -ECONNRESET || 787 status == -EREMOTEIO || /* Short packet */ 788 status == -ESHUTDOWN)) 789 dev_err(&file_data->data->intf->dev, 790 "%s - nonzero read bulk status received: %d\n", 791 __func__, status); 792 793 spin_lock_irqsave(&file_data->err_lock, flags); 794 if (!file_data->in_status) 795 file_data->in_status = status; 796 spin_unlock_irqrestore(&file_data->err_lock, flags); 797 } 798 799 spin_lock_irqsave(&file_data->err_lock, flags); 800 file_data->in_transfer_size += urb->actual_length; 801 dev_dbg(&file_data->data->intf->dev, 802 "%s - total size: %u current: %d status: %d\n", 803 __func__, file_data->in_transfer_size, 804 urb->actual_length, status); 805 spin_unlock_irqrestore(&file_data->err_lock, flags); 806 usb_anchor_urb(urb, &file_data->in_anchor); 807 808 wake_up_interruptible(&file_data->wait_bulk_in); 809 wake_up_interruptible(&file_data->data->waitq); 810 } 811 812 static inline bool usbtmc_do_transfer(struct usbtmc_file_data *file_data) 813 { 814 bool data_or_error; 815 816 spin_lock_irq(&file_data->err_lock); 817 data_or_error = !usb_anchor_empty(&file_data->in_anchor) 818 || file_data->in_status; 819 spin_unlock_irq(&file_data->err_lock); 820 dev_dbg(&file_data->data->intf->dev, "%s: returns %d\n", __func__, 821 data_or_error); 822 return data_or_error; 823 } 824 825 static ssize_t usbtmc_generic_read(struct usbtmc_file_data *file_data, 826 void __user *user_buffer, 827 u32 transfer_size, 828 u32 *transferred, 829 u32 flags) 830 { 831 struct usbtmc_device_data *data = file_data->data; 832 struct device *dev = &data->intf->dev; 833 u32 done = 0; 834 u32 remaining; 835 const u32 bufsize = USBTMC_BUFSIZE; 836 int retval = 0; 837 u32 max_transfer_size; 838 unsigned long expire; 839 int bufcount = 1; 840 int again = 0; 841 long wait_rv; 842 843 /* mutex already locked */ 844 845 *transferred = done; 846 847 max_transfer_size = transfer_size; 848 849 if (flags & USBTMC_FLAG_IGNORE_TRAILER) { 850 /* The device may send extra alignment bytes (up to 851 * wMaxPacketSize – 1) to avoid sending a zero-length 852 * packet 853 */ 854 remaining = transfer_size; 855 if ((max_transfer_size % data->wMaxPacketSize) == 0) 856 max_transfer_size += (data->wMaxPacketSize - 1); 857 } else { 858 /* round down to bufsize to avoid truncated data left */ 859 if (max_transfer_size > bufsize) { 860 max_transfer_size = 861 roundup(max_transfer_size + 1 - bufsize, 862 bufsize); 863 } 864 remaining = max_transfer_size; 865 } 866 867 spin_lock_irq(&file_data->err_lock); 868 869 if (file_data->in_status) { 870 /* return the very first error */ 871 retval = file_data->in_status; 872 spin_unlock_irq(&file_data->err_lock); 873 goto error; 874 } 875 876 if (flags & USBTMC_FLAG_ASYNC) { 877 if (usb_anchor_empty(&file_data->in_anchor)) 878 again = 1; 879 880 if (file_data->in_urbs_used == 0) { 881 file_data->in_transfer_size = 0; 882 file_data->in_status = 0; 883 } 884 } else { 885 file_data->in_transfer_size = 0; 886 file_data->in_status = 0; 887 } 888 889 if (max_transfer_size == 0) { 890 bufcount = 0; 891 } else { 892 bufcount = roundup(max_transfer_size, bufsize) / bufsize; 893 if (bufcount > file_data->in_urbs_used) 894 bufcount -= file_data->in_urbs_used; 895 else 896 bufcount = 0; 897 898 if (bufcount + file_data->in_urbs_used > MAX_URBS_IN_FLIGHT) { 899 bufcount = MAX_URBS_IN_FLIGHT - 900 file_data->in_urbs_used; 901 } 902 } 903 spin_unlock_irq(&file_data->err_lock); 904 905 dev_dbg(dev, "%s: requested=%u flags=0x%X size=%u bufs=%d used=%d\n", 906 __func__, transfer_size, flags, 907 max_transfer_size, bufcount, file_data->in_urbs_used); 908 909 while (bufcount > 0) { 910 u8 *dmabuf = NULL; 911 struct urb *urb = usbtmc_create_urb(); 912 913 if (!urb) { 914 retval = -ENOMEM; 915 goto error; 916 } 917 918 dmabuf = urb->transfer_buffer; 919 920 usb_fill_bulk_urb(urb, data->usb_dev, 921 usb_rcvbulkpipe(data->usb_dev, data->bulk_in), 922 dmabuf, bufsize, 923 usbtmc_read_bulk_cb, file_data); 924 925 usb_anchor_urb(urb, &file_data->submitted); 926 retval = usb_submit_urb(urb, GFP_KERNEL); 927 /* urb is anchored. We can release our reference. */ 928 usb_free_urb(urb); 929 if (unlikely(retval)) { 930 usb_unanchor_urb(urb); 931 goto error; 932 } 933 file_data->in_urbs_used++; 934 bufcount--; 935 } 936 937 if (again) { 938 dev_dbg(dev, "%s: ret=again\n", __func__); 939 return -EAGAIN; 940 } 941 942 if (user_buffer == NULL) 943 return -EINVAL; 944 945 expire = msecs_to_jiffies(file_data->timeout); 946 947 while (max_transfer_size > 0) { 948 u32 this_part; 949 struct urb *urb = NULL; 950 951 if (!(flags & USBTMC_FLAG_ASYNC)) { 952 dev_dbg(dev, "%s: before wait time %lu\n", 953 __func__, expire); 954 wait_rv = wait_event_interruptible_timeout( 955 file_data->wait_bulk_in, 956 usbtmc_do_transfer(file_data), 957 expire); 958 959 dev_dbg(dev, "%s: wait returned %ld\n", 960 __func__, wait_rv); 961 962 if (wait_rv < 0) { 963 retval = wait_rv; 964 goto error; 965 } 966 967 if (wait_rv == 0) { 968 retval = -ETIMEDOUT; 969 goto error; 970 } 971 972 } 973 974 urb = usb_get_from_anchor(&file_data->in_anchor); 975 if (!urb) { 976 if (!(flags & USBTMC_FLAG_ASYNC)) { 977 /* synchronous case: must not happen */ 978 retval = -EFAULT; 979 goto error; 980 } 981 982 /* asynchronous case: ready, do not block or wait */ 983 *transferred = done; 984 dev_dbg(dev, "%s: (async) done=%u ret=0\n", 985 __func__, done); 986 return 0; 987 } 988 989 file_data->in_urbs_used--; 990 991 if (max_transfer_size > urb->actual_length) 992 max_transfer_size -= urb->actual_length; 993 else 994 max_transfer_size = 0; 995 996 if (remaining > urb->actual_length) 997 this_part = urb->actual_length; 998 else 999 this_part = remaining; 1000 1001 print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 16, 1, 1002 urb->transfer_buffer, urb->actual_length, true); 1003 1004 if (copy_to_user(user_buffer + done, 1005 urb->transfer_buffer, this_part)) { 1006 usb_free_urb(urb); 1007 retval = -EFAULT; 1008 goto error; 1009 } 1010 1011 remaining -= this_part; 1012 done += this_part; 1013 1014 spin_lock_irq(&file_data->err_lock); 1015 if (urb->status) { 1016 /* return the very first error */ 1017 retval = file_data->in_status; 1018 spin_unlock_irq(&file_data->err_lock); 1019 usb_free_urb(urb); 1020 goto error; 1021 } 1022 spin_unlock_irq(&file_data->err_lock); 1023 1024 if (urb->actual_length < bufsize) { 1025 /* short packet or ZLP received => ready */ 1026 usb_free_urb(urb); 1027 retval = 1; 1028 break; 1029 } 1030 1031 if (!(flags & USBTMC_FLAG_ASYNC) && 1032 max_transfer_size > (bufsize * file_data->in_urbs_used)) { 1033 /* resubmit, since other buffers still not enough */ 1034 usb_anchor_urb(urb, &file_data->submitted); 1035 retval = usb_submit_urb(urb, GFP_KERNEL); 1036 if (unlikely(retval)) { 1037 usb_unanchor_urb(urb); 1038 usb_free_urb(urb); 1039 goto error; 1040 } 1041 file_data->in_urbs_used++; 1042 } 1043 usb_free_urb(urb); 1044 retval = 0; 1045 } 1046 1047 error: 1048 *transferred = done; 1049 1050 dev_dbg(dev, "%s: before kill\n", __func__); 1051 /* Attention: killing urbs can take long time (2 ms) */ 1052 usb_kill_anchored_urbs(&file_data->submitted); 1053 dev_dbg(dev, "%s: after kill\n", __func__); 1054 usb_scuttle_anchored_urbs(&file_data->in_anchor); 1055 file_data->in_urbs_used = 0; 1056 file_data->in_status = 0; /* no spinlock needed here */ 1057 dev_dbg(dev, "%s: done=%u ret=%d\n", __func__, done, retval); 1058 1059 return retval; 1060 } 1061 1062 static ssize_t usbtmc_ioctl_generic_read(struct usbtmc_file_data *file_data, 1063 void __user *arg) 1064 { 1065 struct usbtmc_message msg; 1066 ssize_t retval = 0; 1067 1068 /* mutex already locked */ 1069 1070 if (copy_from_user(&msg, arg, sizeof(struct usbtmc_message))) 1071 return -EFAULT; 1072 1073 retval = usbtmc_generic_read(file_data, msg.message, 1074 msg.transfer_size, &msg.transferred, 1075 msg.flags); 1076 1077 if (put_user(msg.transferred, 1078 &((struct usbtmc_message __user *)arg)->transferred)) 1079 return -EFAULT; 1080 1081 return retval; 1082 } 1083 1084 static void usbtmc_write_bulk_cb(struct urb *urb) 1085 { 1086 struct usbtmc_file_data *file_data = urb->context; 1087 int wakeup = 0; 1088 unsigned long flags; 1089 1090 spin_lock_irqsave(&file_data->err_lock, flags); 1091 file_data->out_transfer_size += urb->actual_length; 1092 1093 /* sync/async unlink faults aren't errors */ 1094 if (urb->status) { 1095 if (!(urb->status == -ENOENT || 1096 urb->status == -ECONNRESET || 1097 urb->status == -ESHUTDOWN)) 1098 dev_err(&file_data->data->intf->dev, 1099 "%s - nonzero write bulk status received: %d\n", 1100 __func__, urb->status); 1101 1102 if (!file_data->out_status) { 1103 file_data->out_status = urb->status; 1104 wakeup = 1; 1105 } 1106 } 1107 spin_unlock_irqrestore(&file_data->err_lock, flags); 1108 1109 dev_dbg(&file_data->data->intf->dev, 1110 "%s - write bulk total size: %u\n", 1111 __func__, file_data->out_transfer_size); 1112 1113 up(&file_data->limit_write_sem); 1114 if (usb_anchor_empty(&file_data->submitted) || wakeup) 1115 wake_up_interruptible(&file_data->data->waitq); 1116 } 1117 1118 static ssize_t usbtmc_generic_write(struct usbtmc_file_data *file_data, 1119 const void __user *user_buffer, 1120 u32 transfer_size, 1121 u32 *transferred, 1122 u32 flags) 1123 { 1124 struct usbtmc_device_data *data = file_data->data; 1125 struct device *dev; 1126 u32 done = 0; 1127 u32 remaining; 1128 unsigned long expire; 1129 const u32 bufsize = USBTMC_BUFSIZE; 1130 struct urb *urb = NULL; 1131 int retval = 0; 1132 u32 timeout; 1133 1134 *transferred = 0; 1135 1136 /* Get pointer to private data structure */ 1137 dev = &data->intf->dev; 1138 1139 dev_dbg(dev, "%s: size=%u flags=0x%X sema=%u\n", 1140 __func__, transfer_size, flags, 1141 file_data->limit_write_sem.count); 1142 1143 if (flags & USBTMC_FLAG_APPEND) { 1144 spin_lock_irq(&file_data->err_lock); 1145 retval = file_data->out_status; 1146 spin_unlock_irq(&file_data->err_lock); 1147 if (retval < 0) 1148 return retval; 1149 } else { 1150 spin_lock_irq(&file_data->err_lock); 1151 file_data->out_transfer_size = 0; 1152 file_data->out_status = 0; 1153 spin_unlock_irq(&file_data->err_lock); 1154 } 1155 1156 remaining = transfer_size; 1157 if (remaining > INT_MAX) 1158 remaining = INT_MAX; 1159 1160 timeout = file_data->timeout; 1161 expire = msecs_to_jiffies(timeout); 1162 1163 while (remaining > 0) { 1164 u32 this_part, aligned; 1165 u8 *buffer = NULL; 1166 1167 if (flags & USBTMC_FLAG_ASYNC) { 1168 if (down_trylock(&file_data->limit_write_sem)) { 1169 retval = (done)?(0):(-EAGAIN); 1170 goto exit; 1171 } 1172 } else { 1173 retval = down_timeout(&file_data->limit_write_sem, 1174 expire); 1175 if (retval < 0) { 1176 retval = -ETIMEDOUT; 1177 goto error; 1178 } 1179 } 1180 1181 spin_lock_irq(&file_data->err_lock); 1182 retval = file_data->out_status; 1183 spin_unlock_irq(&file_data->err_lock); 1184 if (retval < 0) { 1185 up(&file_data->limit_write_sem); 1186 goto error; 1187 } 1188 1189 /* prepare next urb to send */ 1190 urb = usbtmc_create_urb(); 1191 if (!urb) { 1192 retval = -ENOMEM; 1193 up(&file_data->limit_write_sem); 1194 goto error; 1195 } 1196 buffer = urb->transfer_buffer; 1197 1198 if (remaining > bufsize) 1199 this_part = bufsize; 1200 else 1201 this_part = remaining; 1202 1203 if (copy_from_user(buffer, user_buffer + done, this_part)) { 1204 retval = -EFAULT; 1205 up(&file_data->limit_write_sem); 1206 goto error; 1207 } 1208 1209 print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 1210 16, 1, buffer, this_part, true); 1211 1212 /* fill bulk with 32 bit alignment to meet USBTMC specification 1213 * (size + 3 & ~3) rounds up and simplifies user code 1214 */ 1215 aligned = (this_part + 3) & ~3; 1216 dev_dbg(dev, "write(size:%u align:%u done:%u)\n", 1217 (unsigned int)this_part, 1218 (unsigned int)aligned, 1219 (unsigned int)done); 1220 1221 usb_fill_bulk_urb(urb, data->usb_dev, 1222 usb_sndbulkpipe(data->usb_dev, data->bulk_out), 1223 urb->transfer_buffer, aligned, 1224 usbtmc_write_bulk_cb, file_data); 1225 1226 usb_anchor_urb(urb, &file_data->submitted); 1227 retval = usb_submit_urb(urb, GFP_KERNEL); 1228 if (unlikely(retval)) { 1229 usb_unanchor_urb(urb); 1230 up(&file_data->limit_write_sem); 1231 goto error; 1232 } 1233 1234 usb_free_urb(urb); 1235 urb = NULL; /* urb will be finally released by usb driver */ 1236 1237 remaining -= this_part; 1238 done += this_part; 1239 } 1240 1241 /* All urbs are on the fly */ 1242 if (!(flags & USBTMC_FLAG_ASYNC)) { 1243 if (!usb_wait_anchor_empty_timeout(&file_data->submitted, 1244 timeout)) { 1245 retval = -ETIMEDOUT; 1246 goto error; 1247 } 1248 } 1249 1250 retval = 0; 1251 goto exit; 1252 1253 error: 1254 usb_kill_anchored_urbs(&file_data->submitted); 1255 exit: 1256 usb_free_urb(urb); 1257 1258 spin_lock_irq(&file_data->err_lock); 1259 if (!(flags & USBTMC_FLAG_ASYNC)) 1260 done = file_data->out_transfer_size; 1261 if (!retval && file_data->out_status) 1262 retval = file_data->out_status; 1263 spin_unlock_irq(&file_data->err_lock); 1264 1265 *transferred = done; 1266 1267 dev_dbg(dev, "%s: done=%u, retval=%d, urbstat=%d\n", 1268 __func__, done, retval, file_data->out_status); 1269 1270 return retval; 1271 } 1272 1273 static ssize_t usbtmc_ioctl_generic_write(struct usbtmc_file_data *file_data, 1274 void __user *arg) 1275 { 1276 struct usbtmc_message msg; 1277 ssize_t retval = 0; 1278 1279 /* mutex already locked */ 1280 1281 if (copy_from_user(&msg, arg, sizeof(struct usbtmc_message))) 1282 return -EFAULT; 1283 1284 retval = usbtmc_generic_write(file_data, msg.message, 1285 msg.transfer_size, &msg.transferred, 1286 msg.flags); 1287 1288 if (put_user(msg.transferred, 1289 &((struct usbtmc_message __user *)arg)->transferred)) 1290 return -EFAULT; 1291 1292 return retval; 1293 } 1294 1295 /* 1296 * Get the generic write result 1297 */ 1298 static ssize_t usbtmc_ioctl_write_result(struct usbtmc_file_data *file_data, 1299 void __user *arg) 1300 { 1301 u32 transferred; 1302 int retval; 1303 1304 spin_lock_irq(&file_data->err_lock); 1305 transferred = file_data->out_transfer_size; 1306 retval = file_data->out_status; 1307 spin_unlock_irq(&file_data->err_lock); 1308 1309 if (put_user(transferred, (__u32 __user *)arg)) 1310 return -EFAULT; 1311 1312 return retval; 1313 } 1314 1315 /* 1316 * Sends a REQUEST_DEV_DEP_MSG_IN message on the Bulk-OUT endpoint. 1317 * @transfer_size: number of bytes to request from the device. 1318 * 1319 * See the USBTMC specification, Table 4. 1320 * 1321 * Also updates bTag_last_write. 1322 */ 1323 static int send_request_dev_dep_msg_in(struct usbtmc_file_data *file_data, 1324 u32 transfer_size) 1325 { 1326 struct usbtmc_device_data *data = file_data->data; 1327 int retval; 1328 u8 *buffer; 1329 int actual; 1330 1331 buffer = kmalloc(USBTMC_HEADER_SIZE, GFP_KERNEL); 1332 if (!buffer) 1333 return -ENOMEM; 1334 /* Setup IO buffer for REQUEST_DEV_DEP_MSG_IN message 1335 * Refer to class specs for details 1336 */ 1337 buffer[0] = 2; 1338 buffer[1] = data->bTag; 1339 buffer[2] = ~data->bTag; 1340 buffer[3] = 0; /* Reserved */ 1341 buffer[4] = transfer_size >> 0; 1342 buffer[5] = transfer_size >> 8; 1343 buffer[6] = transfer_size >> 16; 1344 buffer[7] = transfer_size >> 24; 1345 buffer[8] = file_data->term_char_enabled * 2; 1346 /* Use term character? */ 1347 buffer[9] = file_data->term_char; 1348 buffer[10] = 0; /* Reserved */ 1349 buffer[11] = 0; /* Reserved */ 1350 1351 /* Send bulk URB */ 1352 retval = usb_bulk_msg_killable(data->usb_dev, 1353 usb_sndbulkpipe(data->usb_dev, 1354 data->bulk_out), 1355 buffer, USBTMC_HEADER_SIZE, 1356 &actual, file_data->timeout); 1357 1358 /* Store bTag (in case we need to abort) */ 1359 data->bTag_last_write = data->bTag; 1360 1361 /* Increment bTag -- and increment again if zero */ 1362 data->bTag++; 1363 if (!data->bTag) 1364 data->bTag++; 1365 1366 kfree(buffer); 1367 if (retval < 0) 1368 dev_err(&data->intf->dev, "%s returned %d\n", 1369 __func__, retval); 1370 1371 return retval; 1372 } 1373 1374 static ssize_t usbtmc_read(struct file *filp, char __user *buf, 1375 size_t count, loff_t *f_pos) 1376 { 1377 struct usbtmc_file_data *file_data; 1378 struct usbtmc_device_data *data; 1379 struct device *dev; 1380 const u32 bufsize = USBTMC_BUFSIZE; 1381 u32 n_characters; 1382 u8 *buffer; 1383 int actual; 1384 u32 done = 0; 1385 u32 remaining; 1386 int retval; 1387 1388 /* Get pointer to private data structure */ 1389 file_data = filp->private_data; 1390 data = file_data->data; 1391 dev = &data->intf->dev; 1392 1393 buffer = kmalloc(bufsize, GFP_KERNEL); 1394 if (!buffer) 1395 return -ENOMEM; 1396 1397 retval = mutex_lock_interruptible(&data->io_mutex); 1398 if (retval < 0) 1399 goto exit_nolock; 1400 1401 if (data->zombie) { 1402 retval = -ENODEV; 1403 goto exit; 1404 } 1405 1406 if (count > INT_MAX) 1407 count = INT_MAX; 1408 1409 dev_dbg(dev, "%s(count:%zu)\n", __func__, count); 1410 1411 retval = send_request_dev_dep_msg_in(file_data, count); 1412 1413 if (retval < 0) { 1414 if (file_data->auto_abort) 1415 usbtmc_ioctl_abort_bulk_out(data); 1416 goto exit; 1417 } 1418 1419 /* Loop until we have fetched everything we requested */ 1420 remaining = count; 1421 actual = 0; 1422 1423 /* Send bulk URB */ 1424 retval = usb_bulk_msg_killable(data->usb_dev, 1425 usb_rcvbulkpipe(data->usb_dev, 1426 data->bulk_in), 1427 buffer, bufsize, &actual, 1428 file_data->timeout); 1429 1430 dev_dbg(dev, "%s: bulk_msg retval(%u), actual(%d)\n", 1431 __func__, retval, actual); 1432 1433 /* Store bTag (in case we need to abort) */ 1434 data->bTag_last_read = data->bTag; 1435 1436 if (retval < 0) { 1437 if (file_data->auto_abort) 1438 usbtmc_ioctl_abort_bulk_in(data); 1439 goto exit; 1440 } 1441 1442 /* Sanity checks for the header */ 1443 if (actual < USBTMC_HEADER_SIZE) { 1444 dev_err(dev, "Device sent too small first packet: %u < %u\n", 1445 actual, USBTMC_HEADER_SIZE); 1446 if (file_data->auto_abort) 1447 usbtmc_ioctl_abort_bulk_in(data); 1448 goto exit; 1449 } 1450 1451 if (buffer[0] != 2) { 1452 dev_err(dev, "Device sent reply with wrong MsgID: %u != 2\n", 1453 buffer[0]); 1454 if (file_data->auto_abort) 1455 usbtmc_ioctl_abort_bulk_in(data); 1456 goto exit; 1457 } 1458 1459 if (buffer[1] != data->bTag_last_write) { 1460 dev_err(dev, "Device sent reply with wrong bTag: %u != %u\n", 1461 buffer[1], data->bTag_last_write); 1462 if (file_data->auto_abort) 1463 usbtmc_ioctl_abort_bulk_in(data); 1464 goto exit; 1465 } 1466 1467 /* How many characters did the instrument send? */ 1468 n_characters = buffer[4] + 1469 (buffer[5] << 8) + 1470 (buffer[6] << 16) + 1471 (buffer[7] << 24); 1472 1473 file_data->bmTransferAttributes = buffer[8]; 1474 1475 dev_dbg(dev, "Bulk-IN header: N_characters(%u), bTransAttr(%u)\n", 1476 n_characters, buffer[8]); 1477 1478 if (n_characters > remaining) { 1479 dev_err(dev, "Device wants to return more data than requested: %u > %zu\n", 1480 n_characters, count); 1481 if (file_data->auto_abort) 1482 usbtmc_ioctl_abort_bulk_in(data); 1483 goto exit; 1484 } 1485 1486 print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 1487 16, 1, buffer, actual, true); 1488 1489 remaining = n_characters; 1490 1491 /* Remove the USBTMC header */ 1492 actual -= USBTMC_HEADER_SIZE; 1493 1494 /* Remove padding if it exists */ 1495 if (actual > remaining) 1496 actual = remaining; 1497 1498 remaining -= actual; 1499 1500 /* Copy buffer to user space */ 1501 if (copy_to_user(buf, &buffer[USBTMC_HEADER_SIZE], actual)) { 1502 /* There must have been an addressing problem */ 1503 retval = -EFAULT; 1504 goto exit; 1505 } 1506 1507 if ((actual + USBTMC_HEADER_SIZE) == bufsize) { 1508 retval = usbtmc_generic_read(file_data, buf + actual, 1509 remaining, 1510 &done, 1511 USBTMC_FLAG_IGNORE_TRAILER); 1512 if (retval < 0) 1513 goto exit; 1514 } 1515 done += actual; 1516 1517 /* Update file position value */ 1518 *f_pos = *f_pos + done; 1519 retval = done; 1520 1521 exit: 1522 mutex_unlock(&data->io_mutex); 1523 exit_nolock: 1524 kfree(buffer); 1525 return retval; 1526 } 1527 1528 static ssize_t usbtmc_write(struct file *filp, const char __user *buf, 1529 size_t count, loff_t *f_pos) 1530 { 1531 struct usbtmc_file_data *file_data; 1532 struct usbtmc_device_data *data; 1533 struct urb *urb = NULL; 1534 ssize_t retval = 0; 1535 u8 *buffer; 1536 u32 remaining, done; 1537 u32 transfersize, aligned, buflen; 1538 1539 file_data = filp->private_data; 1540 data = file_data->data; 1541 1542 mutex_lock(&data->io_mutex); 1543 1544 if (data->zombie) { 1545 retval = -ENODEV; 1546 goto exit; 1547 } 1548 1549 done = 0; 1550 1551 spin_lock_irq(&file_data->err_lock); 1552 file_data->out_transfer_size = 0; 1553 file_data->out_status = 0; 1554 spin_unlock_irq(&file_data->err_lock); 1555 1556 if (!count) 1557 goto exit; 1558 1559 if (down_trylock(&file_data->limit_write_sem)) { 1560 /* previous calls were async */ 1561 retval = -EBUSY; 1562 goto exit; 1563 } 1564 1565 urb = usbtmc_create_urb(); 1566 if (!urb) { 1567 retval = -ENOMEM; 1568 up(&file_data->limit_write_sem); 1569 goto exit; 1570 } 1571 1572 buffer = urb->transfer_buffer; 1573 buflen = urb->transfer_buffer_length; 1574 1575 if (count > INT_MAX) { 1576 transfersize = INT_MAX; 1577 buffer[8] = 0; 1578 } else { 1579 transfersize = count; 1580 buffer[8] = file_data->eom_val; 1581 } 1582 1583 /* Setup IO buffer for DEV_DEP_MSG_OUT message */ 1584 buffer[0] = 1; 1585 buffer[1] = data->bTag; 1586 buffer[2] = ~data->bTag; 1587 buffer[3] = 0; /* Reserved */ 1588 buffer[4] = transfersize >> 0; 1589 buffer[5] = transfersize >> 8; 1590 buffer[6] = transfersize >> 16; 1591 buffer[7] = transfersize >> 24; 1592 /* buffer[8] is set above... */ 1593 buffer[9] = 0; /* Reserved */ 1594 buffer[10] = 0; /* Reserved */ 1595 buffer[11] = 0; /* Reserved */ 1596 1597 remaining = transfersize; 1598 1599 if (transfersize + USBTMC_HEADER_SIZE > buflen) { 1600 transfersize = buflen - USBTMC_HEADER_SIZE; 1601 aligned = buflen; 1602 } else { 1603 aligned = (transfersize + (USBTMC_HEADER_SIZE + 3)) & ~3; 1604 } 1605 1606 if (copy_from_user(&buffer[USBTMC_HEADER_SIZE], buf, transfersize)) { 1607 retval = -EFAULT; 1608 up(&file_data->limit_write_sem); 1609 goto exit; 1610 } 1611 1612 dev_dbg(&data->intf->dev, "%s(size:%u align:%u)\n", __func__, 1613 (unsigned int)transfersize, (unsigned int)aligned); 1614 1615 print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 1616 16, 1, buffer, aligned, true); 1617 1618 usb_fill_bulk_urb(urb, data->usb_dev, 1619 usb_sndbulkpipe(data->usb_dev, data->bulk_out), 1620 urb->transfer_buffer, aligned, 1621 usbtmc_write_bulk_cb, file_data); 1622 1623 usb_anchor_urb(urb, &file_data->submitted); 1624 retval = usb_submit_urb(urb, GFP_KERNEL); 1625 if (unlikely(retval)) { 1626 usb_unanchor_urb(urb); 1627 up(&file_data->limit_write_sem); 1628 goto exit; 1629 } 1630 1631 remaining -= transfersize; 1632 1633 data->bTag_last_write = data->bTag; 1634 data->bTag++; 1635 1636 if (!data->bTag) 1637 data->bTag++; 1638 1639 /* call generic_write even when remaining = 0 */ 1640 retval = usbtmc_generic_write(file_data, buf + transfersize, remaining, 1641 &done, USBTMC_FLAG_APPEND); 1642 /* truncate alignment bytes */ 1643 if (done > remaining) 1644 done = remaining; 1645 1646 /*add size of first urb*/ 1647 done += transfersize; 1648 1649 if (retval < 0) { 1650 usb_kill_anchored_urbs(&file_data->submitted); 1651 1652 dev_err(&data->intf->dev, 1653 "Unable to send data, error %d\n", (int)retval); 1654 if (file_data->auto_abort) 1655 usbtmc_ioctl_abort_bulk_out(data); 1656 goto exit; 1657 } 1658 1659 retval = done; 1660 exit: 1661 usb_free_urb(urb); 1662 mutex_unlock(&data->io_mutex); 1663 return retval; 1664 } 1665 1666 static int usbtmc_ioctl_clear(struct usbtmc_device_data *data) 1667 { 1668 struct device *dev; 1669 u8 *buffer; 1670 int rv; 1671 int n; 1672 int actual = 0; 1673 1674 dev = &data->intf->dev; 1675 1676 dev_dbg(dev, "Sending INITIATE_CLEAR request\n"); 1677 1678 buffer = kmalloc(USBTMC_BUFSIZE, GFP_KERNEL); 1679 if (!buffer) 1680 return -ENOMEM; 1681 1682 rv = usb_control_msg(data->usb_dev, 1683 usb_rcvctrlpipe(data->usb_dev, 0), 1684 USBTMC_REQUEST_INITIATE_CLEAR, 1685 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 1686 0, 0, buffer, 1, USB_CTRL_GET_TIMEOUT); 1687 if (rv < 0) { 1688 dev_err(dev, "usb_control_msg returned %d\n", rv); 1689 goto exit; 1690 } 1691 1692 dev_dbg(dev, "INITIATE_CLEAR returned %x\n", buffer[0]); 1693 1694 if (buffer[0] != USBTMC_STATUS_SUCCESS) { 1695 dev_err(dev, "INITIATE_CLEAR returned %x\n", buffer[0]); 1696 rv = -EPERM; 1697 goto exit; 1698 } 1699 1700 n = 0; 1701 1702 usbtmc_clear_check_status: 1703 1704 dev_dbg(dev, "Sending CHECK_CLEAR_STATUS request\n"); 1705 1706 rv = usb_control_msg(data->usb_dev, 1707 usb_rcvctrlpipe(data->usb_dev, 0), 1708 USBTMC_REQUEST_CHECK_CLEAR_STATUS, 1709 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 1710 0, 0, buffer, 2, USB_CTRL_GET_TIMEOUT); 1711 if (rv < 0) { 1712 dev_err(dev, "usb_control_msg returned %d\n", rv); 1713 goto exit; 1714 } 1715 1716 dev_dbg(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]); 1717 1718 if (buffer[0] == USBTMC_STATUS_SUCCESS) 1719 goto usbtmc_clear_bulk_out_halt; 1720 1721 if (buffer[0] != USBTMC_STATUS_PENDING) { 1722 dev_err(dev, "CHECK_CLEAR_STATUS returned %x\n", buffer[0]); 1723 rv = -EPERM; 1724 goto exit; 1725 } 1726 1727 if ((buffer[1] & 1) != 0) { 1728 do { 1729 dev_dbg(dev, "Reading from bulk in EP\n"); 1730 1731 actual = 0; 1732 rv = usb_bulk_msg(data->usb_dev, 1733 usb_rcvbulkpipe(data->usb_dev, 1734 data->bulk_in), 1735 buffer, USBTMC_BUFSIZE, 1736 &actual, USB_CTRL_GET_TIMEOUT); 1737 1738 print_hex_dump_debug("usbtmc ", DUMP_PREFIX_NONE, 1739 16, 1, buffer, actual, true); 1740 1741 n++; 1742 1743 if (rv < 0) { 1744 dev_err(dev, "usb_control_msg returned %d\n", 1745 rv); 1746 goto exit; 1747 } 1748 } while ((actual == USBTMC_BUFSIZE) && 1749 (n < USBTMC_MAX_READS_TO_CLEAR_BULK_IN)); 1750 } else { 1751 /* do not stress device with subsequent requests */ 1752 msleep(50); 1753 n++; 1754 } 1755 1756 if (n >= USBTMC_MAX_READS_TO_CLEAR_BULK_IN) { 1757 dev_err(dev, "Couldn't clear device buffer within %d cycles\n", 1758 USBTMC_MAX_READS_TO_CLEAR_BULK_IN); 1759 rv = -EPERM; 1760 goto exit; 1761 } 1762 1763 goto usbtmc_clear_check_status; 1764 1765 usbtmc_clear_bulk_out_halt: 1766 1767 rv = usb_clear_halt(data->usb_dev, 1768 usb_sndbulkpipe(data->usb_dev, data->bulk_out)); 1769 if (rv < 0) { 1770 dev_err(dev, "usb_clear_halt returned %d\n", rv); 1771 goto exit; 1772 } 1773 rv = 0; 1774 1775 exit: 1776 kfree(buffer); 1777 return rv; 1778 } 1779 1780 static int usbtmc_ioctl_clear_out_halt(struct usbtmc_device_data *data) 1781 { 1782 int rv; 1783 1784 rv = usb_clear_halt(data->usb_dev, 1785 usb_sndbulkpipe(data->usb_dev, data->bulk_out)); 1786 1787 if (rv < 0) 1788 dev_err(&data->usb_dev->dev, "%s returned %d\n", __func__, rv); 1789 return rv; 1790 } 1791 1792 static int usbtmc_ioctl_clear_in_halt(struct usbtmc_device_data *data) 1793 { 1794 int rv; 1795 1796 rv = usb_clear_halt(data->usb_dev, 1797 usb_rcvbulkpipe(data->usb_dev, data->bulk_in)); 1798 1799 if (rv < 0) 1800 dev_err(&data->usb_dev->dev, "%s returned %d\n", __func__, rv); 1801 return rv; 1802 } 1803 1804 static int usbtmc_ioctl_cancel_io(struct usbtmc_file_data *file_data) 1805 { 1806 spin_lock_irq(&file_data->err_lock); 1807 file_data->in_status = -ECANCELED; 1808 file_data->out_status = -ECANCELED; 1809 spin_unlock_irq(&file_data->err_lock); 1810 usb_kill_anchored_urbs(&file_data->submitted); 1811 return 0; 1812 } 1813 1814 static int usbtmc_ioctl_cleanup_io(struct usbtmc_file_data *file_data) 1815 { 1816 usb_kill_anchored_urbs(&file_data->submitted); 1817 usb_scuttle_anchored_urbs(&file_data->in_anchor); 1818 spin_lock_irq(&file_data->err_lock); 1819 file_data->in_status = 0; 1820 file_data->in_transfer_size = 0; 1821 file_data->out_status = 0; 1822 file_data->out_transfer_size = 0; 1823 spin_unlock_irq(&file_data->err_lock); 1824 1825 file_data->in_urbs_used = 0; 1826 return 0; 1827 } 1828 1829 static int get_capabilities(struct usbtmc_device_data *data) 1830 { 1831 struct device *dev = &data->usb_dev->dev; 1832 char *buffer; 1833 int rv = 0; 1834 1835 buffer = kmalloc(0x18, GFP_KERNEL); 1836 if (!buffer) 1837 return -ENOMEM; 1838 1839 rv = usb_control_msg(data->usb_dev, usb_rcvctrlpipe(data->usb_dev, 0), 1840 USBTMC_REQUEST_GET_CAPABILITIES, 1841 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 1842 0, 0, buffer, 0x18, USB_CTRL_GET_TIMEOUT); 1843 if (rv < 0) { 1844 dev_err(dev, "usb_control_msg returned %d\n", rv); 1845 goto err_out; 1846 } 1847 1848 dev_dbg(dev, "GET_CAPABILITIES returned %x\n", buffer[0]); 1849 if (buffer[0] != USBTMC_STATUS_SUCCESS) { 1850 dev_err(dev, "GET_CAPABILITIES returned %x\n", buffer[0]); 1851 rv = -EPERM; 1852 goto err_out; 1853 } 1854 dev_dbg(dev, "Interface capabilities are %x\n", buffer[4]); 1855 dev_dbg(dev, "Device capabilities are %x\n", buffer[5]); 1856 dev_dbg(dev, "USB488 interface capabilities are %x\n", buffer[14]); 1857 dev_dbg(dev, "USB488 device capabilities are %x\n", buffer[15]); 1858 1859 data->capabilities.interface_capabilities = buffer[4]; 1860 data->capabilities.device_capabilities = buffer[5]; 1861 data->capabilities.usb488_interface_capabilities = buffer[14]; 1862 data->capabilities.usb488_device_capabilities = buffer[15]; 1863 data->usb488_caps = (buffer[14] & 0x07) | ((buffer[15] & 0x0f) << 4); 1864 rv = 0; 1865 1866 err_out: 1867 kfree(buffer); 1868 return rv; 1869 } 1870 1871 #define capability_attribute(name) \ 1872 static ssize_t name##_show(struct device *dev, \ 1873 struct device_attribute *attr, char *buf) \ 1874 { \ 1875 struct usb_interface *intf = to_usb_interface(dev); \ 1876 struct usbtmc_device_data *data = usb_get_intfdata(intf); \ 1877 \ 1878 return sprintf(buf, "%d\n", data->capabilities.name); \ 1879 } \ 1880 static DEVICE_ATTR_RO(name) 1881 1882 capability_attribute(interface_capabilities); 1883 capability_attribute(device_capabilities); 1884 capability_attribute(usb488_interface_capabilities); 1885 capability_attribute(usb488_device_capabilities); 1886 1887 static struct attribute *usbtmc_attrs[] = { 1888 &dev_attr_interface_capabilities.attr, 1889 &dev_attr_device_capabilities.attr, 1890 &dev_attr_usb488_interface_capabilities.attr, 1891 &dev_attr_usb488_device_capabilities.attr, 1892 NULL, 1893 }; 1894 ATTRIBUTE_GROUPS(usbtmc); 1895 1896 static int usbtmc_ioctl_indicator_pulse(struct usbtmc_device_data *data) 1897 { 1898 struct device *dev; 1899 u8 *buffer; 1900 int rv; 1901 1902 dev = &data->intf->dev; 1903 1904 buffer = kmalloc(2, GFP_KERNEL); 1905 if (!buffer) 1906 return -ENOMEM; 1907 1908 rv = usb_control_msg(data->usb_dev, 1909 usb_rcvctrlpipe(data->usb_dev, 0), 1910 USBTMC_REQUEST_INDICATOR_PULSE, 1911 USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_INTERFACE, 1912 0, 0, buffer, 0x01, USB_CTRL_GET_TIMEOUT); 1913 1914 if (rv < 0) { 1915 dev_err(dev, "usb_control_msg returned %d\n", rv); 1916 goto exit; 1917 } 1918 1919 dev_dbg(dev, "INDICATOR_PULSE returned %x\n", buffer[0]); 1920 1921 if (buffer[0] != USBTMC_STATUS_SUCCESS) { 1922 dev_err(dev, "INDICATOR_PULSE returned %x\n", buffer[0]); 1923 rv = -EPERM; 1924 goto exit; 1925 } 1926 rv = 0; 1927 1928 exit: 1929 kfree(buffer); 1930 return rv; 1931 } 1932 1933 static int usbtmc_ioctl_request(struct usbtmc_device_data *data, 1934 void __user *arg) 1935 { 1936 struct device *dev = &data->intf->dev; 1937 struct usbtmc_ctrlrequest request; 1938 u8 *buffer = NULL; 1939 int rv; 1940 unsigned int is_in, pipe; 1941 1942 if (copy_from_user(&request, arg, sizeof(struct usbtmc_ctrlrequest))) 1943 return -EFAULT; 1944 1945 if (request.req.wLength > USBTMC_BUFSIZE) 1946 return -EMSGSIZE; 1947 if (request.req.wLength == 0) /* Length-0 requests are never IN */ 1948 request.req.bRequestType &= ~USB_DIR_IN; 1949 1950 is_in = request.req.bRequestType & USB_DIR_IN; 1951 1952 if (request.req.wLength) { 1953 buffer = kmalloc(request.req.wLength, GFP_KERNEL); 1954 if (!buffer) 1955 return -ENOMEM; 1956 1957 if (!is_in) { 1958 /* Send control data to device */ 1959 if (copy_from_user(buffer, request.data, 1960 request.req.wLength)) { 1961 rv = -EFAULT; 1962 goto exit; 1963 } 1964 } 1965 } 1966 1967 if (is_in) 1968 pipe = usb_rcvctrlpipe(data->usb_dev, 0); 1969 else 1970 pipe = usb_sndctrlpipe(data->usb_dev, 0); 1971 rv = usb_control_msg(data->usb_dev, 1972 pipe, 1973 request.req.bRequest, 1974 request.req.bRequestType, 1975 request.req.wValue, 1976 request.req.wIndex, 1977 buffer, request.req.wLength, USB_CTRL_GET_TIMEOUT); 1978 1979 if (rv < 0) { 1980 dev_err(dev, "%s failed %d\n", __func__, rv); 1981 goto exit; 1982 } 1983 1984 if (rv && is_in) { 1985 /* Read control data from device */ 1986 if (copy_to_user(request.data, buffer, rv)) 1987 rv = -EFAULT; 1988 } 1989 1990 exit: 1991 kfree(buffer); 1992 return rv; 1993 } 1994 1995 /* 1996 * Get the usb timeout value 1997 */ 1998 static int usbtmc_ioctl_get_timeout(struct usbtmc_file_data *file_data, 1999 void __user *arg) 2000 { 2001 u32 timeout; 2002 2003 timeout = file_data->timeout; 2004 2005 return put_user(timeout, (__u32 __user *)arg); 2006 } 2007 2008 /* 2009 * Set the usb timeout value 2010 */ 2011 static int usbtmc_ioctl_set_timeout(struct usbtmc_file_data *file_data, 2012 void __user *arg) 2013 { 2014 u32 timeout; 2015 2016 if (get_user(timeout, (__u32 __user *)arg)) 2017 return -EFAULT; 2018 2019 /* Note that timeout = 0 means 2020 * MAX_SCHEDULE_TIMEOUT in usb_control_msg 2021 */ 2022 if (timeout < USBTMC_MIN_TIMEOUT) 2023 return -EINVAL; 2024 2025 file_data->timeout = timeout; 2026 2027 return 0; 2028 } 2029 2030 /* 2031 * enables/disables sending EOM on write 2032 */ 2033 static int usbtmc_ioctl_eom_enable(struct usbtmc_file_data *file_data, 2034 void __user *arg) 2035 { 2036 u8 eom_enable; 2037 2038 if (copy_from_user(&eom_enable, arg, sizeof(eom_enable))) 2039 return -EFAULT; 2040 2041 if (eom_enable > 1) 2042 return -EINVAL; 2043 2044 file_data->eom_val = eom_enable; 2045 2046 return 0; 2047 } 2048 2049 /* 2050 * Configure termination character for read() 2051 */ 2052 static int usbtmc_ioctl_config_termc(struct usbtmc_file_data *file_data, 2053 void __user *arg) 2054 { 2055 struct usbtmc_termchar termc; 2056 2057 if (copy_from_user(&termc, arg, sizeof(termc))) 2058 return -EFAULT; 2059 2060 if ((termc.term_char_enabled > 1) || 2061 (termc.term_char_enabled && 2062 !(file_data->data->capabilities.device_capabilities & 1))) 2063 return -EINVAL; 2064 2065 file_data->term_char = termc.term_char; 2066 file_data->term_char_enabled = termc.term_char_enabled; 2067 2068 return 0; 2069 } 2070 2071 static long usbtmc_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 2072 { 2073 struct usbtmc_file_data *file_data; 2074 struct usbtmc_device_data *data; 2075 int retval = -EBADRQC; 2076 __u8 tmp_byte; 2077 2078 file_data = file->private_data; 2079 data = file_data->data; 2080 2081 mutex_lock(&data->io_mutex); 2082 if (data->zombie) { 2083 retval = -ENODEV; 2084 goto skip_io_on_zombie; 2085 } 2086 2087 switch (cmd) { 2088 case USBTMC_IOCTL_CLEAR_OUT_HALT: 2089 retval = usbtmc_ioctl_clear_out_halt(data); 2090 break; 2091 2092 case USBTMC_IOCTL_CLEAR_IN_HALT: 2093 retval = usbtmc_ioctl_clear_in_halt(data); 2094 break; 2095 2096 case USBTMC_IOCTL_INDICATOR_PULSE: 2097 retval = usbtmc_ioctl_indicator_pulse(data); 2098 break; 2099 2100 case USBTMC_IOCTL_CLEAR: 2101 retval = usbtmc_ioctl_clear(data); 2102 break; 2103 2104 case USBTMC_IOCTL_ABORT_BULK_OUT: 2105 retval = usbtmc_ioctl_abort_bulk_out(data); 2106 break; 2107 2108 case USBTMC_IOCTL_ABORT_BULK_IN: 2109 retval = usbtmc_ioctl_abort_bulk_in(data); 2110 break; 2111 2112 case USBTMC_IOCTL_CTRL_REQUEST: 2113 retval = usbtmc_ioctl_request(data, (void __user *)arg); 2114 break; 2115 2116 case USBTMC_IOCTL_GET_TIMEOUT: 2117 retval = usbtmc_ioctl_get_timeout(file_data, 2118 (void __user *)arg); 2119 break; 2120 2121 case USBTMC_IOCTL_SET_TIMEOUT: 2122 retval = usbtmc_ioctl_set_timeout(file_data, 2123 (void __user *)arg); 2124 break; 2125 2126 case USBTMC_IOCTL_EOM_ENABLE: 2127 retval = usbtmc_ioctl_eom_enable(file_data, 2128 (void __user *)arg); 2129 break; 2130 2131 case USBTMC_IOCTL_CONFIG_TERMCHAR: 2132 retval = usbtmc_ioctl_config_termc(file_data, 2133 (void __user *)arg); 2134 break; 2135 2136 case USBTMC_IOCTL_WRITE: 2137 retval = usbtmc_ioctl_generic_write(file_data, 2138 (void __user *)arg); 2139 break; 2140 2141 case USBTMC_IOCTL_READ: 2142 retval = usbtmc_ioctl_generic_read(file_data, 2143 (void __user *)arg); 2144 break; 2145 2146 case USBTMC_IOCTL_WRITE_RESULT: 2147 retval = usbtmc_ioctl_write_result(file_data, 2148 (void __user *)arg); 2149 break; 2150 2151 case USBTMC_IOCTL_API_VERSION: 2152 retval = put_user(USBTMC_API_VERSION, 2153 (__u32 __user *)arg); 2154 break; 2155 2156 case USBTMC488_IOCTL_GET_CAPS: 2157 retval = put_user(data->usb488_caps, 2158 (unsigned char __user *)arg); 2159 break; 2160 2161 case USBTMC488_IOCTL_READ_STB: 2162 retval = usbtmc488_ioctl_read_stb(file_data, 2163 (void __user *)arg); 2164 break; 2165 2166 case USBTMC488_IOCTL_REN_CONTROL: 2167 retval = usbtmc488_ioctl_simple(data, (void __user *)arg, 2168 USBTMC488_REQUEST_REN_CONTROL); 2169 break; 2170 2171 case USBTMC488_IOCTL_GOTO_LOCAL: 2172 retval = usbtmc488_ioctl_simple(data, (void __user *)arg, 2173 USBTMC488_REQUEST_GOTO_LOCAL); 2174 break; 2175 2176 case USBTMC488_IOCTL_LOCAL_LOCKOUT: 2177 retval = usbtmc488_ioctl_simple(data, (void __user *)arg, 2178 USBTMC488_REQUEST_LOCAL_LOCKOUT); 2179 break; 2180 2181 case USBTMC488_IOCTL_TRIGGER: 2182 retval = usbtmc488_ioctl_trigger(file_data); 2183 break; 2184 2185 case USBTMC488_IOCTL_WAIT_SRQ: 2186 retval = usbtmc488_ioctl_wait_srq(file_data, 2187 (__u32 __user *)arg); 2188 break; 2189 2190 case USBTMC_IOCTL_MSG_IN_ATTR: 2191 retval = put_user(file_data->bmTransferAttributes, 2192 (__u8 __user *)arg); 2193 break; 2194 2195 case USBTMC_IOCTL_AUTO_ABORT: 2196 retval = get_user(tmp_byte, (unsigned char __user *)arg); 2197 if (retval == 0) 2198 file_data->auto_abort = !!tmp_byte; 2199 break; 2200 2201 case USBTMC_IOCTL_GET_STB: 2202 retval = usbtmc_get_stb(file_data, &tmp_byte); 2203 if (!retval) 2204 retval = put_user(tmp_byte, (__u8 __user *)arg); 2205 break; 2206 2207 case USBTMC_IOCTL_GET_SRQ_STB: 2208 retval = usbtmc_ioctl_get_srq_stb(file_data, 2209 (void __user *)arg); 2210 break; 2211 2212 case USBTMC_IOCTL_CANCEL_IO: 2213 retval = usbtmc_ioctl_cancel_io(file_data); 2214 break; 2215 2216 case USBTMC_IOCTL_CLEANUP_IO: 2217 retval = usbtmc_ioctl_cleanup_io(file_data); 2218 break; 2219 } 2220 2221 skip_io_on_zombie: 2222 mutex_unlock(&data->io_mutex); 2223 return retval; 2224 } 2225 2226 static int usbtmc_fasync(int fd, struct file *file, int on) 2227 { 2228 struct usbtmc_file_data *file_data = file->private_data; 2229 2230 return fasync_helper(fd, file, on, &file_data->data->fasync); 2231 } 2232 2233 static __poll_t usbtmc_poll(struct file *file, poll_table *wait) 2234 { 2235 struct usbtmc_file_data *file_data = file->private_data; 2236 struct usbtmc_device_data *data = file_data->data; 2237 __poll_t mask; 2238 2239 mutex_lock(&data->io_mutex); 2240 2241 if (data->zombie) { 2242 mask = EPOLLHUP | EPOLLERR; 2243 goto no_poll; 2244 } 2245 2246 poll_wait(file, &data->waitq, wait); 2247 2248 /* Note that EPOLLPRI is now assigned to SRQ, and 2249 * EPOLLIN|EPOLLRDNORM to normal read data. 2250 */ 2251 mask = 0; 2252 if (atomic_read(&file_data->srq_asserted)) 2253 mask |= EPOLLPRI; 2254 2255 /* Note that the anchor submitted includes all urbs for BULK IN 2256 * and OUT. So EPOLLOUT is signaled when BULK OUT is empty and 2257 * all BULK IN urbs are completed and moved to in_anchor. 2258 */ 2259 if (usb_anchor_empty(&file_data->submitted)) 2260 mask |= (EPOLLOUT | EPOLLWRNORM); 2261 if (!usb_anchor_empty(&file_data->in_anchor)) 2262 mask |= (EPOLLIN | EPOLLRDNORM); 2263 2264 spin_lock_irq(&file_data->err_lock); 2265 if (file_data->in_status || file_data->out_status) 2266 mask |= EPOLLERR; 2267 spin_unlock_irq(&file_data->err_lock); 2268 2269 dev_dbg(&data->intf->dev, "poll mask = %x\n", mask); 2270 2271 no_poll: 2272 mutex_unlock(&data->io_mutex); 2273 return mask; 2274 } 2275 2276 static const struct file_operations fops = { 2277 .owner = THIS_MODULE, 2278 .read = usbtmc_read, 2279 .write = usbtmc_write, 2280 .open = usbtmc_open, 2281 .release = usbtmc_release, 2282 .flush = usbtmc_flush, 2283 .unlocked_ioctl = usbtmc_ioctl, 2284 .compat_ioctl = compat_ptr_ioctl, 2285 .fasync = usbtmc_fasync, 2286 .poll = usbtmc_poll, 2287 .llseek = default_llseek, 2288 }; 2289 2290 static struct usb_class_driver usbtmc_class = { 2291 .name = "usbtmc%d", 2292 .fops = &fops, 2293 .minor_base = USBTMC_MINOR_BASE, 2294 }; 2295 2296 static void usbtmc_interrupt(struct urb *urb) 2297 { 2298 struct usbtmc_device_data *data = urb->context; 2299 struct device *dev = &data->intf->dev; 2300 int status = urb->status; 2301 int rv; 2302 2303 dev_dbg(&data->intf->dev, "int status: %d len %d\n", 2304 status, urb->actual_length); 2305 2306 switch (status) { 2307 case 0: /* SUCCESS */ 2308 /* ensure at least two bytes of headers were transferred */ 2309 if (urb->actual_length < 2) { 2310 dev_warn(dev, 2311 "actual length %d not sufficient for interrupt headers\n", 2312 urb->actual_length); 2313 goto exit; 2314 } 2315 2316 /* check for valid STB notification */ 2317 if (data->iin_buffer[0] > 0x81) { 2318 data->bNotify1 = data->iin_buffer[0]; 2319 data->bNotify2 = data->iin_buffer[1]; 2320 atomic_set(&data->iin_data_valid, 1); 2321 wake_up_interruptible(&data->waitq); 2322 goto exit; 2323 } 2324 /* check for SRQ notification */ 2325 if (data->iin_buffer[0] == 0x81) { 2326 unsigned long flags; 2327 struct list_head *elem; 2328 2329 if (data->fasync) 2330 kill_fasync(&data->fasync, 2331 SIGIO, POLL_PRI); 2332 2333 spin_lock_irqsave(&data->dev_lock, flags); 2334 list_for_each(elem, &data->file_list) { 2335 struct usbtmc_file_data *file_data; 2336 2337 file_data = list_entry(elem, 2338 struct usbtmc_file_data, 2339 file_elem); 2340 file_data->srq_byte = data->iin_buffer[1]; 2341 atomic_set(&file_data->srq_asserted, 1); 2342 } 2343 spin_unlock_irqrestore(&data->dev_lock, flags); 2344 2345 dev_dbg(dev, "srq received bTag %x stb %x\n", 2346 (unsigned int)data->iin_buffer[0], 2347 (unsigned int)data->iin_buffer[1]); 2348 wake_up_interruptible_all(&data->waitq); 2349 goto exit; 2350 } 2351 dev_warn(dev, "invalid notification: %x\n", 2352 data->iin_buffer[0]); 2353 break; 2354 case -EOVERFLOW: 2355 dev_err(dev, "overflow with length %d, actual length is %d\n", 2356 data->iin_wMaxPacketSize, urb->actual_length); 2357 fallthrough; 2358 default: 2359 /* urb terminated, clean up */ 2360 dev_dbg(dev, "urb terminated, status: %d\n", status); 2361 return; 2362 } 2363 exit: 2364 rv = usb_submit_urb(urb, GFP_ATOMIC); 2365 if (rv) 2366 dev_err(dev, "usb_submit_urb failed: %d\n", rv); 2367 } 2368 2369 static void usbtmc_free_int(struct usbtmc_device_data *data) 2370 { 2371 if (!data->iin_ep_present || !data->iin_urb) 2372 return; 2373 usb_kill_urb(data->iin_urb); 2374 kfree(data->iin_buffer); 2375 data->iin_buffer = NULL; 2376 usb_free_urb(data->iin_urb); 2377 data->iin_urb = NULL; 2378 kref_put(&data->kref, usbtmc_delete); 2379 } 2380 2381 static int usbtmc_probe(struct usb_interface *intf, 2382 const struct usb_device_id *id) 2383 { 2384 struct usbtmc_device_data *data; 2385 struct usb_host_interface *iface_desc; 2386 struct usb_endpoint_descriptor *bulk_in, *bulk_out, *int_in; 2387 int retcode; 2388 2389 dev_dbg(&intf->dev, "%s called\n", __func__); 2390 2391 data = kzalloc_obj(*data); 2392 if (!data) 2393 return -ENOMEM; 2394 2395 data->intf = intf; 2396 data->usb_dev = usb_get_dev(interface_to_usbdev(intf)); 2397 usb_set_intfdata(intf, data); 2398 kref_init(&data->kref); 2399 mutex_init(&data->io_mutex); 2400 init_waitqueue_head(&data->waitq); 2401 atomic_set(&data->iin_data_valid, 0); 2402 INIT_LIST_HEAD(&data->file_list); 2403 spin_lock_init(&data->dev_lock); 2404 2405 data->zombie = 0; 2406 2407 /* Initialize USBTMC bTag and other fields */ 2408 data->bTag = 1; 2409 /* 2 <= bTag <= 127 USBTMC-USB488 subclass specification 4.3.1 */ 2410 data->iin_bTag = 2; 2411 2412 /* USBTMC devices have only one setting, so use that */ 2413 iface_desc = data->intf->cur_altsetting; 2414 data->ifnum = iface_desc->desc.bInterfaceNumber; 2415 2416 /* Find bulk endpoints */ 2417 retcode = usb_find_common_endpoints(iface_desc, 2418 &bulk_in, &bulk_out, NULL, NULL); 2419 if (retcode) { 2420 dev_err(&intf->dev, "bulk endpoints not found\n"); 2421 goto err_put; 2422 } 2423 2424 retcode = -EINVAL; 2425 data->bulk_in = bulk_in->bEndpointAddress; 2426 data->wMaxPacketSize = usb_endpoint_maxp(bulk_in); 2427 if (!data->wMaxPacketSize) 2428 goto err_put; 2429 dev_dbg(&intf->dev, "Found bulk in endpoint at %u\n", data->bulk_in); 2430 2431 data->bulk_out = bulk_out->bEndpointAddress; 2432 dev_dbg(&intf->dev, "Found Bulk out endpoint at %u\n", data->bulk_out); 2433 2434 /* Find int endpoint */ 2435 retcode = usb_find_int_in_endpoint(iface_desc, &int_in); 2436 if (!retcode) { 2437 data->iin_ep_present = 1; 2438 data->iin_ep = int_in->bEndpointAddress; 2439 data->iin_wMaxPacketSize = usb_endpoint_maxp(int_in); 2440 data->iin_interval = int_in->bInterval; 2441 /* wMaxPacketSize should be 0x02 or more as per USB488 Table 22 */ 2442 if (iface_desc->desc.bInterfaceProtocol == 1 && 2443 data->iin_wMaxPacketSize < 2) { 2444 retcode = -EINVAL; 2445 goto err_put; 2446 } 2447 dev_dbg(&intf->dev, "Found Int in endpoint at %u\n", 2448 data->iin_ep); 2449 } 2450 2451 retcode = get_capabilities(data); 2452 if (retcode) 2453 dev_err(&intf->dev, "can't read capabilities\n"); 2454 2455 if (data->iin_ep_present) { 2456 /* allocate int urb */ 2457 data->iin_urb = usb_alloc_urb(0, GFP_KERNEL); 2458 if (!data->iin_urb) { 2459 retcode = -ENOMEM; 2460 goto error_register; 2461 } 2462 2463 /* Protect interrupt in endpoint data until iin_urb is freed */ 2464 kref_get(&data->kref); 2465 2466 /* allocate buffer for interrupt in */ 2467 data->iin_buffer = kmalloc(data->iin_wMaxPacketSize, 2468 GFP_KERNEL); 2469 if (!data->iin_buffer) { 2470 retcode = -ENOMEM; 2471 goto error_register; 2472 } 2473 2474 /* fill interrupt urb */ 2475 usb_fill_int_urb(data->iin_urb, data->usb_dev, 2476 usb_rcvintpipe(data->usb_dev, data->iin_ep), 2477 data->iin_buffer, data->iin_wMaxPacketSize, 2478 usbtmc_interrupt, 2479 data, data->iin_interval); 2480 2481 retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL); 2482 if (retcode) { 2483 dev_err(&intf->dev, "Failed to submit iin_urb\n"); 2484 goto error_register; 2485 } 2486 } 2487 2488 retcode = usb_register_dev(intf, &usbtmc_class); 2489 if (retcode) { 2490 dev_err(&intf->dev, "Not able to get a minor (base %u, slice default): %d\n", 2491 USBTMC_MINOR_BASE, 2492 retcode); 2493 goto error_register; 2494 } 2495 dev_dbg(&intf->dev, "Using minor number %d\n", intf->minor); 2496 2497 return 0; 2498 2499 error_register: 2500 usbtmc_free_int(data); 2501 err_put: 2502 kref_put(&data->kref, usbtmc_delete); 2503 return retcode; 2504 } 2505 2506 static void usbtmc_disconnect(struct usb_interface *intf) 2507 { 2508 struct usbtmc_device_data *data = usb_get_intfdata(intf); 2509 struct list_head *elem; 2510 2511 usb_deregister_dev(intf, &usbtmc_class); 2512 mutex_lock(&data->io_mutex); 2513 data->zombie = 1; 2514 wake_up_interruptible_all(&data->waitq); 2515 list_for_each(elem, &data->file_list) { 2516 struct usbtmc_file_data *file_data; 2517 2518 file_data = list_entry(elem, 2519 struct usbtmc_file_data, 2520 file_elem); 2521 usb_kill_anchored_urbs(&file_data->submitted); 2522 usb_scuttle_anchored_urbs(&file_data->in_anchor); 2523 } 2524 mutex_unlock(&data->io_mutex); 2525 usbtmc_free_int(data); 2526 kref_put(&data->kref, usbtmc_delete); 2527 } 2528 2529 static void usbtmc_draw_down(struct usbtmc_file_data *file_data) 2530 { 2531 int time; 2532 2533 time = usb_wait_anchor_empty_timeout(&file_data->submitted, 1000); 2534 if (!time) 2535 usb_kill_anchored_urbs(&file_data->submitted); 2536 usb_scuttle_anchored_urbs(&file_data->in_anchor); 2537 } 2538 2539 static int usbtmc_suspend(struct usb_interface *intf, pm_message_t message) 2540 { 2541 struct usbtmc_device_data *data = usb_get_intfdata(intf); 2542 struct list_head *elem; 2543 2544 if (!data) 2545 return 0; 2546 2547 mutex_lock(&data->io_mutex); 2548 list_for_each(elem, &data->file_list) { 2549 struct usbtmc_file_data *file_data; 2550 2551 file_data = list_entry(elem, 2552 struct usbtmc_file_data, 2553 file_elem); 2554 usbtmc_draw_down(file_data); 2555 } 2556 2557 if (data->iin_ep_present && data->iin_urb) 2558 usb_kill_urb(data->iin_urb); 2559 2560 mutex_unlock(&data->io_mutex); 2561 return 0; 2562 } 2563 2564 static int usbtmc_resume(struct usb_interface *intf) 2565 { 2566 struct usbtmc_device_data *data = usb_get_intfdata(intf); 2567 int retcode = 0; 2568 2569 if (data->iin_ep_present && data->iin_urb) 2570 retcode = usb_submit_urb(data->iin_urb, GFP_KERNEL); 2571 if (retcode) 2572 dev_err(&intf->dev, "Failed to submit iin_urb\n"); 2573 2574 return retcode; 2575 } 2576 2577 static int usbtmc_pre_reset(struct usb_interface *intf) 2578 { 2579 struct usbtmc_device_data *data = usb_get_intfdata(intf); 2580 struct list_head *elem; 2581 2582 if (!data) 2583 return 0; 2584 2585 mutex_lock(&data->io_mutex); 2586 2587 list_for_each(elem, &data->file_list) { 2588 struct usbtmc_file_data *file_data; 2589 2590 file_data = list_entry(elem, 2591 struct usbtmc_file_data, 2592 file_elem); 2593 usbtmc_ioctl_cancel_io(file_data); 2594 } 2595 2596 return 0; 2597 } 2598 2599 static int usbtmc_post_reset(struct usb_interface *intf) 2600 { 2601 struct usbtmc_device_data *data = usb_get_intfdata(intf); 2602 2603 mutex_unlock(&data->io_mutex); 2604 2605 return 0; 2606 } 2607 2608 static struct usb_driver usbtmc_driver = { 2609 .name = "usbtmc", 2610 .id_table = usbtmc_devices, 2611 .probe = usbtmc_probe, 2612 .disconnect = usbtmc_disconnect, 2613 .suspend = usbtmc_suspend, 2614 .resume = usbtmc_resume, 2615 .pre_reset = usbtmc_pre_reset, 2616 .post_reset = usbtmc_post_reset, 2617 .dev_groups = usbtmc_groups, 2618 }; 2619 2620 module_usb_driver(usbtmc_driver); 2621 2622 MODULE_DESCRIPTION("USB Test & Measurement class driver"); 2623 MODULE_LICENSE("GPL"); 2624