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