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