Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0+
2 : : /*
3 : : * usblp.c
4 : : *
5 : : * Copyright (c) 1999 Michael Gee <michael@linuxspecific.com>
6 : : * Copyright (c) 1999 Pavel Machek <pavel@ucw.cz>
7 : : * Copyright (c) 2000 Randy Dunlap <rdunlap@xenotime.net>
8 : : * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
9 : : # Copyright (c) 2001 Pete Zaitcev <zaitcev@redhat.com>
10 : : # Copyright (c) 2001 David Paschal <paschal@rcsis.com>
11 : : * Copyright (c) 2006 Oliver Neukum <oliver@neukum.name>
12 : : *
13 : : * USB Printer Device Class driver for USB printers and printer cables
14 : : *
15 : : * Sponsored by SuSE
16 : : *
17 : : * ChangeLog:
18 : : * v0.1 - thorough cleaning, URBification, almost a rewrite
19 : : * v0.2 - some more cleanups
20 : : * v0.3 - cleaner again, waitqueue fixes
21 : : * v0.4 - fixes in unidirectional mode
22 : : * v0.5 - add DEVICE_ID string support
23 : : * v0.6 - never time out
24 : : * v0.7 - fixed bulk-IN read and poll (David Paschal)
25 : : * v0.8 - add devfs support
26 : : * v0.9 - fix unplug-while-open paths
27 : : * v0.10- remove sleep_on, fix error on oom (oliver@neukum.org)
28 : : * v0.11 - add proto_bias option (Pete Zaitcev)
29 : : * v0.12 - add hpoj.sourceforge.net ioctls (David Paschal)
30 : : * v0.13 - alloc space for statusbuf (<status> not on stack);
31 : : * use usb_alloc_coherent() for read buf & write buf;
32 : : * none - Maintained in Linux kernel after v0.13
33 : : */
34 : :
35 : : #include <linux/module.h>
36 : : #include <linux/kernel.h>
37 : : #include <linux/sched/signal.h>
38 : : #include <linux/signal.h>
39 : : #include <linux/poll.h>
40 : : #include <linux/slab.h>
41 : : #include <linux/lp.h>
42 : : #include <linux/mutex.h>
43 : : #undef DEBUG
44 : : #include <linux/usb.h>
45 : : #include <linux/usb/ch9.h>
46 : : #include <linux/ratelimit.h>
47 : :
48 : : /*
49 : : * Version Information
50 : : */
51 : : #define DRIVER_AUTHOR "Michael Gee, Pavel Machek, Vojtech Pavlik, Randy Dunlap, Pete Zaitcev, David Paschal"
52 : : #define DRIVER_DESC "USB Printer Device Class driver"
53 : :
54 : : #define USBLP_BUF_SIZE 8192
55 : : #define USBLP_BUF_SIZE_IN 1024
56 : : #define USBLP_DEVICE_ID_SIZE 1024
57 : :
58 : : /* ioctls: */
59 : : #define IOCNR_GET_DEVICE_ID 1
60 : : #define IOCNR_GET_PROTOCOLS 2
61 : : #define IOCNR_SET_PROTOCOL 3
62 : : #define IOCNR_HP_SET_CHANNEL 4
63 : : #define IOCNR_GET_BUS_ADDRESS 5
64 : : #define IOCNR_GET_VID_PID 6
65 : : #define IOCNR_SOFT_RESET 7
66 : : /* Get device_id string: */
67 : : #define LPIOC_GET_DEVICE_ID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_DEVICE_ID, len)
68 : : /* The following ioctls were added for http://hpoj.sourceforge.net:
69 : : * Get two-int array:
70 : : * [0]=current protocol
71 : : * (1=USB_CLASS_PRINTER/1/1, 2=USB_CLASS_PRINTER/1/2,
72 : : * 3=USB_CLASS_PRINTER/1/3),
73 : : * [1]=supported protocol mask (mask&(1<<n)!=0 means
74 : : * USB_CLASS_PRINTER/1/n supported):
75 : : */
76 : : #define LPIOC_GET_PROTOCOLS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_PROTOCOLS, len)
77 : : /*
78 : : * Set protocol
79 : : * (arg: 1=USB_CLASS_PRINTER/1/1, 2=USB_CLASS_PRINTER/1/2,
80 : : * 3=USB_CLASS_PRINTER/1/3):
81 : : */
82 : : #define LPIOC_SET_PROTOCOL _IOC(_IOC_WRITE, 'P', IOCNR_SET_PROTOCOL, 0)
83 : : /* Set channel number (HP Vendor-specific command): */
84 : : #define LPIOC_HP_SET_CHANNEL _IOC(_IOC_WRITE, 'P', IOCNR_HP_SET_CHANNEL, 0)
85 : : /* Get two-int array: [0]=bus number, [1]=device address: */
86 : : #define LPIOC_GET_BUS_ADDRESS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_BUS_ADDRESS, len)
87 : : /* Get two-int array: [0]=vendor ID, [1]=product ID: */
88 : : #define LPIOC_GET_VID_PID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_VID_PID, len)
89 : : /* Perform class specific soft reset */
90 : : #define LPIOC_SOFT_RESET _IOC(_IOC_NONE, 'P', IOCNR_SOFT_RESET, 0);
91 : :
92 : : /*
93 : : * A DEVICE_ID string may include the printer's serial number.
94 : : * It should end with a semi-colon (';').
95 : : * An example from an HP 970C DeskJet printer is (this is one long string,
96 : : * with the serial number changed):
97 : : 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: ;
98 : : */
99 : :
100 : : /*
101 : : * USB Printer Requests
102 : : */
103 : :
104 : : #define USBLP_REQ_GET_ID 0x00
105 : : #define USBLP_REQ_GET_STATUS 0x01
106 : : #define USBLP_REQ_RESET 0x02
107 : : #define USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST 0x00 /* HP Vendor-specific */
108 : :
109 : : #define USBLP_MINORS 16
110 : : #define USBLP_MINOR_BASE 0
111 : :
112 : : #define USBLP_CTL_TIMEOUT 5000 /* 5 seconds */
113 : :
114 : : #define USBLP_FIRST_PROTOCOL 1
115 : : #define USBLP_LAST_PROTOCOL 3
116 : : #define USBLP_MAX_PROTOCOLS (USBLP_LAST_PROTOCOL+1)
117 : :
118 : : /*
119 : : * some arbitrary status buffer size;
120 : : * need a status buffer that is allocated via kmalloc(), not on stack
121 : : */
122 : : #define STATUS_BUF_SIZE 8
123 : :
124 : : /*
125 : : * Locks down the locking order:
126 : : * ->wmut locks wstatus.
127 : : * ->mut locks the whole usblp, except [rw]complete, and thus, by indirection,
128 : : * [rw]status. We only touch status when we know the side idle.
129 : : * ->lock locks what interrupt accesses.
130 : : */
131 : : struct usblp {
132 : : struct usb_device *dev; /* USB device */
133 : : struct mutex wmut;
134 : : struct mutex mut;
135 : : spinlock_t lock; /* locks rcomplete, wcomplete */
136 : : char *readbuf; /* read transfer_buffer */
137 : : char *statusbuf; /* status transfer_buffer */
138 : : struct usb_anchor urbs;
139 : : wait_queue_head_t rwait, wwait;
140 : : int readcount; /* Counter for reads */
141 : : int ifnum; /* Interface number */
142 : : struct usb_interface *intf; /* The interface */
143 : : /*
144 : : * Alternate-setting numbers and endpoints for each protocol
145 : : * (USB_CLASS_PRINTER/1/{index=1,2,3}) that the device supports:
146 : : */
147 : : struct {
148 : : int alt_setting;
149 : : struct usb_endpoint_descriptor *epwrite;
150 : : struct usb_endpoint_descriptor *epread;
151 : : } protocol[USBLP_MAX_PROTOCOLS];
152 : : int current_protocol;
153 : : int minor; /* minor number of device */
154 : : int wcomplete, rcomplete;
155 : : int wstatus; /* bytes written or error */
156 : : int rstatus; /* bytes ready or error */
157 : : unsigned int quirks; /* quirks flags */
158 : : unsigned int flags; /* mode flags */
159 : : unsigned char used; /* True if open */
160 : : unsigned char present; /* True if not disconnected */
161 : : unsigned char bidir; /* interface is bidirectional */
162 : : unsigned char no_paper; /* Paper Out happened */
163 : : unsigned char *device_id_string; /* IEEE 1284 DEVICE ID string (ptr) */
164 : : /* first 2 bytes are (big-endian) length */
165 : : };
166 : :
167 : : #ifdef DEBUG
168 : : static void usblp_dump(struct usblp *usblp)
169 : : {
170 : : struct device *dev = &usblp->intf->dev;
171 : : int p;
172 : :
173 : : dev_dbg(dev, "usblp=0x%p\n", usblp);
174 : : dev_dbg(dev, "dev=0x%p\n", usblp->dev);
175 : : dev_dbg(dev, "present=%d\n", usblp->present);
176 : : dev_dbg(dev, "readbuf=0x%p\n", usblp->readbuf);
177 : : dev_dbg(dev, "readcount=%d\n", usblp->readcount);
178 : : dev_dbg(dev, "ifnum=%d\n", usblp->ifnum);
179 : : for (p = USBLP_FIRST_PROTOCOL; p <= USBLP_LAST_PROTOCOL; p++) {
180 : : dev_dbg(dev, "protocol[%d].alt_setting=%d\n", p,
181 : : usblp->protocol[p].alt_setting);
182 : : dev_dbg(dev, "protocol[%d].epwrite=%p\n", p,
183 : : usblp->protocol[p].epwrite);
184 : : dev_dbg(dev, "protocol[%d].epread=%p\n", p,
185 : : usblp->protocol[p].epread);
186 : : }
187 : : dev_dbg(dev, "current_protocol=%d\n", usblp->current_protocol);
188 : : dev_dbg(dev, "minor=%d\n", usblp->minor);
189 : : dev_dbg(dev, "wstatus=%d\n", usblp->wstatus);
190 : : dev_dbg(dev, "rstatus=%d\n", usblp->rstatus);
191 : : dev_dbg(dev, "quirks=%d\n", usblp->quirks);
192 : : dev_dbg(dev, "used=%d\n", usblp->used);
193 : : dev_dbg(dev, "bidir=%d\n", usblp->bidir);
194 : : dev_dbg(dev, "device_id_string=\"%s\"\n",
195 : : usblp->device_id_string ?
196 : : usblp->device_id_string + 2 :
197 : : (unsigned char *)"(null)");
198 : : }
199 : : #endif
200 : :
201 : : /* Quirks: various printer quirks are handled by this table & its flags. */
202 : :
203 : : struct quirk_printer_struct {
204 : : __u16 vendorId;
205 : : __u16 productId;
206 : : unsigned int quirks;
207 : : };
208 : :
209 : : #define USBLP_QUIRK_BIDIR 0x1 /* reports bidir but requires unidirectional mode (no INs/reads) */
210 : : #define USBLP_QUIRK_USB_INIT 0x2 /* needs vendor USB init string */
211 : : #define USBLP_QUIRK_BAD_CLASS 0x4 /* descriptor uses vendor-specific Class or SubClass */
212 : :
213 : : static const struct quirk_printer_struct quirk_printers[] = {
214 : : { 0x03f0, 0x0004, USBLP_QUIRK_BIDIR }, /* HP DeskJet 895C */
215 : : { 0x03f0, 0x0104, USBLP_QUIRK_BIDIR }, /* HP DeskJet 880C */
216 : : { 0x03f0, 0x0204, USBLP_QUIRK_BIDIR }, /* HP DeskJet 815C */
217 : : { 0x03f0, 0x0304, USBLP_QUIRK_BIDIR }, /* HP DeskJet 810C/812C */
218 : : { 0x03f0, 0x0404, USBLP_QUIRK_BIDIR }, /* HP DeskJet 830C */
219 : : { 0x03f0, 0x0504, USBLP_QUIRK_BIDIR }, /* HP DeskJet 885C */
220 : : { 0x03f0, 0x0604, USBLP_QUIRK_BIDIR }, /* HP DeskJet 840C */
221 : : { 0x03f0, 0x0804, USBLP_QUIRK_BIDIR }, /* HP DeskJet 816C */
222 : : { 0x03f0, 0x1104, USBLP_QUIRK_BIDIR }, /* HP Deskjet 959C */
223 : : { 0x0409, 0xefbe, USBLP_QUIRK_BIDIR }, /* NEC Picty900 (HP OEM) */
224 : : { 0x0409, 0xbef4, USBLP_QUIRK_BIDIR }, /* NEC Picty760 (HP OEM) */
225 : : { 0x0409, 0xf0be, USBLP_QUIRK_BIDIR }, /* NEC Picty920 (HP OEM) */
226 : : { 0x0409, 0xf1be, USBLP_QUIRK_BIDIR }, /* NEC Picty800 (HP OEM) */
227 : : { 0x0482, 0x0010, USBLP_QUIRK_BIDIR }, /* Kyocera Mita FS 820, by zut <kernel@zut.de> */
228 : : { 0x04f9, 0x000d, USBLP_QUIRK_BIDIR }, /* Brother Industries, Ltd HL-1440 Laser Printer */
229 : : { 0x04b8, 0x0202, USBLP_QUIRK_BAD_CLASS }, /* Seiko Epson Receipt Printer M129C */
230 : : { 0, 0 }
231 : : };
232 : :
233 : : static int usblp_wwait(struct usblp *usblp, int nonblock);
234 : : static int usblp_wtest(struct usblp *usblp, int nonblock);
235 : : static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock);
236 : : static int usblp_rtest(struct usblp *usblp, int nonblock);
237 : : static int usblp_submit_read(struct usblp *usblp);
238 : : static int usblp_select_alts(struct usblp *usblp);
239 : : static int usblp_set_protocol(struct usblp *usblp, int protocol);
240 : : static int usblp_cache_device_id_string(struct usblp *usblp);
241 : :
242 : : /* forward reference to make our lives easier */
243 : : static struct usb_driver usblp_driver;
244 : : static DEFINE_MUTEX(usblp_mutex); /* locks the existence of usblp's */
245 : :
246 : : /*
247 : : * Functions for usblp control messages.
248 : : */
249 : :
250 : 0 : static int usblp_ctrl_msg(struct usblp *usblp, int request, int type, int dir, int recip, int value, void *buf, int len)
251 : : {
252 : 0 : int retval;
253 : 0 : int index = usblp->ifnum;
254 : :
255 : : /* High byte has the interface index.
256 : : Low byte has the alternate setting.
257 : : */
258 [ # # ]: 0 : if ((request == USBLP_REQ_GET_ID) && (type == USB_TYPE_CLASS))
259 : 0 : index = (usblp->ifnum<<8)|usblp->protocol[usblp->current_protocol].alt_setting;
260 : :
261 : 0 : retval = usb_control_msg(usblp->dev,
262 : 0 : dir ? usb_rcvctrlpipe(usblp->dev, 0) : usb_sndctrlpipe(usblp->dev, 0),
263 [ # # ]: 0 : request, type | dir | recip, value, index, buf, len, USBLP_CTL_TIMEOUT);
264 : 0 : dev_dbg(&usblp->intf->dev,
265 : : "usblp_control_msg: rq: 0x%02x dir: %d recip: %d value: %d idx: %d len: %#x result: %d\n",
266 : : request, !!dir, recip, value, index, len, retval);
267 : 0 : return retval < 0 ? retval : 0;
268 : : }
269 : :
270 : : #define usblp_read_status(usblp, status)\
271 : : usblp_ctrl_msg(usblp, USBLP_REQ_GET_STATUS, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, 0, status, 1)
272 : : #define usblp_get_id(usblp, config, id, maxlen)\
273 : : usblp_ctrl_msg(usblp, USBLP_REQ_GET_ID, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, config, id, maxlen)
274 : : #define usblp_reset(usblp)\
275 : : usblp_ctrl_msg(usblp, USBLP_REQ_RESET, USB_TYPE_CLASS, USB_DIR_OUT, USB_RECIP_OTHER, 0, NULL, 0)
276 : :
277 : : #define usblp_hp_channel_change_request(usblp, channel, buffer) \
278 : : usblp_ctrl_msg(usblp, USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST, USB_TYPE_VENDOR, USB_DIR_IN, USB_RECIP_INTERFACE, channel, buffer, 1)
279 : :
280 : : /*
281 : : * See the description for usblp_select_alts() below for the usage
282 : : * explanation. Look into your /sys/kernel/debug/usb/devices and dmesg in
283 : : * case of any trouble.
284 : : */
285 : : static int proto_bias = -1;
286 : :
287 : : /*
288 : : * URB callback.
289 : : */
290 : :
291 : 0 : static void usblp_bulk_read(struct urb *urb)
292 : : {
293 : 0 : struct usblp *usblp = urb->context;
294 : 0 : int status = urb->status;
295 : 0 : unsigned long flags;
296 : :
297 [ # # # # ]: 0 : if (usblp->present && usblp->used) {
298 [ # # ]: 0 : if (status)
299 : 0 : printk(KERN_WARNING "usblp%d: "
300 : : "nonzero read bulk status received: %d\n",
301 : : usblp->minor, status);
302 : : }
303 : 0 : spin_lock_irqsave(&usblp->lock, flags);
304 [ # # ]: 0 : if (status < 0)
305 : 0 : usblp->rstatus = status;
306 : : else
307 : 0 : usblp->rstatus = urb->actual_length;
308 : 0 : usblp->rcomplete = 1;
309 : 0 : wake_up(&usblp->rwait);
310 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
311 : :
312 : 0 : usb_free_urb(urb);
313 : 0 : }
314 : :
315 : 0 : static void usblp_bulk_write(struct urb *urb)
316 : : {
317 : 0 : struct usblp *usblp = urb->context;
318 : 0 : int status = urb->status;
319 : 0 : unsigned long flags;
320 : :
321 [ # # # # ]: 0 : if (usblp->present && usblp->used) {
322 [ # # ]: 0 : if (status)
323 : 0 : printk(KERN_WARNING "usblp%d: "
324 : : "nonzero write bulk status received: %d\n",
325 : : usblp->minor, status);
326 : : }
327 : 0 : spin_lock_irqsave(&usblp->lock, flags);
328 [ # # ]: 0 : if (status < 0)
329 : 0 : usblp->wstatus = status;
330 : : else
331 : 0 : usblp->wstatus = urb->actual_length;
332 : 0 : usblp->no_paper = 0;
333 : 0 : usblp->wcomplete = 1;
334 : 0 : wake_up(&usblp->wwait);
335 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
336 : :
337 : 0 : usb_free_urb(urb);
338 : 0 : }
339 : :
340 : : /*
341 : : * Get and print printer errors.
342 : : */
343 : :
344 : : static const char *usblp_messages[] = { "ok", "out of paper", "off-line", "on fire" };
345 : :
346 : 0 : static int usblp_check_status(struct usblp *usblp, int err)
347 : : {
348 : 0 : unsigned char status, newerr = 0;
349 : 0 : int error;
350 : :
351 : 0 : mutex_lock(&usblp->mut);
352 [ # # ]: 0 : if ((error = usblp_read_status(usblp, usblp->statusbuf)) < 0) {
353 : 0 : mutex_unlock(&usblp->mut);
354 [ # # ]: 0 : printk_ratelimited(KERN_ERR
355 : : "usblp%d: error %d reading printer status\n",
356 : : usblp->minor, error);
357 : 0 : return 0;
358 : : }
359 : 0 : status = *usblp->statusbuf;
360 : 0 : mutex_unlock(&usblp->mut);
361 : :
362 [ # # ]: 0 : if (~status & LP_PERRORP)
363 : 0 : newerr = 3;
364 [ # # ]: 0 : if (status & LP_POUTPA)
365 : 0 : newerr = 1;
366 [ # # ]: 0 : if (~status & LP_PSELECD)
367 : 0 : newerr = 2;
368 : :
369 [ # # ]: 0 : if (newerr != err) {
370 : 0 : printk(KERN_INFO "usblp%d: %s\n",
371 : : usblp->minor, usblp_messages[newerr]);
372 : : }
373 : :
374 : : return newerr;
375 : : }
376 : :
377 : 0 : static int handle_bidir(struct usblp *usblp)
378 : : {
379 [ # # # # ]: 0 : if (usblp->bidir && usblp->used) {
380 [ # # # # ]: 0 : if (usblp_submit_read(usblp) < 0)
381 : 0 : return -EIO;
382 : : }
383 : : return 0;
384 : : }
385 : :
386 : : /*
387 : : * File op functions.
388 : : */
389 : :
390 : 0 : static int usblp_open(struct inode *inode, struct file *file)
391 : : {
392 : 0 : int minor = iminor(inode);
393 : 0 : struct usblp *usblp;
394 : 0 : struct usb_interface *intf;
395 : 0 : int retval;
396 : :
397 : 0 : if (minor < 0)
398 : : return -ENODEV;
399 : :
400 : 0 : mutex_lock(&usblp_mutex);
401 : :
402 : 0 : retval = -ENODEV;
403 : 0 : intf = usb_find_interface(&usblp_driver, minor);
404 [ # # ]: 0 : if (!intf)
405 : 0 : goto out;
406 [ # # ]: 0 : usblp = usb_get_intfdata(intf);
407 [ # # # # : 0 : if (!usblp || !usblp->dev || !usblp->present)
# # ]
408 : 0 : goto out;
409 : :
410 : 0 : retval = -EBUSY;
411 [ # # ]: 0 : if (usblp->used)
412 : 0 : goto out;
413 : :
414 : : /*
415 : : * We do not implement LP_ABORTOPEN/LPABORTOPEN for two reasons:
416 : : * - We do not want persistent state which close(2) does not clear
417 : : * - It is not used anyway, according to CUPS people
418 : : */
419 : :
420 : 0 : retval = usb_autopm_get_interface(intf);
421 [ # # ]: 0 : if (retval < 0)
422 : 0 : goto out;
423 : 0 : usblp->used = 1;
424 : 0 : file->private_data = usblp;
425 : :
426 : 0 : usblp->wcomplete = 1; /* we begin writeable */
427 : 0 : usblp->wstatus = 0;
428 : 0 : usblp->rcomplete = 0;
429 : :
430 [ # # ]: 0 : if (handle_bidir(usblp) < 0) {
431 : 0 : usb_autopm_put_interface(intf);
432 : 0 : usblp->used = 0;
433 : 0 : file->private_data = NULL;
434 : 0 : retval = -EIO;
435 : : }
436 : 0 : out:
437 : 0 : mutex_unlock(&usblp_mutex);
438 : 0 : return retval;
439 : : }
440 : :
441 : 0 : static void usblp_cleanup(struct usblp *usblp)
442 : : {
443 : 0 : printk(KERN_INFO "usblp%d: removed\n", usblp->minor);
444 : :
445 : 0 : kfree(usblp->readbuf);
446 : 0 : kfree(usblp->device_id_string);
447 : 0 : kfree(usblp->statusbuf);
448 : 0 : usb_put_intf(usblp->intf);
449 : 0 : kfree(usblp);
450 : 0 : }
451 : :
452 : 0 : static void usblp_unlink_urbs(struct usblp *usblp)
453 : : {
454 : 0 : usb_kill_anchored_urbs(&usblp->urbs);
455 : 0 : }
456 : :
457 : 0 : static int usblp_release(struct inode *inode, struct file *file)
458 : : {
459 : 0 : struct usblp *usblp = file->private_data;
460 : :
461 : 0 : usblp->flags &= ~LP_ABORT;
462 : :
463 : 0 : mutex_lock(&usblp_mutex);
464 : 0 : usblp->used = 0;
465 [ # # ]: 0 : if (usblp->present)
466 : 0 : usblp_unlink_urbs(usblp);
467 : :
468 : 0 : usb_autopm_put_interface(usblp->intf);
469 : :
470 [ # # ]: 0 : if (!usblp->present) /* finish cleanup from disconnect */
471 : 0 : usblp_cleanup(usblp);
472 : 0 : mutex_unlock(&usblp_mutex);
473 : 0 : return 0;
474 : : }
475 : :
476 : : /* No kernel lock - fine */
477 : 0 : static __poll_t usblp_poll(struct file *file, struct poll_table_struct *wait)
478 : : {
479 : 0 : __poll_t ret;
480 : 0 : unsigned long flags;
481 : :
482 : 0 : struct usblp *usblp = file->private_data;
483 : : /* Should we check file->f_mode & FMODE_WRITE before poll_wait()? */
484 [ # # ]: 0 : poll_wait(file, &usblp->rwait, wait);
485 [ # # ]: 0 : poll_wait(file, &usblp->wwait, wait);
486 : 0 : spin_lock_irqsave(&usblp->lock, flags);
487 [ # # # # ]: 0 : ret = ((usblp->bidir && usblp->rcomplete) ? EPOLLIN | EPOLLRDNORM : 0) |
488 [ # # # # ]: 0 : ((usblp->no_paper || usblp->wcomplete) ? EPOLLOUT | EPOLLWRNORM : 0);
489 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
490 : 0 : return ret;
491 : : }
492 : :
493 : 0 : static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
494 : : {
495 : 0 : struct usblp *usblp = file->private_data;
496 : 0 : int length, err, i;
497 : 0 : unsigned char newChannel;
498 : 0 : int status;
499 : 0 : int twoints[2];
500 : 0 : int retval = 0;
501 : :
502 : 0 : mutex_lock(&usblp->mut);
503 [ # # ]: 0 : if (!usblp->present) {
504 : 0 : retval = -ENODEV;
505 : 0 : goto done;
506 : : }
507 : :
508 : 0 : dev_dbg(&usblp->intf->dev,
509 : : "usblp_ioctl: cmd=0x%x (%c nr=%d len=%d dir=%d)\n", cmd,
510 : : _IOC_TYPE(cmd), _IOC_NR(cmd), _IOC_SIZE(cmd), _IOC_DIR(cmd));
511 : :
512 [ # # ]: 0 : if (_IOC_TYPE(cmd) == 'P') /* new-style ioctl number */
513 : :
514 [ # # # # : 0 : switch (_IOC_NR(cmd)) {
# # # # ]
515 : :
516 : 0 : case IOCNR_GET_DEVICE_ID: /* get the DEVICE_ID string */
517 [ # # ]: 0 : if (_IOC_DIR(cmd) != _IOC_READ) {
518 : 0 : retval = -EINVAL;
519 : 0 : goto done;
520 : : }
521 : :
522 : 0 : length = usblp_cache_device_id_string(usblp);
523 [ # # ]: 0 : if (length < 0) {
524 : 0 : retval = length;
525 : 0 : goto done;
526 : : }
527 [ # # ]: 0 : if (length > _IOC_SIZE(cmd))
528 : 0 : length = _IOC_SIZE(cmd); /* truncate */
529 : :
530 [ # # ]: 0 : if (copy_to_user((void __user *) arg,
531 [ # # ]: 0 : usblp->device_id_string,
532 : : (unsigned long) length)) {
533 : 0 : retval = -EFAULT;
534 : 0 : goto done;
535 : : }
536 : :
537 : : break;
538 : :
539 : 0 : case IOCNR_GET_PROTOCOLS:
540 [ # # ]: 0 : if (_IOC_DIR(cmd) != _IOC_READ ||
541 [ # # ]: 0 : _IOC_SIZE(cmd) < sizeof(twoints)) {
542 : 0 : retval = -EINVAL;
543 : 0 : goto done;
544 : : }
545 : :
546 : 0 : twoints[0] = usblp->current_protocol;
547 : 0 : twoints[1] = 0;
548 : 0 : for (i = USBLP_FIRST_PROTOCOL;
549 [ # # ]: 0 : i <= USBLP_LAST_PROTOCOL; i++) {
550 [ # # ]: 0 : if (usblp->protocol[i].alt_setting >= 0)
551 : 0 : twoints[1] |= (1<<i);
552 : : }
553 : :
554 [ # # ]: 0 : if (copy_to_user((void __user *)arg,
555 : : (unsigned char *)twoints,
556 : : sizeof(twoints))) {
557 : 0 : retval = -EFAULT;
558 : 0 : goto done;
559 : : }
560 : :
561 : : break;
562 : :
563 : 0 : case IOCNR_SET_PROTOCOL:
564 [ # # ]: 0 : if (_IOC_DIR(cmd) != _IOC_WRITE) {
565 : 0 : retval = -EINVAL;
566 : 0 : goto done;
567 : : }
568 : :
569 : : #ifdef DEBUG
570 : : if (arg == -10) {
571 : : usblp_dump(usblp);
572 : : break;
573 : : }
574 : : #endif
575 : :
576 : 0 : usblp_unlink_urbs(usblp);
577 : 0 : retval = usblp_set_protocol(usblp, arg);
578 [ # # ]: 0 : if (retval < 0) {
579 : 0 : usblp_set_protocol(usblp,
580 : : usblp->current_protocol);
581 : : }
582 : : break;
583 : :
584 : 0 : case IOCNR_HP_SET_CHANNEL:
585 [ # # ]: 0 : if (_IOC_DIR(cmd) != _IOC_WRITE ||
586 [ # # ]: 0 : le16_to_cpu(usblp->dev->descriptor.idVendor) != 0x03F0 ||
587 [ # # ]: 0 : usblp->quirks & USBLP_QUIRK_BIDIR) {
588 : 0 : retval = -EINVAL;
589 : 0 : goto done;
590 : : }
591 : :
592 : 0 : err = usblp_hp_channel_change_request(usblp,
593 : : arg, &newChannel);
594 [ # # ]: 0 : if (err < 0) {
595 : 0 : dev_err(&usblp->dev->dev,
596 : : "usblp%d: error = %d setting "
597 : : "HP channel\n",
598 : : usblp->minor, err);
599 : 0 : retval = -EIO;
600 : 0 : goto done;
601 : : }
602 : :
603 : : dev_dbg(&usblp->intf->dev,
604 : : "usblp%d requested/got HP channel %ld/%d\n",
605 : : usblp->minor, arg, newChannel);
606 : : break;
607 : :
608 : 0 : case IOCNR_GET_BUS_ADDRESS:
609 [ # # ]: 0 : if (_IOC_DIR(cmd) != _IOC_READ ||
610 [ # # ]: 0 : _IOC_SIZE(cmd) < sizeof(twoints)) {
611 : 0 : retval = -EINVAL;
612 : 0 : goto done;
613 : : }
614 : :
615 : 0 : twoints[0] = usblp->dev->bus->busnum;
616 : 0 : twoints[1] = usblp->dev->devnum;
617 [ # # ]: 0 : if (copy_to_user((void __user *)arg,
618 : : (unsigned char *)twoints,
619 : : sizeof(twoints))) {
620 : 0 : retval = -EFAULT;
621 : 0 : goto done;
622 : : }
623 : :
624 : : dev_dbg(&usblp->intf->dev,
625 : : "usblp%d is bus=%d, device=%d\n",
626 : : usblp->minor, twoints[0], twoints[1]);
627 : : break;
628 : :
629 : 0 : case IOCNR_GET_VID_PID:
630 [ # # ]: 0 : if (_IOC_DIR(cmd) != _IOC_READ ||
631 [ # # ]: 0 : _IOC_SIZE(cmd) < sizeof(twoints)) {
632 : 0 : retval = -EINVAL;
633 : 0 : goto done;
634 : : }
635 : :
636 : 0 : twoints[0] = le16_to_cpu(usblp->dev->descriptor.idVendor);
637 : 0 : twoints[1] = le16_to_cpu(usblp->dev->descriptor.idProduct);
638 [ # # ]: 0 : if (copy_to_user((void __user *)arg,
639 : : (unsigned char *)twoints,
640 : : sizeof(twoints))) {
641 : 0 : retval = -EFAULT;
642 : 0 : goto done;
643 : : }
644 : :
645 : : dev_dbg(&usblp->intf->dev,
646 : : "usblp%d is VID=0x%4.4X, PID=0x%4.4X\n",
647 : : usblp->minor, twoints[0], twoints[1]);
648 : : break;
649 : :
650 : 0 : case IOCNR_SOFT_RESET:
651 [ # # ]: 0 : if (_IOC_DIR(cmd) != _IOC_NONE) {
652 : 0 : retval = -EINVAL;
653 : 0 : goto done;
654 : : }
655 : 0 : retval = usblp_reset(usblp);
656 : 0 : break;
657 : : default:
658 : : retval = -ENOTTY;
659 : : }
660 : : else /* old-style ioctl value */
661 [ # # # ]: 0 : switch (cmd) {
662 : :
663 : 0 : case LPGETSTATUS:
664 : 0 : retval = usblp_read_status(usblp, usblp->statusbuf);
665 [ # # ]: 0 : if (retval) {
666 [ # # ]: 0 : printk_ratelimited(KERN_ERR "usblp%d:"
667 : : "failed reading printer status (%d)\n",
668 : : usblp->minor, retval);
669 : 0 : retval = -EIO;
670 : 0 : goto done;
671 : : }
672 : 0 : status = *usblp->statusbuf;
673 [ # # ]: 0 : if (copy_to_user((void __user *)arg, &status, sizeof(int)))
674 : 0 : retval = -EFAULT;
675 : : break;
676 : :
677 : 0 : case LPABORT:
678 [ # # ]: 0 : if (arg)
679 : 0 : usblp->flags |= LP_ABORT;
680 : : else
681 : 0 : usblp->flags &= ~LP_ABORT;
682 : : break;
683 : :
684 : : default:
685 : : retval = -ENOTTY;
686 : : }
687 : :
688 : 0 : done:
689 : 0 : mutex_unlock(&usblp->mut);
690 : 0 : return retval;
691 : : }
692 : :
693 : 0 : static struct urb *usblp_new_writeurb(struct usblp *usblp, int transfer_length)
694 : : {
695 : 0 : struct urb *urb;
696 : 0 : char *writebuf;
697 : :
698 [ # # ]: 0 : writebuf = kmalloc(transfer_length, GFP_KERNEL);
699 [ # # ]: 0 : if (writebuf == NULL)
700 : : return NULL;
701 : 0 : urb = usb_alloc_urb(0, GFP_KERNEL);
702 [ # # ]: 0 : if (urb == NULL) {
703 : 0 : kfree(writebuf);
704 : 0 : return NULL;
705 : : }
706 : :
707 : 0 : usb_fill_bulk_urb(urb, usblp->dev,
708 : 0 : usb_sndbulkpipe(usblp->dev,
709 : : usblp->protocol[usblp->current_protocol].epwrite->bEndpointAddress),
710 : : writebuf, transfer_length, usblp_bulk_write, usblp);
711 : 0 : urb->transfer_flags |= URB_FREE_BUFFER;
712 : :
713 : 0 : return urb;
714 : : }
715 : :
716 : 0 : static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
717 : : {
718 : 0 : struct usblp *usblp = file->private_data;
719 : 0 : struct urb *writeurb;
720 : 0 : int rv;
721 : 0 : int transfer_length;
722 : 0 : ssize_t writecount = 0;
723 : :
724 [ # # ]: 0 : if (mutex_lock_interruptible(&usblp->wmut)) {
725 : 0 : rv = -EINTR;
726 : 0 : goto raise_biglock;
727 : : }
728 [ # # ]: 0 : if ((rv = usblp_wwait(usblp, !!(file->f_flags & O_NONBLOCK))) < 0)
729 : 0 : goto raise_wait;
730 : :
731 [ # # ]: 0 : while (writecount < count) {
732 : : /*
733 : : * Step 1: Submit next block.
734 : : */
735 : 0 : if ((transfer_length = count - writecount) > USBLP_BUF_SIZE)
736 : : transfer_length = USBLP_BUF_SIZE;
737 : :
738 : 0 : rv = -ENOMEM;
739 : 0 : writeurb = usblp_new_writeurb(usblp, transfer_length);
740 [ # # ]: 0 : if (writeurb == NULL)
741 : 0 : goto raise_urb;
742 : 0 : usb_anchor_urb(writeurb, &usblp->urbs);
743 : :
744 [ # # ]: 0 : if (copy_from_user(writeurb->transfer_buffer,
745 [ # # ]: 0 : buffer + writecount, transfer_length)) {
746 : 0 : rv = -EFAULT;
747 : 0 : goto raise_badaddr;
748 : : }
749 : :
750 : 0 : spin_lock_irq(&usblp->lock);
751 : 0 : usblp->wcomplete = 0;
752 : 0 : spin_unlock_irq(&usblp->lock);
753 [ # # ]: 0 : if ((rv = usb_submit_urb(writeurb, GFP_KERNEL)) < 0) {
754 : 0 : usblp->wstatus = 0;
755 : 0 : spin_lock_irq(&usblp->lock);
756 : 0 : usblp->no_paper = 0;
757 : 0 : usblp->wcomplete = 1;
758 : 0 : wake_up(&usblp->wwait);
759 : 0 : spin_unlock_irq(&usblp->lock);
760 [ # # ]: 0 : if (rv != -ENOMEM)
761 : 0 : rv = -EIO;
762 : 0 : goto raise_submit;
763 : : }
764 : :
765 : : /*
766 : : * Step 2: Wait for transfer to end, collect results.
767 : : */
768 : 0 : rv = usblp_wwait(usblp, !!(file->f_flags&O_NONBLOCK));
769 [ # # ]: 0 : if (rv < 0) {
770 [ # # ]: 0 : if (rv == -EAGAIN) {
771 : : /* Presume that it's going to complete well. */
772 : 0 : writecount += transfer_length;
773 : : }
774 [ # # ]: 0 : if (rv == -ENOSPC) {
775 : 0 : spin_lock_irq(&usblp->lock);
776 : 0 : usblp->no_paper = 1; /* Mark for poll(2) */
777 : 0 : spin_unlock_irq(&usblp->lock);
778 : 0 : writecount += transfer_length;
779 : : }
780 : : /* Leave URB dangling, to be cleaned on close. */
781 : 0 : goto collect_error;
782 : : }
783 : :
784 [ # # ]: 0 : if (usblp->wstatus < 0) {
785 : 0 : rv = -EIO;
786 : 0 : goto collect_error;
787 : : }
788 : : /*
789 : : * This is critical: it must be our URB, not other writer's.
790 : : * The wmut exists mainly to cover us here.
791 : : */
792 : 0 : writecount += usblp->wstatus;
793 : : }
794 : :
795 : 0 : mutex_unlock(&usblp->wmut);
796 : 0 : return writecount;
797 : :
798 : 0 : raise_submit:
799 : 0 : raise_badaddr:
800 : 0 : usb_unanchor_urb(writeurb);
801 : 0 : usb_free_urb(writeurb);
802 : 0 : raise_urb:
803 : 0 : raise_wait:
804 : 0 : collect_error: /* Out of raise sequence */
805 : 0 : mutex_unlock(&usblp->wmut);
806 : : raise_biglock:
807 [ # # ]: 0 : return writecount ? writecount : rv;
808 : : }
809 : :
810 : : /*
811 : : * Notice that we fail to restart in a few cases: on EFAULT, on restart
812 : : * error, etc. This is the historical behaviour. In all such cases we return
813 : : * EIO, and applications loop in order to get the new read going.
814 : : */
815 : 0 : static ssize_t usblp_read(struct file *file, char __user *buffer, size_t len, loff_t *ppos)
816 : : {
817 : 0 : struct usblp *usblp = file->private_data;
818 : 0 : ssize_t count;
819 : 0 : ssize_t avail;
820 : 0 : int rv;
821 : :
822 [ # # ]: 0 : if (!usblp->bidir)
823 : : return -EINVAL;
824 : :
825 : 0 : rv = usblp_rwait_and_lock(usblp, !!(file->f_flags & O_NONBLOCK));
826 [ # # ]: 0 : if (rv < 0)
827 : 0 : return rv;
828 : :
829 [ # # ]: 0 : if ((avail = usblp->rstatus) < 0) {
830 : 0 : printk(KERN_ERR "usblp%d: error %d reading from printer\n",
831 : : usblp->minor, (int)avail);
832 : 0 : usblp_submit_read(usblp);
833 : 0 : count = -EIO;
834 : 0 : goto done;
835 : : }
836 : :
837 : 0 : count = len < avail - usblp->readcount ? len : avail - usblp->readcount;
838 [ # # # # ]: 0 : if (count != 0 &&
839 [ # # ]: 0 : copy_to_user(buffer, usblp->readbuf + usblp->readcount, count)) {
840 : 0 : count = -EFAULT;
841 : 0 : goto done;
842 : : }
843 : :
844 [ # # ]: 0 : if ((usblp->readcount += count) == avail) {
845 [ # # ]: 0 : if (usblp_submit_read(usblp) < 0) {
846 : : /* We don't want to leak USB return codes into errno. */
847 [ # # ]: 0 : if (count == 0)
848 : 0 : count = -EIO;
849 : 0 : goto done;
850 : : }
851 : : }
852 : :
853 : 0 : done:
854 : 0 : mutex_unlock(&usblp->mut);
855 : 0 : return count;
856 : : }
857 : :
858 : : /*
859 : : * Wait for the write path to come idle.
860 : : * This is called under the ->wmut, so the idle path stays idle.
861 : : *
862 : : * Our write path has a peculiar property: it does not buffer like a tty,
863 : : * but waits for the write to succeed. This allows our ->release to bug out
864 : : * without waiting for writes to drain. But it obviously does not work
865 : : * when O_NONBLOCK is set. So, applications setting O_NONBLOCK must use
866 : : * select(2) or poll(2) to wait for the buffer to drain before closing.
867 : : * Alternatively, set blocking mode with fcntl and issue a zero-size write.
868 : : */
869 : 0 : static int usblp_wwait(struct usblp *usblp, int nonblock)
870 : : {
871 : 0 : DECLARE_WAITQUEUE(waita, current);
872 : 0 : int rc;
873 : 0 : int err = 0;
874 : :
875 : 0 : add_wait_queue(&usblp->wwait, &waita);
876 : 0 : for (;;) {
877 [ # # ]: 0 : if (mutex_lock_interruptible(&usblp->mut)) {
878 : : rc = -EINTR;
879 : : break;
880 : : }
881 : 0 : set_current_state(TASK_INTERRUPTIBLE);
882 : 0 : rc = usblp_wtest(usblp, nonblock);
883 : 0 : mutex_unlock(&usblp->mut);
884 [ # # ]: 0 : if (rc <= 0)
885 : : break;
886 : :
887 [ # # ]: 0 : if (schedule_timeout(msecs_to_jiffies(1500)) == 0) {
888 [ # # ]: 0 : if (usblp->flags & LP_ABORT) {
889 : 0 : err = usblp_check_status(usblp, err);
890 [ # # ]: 0 : if (err == 1) { /* Paper out */
891 : : rc = -ENOSPC;
892 : : break;
893 : : }
894 : : } else {
895 : : /* Prod the printer, Gentoo#251237. */
896 : 0 : mutex_lock(&usblp->mut);
897 : 0 : usblp_read_status(usblp, usblp->statusbuf);
898 : 0 : mutex_unlock(&usblp->mut);
899 : : }
900 : : }
901 : : }
902 : 0 : set_current_state(TASK_RUNNING);
903 : 0 : remove_wait_queue(&usblp->wwait, &waita);
904 : 0 : return rc;
905 : : }
906 : :
907 : 0 : static int usblp_wtest(struct usblp *usblp, int nonblock)
908 : : {
909 : 0 : unsigned long flags;
910 : :
911 [ # # ]: 0 : if (!usblp->present)
912 : : return -ENODEV;
913 [ # # ]: 0 : if (signal_pending(current))
914 : : return -EINTR;
915 : 0 : spin_lock_irqsave(&usblp->lock, flags);
916 [ # # ]: 0 : if (usblp->wcomplete) {
917 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
918 : 0 : return 0;
919 : : }
920 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
921 [ # # ]: 0 : if (nonblock)
922 : 0 : return -EAGAIN;
923 : : return 1;
924 : : }
925 : :
926 : : /*
927 : : * Wait for read bytes to become available. This probably should have been
928 : : * called usblp_r_lock_and_wait(), because we lock first. But it's a traditional
929 : : * name for functions which lock and return.
930 : : *
931 : : * We do not use wait_event_interruptible because it makes locking iffy.
932 : : */
933 : 0 : static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock)
934 : : {
935 : 0 : DECLARE_WAITQUEUE(waita, current);
936 : 0 : int rc;
937 : :
938 : 0 : add_wait_queue(&usblp->rwait, &waita);
939 : 0 : for (;;) {
940 [ # # ]: 0 : if (mutex_lock_interruptible(&usblp->mut)) {
941 : : rc = -EINTR;
942 : : break;
943 : : }
944 : 0 : set_current_state(TASK_INTERRUPTIBLE);
945 [ # # ]: 0 : if ((rc = usblp_rtest(usblp, nonblock)) < 0) {
946 : 0 : mutex_unlock(&usblp->mut);
947 : 0 : break;
948 : : }
949 [ # # ]: 0 : if (rc == 0) /* Keep it locked */
950 : : break;
951 : 0 : mutex_unlock(&usblp->mut);
952 : 0 : schedule();
953 : : }
954 : 0 : set_current_state(TASK_RUNNING);
955 : 0 : remove_wait_queue(&usblp->rwait, &waita);
956 : 0 : return rc;
957 : : }
958 : :
959 : 0 : static int usblp_rtest(struct usblp *usblp, int nonblock)
960 : : {
961 : 0 : unsigned long flags;
962 : :
963 [ # # ]: 0 : if (!usblp->present)
964 : : return -ENODEV;
965 [ # # ]: 0 : if (signal_pending(current))
966 : : return -EINTR;
967 : 0 : spin_lock_irqsave(&usblp->lock, flags);
968 [ # # ]: 0 : if (usblp->rcomplete) {
969 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
970 : 0 : return 0;
971 : : }
972 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
973 [ # # ]: 0 : if (nonblock)
974 : 0 : return -EAGAIN;
975 : : return 1;
976 : : }
977 : :
978 : : /*
979 : : * Please check ->bidir and other such things outside for now.
980 : : */
981 : 0 : static int usblp_submit_read(struct usblp *usblp)
982 : : {
983 : 0 : struct urb *urb;
984 : 0 : unsigned long flags;
985 : 0 : int rc;
986 : :
987 : 0 : rc = -ENOMEM;
988 : 0 : urb = usb_alloc_urb(0, GFP_KERNEL);
989 [ # # ]: 0 : if (urb == NULL)
990 : 0 : goto raise_urb;
991 : :
992 : 0 : usb_fill_bulk_urb(urb, usblp->dev,
993 : 0 : usb_rcvbulkpipe(usblp->dev,
994 : : usblp->protocol[usblp->current_protocol].epread->bEndpointAddress),
995 : 0 : usblp->readbuf, USBLP_BUF_SIZE_IN,
996 : : usblp_bulk_read, usblp);
997 : 0 : usb_anchor_urb(urb, &usblp->urbs);
998 : :
999 : 0 : spin_lock_irqsave(&usblp->lock, flags);
1000 : 0 : usblp->readcount = 0; /* XXX Why here? */
1001 : 0 : usblp->rcomplete = 0;
1002 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
1003 [ # # ]: 0 : if ((rc = usb_submit_urb(urb, GFP_KERNEL)) < 0) {
1004 : 0 : dev_dbg(&usblp->intf->dev, "error submitting urb (%d)\n", rc);
1005 : 0 : spin_lock_irqsave(&usblp->lock, flags);
1006 : 0 : usblp->rstatus = rc;
1007 : 0 : usblp->rcomplete = 1;
1008 : 0 : spin_unlock_irqrestore(&usblp->lock, flags);
1009 : 0 : goto raise_submit;
1010 : : }
1011 : :
1012 : : return 0;
1013 : :
1014 : : raise_submit:
1015 : 0 : usb_unanchor_urb(urb);
1016 : 0 : usb_free_urb(urb);
1017 : : raise_urb:
1018 : : return rc;
1019 : : }
1020 : :
1021 : : /*
1022 : : * Checks for printers that have quirks, such as requiring unidirectional
1023 : : * communication but reporting bidirectional; currently some HP printers
1024 : : * have this flaw (HP 810, 880, 895, etc.), or needing an init string
1025 : : * sent at each open (like some Epsons).
1026 : : * Returns 1 if found, 0 if not found.
1027 : : *
1028 : : * HP recommended that we use the bidirectional interface but
1029 : : * don't attempt any bulk IN transfers from the IN endpoint.
1030 : : * Here's some more detail on the problem:
1031 : : * The problem is not that it isn't bidirectional though. The problem
1032 : : * is that if you request a device ID, or status information, while
1033 : : * the buffers are full, the return data will end up in the print data
1034 : : * buffer. For example if you make sure you never request the device ID
1035 : : * while you are sending print data, and you don't try to query the
1036 : : * printer status every couple of milliseconds, you will probably be OK.
1037 : : */
1038 : 0 : static unsigned int usblp_quirks(__u16 vendor, __u16 product)
1039 : : {
1040 : 0 : int i;
1041 : :
1042 [ # # ]: 0 : for (i = 0; quirk_printers[i].vendorId; i++) {
1043 [ # # ]: 0 : if (vendor == quirk_printers[i].vendorId &&
1044 [ # # ]: 0 : product == quirk_printers[i].productId)
1045 : 0 : return quirk_printers[i].quirks;
1046 : : }
1047 : : return 0;
1048 : : }
1049 : :
1050 : : static const struct file_operations usblp_fops = {
1051 : : .owner = THIS_MODULE,
1052 : : .read = usblp_read,
1053 : : .write = usblp_write,
1054 : : .poll = usblp_poll,
1055 : : .unlocked_ioctl = usblp_ioctl,
1056 : : .compat_ioctl = usblp_ioctl,
1057 : : .open = usblp_open,
1058 : : .release = usblp_release,
1059 : : .llseek = noop_llseek,
1060 : : };
1061 : :
1062 : 0 : static char *usblp_devnode(struct device *dev, umode_t *mode)
1063 : : {
1064 [ # # ]: 0 : return kasprintf(GFP_KERNEL, "usb/%s", dev_name(dev));
1065 : : }
1066 : :
1067 : : static struct usb_class_driver usblp_class = {
1068 : : .name = "lp%d",
1069 : : .devnode = usblp_devnode,
1070 : : .fops = &usblp_fops,
1071 : : .minor_base = USBLP_MINOR_BASE,
1072 : : };
1073 : :
1074 : 0 : static ssize_t ieee1284_id_show(struct device *dev, struct device_attribute *attr, char *buf)
1075 : : {
1076 : 0 : struct usb_interface *intf = to_usb_interface(dev);
1077 [ # # ]: 0 : struct usblp *usblp = usb_get_intfdata(intf);
1078 : :
1079 [ # # ]: 0 : if (usblp->device_id_string[0] == 0 &&
1080 [ # # ]: 0 : usblp->device_id_string[1] == 0)
1081 : : return 0;
1082 : :
1083 : 0 : return sprintf(buf, "%s", usblp->device_id_string+2);
1084 : : }
1085 : :
1086 : : static DEVICE_ATTR_RO(ieee1284_id);
1087 : :
1088 : : static struct attribute *usblp_attrs[] = {
1089 : : &dev_attr_ieee1284_id.attr,
1090 : : NULL,
1091 : : };
1092 : : ATTRIBUTE_GROUPS(usblp);
1093 : :
1094 : 0 : static int usblp_probe(struct usb_interface *intf,
1095 : : const struct usb_device_id *id)
1096 : : {
1097 : 0 : struct usb_device *dev = interface_to_usbdev(intf);
1098 : 0 : struct usblp *usblp;
1099 : 0 : int protocol;
1100 : 0 : int retval;
1101 : :
1102 : : /* Malloc and start initializing usblp structure so we can use it
1103 : : * directly. */
1104 : 0 : usblp = kzalloc(sizeof(struct usblp), GFP_KERNEL);
1105 [ # # ]: 0 : if (!usblp) {
1106 : 0 : retval = -ENOMEM;
1107 : 0 : goto abort_ret;
1108 : : }
1109 : 0 : usblp->dev = dev;
1110 : 0 : mutex_init(&usblp->wmut);
1111 : 0 : mutex_init(&usblp->mut);
1112 : 0 : spin_lock_init(&usblp->lock);
1113 : 0 : init_waitqueue_head(&usblp->rwait);
1114 : 0 : init_waitqueue_head(&usblp->wwait);
1115 : 0 : init_usb_anchor(&usblp->urbs);
1116 : 0 : usblp->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
1117 : 0 : usblp->intf = usb_get_intf(intf);
1118 : :
1119 : : /* Malloc device ID string buffer to the largest expected length,
1120 : : * since we can re-query it on an ioctl and a dynamic string
1121 : : * could change in length. */
1122 [ # # ]: 0 : if (!(usblp->device_id_string = kmalloc(USBLP_DEVICE_ID_SIZE, GFP_KERNEL))) {
1123 : 0 : retval = -ENOMEM;
1124 : 0 : goto abort;
1125 : : }
1126 : :
1127 : : /*
1128 : : * Allocate read buffer. We somewhat wastefully
1129 : : * malloc both regardless of bidirectionality, because the
1130 : : * alternate setting can be changed later via an ioctl.
1131 : : */
1132 [ # # ]: 0 : if (!(usblp->readbuf = kmalloc(USBLP_BUF_SIZE_IN, GFP_KERNEL))) {
1133 : 0 : retval = -ENOMEM;
1134 : 0 : goto abort;
1135 : : }
1136 : :
1137 : : /* Allocate buffer for printer status */
1138 : 0 : usblp->statusbuf = kmalloc(STATUS_BUF_SIZE, GFP_KERNEL);
1139 [ # # ]: 0 : if (!usblp->statusbuf) {
1140 : 0 : retval = -ENOMEM;
1141 : 0 : goto abort;
1142 : : }
1143 : :
1144 : : /* Lookup quirks for this printer. */
1145 : 0 : usblp->quirks = usblp_quirks(
1146 : 0 : le16_to_cpu(dev->descriptor.idVendor),
1147 : 0 : le16_to_cpu(dev->descriptor.idProduct));
1148 : :
1149 : : /* Analyze and pick initial alternate settings and endpoints. */
1150 : 0 : protocol = usblp_select_alts(usblp);
1151 [ # # ]: 0 : if (protocol < 0) {
1152 : 0 : dev_dbg(&intf->dev,
1153 : : "incompatible printer-class device 0x%4.4X/0x%4.4X\n",
1154 : : le16_to_cpu(dev->descriptor.idVendor),
1155 : : le16_to_cpu(dev->descriptor.idProduct));
1156 : 0 : retval = -ENODEV;
1157 : 0 : goto abort;
1158 : : }
1159 : :
1160 : : /* Setup the selected alternate setting and endpoints. */
1161 [ # # ]: 0 : if (usblp_set_protocol(usblp, protocol) < 0) {
1162 : 0 : retval = -ENODEV; /* ->probe isn't ->ioctl */
1163 : 0 : goto abort;
1164 : : }
1165 : :
1166 : : /* Retrieve and store the device ID string. */
1167 : 0 : usblp_cache_device_id_string(usblp);
1168 : :
1169 : : #ifdef DEBUG
1170 : : usblp_check_status(usblp, 0);
1171 : : #endif
1172 : :
1173 : 0 : usb_set_intfdata(intf, usblp);
1174 : :
1175 : 0 : usblp->present = 1;
1176 : :
1177 : 0 : retval = usb_register_dev(intf, &usblp_class);
1178 [ # # ]: 0 : if (retval) {
1179 : 0 : dev_err(&intf->dev,
1180 : : "usblp: Not able to get a minor (base %u, slice default): %d\n",
1181 : : USBLP_MINOR_BASE, retval);
1182 : 0 : goto abort_intfdata;
1183 : : }
1184 : 0 : usblp->minor = intf->minor;
1185 [ # # ]: 0 : dev_info(&intf->dev,
1186 : : "usblp%d: USB %sdirectional printer dev %d if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X\n",
1187 : : usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum,
1188 : : usblp->ifnum,
1189 : : usblp->protocol[usblp->current_protocol].alt_setting,
1190 : : usblp->current_protocol,
1191 : : le16_to_cpu(usblp->dev->descriptor.idVendor),
1192 : : le16_to_cpu(usblp->dev->descriptor.idProduct));
1193 : :
1194 : 0 : return 0;
1195 : :
1196 : : abort_intfdata:
1197 : 0 : usb_set_intfdata(intf, NULL);
1198 : 0 : abort:
1199 : 0 : kfree(usblp->readbuf);
1200 : 0 : kfree(usblp->statusbuf);
1201 : 0 : kfree(usblp->device_id_string);
1202 : 0 : usb_put_intf(usblp->intf);
1203 : 0 : kfree(usblp);
1204 : : abort_ret:
1205 : : return retval;
1206 : : }
1207 : :
1208 : : /*
1209 : : * We are a "new" style driver with usb_device_id table,
1210 : : * but our requirements are too intricate for simple match to handle.
1211 : : *
1212 : : * The "proto_bias" option may be used to specify the preferred protocol
1213 : : * for all USB printers (1=USB_CLASS_PRINTER/1/1, 2=USB_CLASS_PRINTER/1/2,
1214 : : * 3=USB_CLASS_PRINTER/1/3). If the device supports the preferred protocol,
1215 : : * then we bind to it.
1216 : : *
1217 : : * The best interface for us is USB_CLASS_PRINTER/1/2, because it
1218 : : * is compatible with a stream of characters. If we find it, we bind to it.
1219 : : *
1220 : : * Note that the people from hpoj.sourceforge.net need to be able to
1221 : : * bind to USB_CLASS_PRINTER/1/3 (MLC/1284.4), so we provide them ioctls
1222 : : * for this purpose.
1223 : : *
1224 : : * Failing USB_CLASS_PRINTER/1/2, we look for USB_CLASS_PRINTER/1/3,
1225 : : * even though it's probably not stream-compatible, because this matches
1226 : : * the behaviour of the old code.
1227 : : *
1228 : : * If nothing else, we bind to USB_CLASS_PRINTER/1/1
1229 : : * - the unidirectional interface.
1230 : : */
1231 : 0 : static int usblp_select_alts(struct usblp *usblp)
1232 : : {
1233 : 0 : struct usb_interface *if_alt;
1234 : 0 : struct usb_host_interface *ifd;
1235 : 0 : struct usb_endpoint_descriptor *epwrite, *epread;
1236 : 0 : int p, i;
1237 : 0 : int res;
1238 : :
1239 : 0 : if_alt = usblp->intf;
1240 : :
1241 [ # # ]: 0 : for (p = 0; p < USBLP_MAX_PROTOCOLS; p++)
1242 : 0 : usblp->protocol[p].alt_setting = -1;
1243 : :
1244 : : /* Find out what we have. */
1245 [ # # ]: 0 : for (i = 0; i < if_alt->num_altsetting; i++) {
1246 : 0 : ifd = &if_alt->altsetting[i];
1247 : :
1248 [ # # ]: 0 : if (ifd->desc.bInterfaceClass != USB_CLASS_PRINTER ||
1249 : : ifd->desc.bInterfaceSubClass != 1)
1250 [ # # ]: 0 : if (!(usblp->quirks & USBLP_QUIRK_BAD_CLASS))
1251 : 0 : continue;
1252 : :
1253 [ # # ]: 0 : if (ifd->desc.bInterfaceProtocol < USBLP_FIRST_PROTOCOL ||
1254 : : ifd->desc.bInterfaceProtocol > USBLP_LAST_PROTOCOL)
1255 : 0 : continue;
1256 : :
1257 : : /* Look for the expected bulk endpoints. */
1258 [ # # ]: 0 : if (ifd->desc.bInterfaceProtocol > 1) {
1259 : 0 : res = usb_find_common_endpoints(ifd,
1260 : : &epread, &epwrite, NULL, NULL);
1261 : : } else {
1262 : 0 : epread = NULL;
1263 : 0 : res = usb_find_bulk_out_endpoint(ifd, &epwrite);
1264 : : }
1265 : :
1266 : : /* Ignore buggy hardware without the right endpoints. */
1267 [ # # ]: 0 : if (res)
1268 : 0 : continue;
1269 : :
1270 : : /* Turn off reads for buggy bidirectional printers. */
1271 [ # # ]: 0 : if (usblp->quirks & USBLP_QUIRK_BIDIR) {
1272 : 0 : printk(KERN_INFO "usblp%d: Disabling reads from "
1273 : : "problematic bidirectional printer\n",
1274 : : usblp->minor);
1275 : 0 : epread = NULL;
1276 : : }
1277 : :
1278 : 0 : usblp->protocol[ifd->desc.bInterfaceProtocol].alt_setting =
1279 : 0 : ifd->desc.bAlternateSetting;
1280 : 0 : usblp->protocol[ifd->desc.bInterfaceProtocol].epwrite = epwrite;
1281 : 0 : usblp->protocol[ifd->desc.bInterfaceProtocol].epread = epread;
1282 : : }
1283 : :
1284 : : /* If our requested protocol is supported, then use it. */
1285 [ # # ]: 0 : if (proto_bias >= USBLP_FIRST_PROTOCOL &&
1286 : 0 : proto_bias <= USBLP_LAST_PROTOCOL &&
1287 [ # # ]: 0 : usblp->protocol[proto_bias].alt_setting != -1)
1288 : : return proto_bias;
1289 : :
1290 : : /* Ordering is important here. */
1291 [ # # ]: 0 : if (usblp->protocol[2].alt_setting != -1)
1292 : : return 2;
1293 [ # # ]: 0 : if (usblp->protocol[1].alt_setting != -1)
1294 : : return 1;
1295 [ # # ]: 0 : if (usblp->protocol[3].alt_setting != -1)
1296 : 0 : return 3;
1297 : :
1298 : : /* If nothing is available, then don't bind to this device. */
1299 : : return -1;
1300 : : }
1301 : :
1302 : 0 : static int usblp_set_protocol(struct usblp *usblp, int protocol)
1303 : : {
1304 : 0 : int r, alts;
1305 : :
1306 [ # # ]: 0 : if (protocol < USBLP_FIRST_PROTOCOL || protocol > USBLP_LAST_PROTOCOL)
1307 : : return -EINVAL;
1308 : :
1309 : 0 : alts = usblp->protocol[protocol].alt_setting;
1310 [ # # ]: 0 : if (alts < 0)
1311 : : return -EINVAL;
1312 : 0 : r = usb_set_interface(usblp->dev, usblp->ifnum, alts);
1313 [ # # ]: 0 : if (r < 0) {
1314 : 0 : printk(KERN_ERR "usblp: can't set desired altsetting %d on interface %d\n",
1315 : : alts, usblp->ifnum);
1316 : 0 : return r;
1317 : : }
1318 : :
1319 : 0 : usblp->bidir = (usblp->protocol[protocol].epread != NULL);
1320 : 0 : usblp->current_protocol = protocol;
1321 : 0 : dev_dbg(&usblp->intf->dev, "usblp%d set protocol %d\n",
1322 : : usblp->minor, protocol);
1323 : 0 : return 0;
1324 : : }
1325 : :
1326 : : /* Retrieves and caches device ID string.
1327 : : * Returns length, including length bytes but not null terminator.
1328 : : * On error, returns a negative errno value. */
1329 : 0 : static int usblp_cache_device_id_string(struct usblp *usblp)
1330 : : {
1331 : 0 : int err, length;
1332 : :
1333 : 0 : err = usblp_get_id(usblp, 0, usblp->device_id_string, USBLP_DEVICE_ID_SIZE - 1);
1334 [ # # ]: 0 : if (err < 0) {
1335 : 0 : dev_dbg(&usblp->intf->dev,
1336 : : "usblp%d: error = %d reading IEEE-1284 Device ID string\n",
1337 : : usblp->minor, err);
1338 : 0 : usblp->device_id_string[0] = usblp->device_id_string[1] = '\0';
1339 : 0 : return -EIO;
1340 : : }
1341 : :
1342 : : /* First two bytes are length in big-endian.
1343 : : * They count themselves, and we copy them into
1344 : : * the user's buffer. */
1345 : 0 : length = be16_to_cpu(*((__be16 *)usblp->device_id_string));
1346 : 0 : if (length < 2)
1347 : : length = 2;
1348 : : else if (length >= USBLP_DEVICE_ID_SIZE)
1349 : : length = USBLP_DEVICE_ID_SIZE - 1;
1350 : 0 : usblp->device_id_string[length] = '\0';
1351 : :
1352 : 0 : dev_dbg(&usblp->intf->dev, "usblp%d Device ID string [len=%d]=\"%s\"\n",
1353 : : usblp->minor, length, &usblp->device_id_string[2]);
1354 : :
1355 : 0 : return length;
1356 : : }
1357 : :
1358 : 0 : static void usblp_disconnect(struct usb_interface *intf)
1359 : : {
1360 : 0 : struct usblp *usblp = usb_get_intfdata(intf);
1361 : :
1362 : 0 : usb_deregister_dev(intf, &usblp_class);
1363 : :
1364 [ # # # # ]: 0 : if (!usblp || !usblp->dev) {
1365 : 0 : dev_err(&intf->dev, "bogus disconnect\n");
1366 : 0 : BUG();
1367 : : }
1368 : :
1369 : 0 : mutex_lock(&usblp_mutex);
1370 : 0 : mutex_lock(&usblp->mut);
1371 : 0 : usblp->present = 0;
1372 : 0 : wake_up(&usblp->wwait);
1373 : 0 : wake_up(&usblp->rwait);
1374 : 0 : usb_set_intfdata(intf, NULL);
1375 : :
1376 : 0 : usblp_unlink_urbs(usblp);
1377 : 0 : mutex_unlock(&usblp->mut);
1378 : :
1379 [ # # ]: 0 : if (!usblp->used)
1380 : 0 : usblp_cleanup(usblp);
1381 : 0 : mutex_unlock(&usblp_mutex);
1382 : 0 : }
1383 : :
1384 : 0 : static int usblp_suspend(struct usb_interface *intf, pm_message_t message)
1385 : : {
1386 : 0 : struct usblp *usblp = usb_get_intfdata(intf);
1387 : :
1388 : 0 : usblp_unlink_urbs(usblp);
1389 : : #if 0 /* XXX Do we want this? What if someone is reading, should we fail? */
1390 : : /* not strictly necessary, but just in case */
1391 : : wake_up(&usblp->wwait);
1392 : : wake_up(&usblp->rwait);
1393 : : #endif
1394 : :
1395 : 0 : return 0;
1396 : : }
1397 : :
1398 : 0 : static int usblp_resume(struct usb_interface *intf)
1399 : : {
1400 [ # # ]: 0 : struct usblp *usblp = usb_get_intfdata(intf);
1401 : 0 : int r;
1402 : :
1403 [ # # ]: 0 : r = handle_bidir(usblp);
1404 : :
1405 : 0 : return r;
1406 : : }
1407 : :
1408 : : static const struct usb_device_id usblp_ids[] = {
1409 : : { USB_DEVICE_INFO(USB_CLASS_PRINTER, 1, 1) },
1410 : : { USB_DEVICE_INFO(USB_CLASS_PRINTER, 1, 2) },
1411 : : { USB_DEVICE_INFO(USB_CLASS_PRINTER, 1, 3) },
1412 : : { USB_INTERFACE_INFO(USB_CLASS_PRINTER, 1, 1) },
1413 : : { USB_INTERFACE_INFO(USB_CLASS_PRINTER, 1, 2) },
1414 : : { USB_INTERFACE_INFO(USB_CLASS_PRINTER, 1, 3) },
1415 : : { USB_DEVICE(0x04b8, 0x0202) }, /* Seiko Epson Receipt Printer M129C */
1416 : : { } /* Terminating entry */
1417 : : };
1418 : :
1419 : : MODULE_DEVICE_TABLE(usb, usblp_ids);
1420 : :
1421 : : static struct usb_driver usblp_driver = {
1422 : : .name = "usblp",
1423 : : .probe = usblp_probe,
1424 : : .disconnect = usblp_disconnect,
1425 : : .suspend = usblp_suspend,
1426 : : .resume = usblp_resume,
1427 : : .id_table = usblp_ids,
1428 : : .dev_groups = usblp_groups,
1429 : : .supports_autosuspend = 1,
1430 : : };
1431 : :
1432 : 3 : module_usb_driver(usblp_driver);
1433 : :
1434 : : MODULE_AUTHOR(DRIVER_AUTHOR);
1435 : : MODULE_DESCRIPTION(DRIVER_DESC);
1436 : : module_param(proto_bias, int, S_IRUGO | S_IWUSR);
1437 : : MODULE_PARM_DESC(proto_bias, "Favourite protocol number");
1438 : : MODULE_LICENSE("GPL");
|
