Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0+
0002 /*
0003  * usblp.c
0004  *
0005  * Copyright (c) 1999 Michael Gee   <michael@linuxspecific.com>
0006  * Copyright (c) 1999 Pavel Machek  <pavel@ucw.cz>
0007  * Copyright (c) 2000 Randy Dunlap  <rdunlap@xenotime.net>
0008  * Copyright (c) 2000 Vojtech Pavlik    <vojtech@suse.cz>
0009  # Copyright (c) 2001 Pete Zaitcev  <zaitcev@redhat.com>
0010  # Copyright (c) 2001 David Paschal <paschal@rcsis.com>
0011  * Copyright (c) 2006 Oliver Neukum <oliver@neukum.name>
0012  *
0013  * USB Printer Device Class driver for USB printers and printer cables
0014  *
0015  * Sponsored by SuSE
0016  *
0017  * ChangeLog:
0018  *  v0.1 - thorough cleaning, URBification, almost a rewrite
0019  *  v0.2 - some more cleanups
0020  *  v0.3 - cleaner again, waitqueue fixes
0021  *  v0.4 - fixes in unidirectional mode
0022  *  v0.5 - add DEVICE_ID string support
0023  *  v0.6 - never time out
0024  *  v0.7 - fixed bulk-IN read and poll (David Paschal)
0025  *  v0.8 - add devfs support
0026  *  v0.9 - fix unplug-while-open paths
0027  *  v0.10- remove sleep_on, fix error on oom (oliver@neukum.org)
0028  *  v0.11 - add proto_bias option (Pete Zaitcev)
0029  *  v0.12 - add hpoj.sourceforge.net ioctls (David Paschal)
0030  *  v0.13 - alloc space for statusbuf (<status> not on stack);
0031  *      use usb_alloc_coherent() for read buf & write buf;
0032  *      none  - Maintained in Linux kernel after v0.13
0033  */
0034 
0035 #include <linux/module.h>
0036 #include <linux/kernel.h>
0037 #include <linux/sched/signal.h>
0038 #include <linux/signal.h>
0039 #include <linux/poll.h>
0040 #include <linux/slab.h>
0041 #include <linux/lp.h>
0042 #include <linux/mutex.h>
0043 #undef DEBUG
0044 #include <linux/usb.h>
0045 #include <linux/usb/ch9.h>
0046 #include <linux/ratelimit.h>
0047 
0048 /*
0049  * Version Information
0050  */
0051 #define DRIVER_AUTHOR "Michael Gee, Pavel Machek, Vojtech Pavlik, Randy Dunlap, Pete Zaitcev, David Paschal"
0052 #define DRIVER_DESC "USB Printer Device Class driver"
0053 
0054 #define USBLP_BUF_SIZE      8192
0055 #define USBLP_BUF_SIZE_IN   1024
0056 #define USBLP_DEVICE_ID_SIZE    1024
0057 
0058 /* ioctls: */
0059 #define IOCNR_GET_DEVICE_ID     1
0060 #define IOCNR_GET_PROTOCOLS     2
0061 #define IOCNR_SET_PROTOCOL      3
0062 #define IOCNR_HP_SET_CHANNEL        4
0063 #define IOCNR_GET_BUS_ADDRESS       5
0064 #define IOCNR_GET_VID_PID       6
0065 #define IOCNR_SOFT_RESET        7
0066 /* Get device_id string: */
0067 #define LPIOC_GET_DEVICE_ID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_DEVICE_ID, len)
0068 /* The following ioctls were added for http://hpoj.sourceforge.net:
0069  * Get two-int array:
0070  * [0]=current protocol
0071  *     (1=USB_CLASS_PRINTER/1/1, 2=USB_CLASS_PRINTER/1/2,
0072  *         3=USB_CLASS_PRINTER/1/3),
0073  * [1]=supported protocol mask (mask&(1<<n)!=0 means
0074  *     USB_CLASS_PRINTER/1/n supported):
0075  */
0076 #define LPIOC_GET_PROTOCOLS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_PROTOCOLS, len)
0077 /*
0078  * Set protocol
0079  *     (arg: 1=USB_CLASS_PRINTER/1/1, 2=USB_CLASS_PRINTER/1/2,
0080  *         3=USB_CLASS_PRINTER/1/3):
0081  */
0082 #define LPIOC_SET_PROTOCOL _IOC(_IOC_WRITE, 'P', IOCNR_SET_PROTOCOL, 0)
0083 /* Set channel number (HP Vendor-specific command): */
0084 #define LPIOC_HP_SET_CHANNEL _IOC(_IOC_WRITE, 'P', IOCNR_HP_SET_CHANNEL, 0)
0085 /* Get two-int array: [0]=bus number, [1]=device address: */
0086 #define LPIOC_GET_BUS_ADDRESS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_BUS_ADDRESS, len)
0087 /* Get two-int array: [0]=vendor ID, [1]=product ID: */
0088 #define LPIOC_GET_VID_PID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_VID_PID, len)
0089 /* Perform class specific soft reset */
0090 #define LPIOC_SOFT_RESET _IOC(_IOC_NONE, 'P', IOCNR_SOFT_RESET, 0);
0091 
0092 /*
0093  * A DEVICE_ID string may include the printer's serial number.
0094  * It should end with a semi-colon (';').
0095  * An example from an HP 970C DeskJet printer is (this is one long string,
0096  * with the serial number changed):
0097 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:                    ;
0098  */
0099 
0100 /*
0101  * USB Printer Requests
0102  */
0103 
0104 #define USBLP_REQ_GET_ID            0x00
0105 #define USBLP_REQ_GET_STATUS            0x01
0106 #define USBLP_REQ_RESET             0x02
0107 #define USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST 0x00    /* HP Vendor-specific */
0108 
0109 #define USBLP_MINORS        16
0110 #define USBLP_MINOR_BASE    0
0111 
0112 #define USBLP_CTL_TIMEOUT   5000            /* 5 seconds */
0113 
0114 #define USBLP_FIRST_PROTOCOL    1
0115 #define USBLP_LAST_PROTOCOL 3
0116 #define USBLP_MAX_PROTOCOLS (USBLP_LAST_PROTOCOL+1)
0117 
0118 /*
0119  * some arbitrary status buffer size;
0120  * need a status buffer that is allocated via kmalloc(), not on stack
0121  */
0122 #define STATUS_BUF_SIZE     8
0123 
0124 /*
0125  * Locks down the locking order:
0126  * ->wmut locks wstatus.
0127  * ->mut locks the whole usblp, except [rw]complete, and thus, by indirection,
0128  * [rw]status. We only touch status when we know the side idle.
0129  * ->lock locks what interrupt accesses.
0130  */
0131 struct usblp {
0132     struct usb_device   *dev;           /* USB device */
0133     struct mutex        wmut;
0134     struct mutex        mut;
0135     spinlock_t      lock;       /* locks rcomplete, wcomplete */
0136     char            *readbuf;       /* read transfer_buffer */
0137     char            *statusbuf;     /* status transfer_buffer */
0138     struct usb_anchor   urbs;
0139     wait_queue_head_t   rwait, wwait;
0140     int         readcount;      /* Counter for reads */
0141     int         ifnum;          /* Interface number */
0142     struct usb_interface    *intf;          /* The interface */
0143     /*
0144      * Alternate-setting numbers and endpoints for each protocol
0145      * (USB_CLASS_PRINTER/1/{index=1,2,3}) that the device supports:
0146      */
0147     struct {
0148         int             alt_setting;
0149         struct usb_endpoint_descriptor  *epwrite;
0150         struct usb_endpoint_descriptor  *epread;
0151     }           protocol[USBLP_MAX_PROTOCOLS];
0152     int         current_protocol;
0153     int         minor;          /* minor number of device */
0154     int         wcomplete, rcomplete;
0155     int         wstatus;    /* bytes written or error */
0156     int         rstatus;    /* bytes ready or error */
0157     unsigned int        quirks;         /* quirks flags */
0158     unsigned int        flags;          /* mode flags */
0159     unsigned char       used;           /* True if open */
0160     unsigned char       present;        /* True if not disconnected */
0161     unsigned char       bidir;          /* interface is bidirectional */
0162     unsigned char       no_paper;       /* Paper Out happened */
0163     unsigned char       *device_id_string;  /* IEEE 1284 DEVICE ID string (ptr) */
0164                             /* first 2 bytes are (big-endian) length */
0165 };
0166 
0167 #ifdef DEBUG
0168 static void usblp_dump(struct usblp *usblp)
0169 {
0170     struct device *dev = &usblp->intf->dev;
0171     int p;
0172 
0173     dev_dbg(dev, "usblp=0x%p\n", usblp);
0174     dev_dbg(dev, "dev=0x%p\n", usblp->dev);
0175     dev_dbg(dev, "present=%d\n", usblp->present);
0176     dev_dbg(dev, "readbuf=0x%p\n", usblp->readbuf);
0177     dev_dbg(dev, "readcount=%d\n", usblp->readcount);
0178     dev_dbg(dev, "ifnum=%d\n", usblp->ifnum);
0179     for (p = USBLP_FIRST_PROTOCOL; p <= USBLP_LAST_PROTOCOL; p++) {
0180         dev_dbg(dev, "protocol[%d].alt_setting=%d\n", p,
0181             usblp->protocol[p].alt_setting);
0182         dev_dbg(dev, "protocol[%d].epwrite=%p\n", p,
0183             usblp->protocol[p].epwrite);
0184         dev_dbg(dev, "protocol[%d].epread=%p\n", p,
0185             usblp->protocol[p].epread);
0186     }
0187     dev_dbg(dev, "current_protocol=%d\n", usblp->current_protocol);
0188     dev_dbg(dev, "minor=%d\n", usblp->minor);
0189     dev_dbg(dev, "wstatus=%d\n", usblp->wstatus);
0190     dev_dbg(dev, "rstatus=%d\n", usblp->rstatus);
0191     dev_dbg(dev, "quirks=%d\n", usblp->quirks);
0192     dev_dbg(dev, "used=%d\n", usblp->used);
0193     dev_dbg(dev, "bidir=%d\n", usblp->bidir);
0194     dev_dbg(dev, "device_id_string=\"%s\"\n",
0195         usblp->device_id_string ?
0196             usblp->device_id_string + 2 :
0197             (unsigned char *)"(null)");
0198 }
0199 #endif
0200 
0201 /* Quirks: various printer quirks are handled by this table & its flags. */
0202 
0203 struct quirk_printer_struct {
0204     __u16 vendorId;
0205     __u16 productId;
0206     unsigned int quirks;
0207 };
0208 
0209 #define USBLP_QUIRK_BIDIR   0x1 /* reports bidir but requires unidirectional mode (no INs/reads) */
0210 #define USBLP_QUIRK_USB_INIT    0x2 /* needs vendor USB init string */
0211 #define USBLP_QUIRK_BAD_CLASS   0x4 /* descriptor uses vendor-specific Class or SubClass */
0212 
0213 static const struct quirk_printer_struct quirk_printers[] = {
0214     { 0x03f0, 0x0004, USBLP_QUIRK_BIDIR }, /* HP DeskJet 895C */
0215     { 0x03f0, 0x0104, USBLP_QUIRK_BIDIR }, /* HP DeskJet 880C */
0216     { 0x03f0, 0x0204, USBLP_QUIRK_BIDIR }, /* HP DeskJet 815C */
0217     { 0x03f0, 0x0304, USBLP_QUIRK_BIDIR }, /* HP DeskJet 810C/812C */
0218     { 0x03f0, 0x0404, USBLP_QUIRK_BIDIR }, /* HP DeskJet 830C */
0219     { 0x03f0, 0x0504, USBLP_QUIRK_BIDIR }, /* HP DeskJet 885C */
0220     { 0x03f0, 0x0604, USBLP_QUIRK_BIDIR }, /* HP DeskJet 840C */
0221     { 0x03f0, 0x0804, USBLP_QUIRK_BIDIR }, /* HP DeskJet 816C */
0222     { 0x03f0, 0x1104, USBLP_QUIRK_BIDIR }, /* HP Deskjet 959C */
0223     { 0x0409, 0xefbe, USBLP_QUIRK_BIDIR }, /* NEC Picty900 (HP OEM) */
0224     { 0x0409, 0xbef4, USBLP_QUIRK_BIDIR }, /* NEC Picty760 (HP OEM) */
0225     { 0x0409, 0xf0be, USBLP_QUIRK_BIDIR }, /* NEC Picty920 (HP OEM) */
0226     { 0x0409, 0xf1be, USBLP_QUIRK_BIDIR }, /* NEC Picty800 (HP OEM) */
0227     { 0x0482, 0x0010, USBLP_QUIRK_BIDIR }, /* Kyocera Mita FS 820, by zut <kernel@zut.de> */
0228     { 0x04f9, 0x000d, USBLP_QUIRK_BIDIR }, /* Brother Industries, Ltd HL-1440 Laser Printer */
0229     { 0x04b8, 0x0202, USBLP_QUIRK_BAD_CLASS }, /* Seiko Epson Receipt Printer M129C */
0230     { 0, 0 }
0231 };
0232 
0233 static int usblp_wwait(struct usblp *usblp, int nonblock);
0234 static int usblp_wtest(struct usblp *usblp, int nonblock);
0235 static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock);
0236 static int usblp_rtest(struct usblp *usblp, int nonblock);
0237 static int usblp_submit_read(struct usblp *usblp);
0238 static int usblp_select_alts(struct usblp *usblp);
0239 static int usblp_set_protocol(struct usblp *usblp, int protocol);
0240 static int usblp_cache_device_id_string(struct usblp *usblp);
0241 
0242 /* forward reference to make our lives easier */
0243 static struct usb_driver usblp_driver;
0244 static DEFINE_MUTEX(usblp_mutex);   /* locks the existence of usblp's */
0245 
0246 /*
0247  * Functions for usblp control messages.
0248  */
0249 
0250 static int usblp_ctrl_msg(struct usblp *usblp, int request, int type, int dir, int recip, int value, void *buf, int len)
0251 {
0252     int retval;
0253     int index = usblp->ifnum;
0254 
0255     /* High byte has the interface index.
0256        Low byte has the alternate setting.
0257      */
0258     if ((request == USBLP_REQ_GET_ID) && (type == USB_TYPE_CLASS))
0259         index = (usblp->ifnum<<8)|usblp->protocol[usblp->current_protocol].alt_setting;
0260 
0261     retval = usb_control_msg(usblp->dev,
0262         dir ? usb_rcvctrlpipe(usblp->dev, 0) : usb_sndctrlpipe(usblp->dev, 0),
0263         request, type | dir | recip, value, index, buf, len, USBLP_CTL_TIMEOUT);
0264     dev_dbg(&usblp->intf->dev,
0265         "usblp_control_msg: rq: 0x%02x dir: %d recip: %d value: %d idx: %d len: %#x result: %d\n",
0266         request, !!dir, recip, value, index, len, retval);
0267     return retval < 0 ? retval : 0;
0268 }
0269 
0270 #define usblp_read_status(usblp, status)\
0271     usblp_ctrl_msg(usblp, USBLP_REQ_GET_STATUS, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, 0, status, 1)
0272 #define usblp_get_id(usblp, config, id, maxlen)\
0273     usblp_ctrl_msg(usblp, USBLP_REQ_GET_ID, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, config, id, maxlen)
0274 #define usblp_reset(usblp)\
0275     usblp_ctrl_msg(usblp, USBLP_REQ_RESET, USB_TYPE_CLASS, USB_DIR_OUT, USB_RECIP_OTHER, 0, NULL, 0)
0276 
0277 static int usblp_hp_channel_change_request(struct usblp *usblp, int channel, u8 *new_channel)
0278 {
0279     u8 *buf;
0280     int ret;
0281 
0282     buf = kzalloc(1, GFP_KERNEL);
0283     if (!buf)
0284         return -ENOMEM;
0285 
0286     ret = usblp_ctrl_msg(usblp, USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST,
0287             USB_TYPE_VENDOR, USB_DIR_IN, USB_RECIP_INTERFACE,
0288             channel, buf, 1);
0289     if (ret == 0)
0290         *new_channel = buf[0];
0291 
0292     kfree(buf);
0293 
0294     return ret;
0295 }
0296 
0297 /*
0298  * See the description for usblp_select_alts() below for the usage
0299  * explanation.  Look into your /sys/kernel/debug/usb/devices and dmesg in
0300  * case of any trouble.
0301  */
0302 static int proto_bias = -1;
0303 
0304 /*
0305  * URB callback.
0306  */
0307 
0308 static void usblp_bulk_read(struct urb *urb)
0309 {
0310     struct usblp *usblp = urb->context;
0311     int status = urb->status;
0312     unsigned long flags;
0313 
0314     if (usblp->present && usblp->used) {
0315         if (status)
0316             printk(KERN_WARNING "usblp%d: "
0317                 "nonzero read bulk status received: %d\n",
0318                 usblp->minor, status);
0319     }
0320     spin_lock_irqsave(&usblp->lock, flags);
0321     if (status < 0)
0322         usblp->rstatus = status;
0323     else
0324         usblp->rstatus = urb->actual_length;
0325     usblp->rcomplete = 1;
0326     wake_up(&usblp->rwait);
0327     spin_unlock_irqrestore(&usblp->lock, flags);
0328 
0329     usb_free_urb(urb);
0330 }
0331 
0332 static void usblp_bulk_write(struct urb *urb)
0333 {
0334     struct usblp *usblp = urb->context;
0335     int status = urb->status;
0336     unsigned long flags;
0337 
0338     if (usblp->present && usblp->used) {
0339         if (status)
0340             printk(KERN_WARNING "usblp%d: "
0341                 "nonzero write bulk status received: %d\n",
0342                 usblp->minor, status);
0343     }
0344     spin_lock_irqsave(&usblp->lock, flags);
0345     if (status < 0)
0346         usblp->wstatus = status;
0347     else
0348         usblp->wstatus = urb->actual_length;
0349     usblp->no_paper = 0;
0350     usblp->wcomplete = 1;
0351     wake_up(&usblp->wwait);
0352     spin_unlock_irqrestore(&usblp->lock, flags);
0353 
0354     usb_free_urb(urb);
0355 }
0356 
0357 /*
0358  * Get and print printer errors.
0359  */
0360 
0361 static const char *usblp_messages[] = { "ok", "out of paper", "off-line", "on fire" };
0362 
0363 static int usblp_check_status(struct usblp *usblp, int err)
0364 {
0365     unsigned char status, newerr = 0;
0366     int error;
0367 
0368     mutex_lock(&usblp->mut);
0369     if ((error = usblp_read_status(usblp, usblp->statusbuf)) < 0) {
0370         mutex_unlock(&usblp->mut);
0371         printk_ratelimited(KERN_ERR
0372                 "usblp%d: error %d reading printer status\n",
0373                 usblp->minor, error);
0374         return 0;
0375     }
0376     status = *usblp->statusbuf;
0377     mutex_unlock(&usblp->mut);
0378 
0379     if (~status & LP_PERRORP)
0380         newerr = 3;
0381     if (status & LP_POUTPA)
0382         newerr = 1;
0383     if (~status & LP_PSELECD)
0384         newerr = 2;
0385 
0386     if (newerr != err) {
0387         printk(KERN_INFO "usblp%d: %s\n",
0388            usblp->minor, usblp_messages[newerr]);
0389     }
0390 
0391     return newerr;
0392 }
0393 
0394 static int handle_bidir(struct usblp *usblp)
0395 {
0396     if (usblp->bidir && usblp->used) {
0397         if (usblp_submit_read(usblp) < 0)
0398             return -EIO;
0399     }
0400     return 0;
0401 }
0402 
0403 /*
0404  * File op functions.
0405  */
0406 
0407 static int usblp_open(struct inode *inode, struct file *file)
0408 {
0409     int minor = iminor(inode);
0410     struct usblp *usblp;
0411     struct usb_interface *intf;
0412     int retval;
0413 
0414     if (minor < 0)
0415         return -ENODEV;
0416 
0417     mutex_lock(&usblp_mutex);
0418 
0419     retval = -ENODEV;
0420     intf = usb_find_interface(&usblp_driver, minor);
0421     if (!intf)
0422         goto out;
0423     usblp = usb_get_intfdata(intf);
0424     if (!usblp || !usblp->dev || !usblp->present)
0425         goto out;
0426 
0427     retval = -EBUSY;
0428     if (usblp->used)
0429         goto out;
0430 
0431     /*
0432      * We do not implement LP_ABORTOPEN/LPABORTOPEN for two reasons:
0433      *  - We do not want persistent state which close(2) does not clear
0434      *  - It is not used anyway, according to CUPS people
0435      */
0436 
0437     retval = usb_autopm_get_interface(intf);
0438     if (retval < 0)
0439         goto out;
0440     usblp->used = 1;
0441     file->private_data = usblp;
0442 
0443     usblp->wcomplete = 1; /* we begin writeable */
0444     usblp->wstatus = 0;
0445     usblp->rcomplete = 0;
0446 
0447     if (handle_bidir(usblp) < 0) {
0448         usb_autopm_put_interface(intf);
0449         usblp->used = 0;
0450         file->private_data = NULL;
0451         retval = -EIO;
0452     }
0453 out:
0454     mutex_unlock(&usblp_mutex);
0455     return retval;
0456 }
0457 
0458 static void usblp_cleanup(struct usblp *usblp)
0459 {
0460     printk(KERN_INFO "usblp%d: removed\n", usblp->minor);
0461 
0462     kfree(usblp->readbuf);
0463     kfree(usblp->device_id_string);
0464     kfree(usblp->statusbuf);
0465     usb_put_intf(usblp->intf);
0466     kfree(usblp);
0467 }
0468 
0469 static void usblp_unlink_urbs(struct usblp *usblp)
0470 {
0471     usb_kill_anchored_urbs(&usblp->urbs);
0472 }
0473 
0474 static int usblp_release(struct inode *inode, struct file *file)
0475 {
0476     struct usblp *usblp = file->private_data;
0477 
0478     usblp->flags &= ~LP_ABORT;
0479 
0480     mutex_lock(&usblp_mutex);
0481     usblp->used = 0;
0482     if (usblp->present)
0483         usblp_unlink_urbs(usblp);
0484 
0485     usb_autopm_put_interface(usblp->intf);
0486 
0487     if (!usblp->present)        /* finish cleanup from disconnect */
0488         usblp_cleanup(usblp);   /* any URBs must be dead */
0489 
0490     mutex_unlock(&usblp_mutex);
0491     return 0;
0492 }
0493 
0494 /* No kernel lock - fine */
0495 static __poll_t usblp_poll(struct file *file, struct poll_table_struct *wait)
0496 {
0497     struct usblp *usblp = file->private_data;
0498     __poll_t ret = 0;
0499     unsigned long flags;
0500 
0501     /* Should we check file->f_mode & FMODE_WRITE before poll_wait()? */
0502     poll_wait(file, &usblp->rwait, wait);
0503     poll_wait(file, &usblp->wwait, wait);
0504 
0505     mutex_lock(&usblp->mut);
0506     if (!usblp->present)
0507         ret |= EPOLLHUP;
0508     mutex_unlock(&usblp->mut);
0509 
0510     spin_lock_irqsave(&usblp->lock, flags);
0511     if (usblp->bidir && usblp->rcomplete)
0512         ret |= EPOLLIN  | EPOLLRDNORM;
0513     if (usblp->no_paper || usblp->wcomplete)
0514         ret |= EPOLLOUT | EPOLLWRNORM;
0515     spin_unlock_irqrestore(&usblp->lock, flags);
0516     return ret;
0517 }
0518 
0519 static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
0520 {
0521     struct usblp *usblp = file->private_data;
0522     int length, err, i;
0523     unsigned char newChannel;
0524     int status;
0525     int twoints[2];
0526     int retval = 0;
0527 
0528     mutex_lock(&usblp->mut);
0529     if (!usblp->present) {
0530         retval = -ENODEV;
0531         goto done;
0532     }
0533 
0534     dev_dbg(&usblp->intf->dev,
0535         "usblp_ioctl: cmd=0x%x (%c nr=%d len=%d dir=%d)\n", cmd,
0536         _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd), _IOC_DIR(cmd));
0537 
0538     if (_IOC_TYPE(cmd) == 'P')  /* new-style ioctl number */
0539 
0540         switch (_IOC_NR(cmd)) {
0541 
0542         case IOCNR_GET_DEVICE_ID: /* get the DEVICE_ID string */
0543             if (_IOC_DIR(cmd) != _IOC_READ) {
0544                 retval = -EINVAL;
0545                 goto done;
0546             }
0547 
0548             length = usblp_cache_device_id_string(usblp);
0549             if (length < 0) {
0550                 retval = length;
0551                 goto done;
0552             }
0553             if (length > _IOC_SIZE(cmd))
0554                 length = _IOC_SIZE(cmd); /* truncate */
0555 
0556             if (copy_to_user((void __user *) arg,
0557                     usblp->device_id_string,
0558                     (unsigned long) length)) {
0559                 retval = -EFAULT;
0560                 goto done;
0561             }
0562 
0563             break;
0564 
0565         case IOCNR_GET_PROTOCOLS:
0566             if (_IOC_DIR(cmd) != _IOC_READ ||
0567                 _IOC_SIZE(cmd) < sizeof(twoints)) {
0568                 retval = -EINVAL;
0569                 goto done;
0570             }
0571 
0572             twoints[0] = usblp->current_protocol;
0573             twoints[1] = 0;
0574             for (i = USBLP_FIRST_PROTOCOL;
0575                  i <= USBLP_LAST_PROTOCOL; i++) {
0576                 if (usblp->protocol[i].alt_setting >= 0)
0577                     twoints[1] |= (1<<i);
0578             }
0579 
0580             if (copy_to_user((void __user *)arg,
0581                     (unsigned char *)twoints,
0582                     sizeof(twoints))) {
0583                 retval = -EFAULT;
0584                 goto done;
0585             }
0586 
0587             break;
0588 
0589         case IOCNR_SET_PROTOCOL:
0590             if (_IOC_DIR(cmd) != _IOC_WRITE) {
0591                 retval = -EINVAL;
0592                 goto done;
0593             }
0594 
0595 #ifdef DEBUG
0596             if (arg == -10) {
0597                 usblp_dump(usblp);
0598                 break;
0599             }
0600 #endif
0601 
0602             usblp_unlink_urbs(usblp);
0603             retval = usblp_set_protocol(usblp, arg);
0604             if (retval < 0) {
0605                 usblp_set_protocol(usblp,
0606                     usblp->current_protocol);
0607             }
0608             break;
0609 
0610         case IOCNR_HP_SET_CHANNEL:
0611             if (_IOC_DIR(cmd) != _IOC_WRITE ||
0612                 le16_to_cpu(usblp->dev->descriptor.idVendor) != 0x03F0 ||
0613                 usblp->quirks & USBLP_QUIRK_BIDIR) {
0614                 retval = -EINVAL;
0615                 goto done;
0616             }
0617 
0618             err = usblp_hp_channel_change_request(usblp,
0619                 arg, &newChannel);
0620             if (err < 0) {
0621                 dev_err(&usblp->dev->dev,
0622                     "usblp%d: error = %d setting "
0623                     "HP channel\n",
0624                     usblp->minor, err);
0625                 retval = -EIO;
0626                 goto done;
0627             }
0628 
0629             dev_dbg(&usblp->intf->dev,
0630                 "usblp%d requested/got HP channel %ld/%d\n",
0631                 usblp->minor, arg, newChannel);
0632             break;
0633 
0634         case IOCNR_GET_BUS_ADDRESS:
0635             if (_IOC_DIR(cmd) != _IOC_READ ||
0636                 _IOC_SIZE(cmd) < sizeof(twoints)) {
0637                 retval = -EINVAL;
0638                 goto done;
0639             }
0640 
0641             twoints[0] = usblp->dev->bus->busnum;
0642             twoints[1] = usblp->dev->devnum;
0643             if (copy_to_user((void __user *)arg,
0644                     (unsigned char *)twoints,
0645                     sizeof(twoints))) {
0646                 retval = -EFAULT;
0647                 goto done;
0648             }
0649 
0650             dev_dbg(&usblp->intf->dev,
0651                 "usblp%d is bus=%d, device=%d\n",
0652                 usblp->minor, twoints[0], twoints[1]);
0653             break;
0654 
0655         case IOCNR_GET_VID_PID:
0656             if (_IOC_DIR(cmd) != _IOC_READ ||
0657                 _IOC_SIZE(cmd) < sizeof(twoints)) {
0658                 retval = -EINVAL;
0659                 goto done;
0660             }
0661 
0662             twoints[0] = le16_to_cpu(usblp->dev->descriptor.idVendor);
0663             twoints[1] = le16_to_cpu(usblp->dev->descriptor.idProduct);
0664             if (copy_to_user((void __user *)arg,
0665                     (unsigned char *)twoints,
0666                     sizeof(twoints))) {
0667                 retval = -EFAULT;
0668                 goto done;
0669             }
0670 
0671             dev_dbg(&usblp->intf->dev,
0672                 "usblp%d is VID=0x%4.4X, PID=0x%4.4X\n",
0673                 usblp->minor, twoints[0], twoints[1]);
0674             break;
0675 
0676         case IOCNR_SOFT_RESET:
0677             if (_IOC_DIR(cmd) != _IOC_NONE) {
0678                 retval = -EINVAL;
0679                 goto done;
0680             }
0681             retval = usblp_reset(usblp);
0682             break;
0683         default:
0684             retval = -ENOTTY;
0685         }
0686     else    /* old-style ioctl value */
0687         switch (cmd) {
0688 
0689         case LPGETSTATUS:
0690             retval = usblp_read_status(usblp, usblp->statusbuf);
0691             if (retval) {
0692                 printk_ratelimited(KERN_ERR "usblp%d:"
0693                         "failed reading printer status (%d)\n",
0694                         usblp->minor, retval);
0695                 retval = -EIO;
0696                 goto done;
0697             }
0698             status = *usblp->statusbuf;
0699             if (copy_to_user((void __user *)arg, &status, sizeof(int)))
0700                 retval = -EFAULT;
0701             break;
0702 
0703         case LPABORT:
0704             if (arg)
0705                 usblp->flags |= LP_ABORT;
0706             else
0707                 usblp->flags &= ~LP_ABORT;
0708             break;
0709 
0710         default:
0711             retval = -ENOTTY;
0712         }
0713 
0714 done:
0715     mutex_unlock(&usblp->mut);
0716     return retval;
0717 }
0718 
0719 static struct urb *usblp_new_writeurb(struct usblp *usblp, int transfer_length)
0720 {
0721     struct urb *urb;
0722     char *writebuf;
0723 
0724     writebuf = kmalloc(transfer_length, GFP_KERNEL);
0725     if (writebuf == NULL)
0726         return NULL;
0727     urb = usb_alloc_urb(0, GFP_KERNEL);
0728     if (urb == NULL) {
0729         kfree(writebuf);
0730         return NULL;
0731     }
0732 
0733     usb_fill_bulk_urb(urb, usblp->dev,
0734         usb_sndbulkpipe(usblp->dev,
0735          usblp->protocol[usblp->current_protocol].epwrite->bEndpointAddress),
0736         writebuf, transfer_length, usblp_bulk_write, usblp);
0737     urb->transfer_flags |= URB_FREE_BUFFER;
0738 
0739     return urb;
0740 }
0741 
0742 static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
0743 {
0744     struct usblp *usblp = file->private_data;
0745     struct urb *writeurb;
0746     int rv;
0747     int transfer_length;
0748     ssize_t writecount = 0;
0749 
0750     if (mutex_lock_interruptible(&usblp->wmut)) {
0751         rv = -EINTR;
0752         goto raise_biglock;
0753     }
0754     if ((rv = usblp_wwait(usblp, !!(file->f_flags & O_NONBLOCK))) < 0)
0755         goto raise_wait;
0756 
0757     while (writecount < count) {
0758         /*
0759          * Step 1: Submit next block.
0760          */
0761         if ((transfer_length = count - writecount) > USBLP_BUF_SIZE)
0762             transfer_length = USBLP_BUF_SIZE;
0763 
0764         rv = -ENOMEM;
0765         writeurb = usblp_new_writeurb(usblp, transfer_length);
0766         if (writeurb == NULL)
0767             goto raise_urb;
0768         usb_anchor_urb(writeurb, &usblp->urbs);
0769 
0770         if (copy_from_user(writeurb->transfer_buffer,
0771                    buffer + writecount, transfer_length)) {
0772             rv = -EFAULT;
0773             goto raise_badaddr;
0774         }
0775 
0776         spin_lock_irq(&usblp->lock);
0777         usblp->wcomplete = 0;
0778         spin_unlock_irq(&usblp->lock);
0779         if ((rv = usb_submit_urb(writeurb, GFP_KERNEL)) < 0) {
0780             usblp->wstatus = 0;
0781             spin_lock_irq(&usblp->lock);
0782             usblp->no_paper = 0;
0783             usblp->wcomplete = 1;
0784             wake_up(&usblp->wwait);
0785             spin_unlock_irq(&usblp->lock);
0786             if (rv != -ENOMEM)
0787                 rv = -EIO;
0788             goto raise_submit;
0789         }
0790 
0791         /*
0792          * Step 2: Wait for transfer to end, collect results.
0793          */
0794         rv = usblp_wwait(usblp, !!(file->f_flags&O_NONBLOCK));
0795         if (rv < 0) {
0796             if (rv == -EAGAIN) {
0797                 /* Presume that it's going to complete well. */
0798                 writecount += transfer_length;
0799             }
0800             if (rv == -ENOSPC) {
0801                 spin_lock_irq(&usblp->lock);
0802                 usblp->no_paper = 1;    /* Mark for poll(2) */
0803                 spin_unlock_irq(&usblp->lock);
0804                 writecount += transfer_length;
0805             }
0806             /* Leave URB dangling, to be cleaned on close. */
0807             goto collect_error;
0808         }
0809 
0810         if (usblp->wstatus < 0) {
0811             rv = -EIO;
0812             goto collect_error;
0813         }
0814         /*
0815          * This is critical: it must be our URB, not other writer's.
0816          * The wmut exists mainly to cover us here.
0817          */
0818         writecount += usblp->wstatus;
0819     }
0820 
0821     mutex_unlock(&usblp->wmut);
0822     return writecount;
0823 
0824 raise_submit:
0825 raise_badaddr:
0826     usb_unanchor_urb(writeurb);
0827     usb_free_urb(writeurb);
0828 raise_urb:
0829 raise_wait:
0830 collect_error:      /* Out of raise sequence */
0831     mutex_unlock(&usblp->wmut);
0832 raise_biglock:
0833     return writecount ? writecount : rv;
0834 }
0835 
0836 /*
0837  * Notice that we fail to restart in a few cases: on EFAULT, on restart
0838  * error, etc. This is the historical behaviour. In all such cases we return
0839  * EIO, and applications loop in order to get the new read going.
0840  */
0841 static ssize_t usblp_read(struct file *file, char __user *buffer, size_t len, loff_t *ppos)
0842 {
0843     struct usblp *usblp = file->private_data;
0844     ssize_t count;
0845     ssize_t avail;
0846     int rv;
0847 
0848     if (!usblp->bidir)
0849         return -EINVAL;
0850 
0851     rv = usblp_rwait_and_lock(usblp, !!(file->f_flags & O_NONBLOCK));
0852     if (rv < 0)
0853         return rv;
0854 
0855     if (!usblp->present) {
0856         count = -ENODEV;
0857         goto done;
0858     }
0859 
0860     if ((avail = usblp->rstatus) < 0) {
0861         printk(KERN_ERR "usblp%d: error %d reading from printer\n",
0862             usblp->minor, (int)avail);
0863         usblp_submit_read(usblp);
0864         count = -EIO;
0865         goto done;
0866     }
0867 
0868     count = len < avail - usblp->readcount ? len : avail - usblp->readcount;
0869     if (count != 0 &&
0870         copy_to_user(buffer, usblp->readbuf + usblp->readcount, count)) {
0871         count = -EFAULT;
0872         goto done;
0873     }
0874 
0875     if ((usblp->readcount += count) == avail) {
0876         if (usblp_submit_read(usblp) < 0) {
0877             /* We don't want to leak USB return codes into errno. */
0878             if (count == 0)
0879                 count = -EIO;
0880             goto done;
0881         }
0882     }
0883 
0884 done:
0885     mutex_unlock(&usblp->mut);
0886     return count;
0887 }
0888 
0889 /*
0890  * Wait for the write path to come idle.
0891  * This is called under the ->wmut, so the idle path stays idle.
0892  *
0893  * Our write path has a peculiar property: it does not buffer like a tty,
0894  * but waits for the write to succeed. This allows our ->release to bug out
0895  * without waiting for writes to drain. But it obviously does not work
0896  * when O_NONBLOCK is set. So, applications setting O_NONBLOCK must use
0897  * select(2) or poll(2) to wait for the buffer to drain before closing.
0898  * Alternatively, set blocking mode with fcntl and issue a zero-size write.
0899  */
0900 static int usblp_wwait(struct usblp *usblp, int nonblock)
0901 {
0902     DECLARE_WAITQUEUE(waita, current);
0903     int rc;
0904     int err = 0;
0905 
0906     add_wait_queue(&usblp->wwait, &waita);
0907     for (;;) {
0908         if (mutex_lock_interruptible(&usblp->mut)) {
0909             rc = -EINTR;
0910             break;
0911         }
0912         set_current_state(TASK_INTERRUPTIBLE);
0913         rc = usblp_wtest(usblp, nonblock);
0914         mutex_unlock(&usblp->mut);
0915         if (rc <= 0)
0916             break;
0917 
0918         if (schedule_timeout(msecs_to_jiffies(1500)) == 0) {
0919             if (usblp->flags & LP_ABORT) {
0920                 err = usblp_check_status(usblp, err);
0921                 if (err == 1) { /* Paper out */
0922                     rc = -ENOSPC;
0923                     break;
0924                 }
0925             } else {
0926                 /* Prod the printer, Gentoo#251237. */
0927                 mutex_lock(&usblp->mut);
0928                 usblp_read_status(usblp, usblp->statusbuf);
0929                 mutex_unlock(&usblp->mut);
0930             }
0931         }
0932     }
0933     set_current_state(TASK_RUNNING);
0934     remove_wait_queue(&usblp->wwait, &waita);
0935     return rc;
0936 }
0937 
0938 static int usblp_wtest(struct usblp *usblp, int nonblock)
0939 {
0940     unsigned long flags;
0941 
0942     if (!usblp->present)
0943         return -ENODEV;
0944     if (signal_pending(current))
0945         return -EINTR;
0946     spin_lock_irqsave(&usblp->lock, flags);
0947     if (usblp->wcomplete) {
0948         spin_unlock_irqrestore(&usblp->lock, flags);
0949         return 0;
0950     }
0951     spin_unlock_irqrestore(&usblp->lock, flags);
0952     if (nonblock)
0953         return -EAGAIN;
0954     return 1;
0955 }
0956 
0957 /*
0958  * Wait for read bytes to become available. This probably should have been
0959  * called usblp_r_lock_and_wait(), because we lock first. But it's a traditional
0960  * name for functions which lock and return.
0961  *
0962  * We do not use wait_event_interruptible because it makes locking iffy.
0963  */
0964 static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock)
0965 {
0966     DECLARE_WAITQUEUE(waita, current);
0967     int rc;
0968 
0969     add_wait_queue(&usblp->rwait, &waita);
0970     for (;;) {
0971         if (mutex_lock_interruptible(&usblp->mut)) {
0972             rc = -EINTR;
0973             break;
0974         }
0975         set_current_state(TASK_INTERRUPTIBLE);
0976         if ((rc = usblp_rtest(usblp, nonblock)) < 0) {
0977             mutex_unlock(&usblp->mut);
0978             break;
0979         }
0980         if (rc == 0)    /* Keep it locked */
0981             break;
0982         mutex_unlock(&usblp->mut);
0983         schedule();
0984     }
0985     set_current_state(TASK_RUNNING);
0986     remove_wait_queue(&usblp->rwait, &waita);
0987     return rc;
0988 }
0989 
0990 static int usblp_rtest(struct usblp *usblp, int nonblock)
0991 {
0992     unsigned long flags;
0993 
0994     if (!usblp->present)
0995         return -ENODEV;
0996     if (signal_pending(current))
0997         return -EINTR;
0998     spin_lock_irqsave(&usblp->lock, flags);
0999     if (usblp->rcomplete) {
1000         spin_unlock_irqrestore(&usblp->lock, flags);
1001         return 0;
1002     }
1003     spin_unlock_irqrestore(&usblp->lock, flags);
1004     if (nonblock)
1005         return -EAGAIN;
1006     return 1;
1007 }
1008 
1009 /*
1010  * Please check ->bidir and other such things outside for now.
1011  */
1012 static int usblp_submit_read(struct usblp *usblp)
1013 {
1014     struct urb *urb;
1015     unsigned long flags;
1016     int rc;
1017 
1018     rc = -ENOMEM;
1019     urb = usb_alloc_urb(0, GFP_KERNEL);
1020     if (urb == NULL)
1021         goto raise_urb;
1022 
1023     usb_fill_bulk_urb(urb, usblp->dev,
1024         usb_rcvbulkpipe(usblp->dev,
1025           usblp->protocol[usblp->current_protocol].epread->bEndpointAddress),
1026         usblp->readbuf, USBLP_BUF_SIZE_IN,
1027         usblp_bulk_read, usblp);
1028     usb_anchor_urb(urb, &usblp->urbs);
1029 
1030     spin_lock_irqsave(&usblp->lock, flags);
1031     usblp->readcount = 0; /* XXX Why here? */
1032     usblp->rcomplete = 0;
1033     spin_unlock_irqrestore(&usblp->lock, flags);
1034     if ((rc = usb_submit_urb(urb, GFP_KERNEL)) < 0) {
1035         dev_dbg(&usblp->intf->dev, "error submitting urb (%d)\n", rc);
1036         spin_lock_irqsave(&usblp->lock, flags);
1037         usblp->rstatus = rc;
1038         usblp->rcomplete = 1;
1039         spin_unlock_irqrestore(&usblp->lock, flags);
1040         goto raise_submit;
1041     }
1042 
1043     return 0;
1044 
1045 raise_submit:
1046     usb_unanchor_urb(urb);
1047     usb_free_urb(urb);
1048 raise_urb:
1049     return rc;
1050 }
1051 
1052 /*
1053  * Checks for printers that have quirks, such as requiring unidirectional
1054  * communication but reporting bidirectional; currently some HP printers
1055  * have this flaw (HP 810, 880, 895, etc.), or needing an init string
1056  * sent at each open (like some Epsons).
1057  * Returns 1 if found, 0 if not found.
1058  *
1059  * HP recommended that we use the bidirectional interface but
1060  * don't attempt any bulk IN transfers from the IN endpoint.
1061  * Here's some more detail on the problem:
1062  * The problem is not that it isn't bidirectional though. The problem
1063  * is that if you request a device ID, or status information, while
1064  * the buffers are full, the return data will end up in the print data
1065  * buffer. For example if you make sure you never request the device ID
1066  * while you are sending print data, and you don't try to query the
1067  * printer status every couple of milliseconds, you will probably be OK.
1068  */
1069 static unsigned int usblp_quirks(__u16 vendor, __u16 product)
1070 {
1071     int i;
1072 
1073     for (i = 0; quirk_printers[i].vendorId; i++) {
1074         if (vendor == quirk_printers[i].vendorId &&
1075             product == quirk_printers[i].productId)
1076             return quirk_printers[i].quirks;
1077     }
1078     return 0;
1079 }
1080 
1081 static const struct file_operations usblp_fops = {
1082     .owner =    THIS_MODULE,
1083     .read =     usblp_read,
1084     .write =    usblp_write,
1085     .poll =     usblp_poll,
1086     .unlocked_ioctl =   usblp_ioctl,
1087     .compat_ioctl =     usblp_ioctl,
1088     .open =     usblp_open,
1089     .release =  usblp_release,
1090     .llseek =   noop_llseek,
1091 };
1092 
1093 static char *usblp_devnode(struct device *dev, umode_t *mode)
1094 {
1095     return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
1096 }
1097 
1098 static struct usb_class_driver usblp_class = {
1099     .name =     "lp%d",
1100     .devnode =  usblp_devnode,
1101     .fops =     &usblp_fops,
1102     .minor_base =   USBLP_MINOR_BASE,
1103 };
1104 
1105 static ssize_t ieee1284_id_show(struct device *dev, struct device_attribute *attr, char *buf)
1106 {
1107     struct usb_interface *intf = to_usb_interface(dev);
1108     struct usblp *usblp = usb_get_intfdata(intf);
1109 
1110     if (usblp->device_id_string[0] == 0 &&
1111         usblp->device_id_string[1] == 0)
1112         return 0;
1113 
1114     return sprintf(buf, "%s", usblp->device_id_string+2);
1115 }
1116 
1117 static DEVICE_ATTR_RO(ieee1284_id);
1118 
1119 static struct attribute *usblp_attrs[] = {
1120     &dev_attr_ieee1284_id.attr,
1121     NULL,
1122 };
1123 ATTRIBUTE_GROUPS(usblp);
1124 
1125 static int usblp_probe(struct usb_interface *intf,
1126                const struct usb_device_id *id)
1127 {
1128     struct usb_device *dev = interface_to_usbdev(intf);
1129     struct usblp *usblp;
1130     int protocol;
1131     int retval;
1132 
1133     /* Malloc and start initializing usblp structure so we can use it
1134      * directly. */
1135     usblp = kzalloc(sizeof(struct usblp), GFP_KERNEL);
1136     if (!usblp) {
1137         retval = -ENOMEM;
1138         goto abort_ret;
1139     }
1140     usblp->dev = dev;
1141     mutex_init(&usblp->wmut);
1142     mutex_init(&usblp->mut);
1143     spin_lock_init(&usblp->lock);
1144     init_waitqueue_head(&usblp->rwait);
1145     init_waitqueue_head(&usblp->wwait);
1146     init_usb_anchor(&usblp->urbs);
1147     usblp->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
1148     usblp->intf = usb_get_intf(intf);
1149 
1150     /* Malloc device ID string buffer to the largest expected length,
1151      * since we can re-query it on an ioctl and a dynamic string
1152      * could change in length. */
1153     if (!(usblp->device_id_string = kmalloc(USBLP_DEVICE_ID_SIZE, GFP_KERNEL))) {
1154         retval = -ENOMEM;
1155         goto abort;
1156     }
1157 
1158     /*
1159      * Allocate read buffer. We somewhat wastefully
1160      * malloc both regardless of bidirectionality, because the
1161      * alternate setting can be changed later via an ioctl.
1162      */
1163     if (!(usblp->readbuf = kmalloc(USBLP_BUF_SIZE_IN, GFP_KERNEL))) {
1164         retval = -ENOMEM;
1165         goto abort;
1166     }
1167 
1168     /* Allocate buffer for printer status */
1169     usblp->statusbuf = kmalloc(STATUS_BUF_SIZE, GFP_KERNEL);
1170     if (!usblp->statusbuf) {
1171         retval = -ENOMEM;
1172         goto abort;
1173     }
1174 
1175     /* Lookup quirks for this printer. */
1176     usblp->quirks = usblp_quirks(
1177         le16_to_cpu(dev->descriptor.idVendor),
1178         le16_to_cpu(dev->descriptor.idProduct));
1179 
1180     /* Analyze and pick initial alternate settings and endpoints. */
1181     protocol = usblp_select_alts(usblp);
1182     if (protocol < 0) {
1183         dev_dbg(&intf->dev,
1184             "incompatible printer-class device 0x%4.4X/0x%4.4X\n",
1185             le16_to_cpu(dev->descriptor.idVendor),
1186             le16_to_cpu(dev->descriptor.idProduct));
1187         retval = -ENODEV;
1188         goto abort;
1189     }
1190 
1191     /* Setup the selected alternate setting and endpoints. */
1192     if (usblp_set_protocol(usblp, protocol) < 0) {
1193         retval = -ENODEV;   /* ->probe isn't ->ioctl */
1194         goto abort;
1195     }
1196 
1197     /* Retrieve and store the device ID string. */
1198     usblp_cache_device_id_string(usblp);
1199 
1200 #ifdef DEBUG
1201     usblp_check_status(usblp, 0);
1202 #endif
1203 
1204     usb_set_intfdata(intf, usblp);
1205 
1206     usblp->present = 1;
1207 
1208     retval = usb_register_dev(intf, &usblp_class);
1209     if (retval) {
1210         dev_err(&intf->dev,
1211             "usblp: Not able to get a minor (base %u, slice default): %d\n",
1212             USBLP_MINOR_BASE, retval);
1213         goto abort_intfdata;
1214     }
1215     usblp->minor = intf->minor;
1216     dev_info(&intf->dev,
1217         "usblp%d: USB %sdirectional printer dev %d if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X\n",
1218         usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum,
1219         usblp->ifnum,
1220         usblp->protocol[usblp->current_protocol].alt_setting,
1221         usblp->current_protocol,
1222         le16_to_cpu(usblp->dev->descriptor.idVendor),
1223         le16_to_cpu(usblp->dev->descriptor.idProduct));
1224 
1225     return 0;
1226 
1227 abort_intfdata:
1228     usb_set_intfdata(intf, NULL);
1229 abort:
1230     kfree(usblp->readbuf);
1231     kfree(usblp->statusbuf);
1232     kfree(usblp->device_id_string);
1233     usb_put_intf(usblp->intf);
1234     kfree(usblp);
1235 abort_ret:
1236     return retval;
1237 }
1238 
1239 /*
1240  * We are a "new" style driver with usb_device_id table,
1241  * but our requirements are too intricate for simple match to handle.
1242  *
1243  * The "proto_bias" option may be used to specify the preferred protocol
1244  * for all USB printers (1=USB_CLASS_PRINTER/1/1, 2=USB_CLASS_PRINTER/1/2,
1245  * 3=USB_CLASS_PRINTER/1/3).  If the device supports the preferred protocol,
1246  * then we bind to it.
1247  *
1248  * The best interface for us is USB_CLASS_PRINTER/1/2, because it
1249  * is compatible with a stream of characters. If we find it, we bind to it.
1250  *
1251  * Note that the people from hpoj.sourceforge.net need to be able to
1252  * bind to USB_CLASS_PRINTER/1/3 (MLC/1284.4), so we provide them ioctls
1253  * for this purpose.
1254  *
1255  * Failing USB_CLASS_PRINTER/1/2, we look for USB_CLASS_PRINTER/1/3,
1256  * even though it's probably not stream-compatible, because this matches
1257  * the behaviour of the old code.
1258  *
1259  * If nothing else, we bind to USB_CLASS_PRINTER/1/1
1260  * - the unidirectional interface.
1261  */
1262 static int usblp_select_alts(struct usblp *usblp)
1263 {
1264     struct usb_interface *if_alt;
1265     struct usb_host_interface *ifd;
1266     struct usb_endpoint_descriptor *epwrite, *epread;
1267     int p, i;
1268     int res;
1269 
1270     if_alt = usblp->intf;
1271 
1272     for (p = 0; p < USBLP_MAX_PROTOCOLS; p++)
1273         usblp->protocol[p].alt_setting = -1;
1274 
1275     /* Find out what we have. */
1276     for (i = 0; i < if_alt->num_altsetting; i++) {
1277         ifd = &if_alt->altsetting[i];
1278 
1279         if (ifd->desc.bInterfaceClass != USB_CLASS_PRINTER ||
1280             ifd->desc.bInterfaceSubClass != 1)
1281             if (!(usblp->quirks & USBLP_QUIRK_BAD_CLASS))
1282                 continue;
1283 
1284         if (ifd->desc.bInterfaceProtocol < USBLP_FIRST_PROTOCOL ||
1285             ifd->desc.bInterfaceProtocol > USBLP_LAST_PROTOCOL)
1286             continue;
1287 
1288         /* Look for the expected bulk endpoints. */
1289         if (ifd->desc.bInterfaceProtocol > 1) {
1290             res = usb_find_common_endpoints(ifd,
1291                     &epread, &epwrite, NULL, NULL);
1292         } else {
1293             epread = NULL;
1294             res = usb_find_bulk_out_endpoint(ifd, &epwrite);
1295         }
1296 
1297         /* Ignore buggy hardware without the right endpoints. */
1298         if (res)
1299             continue;
1300 
1301         /* Turn off reads for buggy bidirectional printers. */
1302         if (usblp->quirks & USBLP_QUIRK_BIDIR) {
1303             printk(KERN_INFO "usblp%d: Disabling reads from "
1304                 "problematic bidirectional printer\n",
1305                 usblp->minor);
1306             epread = NULL;
1307         }
1308 
1309         usblp->protocol[ifd->desc.bInterfaceProtocol].alt_setting =
1310                 ifd->desc.bAlternateSetting;
1311         usblp->protocol[ifd->desc.bInterfaceProtocol].epwrite = epwrite;
1312         usblp->protocol[ifd->desc.bInterfaceProtocol].epread = epread;
1313     }
1314 
1315     /* If our requested protocol is supported, then use it. */
1316     if (proto_bias >= USBLP_FIRST_PROTOCOL &&
1317         proto_bias <= USBLP_LAST_PROTOCOL &&
1318         usblp->protocol[proto_bias].alt_setting != -1)
1319         return proto_bias;
1320 
1321     /* Ordering is important here. */
1322     if (usblp->protocol[2].alt_setting != -1)
1323         return 2;
1324     if (usblp->protocol[1].alt_setting != -1)
1325         return 1;
1326     if (usblp->protocol[3].alt_setting != -1)
1327         return 3;
1328 
1329     /* If nothing is available, then don't bind to this device. */
1330     return -1;
1331 }
1332 
1333 static int usblp_set_protocol(struct usblp *usblp, int protocol)
1334 {
1335     int r, alts;
1336 
1337     if (protocol < USBLP_FIRST_PROTOCOL || protocol > USBLP_LAST_PROTOCOL)
1338         return -EINVAL;
1339 
1340     /* Don't unnecessarily set the interface if there's a single alt. */
1341     if (usblp->intf->num_altsetting > 1) {
1342         alts = usblp->protocol[protocol].alt_setting;
1343         if (alts < 0)
1344             return -EINVAL;
1345         r = usb_set_interface(usblp->dev, usblp->ifnum, alts);
1346         if (r < 0) {
1347             printk(KERN_ERR "usblp: can't set desired altsetting %d on interface %d\n",
1348                 alts, usblp->ifnum);
1349             return r;
1350         }
1351     }
1352 
1353     usblp->bidir = (usblp->protocol[protocol].epread != NULL);
1354     usblp->current_protocol = protocol;
1355     dev_dbg(&usblp->intf->dev, "usblp%d set protocol %d\n",
1356         usblp->minor, protocol);
1357     return 0;
1358 }
1359 
1360 /* Retrieves and caches device ID string.
1361  * Returns length, including length bytes but not null terminator.
1362  * On error, returns a negative errno value. */
1363 static int usblp_cache_device_id_string(struct usblp *usblp)
1364 {
1365     int err, length;
1366 
1367     err = usblp_get_id(usblp, 0, usblp->device_id_string, USBLP_DEVICE_ID_SIZE - 1);
1368     if (err < 0) {
1369         dev_dbg(&usblp->intf->dev,
1370             "usblp%d: error = %d reading IEEE-1284 Device ID string\n",
1371             usblp->minor, err);
1372         usblp->device_id_string[0] = usblp->device_id_string[1] = '\0';
1373         return -EIO;
1374     }
1375 
1376     /* First two bytes are length in big-endian.
1377      * They count themselves, and we copy them into
1378      * the user's buffer. */
1379     length = be16_to_cpu(*((__be16 *)usblp->device_id_string));
1380     if (length < 2)
1381         length = 2;
1382     else if (length >= USBLP_DEVICE_ID_SIZE)
1383         length = USBLP_DEVICE_ID_SIZE - 1;
1384     usblp->device_id_string[length] = '\0';
1385 
1386     dev_dbg(&usblp->intf->dev, "usblp%d Device ID string [len=%d]=\"%s\"\n",
1387         usblp->minor, length, &usblp->device_id_string[2]);
1388 
1389     return length;
1390 }
1391 
1392 static void usblp_disconnect(struct usb_interface *intf)
1393 {
1394     struct usblp *usblp = usb_get_intfdata(intf);
1395 
1396     usb_deregister_dev(intf, &usblp_class);
1397 
1398     if (!usblp || !usblp->dev) {
1399         dev_err(&intf->dev, "bogus disconnect\n");
1400         BUG();
1401     }
1402 
1403     mutex_lock(&usblp_mutex);
1404     mutex_lock(&usblp->mut);
1405     usblp->present = 0;
1406     wake_up(&usblp->wwait);
1407     wake_up(&usblp->rwait);
1408     usb_set_intfdata(intf, NULL);
1409 
1410     usblp_unlink_urbs(usblp);
1411     mutex_unlock(&usblp->mut);
1412     usb_poison_anchored_urbs(&usblp->urbs);
1413 
1414     if (!usblp->used)
1415         usblp_cleanup(usblp);
1416 
1417     mutex_unlock(&usblp_mutex);
1418 }
1419 
1420 static int usblp_suspend(struct usb_interface *intf, pm_message_t message)
1421 {
1422     struct usblp *usblp = usb_get_intfdata(intf);
1423 
1424     usblp_unlink_urbs(usblp);
1425 #if 0 /* XXX Do we want this? What if someone is reading, should we fail? */
1426     /* not strictly necessary, but just in case */
1427     wake_up(&usblp->wwait);
1428     wake_up(&usblp->rwait);
1429 #endif
1430 
1431     return 0;
1432 }
1433 
1434 static int usblp_resume(struct usb_interface *intf)
1435 {
1436     struct usblp *usblp = usb_get_intfdata(intf);
1437     int r;
1438 
1439     r = handle_bidir(usblp);
1440 
1441     return r;
1442 }
1443 
1444 static const struct usb_device_id usblp_ids[] = {
1445     { USB_DEVICE_INFO(USB_CLASS_PRINTER, 1, 1) },
1446     { USB_DEVICE_INFO(USB_CLASS_PRINTER, 1, 2) },
1447     { USB_DEVICE_INFO(USB_CLASS_PRINTER, 1, 3) },
1448     { USB_INTERFACE_INFO(USB_CLASS_PRINTER, 1, 1) },
1449     { USB_INTERFACE_INFO(USB_CLASS_PRINTER, 1, 2) },
1450     { USB_INTERFACE_INFO(USB_CLASS_PRINTER, 1, 3) },
1451     { USB_DEVICE(0x04b8, 0x0202) }, /* Seiko Epson Receipt Printer M129C */
1452     { }                     /* Terminating entry */
1453 };
1454 
1455 MODULE_DEVICE_TABLE(usb, usblp_ids);
1456 
1457 static struct usb_driver usblp_driver = {
1458     .name =     "usblp",
1459     .probe =    usblp_probe,
1460     .disconnect =   usblp_disconnect,
1461     .suspend =  usblp_suspend,
1462     .resume =   usblp_resume,
1463     .id_table = usblp_ids,
1464     .dev_groups =   usblp_groups,
1465     .supports_autosuspend = 1,
1466 };
1467 
1468 module_usb_driver(usblp_driver);
1469 
1470 MODULE_AUTHOR(DRIVER_AUTHOR);
1471 MODULE_DESCRIPTION(DRIVER_DESC);
1472 module_param(proto_bias, int, S_IRUGO | S_IWUSR);
1473 MODULE_PARM_DESC(proto_bias, "Favourite protocol number");
1474 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!