drivers/usb/class/usbtmc.c

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