drivers/usb/printer.c

   1 /*
   2  * printer.c  Version 0.6
   3  *
   4  * Copyright (c) 1999 Michael Gee       <michael@linuxspecific.com>
   5  * Copyright (c) 1999 Pavel Machek      <pavel@suse.cz>
   6  * Copyright (c) 2000 Randy Dunlap      <randy.dunlap@intel.com>
   7  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
   8  *
   9  * USB Printer Device Class driver for USB printers and printer cables
  10  *
  11  * Sponsored by SuSE
  12  *
  13  * ChangeLog:
  14  *      v0.1 - thorough cleaning, URBification, almost a rewrite
  15  *      v0.2 - some more cleanups
  16  *      v0.3 - cleaner again, waitqueue fixes
  17  *      v0.4 - fixes in unidirectional mode
  18  *      v0.5 - add DEVICE_ID string support
  19  *      v0.6 - never time out
  20  */
  21
  22 /*
  23  * This program is free software; you can redistribute it and/or modify
  24  * it under the terms of the GNU General Public License as published by
  25  * the Free Software Foundation; either version 2 of the License, or
  26  * (at your option) any later version.
  27  *
  28  * This program is distributed in the hope that it will be useful,
  29  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  30  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  31  * GNU General Public License for more details.
  32  *
  33  * You should have received a copy of the GNU General Public License
  34  * along with this program; if not, write to the Free Software
  35  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  36  */
  37
  38 #include <linux/module.h>
  39 #include <linux/kernel.h>
  40 #include <linux/sched.h>
  41 #include <linux/smp_lock.h>
  42 #include <linux/signal.h>
  43 #include <linux/poll.h>
  44 #include <linux/init.h>
  45 #include <linux/malloc.h>
  46 #include <linux/lp.h>
  47 #undef DEBUG
  48 #include <linux/usb.h>
  49
  50 #define USBLP_BUF_SIZE          8192
  51 #define DEVICE_ID_SIZE          1024
  52
  53 #define IOCNR_GET_DEVICE_ID     1
  54 #define LPIOC_GET_DEVICE_ID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_DEVICE_ID, len) /* get device_id string */
  55 #define LPGETSTATUS             0x060b          /* same as in drivers/char/lp.c */
  56
  57 /*
  58  * A DEVICE_ID string may include the printer's serial number.
  59  * It should end with a semi-colon (';').
  60  * An example from an HP 970C DeskJet printer is (this is one long string,
  61  * with the serial number changed):
  62 MFG:HEWLETT-PACKARD;MDL:DESKJET 970C;CMD:MLC,PCL,PML;CLASS:PRINTER;DESCRIPTION:Hewlett-Packard DeskJet 970C;SERN:US970CSEPROF;VSTATUS:$HB0$NC0,ff,DN,IDLE,CUT,K1,C0,DP,NR,KP000,CP027;VP:0800,FL,B0;VJ:                    ;
  63  */
  64
  65 /*
  66  * USB Printer Requests
  67  */
  68
  69 #define USBLP_REQ_GET_ID        0x00
  70 #define USBLP_REQ_GET_STATUS    0x01
  71 #define USBLP_REQ_RESET         0x02
  72
  73 #define USBLP_MINORS            16
  74 #define USBLP_MINOR_BASE        0
  75
  76 #define USBLP_WRITE_TIMEOUT     (5*HZ)                  /* 5 seconds */
  77
  78 struct usblp {
  79         struct usb_device       *dev;                   /* USB device */
  80         struct urb              readurb, writeurb;      /* The urbs */
  81         wait_queue_head_t       wait;                   /* Zzzzz ... */
  82         int                     readcount;              /* Counter for reads */
  83         int                     ifnum;                  /* Interface number */
  84         int                     minor;                  /* minor number of device */
  85         unsigned int            quirks;                 /* quirks flags */
  86         unsigned char           used;                   /* True if open */
  87         unsigned char           bidir;                  /* interface is bidirectional */
  88         unsigned char           *device_id_string;      /* IEEE 1284 DEVICE ID string (ptr) */
  89                                                         /* first 2 bytes are (big-endian) length */
  90 };
  91
  92 static struct usblp *usblp_table[USBLP_MINORS];
  93
  94 /* Quirks: various printer quirks are handled by this table & its flags. */
  95
  96 struct quirk_printer_struct {
  97         __u16 vendorId;
  98         __u16 productId;
  99         unsigned int quirks;
 100 };
 101
 102 #define USBLP_QUIRK_BIDIR       0x1     /* reports bidir but requires unidirectional mode (no INs/reads) */
 103 #define USBLP_QUIRK_USB_INIT    0x2     /* needs vendor USB init string */
 104
 105 static struct quirk_printer_struct quirk_printers[] = {
 106         { 0x03f0, 0x0004, USBLP_QUIRK_BIDIR }, /* HP DeskJet 895C */
 107         { 0x03f0, 0x0104, USBLP_QUIRK_BIDIR }, /* HP DeskJet 880C */
 108         { 0x03f0, 0x0204, USBLP_QUIRK_BIDIR }, /* HP DeskJet 815C */
 109         { 0x03f0, 0x0304, USBLP_QUIRK_BIDIR }, /* HP DeskJet 810C/812C */
 110         { 0x03f0, 0x0404, USBLP_QUIRK_BIDIR }, /* HP DeskJet 830C */
 111         { 0, 0 }
 112 };
 113
 114 /*
 115  * Functions for usblp control messages.
 116  */
 117
 118 static int usblp_ctrl_msg(struct usblp *usblp, int request, int dir, int recip, int value, void *buf, int len)
 119 {
 120         int retval = usb_control_msg(usblp->dev,
 121                 dir ? usb_rcvctrlpipe(usblp->dev, 0) : usb_sndctrlpipe(usblp->dev, 0),
 122                 request, USB_TYPE_CLASS | dir | recip, value, usblp->ifnum, buf, len, HZ * 5);
 123         dbg("usblp_control_msg: rq: 0x%02x dir: %d recip: %d value: %d len: %#x result: %d",
 124                 request, !!dir, recip, value, len, retval);
 125         return retval < 0 ? retval : 0;
 126 }
 127
 128 #define usblp_read_status(usblp, status)\
 129         usblp_ctrl_msg(usblp, USBLP_REQ_GET_STATUS, USB_DIR_IN, USB_RECIP_INTERFACE, 0, status, 1)
 130 #define usblp_get_id(usblp, config, id, maxlen)\
 131         usblp_ctrl_msg(usblp, USBLP_REQ_GET_ID, USB_DIR_IN, USB_RECIP_INTERFACE, config, id, maxlen)
 132 #define usblp_reset(usblp)\
 133         usblp_ctrl_msg(usblp, USBLP_REQ_RESET, USB_DIR_OUT, USB_RECIP_OTHER, 0, NULL, 0)
 134
 135 /*
 136  * URB callback.
 137  */
 138
 139 static void usblp_bulk(struct urb *urb)
 140 {
 141         struct usblp *usblp = urb->context;
 142
 143         if (!usblp || !usblp->dev || !usblp->used)
 144                 return;
 145
 146         if (urb->status)
 147                 warn("usblp%d: nonzero read/write bulk status received: %d",
 148                         usblp->minor, urb->status);
 149
 150         wake_up_interruptible(&usblp->wait);
 151 }
 152
 153 /*
 154  * Get and print printer errors.
 155  */
 156
 157 static char *usblp_messages[] = { "ok", "out of paper", "off-line", "on fire" };
 158
 159 static int usblp_check_status(struct usblp *usblp, int err)
 160 {
 161         unsigned char status, newerr = 0;
 162
 163         if (usblp_read_status(usblp, &status)) {
 164                 err("usblp%d: failed reading printer status", usblp->minor);
 165                 return 0;
 166         }
 167
 168         if (~status & LP_PERRORP) {
 169                 newerr = 3;
 170                 if (status & LP_POUTPA) newerr = 1;
 171                 if (~status & LP_PSELECD) newerr = 2;
 172         }
 173
 174         if (newerr != err)
 175                 info("usblp%d: %s", usblp->minor, usblp_messages[newerr]);
 176
 177         return newerr;
 178 }
 179
 180 /*
 181  * File op functions.
 182  */
 183
 184 static int usblp_open(struct inode *inode, struct file *file)
 185 {
 186         int minor = MINOR(inode->i_rdev) - USBLP_MINOR_BASE;
 187         struct usblp *usblp;
 188         int retval;
 189
 190         if (minor < 0 || minor >= USBLP_MINORS)
 191                 return -ENODEV;
 192
 193         lock_kernel();
 194         usblp  = usblp_table[minor];
 195
 196         retval = -ENODEV;
 197         if (!usblp || !usblp->dev)
 198                 goto out;
 199
 200         retval = -EBUSY;
 201         if (usblp->used)
 202                 goto out;
 203
 204         /*
 205          * TODO: need to implement LP_ABORTOPEN + O_NONBLOCK as in drivers/char/lp.c ???
 206          * This is #if 0-ed because we *don't* want to fail an open
 207          * just because the printer is off-line.
 208          */
 209 #if 0
 210         if ((retval = usblp_check_status(usblp, 0))) {
 211                 retval = retval > 1 ? -EIO : -ENOSPC;
 212                 goto out;
 213         }
 214 #else
 215         retval = 0;
 216 #endif
 217
 218         usblp->used = 1;
 219         file->private_data = usblp;
 220
 221         usblp->writeurb.transfer_buffer_length = 0;
 222         usblp->writeurb.status = 0;
 223
 224         if (usblp->bidir) {
 225                 usblp->readcount = 0;
 226                 usblp->readurb.dev = usblp->dev;
 227                 usb_submit_urb(&usblp->readurb);
 228         }
 229 out:
 230         unlock_kernel();
 231         return retval;
 232 }
 233
 234 static int usblp_release(struct inode *inode, struct file *file)
 235 {
 236         struct usblp *usblp = file->private_data;
 237
 238         usblp->used = 0;
 239
 240         if (usblp->dev) {
 241                 if (usblp->bidir)
 242                         usb_unlink_urb(&usblp->readurb);
 243                 usb_unlink_urb(&usblp->writeurb);
 244                 return 0;
 245         }
 246
 247         usblp_table[usblp->minor] = NULL;
 248         kfree(usblp->device_id_string);
 249         kfree(usblp);
 250
 251         return 0;
 252 }
 253
 254 /* No kernel lock - fine */
 255 static unsigned int usblp_poll(struct file *file, struct poll_table_struct *wait)
 256 {
 257         struct usblp *usblp = file->private_data;
 258         poll_wait(file, &usblp->wait, wait);
 259         return ((usblp->bidir || usblp->readurb.status  == -EINPROGRESS) ? 0 : POLLIN  | POLLRDNORM)
 260                               | (usblp->writeurb.status == -EINPROGRESS  ? 0 : POLLOUT | POLLWRNORM);
 261 }
 262
 263 static int usblp_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 264 {
 265         struct usblp *usblp = file->private_data;
 266         int length, err;
 267         unsigned char status;
 268
 269         if (_IOC_TYPE(cmd) == 'P')      /* new-style ioctl number */
 270
 271                 switch (_IOC_NR(cmd)) {
 272
 273                         case IOCNR_GET_DEVICE_ID: /* get the DEVICE_ID string */
 274                                 if (_IOC_DIR(cmd) != _IOC_READ)
 275                                         return -EINVAL;
 276
 277                                 err = usblp_get_id(usblp, 0, usblp->device_id_string, DEVICE_ID_SIZE - 1);
 278                                 if (err < 0) {
 279                                         dbg ("usblp%d: error = %d reading IEEE-1284 Device ID string",
 280                                                 usblp->minor, err);
 281                                         usblp->device_id_string[0] = usblp->device_id_string[1] = '\0';
 282                                         return -EIO;
 283                                 }
 284
 285                                 length = (usblp->device_id_string[0] << 8) + usblp->device_id_string[1]; /* big-endian */
 286                                 if (length < DEVICE_ID_SIZE)
 287                                         usblp->device_id_string[length] = '\0';
 288                                 else
 289                                         usblp->device_id_string[DEVICE_ID_SIZE - 1] = '\0';
 290
 291                                 dbg ("usblp%d Device ID string [%d/max %d]='%s'",
 292                                         usblp->minor, length, _IOC_SIZE(cmd), &usblp->device_id_string[2]);
 293
 294                                 if (length > _IOC_SIZE(cmd)) length = _IOC_SIZE(cmd); /* truncate */
 295
 296                                 if (copy_to_user((unsigned char *) arg, usblp->device_id_string, (unsigned long) length))
 297                                         return -EFAULT;
 298
 299                                 break;
 300
 301                         default:
 302                                 return -EINVAL;
 303                 }
 304         else    /* old-style ioctl value */
 305                 switch (cmd) {
 306
 307                         case LPGETSTATUS:
 308                                 if (usblp_read_status(usblp, &status)) {
 309                                         err("usblp%d: failed reading printer status", usblp->minor);
 310                                         return -EIO;
 311                                 }
 312                                 if (copy_to_user ((unsigned char *)arg, &status, 1))
 313                                         return -EFAULT;
 314                                 break;
 315
 316                         default:
 317                                 return -EINVAL;
 318                 }
 319
 320         return 0;
 321 }
 322
 323 static ssize_t usblp_write(struct file *file, const char *buffer, size_t count, loff_t *ppos)
 324 {
 325         struct usblp *usblp = file->private_data;
 326         int timeout, err = 0, writecount = 0;
 327
 328         while (writecount < count) {
 329
 330                 if (usblp->writeurb.status == -EINPROGRESS) {
 331
 332                         if (file->f_flags & O_NONBLOCK)
 333                                 return -EAGAIN;
 334
 335                         timeout = USBLP_WRITE_TIMEOUT;
 336                         while (timeout && usblp->writeurb.status == -EINPROGRESS) {
 337
 338                                 if (signal_pending(current))
 339                                         return writecount ? writecount : -EINTR;
 340
 341                                 timeout = interruptible_sleep_on_timeout(&usblp->wait, timeout);
 342                         }
 343                 }
 344
 345                 if (!usblp->dev)
 346                         return -ENODEV;
 347
 348                 if (usblp->writeurb.status) {
 349                         if (usblp->quirks & USBLP_QUIRK_BIDIR) {
 350                                 if (usblp->writeurb.status != -EINPROGRESS)
 351                                         err("usblp%d: error %d writing to printer",
 352                                                 usblp->minor, usblp->writeurb.status);
 353                                 err = usblp->writeurb.status;
 354                                 continue;
 355                         }
 356                         else {
 357                                 err = usblp_check_status(usblp, err);
 358                                 continue;
 359                         }
 360                 }
 361
 362                 writecount += usblp->writeurb.transfer_buffer_length;
 363                 usblp->writeurb.transfer_buffer_length = 0;
 364
 365                 if (writecount == count)
 366                         continue;
 367
 368                 usblp->writeurb.transfer_buffer_length = (count - writecount) < USBLP_BUF_SIZE ?
 369                                                          (count - writecount) : USBLP_BUF_SIZE;
 370
 371                 if (copy_from_user(usblp->writeurb.transfer_buffer, buffer + writecount,
 372                                 usblp->writeurb.transfer_buffer_length)) return -EFAULT;
 373
 374                 usblp->writeurb.dev = usblp->dev;
 375                 usb_submit_urb(&usblp->writeurb);
 376         }
 377
 378         return count;
 379 }
 380
 381 static ssize_t usblp_read(struct file *file, char *buffer, size_t count, loff_t *ppos)
 382 {
 383         struct usblp *usblp = file->private_data;
 384
 385         if (!usblp->bidir)
 386                 return -EINVAL;
 387
 388         if (usblp->readurb.status == -EINPROGRESS) {
 389
 390                 if (file->f_flags & O_NONBLOCK)
 391                         return -EAGAIN;
 392
 393                 while (usblp->readurb.status == -EINPROGRESS) {
 394                         if (signal_pending(current))
 395                                 return -EINTR;
 396                         interruptible_sleep_on(&usblp->wait);
 397                 }
 398         }
 399
 400         if (!usblp->dev)
 401                 return -ENODEV;
 402
 403         if (usblp->readurb.status) {
 404                 err("usblp%d: error %d reading from printer",
 405                         usblp->minor, usblp->readurb.status);
 406                 usblp->readurb.dev = usblp->dev;
 407                 usb_submit_urb(&usblp->readurb);
 408                 return -EIO;
 409         }
 410
 411         count = count < usblp->readurb.actual_length - usblp->readcount ?
 412                 count : usblp->readurb.actual_length - usblp->readcount;
 413
 414         if (copy_to_user(buffer, usblp->readurb.transfer_buffer + usblp->readcount, count))
 415                 return -EFAULT;
 416
 417         if ((usblp->readcount += count) == usblp->readurb.actual_length) {
 418                 usblp->readcount = 0;
 419                 usblp->readurb.dev = usblp->dev;
 420                 usb_submit_urb(&usblp->readurb);
 421         }
 422
 423         return count;
 424 }
 425
 426 /*
 427  * Checks for printers that have quirks, such as requiring unidirectional
 428  * communication but reporting bidirectional; currently some HP printers
 429  * have this flaw (HP 810, 880, 895, etc.), or needing an init string
 430  * sent at each open (like some Epsons).
 431  * Returns 1 if found, 0 if not found.
 432  *
 433  * HP recommended that we use the bidirectional interface but
 434  * don't attempt any bulk IN transfers from the IN endpoint.
 435  * Here's some more detail on the problem:
 436  * The problem is not that it isn't bidirectional though. The problem
 437  * is that if you request a device ID, or status information, while
 438  * the buffers are full, the return data will end up in the print data
 439  * buffer. For example if you make sure you never request the device ID
 440  * while you are sending print data, and you don't try to query the
 441  * printer status every couple of milliseconds, you will probably be OK.
 442  */
 443 static unsigned int usblp_quirks (__u16 vendor, __u16 product)
 444 {
 445         int i;
 446
 447         for (i = 0; quirk_printers[i].vendorId; i++) {
 448                 if (vendor == quirk_printers[i].vendorId &&
 449                     product == quirk_printers[i].productId)
 450                         return quirk_printers[i].quirks;
 451         }
 452         return 0;
 453 }
 454
 455 static void *usblp_probe(struct usb_device *dev, unsigned int ifnum,
 456                          const struct usb_device_id *id)
 457 {
 458         struct usb_interface_descriptor *interface;
 459         struct usb_endpoint_descriptor *epread, *epwrite;
 460         struct usblp *usblp;
 461         int minor, i, bidir = 0, quirks;
 462         int alts = dev->actconfig->interface[ifnum].act_altsetting;
 463         int length, err;
 464         char *buf;
 465
 466         /* If a bidirectional interface exists, use it. */
 467         for (i = 0; i < dev->actconfig->interface[ifnum].num_altsetting; i++) {
 468
 469                 interface = &dev->actconfig->interface[ifnum].altsetting[i];
 470
 471                 if (interface->bInterfaceClass != 7 || interface->bInterfaceSubClass != 1 ||
 472                     interface->bInterfaceProtocol < 1 || interface->bInterfaceProtocol > 3 ||
 473                    (interface->bInterfaceProtocol > 1 && interface->bNumEndpoints < 2))
 474                         continue;
 475
 476                 if (interface->bInterfaceProtocol > 1) {
 477                         bidir = 1;
 478                         alts = i;
 479                         break;
 480                 }
 481         }
 482
 483         interface = &dev->actconfig->interface[ifnum].altsetting[alts];
 484         if (usb_set_interface(dev, ifnum, alts))
 485                 err("can't set desired altsetting %d on interface %d", alts, ifnum);
 486
 487         epwrite = interface->endpoint + 0;
 488         epread = bidir ? interface->endpoint + 1 : NULL;
 489
 490         if ((epwrite->bEndpointAddress & 0x80) == 0x80) {
 491                 if (interface->bNumEndpoints == 1)
 492                         return NULL;
 493                 epwrite = interface->endpoint + 1;
 494                 epread = bidir ? interface->endpoint + 0 : NULL;
 495         }
 496
 497         if ((epwrite->bEndpointAddress & 0x80) == 0x80)
 498                 return NULL;
 499
 500         if (bidir && (epread->bEndpointAddress & 0x80) != 0x80)
 501                 return NULL;
 502
 503         for (minor = 0; minor < USBLP_MINORS && usblp_table[minor]; minor++);
 504         if (usblp_table[minor]) {
 505                 err("no more free usblp devices");
 506                 return NULL;
 507         }
 508
 509         if (!(usblp = kmalloc(sizeof(struct usblp), GFP_KERNEL))) {
 510                 err("out of memory");
 511                 return NULL;
 512         }
 513         memset(usblp, 0, sizeof(struct usblp));
 514
 515         /* lookup quirks for this printer */
 516         quirks = usblp_quirks(dev->descriptor.idVendor, dev->descriptor.idProduct);
 517
 518         if (bidir && (quirks & USBLP_QUIRK_BIDIR)) {
 519                 bidir = 0;
 520                 epread = NULL;
 521                 info ("Disabling reads from problem bidirectional printer on usblp%d",
 522                         minor);
 523         }
 524
 525         usblp->dev = dev;
 526         usblp->ifnum = ifnum;
 527         usblp->minor = minor;
 528         usblp->bidir = bidir;
 529         usblp->quirks = quirks;
 530
 531         init_waitqueue_head(&usblp->wait);
 532
 533         if (!(buf = kmalloc(USBLP_BUF_SIZE * (bidir ? 2 : 1), GFP_KERNEL))) {
 534                 err("out of memory");
 535                 kfree(usblp);
 536                 return NULL;
 537         }
 538
 539         if (!(usblp->device_id_string = kmalloc(DEVICE_ID_SIZE, GFP_KERNEL))) {
 540                 err("out of memory");
 541                 kfree(usblp);
 542                 kfree(buf);
 543                 return NULL;
 544         }
 545
 546         FILL_BULK_URB(&usblp->writeurb, dev, usb_sndbulkpipe(dev, epwrite->bEndpointAddress),
 547                 buf, 0, usblp_bulk, usblp);
 548
 549         if (bidir)
 550                 FILL_BULK_URB(&usblp->readurb, dev, usb_rcvbulkpipe(dev, epread->bEndpointAddress),
 551                         buf + USBLP_BUF_SIZE, USBLP_BUF_SIZE, usblp_bulk, usblp);
 552
 553         /* Get the device_id string if possible. FIXME: Could make this kmalloc(length). */
 554         err = usblp_get_id(usblp, 0, usblp->device_id_string, DEVICE_ID_SIZE - 1);
 555         if (err >= 0) {
 556                 length = (usblp->device_id_string[0] << 8) + usblp->device_id_string[1]; /* big-endian */
 557                 if (length < DEVICE_ID_SIZE)
 558                         usblp->device_id_string[length] = '\0';
 559                 else
 560                         usblp->device_id_string[DEVICE_ID_SIZE - 1] = '\0';
 561                 dbg ("usblp%d Device ID string [%d]=%s",
 562                         minor, length, &usblp->device_id_string[2]);
 563         }
 564         else {
 565                 err ("usblp%d: error = %d reading IEEE-1284 Device ID string",
 566                         minor, err);
 567                 usblp->device_id_string[0] = usblp->device_id_string[1] = '\0';
 568         }
 569
 570 #ifdef DEBUG
 571         usblp_check_status(usblp, 0);
 572 #endif
 573
 574         info("usblp%d: USB %sdirectional printer dev %d if %d alt %d",
 575                 minor, bidir ? "Bi" : "Uni", dev->devnum, ifnum, alts);
 576
 577         return usblp_table[minor] = usblp;
 578 }
 579
 580 static void usblp_disconnect(struct usb_device *dev, void *ptr)
 581 {
 582         struct usblp *usblp = ptr;
 583
 584         if (!usblp || !usblp->dev) {
 585                 err("disconnect on nonexisting interface");
 586                 return;
 587         }
 588
 589         usblp->dev = NULL;
 590
 591         usb_unlink_urb(&usblp->writeurb);
 592         if (usblp->bidir)
 593                 usb_unlink_urb(&usblp->readurb);
 594
 595         kfree(usblp->writeurb.transfer_buffer);
 596
 597         if (usblp->used) return;
 598
 599         kfree(usblp->device_id_string);
 600
 601         usblp_table[usblp->minor] = NULL;
 602         kfree(usblp);
 603 }
 604
 605 static struct file_operations usblp_fops = {
 606         owner:          THIS_MODULE,
 607         read:           usblp_read,
 608         write:          usblp_write,
 609         poll:           usblp_poll,
 610         ioctl:          usblp_ioctl,
 611         open:           usblp_open,
 612         release:        usblp_release,
 613 };
 614
 615 static struct usb_device_id usblp_ids [] = {
 616     { bInterfaceClass: 7, bInterfaceSubClass: 1, bInterfaceProtocol: 1},
 617     { bInterfaceClass: 7, bInterfaceSubClass: 1, bInterfaceProtocol: 2},
 618     { bInterfaceClass: 7, bInterfaceSubClass: 1, bInterfaceProtocol: 3},
 619     { }                                         /* Terminating entry */
 620 };
 621
 622 MODULE_DEVICE_TABLE (usb, usblp_ids);
 623
 624 static struct usb_driver usblp_driver = {
 625         name:           "usblp",
 626         probe:          usblp_probe,
 627         disconnect:     usblp_disconnect,
 628         fops:           &usblp_fops,
 629         minor:          USBLP_MINOR_BASE,
 630         id_table:       usblp_ids,
 631 };
 632
 633 static int __init usblp_init(void)
 634 {
 635         if (usb_register(&usblp_driver))
 636                 return -1;
 637         return 0;
 638 }
 639
 640 static void __exit usblp_exit(void)
 641 {
 642         usb_deregister(&usblp_driver);
 643 }
 644
 645 module_init(usblp_init);
 646 module_exit(usblp_exit);
 647
 648 MODULE_AUTHOR("Michael Gee, Pavel Machek, Vojtech Pavlik, Randy Dunlap");
 649 MODULE_DESCRIPTION("USB Printer Device Class driver");