blob: 5192cd9356def4c3b23fb58783ca0ab379e75f14 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Pete Zaitcev317c67b2007-06-21 12:44:56 -07002 * usblp.c
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
4 * Copyright (c) 1999 Michael Gee <michael@linuxspecific.com>
5 * Copyright (c) 1999 Pavel Machek <pavel@suse.cz>
Adrian Bunkf4b09eb2006-01-03 13:37:51 +01006 * Copyright (c) 2000 Randy Dunlap <rdunlap@xenotime.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Copyright (c) 2000 Vojtech Pavlik <vojtech@suse.cz>
8 # Copyright (c) 2001 Pete Zaitcev <zaitcev@redhat.com>
9 # Copyright (c) 2001 David Paschal <paschal@rcsis.com>
Oliver Neukum8e695cd2006-01-07 21:35:20 +010010 * Copyright (c) 2006 Oliver Neukum <oliver@neukum.name>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 *
12 * USB Printer Device Class driver for USB printers and printer cables
13 *
14 * Sponsored by SuSE
15 *
16 * ChangeLog:
17 * v0.1 - thorough cleaning, URBification, almost a rewrite
18 * v0.2 - some more cleanups
19 * v0.3 - cleaner again, waitqueue fixes
20 * v0.4 - fixes in unidirectional mode
21 * v0.5 - add DEVICE_ID string support
22 * v0.6 - never time out
23 * v0.7 - fixed bulk-IN read and poll (David Paschal)
24 * v0.8 - add devfs support
25 * v0.9 - fix unplug-while-open paths
26 * v0.10- remove sleep_on, fix error on oom (oliver@neukum.org)
27 * v0.11 - add proto_bias option (Pete Zaitcev)
28 * v0.12 - add hpoj.sourceforge.net ioctls (David Paschal)
29 * v0.13 - alloc space for statusbuf (<status> not on stack);
30 * use usb_buffer_alloc() for read buf & write buf;
31 */
32
33/*
34 * This program is free software; you can redistribute it and/or modify
35 * it under the terms of the GNU General Public License as published by
36 * the Free Software Foundation; either version 2 of the License, or
37 * (at your option) any later version.
38 *
39 * This program is distributed in the hope that it will be useful,
40 * but WITHOUT ANY WARRANTY; without even the implied warranty of
41 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
42 * GNU General Public License for more details.
43 *
44 * You should have received a copy of the GNU General Public License
45 * along with this program; if not, write to the Free Software
46 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
47 */
48
49#include <linux/module.h>
50#include <linux/kernel.h>
51#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include <linux/signal.h>
53#include <linux/poll.h>
54#include <linux/init.h>
55#include <linux/slab.h>
56#include <linux/lp.h>
Arjan van de Ven4186ecf2006-01-11 15:55:29 +010057#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#undef DEBUG
59#include <linux/usb.h>
60
61/*
62 * Version Information
63 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070064#define DRIVER_AUTHOR "Michael Gee, Pavel Machek, Vojtech Pavlik, Randy Dunlap, Pete Zaitcev, David Paschal"
65#define DRIVER_DESC "USB Printer Device Class driver"
66
67#define USBLP_BUF_SIZE 8192
Pete Zaitcev317c67b2007-06-21 12:44:56 -070068#define USBLP_BUF_SIZE_IN 1024
Linus Torvalds1da177e2005-04-16 15:20:36 -070069#define USBLP_DEVICE_ID_SIZE 1024
70
71/* ioctls: */
72#define LPGETSTATUS 0x060b /* same as in drivers/char/lp.c */
73#define IOCNR_GET_DEVICE_ID 1
74#define IOCNR_GET_PROTOCOLS 2
75#define IOCNR_SET_PROTOCOL 3
76#define IOCNR_HP_SET_CHANNEL 4
77#define IOCNR_GET_BUS_ADDRESS 5
78#define IOCNR_GET_VID_PID 6
79#define IOCNR_SOFT_RESET 7
80/* Get device_id string: */
81#define LPIOC_GET_DEVICE_ID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_DEVICE_ID, len)
82/* The following ioctls were added for http://hpoj.sourceforge.net: */
83/* Get two-int array:
84 * [0]=current protocol (1=7/1/1, 2=7/1/2, 3=7/1/3),
85 * [1]=supported protocol mask (mask&(1<<n)!=0 means 7/1/n supported): */
86#define LPIOC_GET_PROTOCOLS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_PROTOCOLS, len)
87/* Set protocol (arg: 1=7/1/1, 2=7/1/2, 3=7/1/3): */
88#define LPIOC_SET_PROTOCOL _IOC(_IOC_WRITE, 'P', IOCNR_SET_PROTOCOL, 0)
89/* Set channel number (HP Vendor-specific command): */
90#define LPIOC_HP_SET_CHANNEL _IOC(_IOC_WRITE, 'P', IOCNR_HP_SET_CHANNEL, 0)
91/* Get two-int array: [0]=bus number, [1]=device address: */
92#define LPIOC_GET_BUS_ADDRESS(len) _IOC(_IOC_READ, 'P', IOCNR_GET_BUS_ADDRESS, len)
93/* Get two-int array: [0]=vendor ID, [1]=product ID: */
94#define LPIOC_GET_VID_PID(len) _IOC(_IOC_READ, 'P', IOCNR_GET_VID_PID, len)
95/* Perform class specific soft reset */
96#define LPIOC_SOFT_RESET _IOC(_IOC_NONE, 'P', IOCNR_SOFT_RESET, 0);
97
98/*
99 * A DEVICE_ID string may include the printer's serial number.
100 * It should end with a semi-colon (';').
101 * An example from an HP 970C DeskJet printer is (this is one long string,
102 * with the serial number changed):
103MFG: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: ;
104 */
105
106/*
107 * USB Printer Requests
108 */
109
110#define USBLP_REQ_GET_ID 0x00
111#define USBLP_REQ_GET_STATUS 0x01
112#define USBLP_REQ_RESET 0x02
113#define USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST 0x00 /* HP Vendor-specific */
114
115#define USBLP_MINORS 16
116#define USBLP_MINOR_BASE 0
117
118#define USBLP_WRITE_TIMEOUT (5000) /* 5 seconds */
119
120#define USBLP_FIRST_PROTOCOL 1
121#define USBLP_LAST_PROTOCOL 3
122#define USBLP_MAX_PROTOCOLS (USBLP_LAST_PROTOCOL+1)
123
124/*
125 * some arbitrary status buffer size;
126 * need a status buffer that is allocated via kmalloc(), not on stack
127 */
128#define STATUS_BUF_SIZE 8
129
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700130/*
131 * Locks down the locking order:
132 * ->wmut locks wstatus.
133 * ->mut locks the whole usblp, except [rw]complete, and thus, by indirection,
134 * [rw]status. We only touch status when we know the side idle.
135 * ->lock locks what interrupt accesses.
136 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137struct usblp {
138 struct usb_device *dev; /* USB device */
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700139 struct mutex wmut;
140 struct mutex mut;
141 spinlock_t lock; /* locks rcomplete, wcomplete */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142 char *readbuf; /* read transfer_buffer */
143 char *statusbuf; /* status transfer_buffer */
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700144 struct usb_anchor urbs;
145 wait_queue_head_t rwait, wwait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 int readcount; /* Counter for reads */
147 int ifnum; /* Interface number */
148 struct usb_interface *intf; /* The interface */
149 /* Alternate-setting numbers and endpoints for each protocol
150 * (7/1/{index=1,2,3}) that the device supports: */
151 struct {
152 int alt_setting;
153 struct usb_endpoint_descriptor *epwrite;
154 struct usb_endpoint_descriptor *epread;
155 } protocol[USBLP_MAX_PROTOCOLS];
156 int current_protocol;
157 int minor; /* minor number of device */
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700158 int wcomplete, rcomplete;
159 int wstatus; /* bytes written or error */
160 int rstatus; /* bytes ready or error */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 unsigned int quirks; /* quirks flags */
162 unsigned char used; /* True if open */
163 unsigned char present; /* True if not disconnected */
164 unsigned char bidir; /* interface is bidirectional */
Oliver Neukum516077c2006-10-05 09:04:11 +0200165 unsigned char sleeping; /* interface is suspended */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166 unsigned char *device_id_string; /* IEEE 1284 DEVICE ID string (ptr) */
167 /* first 2 bytes are (big-endian) length */
168};
169
170#ifdef DEBUG
171static void usblp_dump(struct usblp *usblp) {
172 int p;
173
174 dbg("usblp=0x%p", usblp);
175 dbg("dev=0x%p", usblp->dev);
176 dbg("present=%d", usblp->present);
177 dbg("readbuf=0x%p", usblp->readbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 dbg("readcount=%d", usblp->readcount);
179 dbg("ifnum=%d", usblp->ifnum);
180 for (p = USBLP_FIRST_PROTOCOL; p <= USBLP_LAST_PROTOCOL; p++) {
181 dbg("protocol[%d].alt_setting=%d", p, usblp->protocol[p].alt_setting);
182 dbg("protocol[%d].epwrite=%p", p, usblp->protocol[p].epwrite);
183 dbg("protocol[%d].epread=%p", p, usblp->protocol[p].epread);
184 }
185 dbg("current_protocol=%d", usblp->current_protocol);
186 dbg("minor=%d", usblp->minor);
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700187 dbg("wstatus=%d", usblp->wstatus);
188 dbg("rstatus=%d", usblp->rstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 dbg("quirks=%d", usblp->quirks);
190 dbg("used=%d", usblp->used);
191 dbg("bidir=%d", usblp->bidir);
Oliver Neukum516077c2006-10-05 09:04:11 +0200192 dbg("sleeping=%d", usblp->sleeping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 dbg("device_id_string=\"%s\"",
194 usblp->device_id_string ?
195 usblp->device_id_string + 2 :
196 (unsigned char *)"(null)");
197}
198#endif
199
200/* Quirks: various printer quirks are handled by this table & its flags. */
201
202struct quirk_printer_struct {
203 __u16 vendorId;
204 __u16 productId;
205 unsigned int quirks;
206};
207
208#define USBLP_QUIRK_BIDIR 0x1 /* reports bidir but requires unidirectional mode (no INs/reads) */
209#define USBLP_QUIRK_USB_INIT 0x2 /* needs vendor USB init string */
Alan Stern5ec71db2007-03-16 15:53:07 -0400210#define USBLP_QUIRK_BAD_CLASS 0x4 /* descriptor uses vendor-specific Class or SubClass */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211
Arjan van de Ven4c4c9432005-11-29 09:43:42 +0100212static const struct quirk_printer_struct quirk_printers[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 { 0x03f0, 0x0004, USBLP_QUIRK_BIDIR }, /* HP DeskJet 895C */
214 { 0x03f0, 0x0104, USBLP_QUIRK_BIDIR }, /* HP DeskJet 880C */
215 { 0x03f0, 0x0204, USBLP_QUIRK_BIDIR }, /* HP DeskJet 815C */
216 { 0x03f0, 0x0304, USBLP_QUIRK_BIDIR }, /* HP DeskJet 810C/812C */
217 { 0x03f0, 0x0404, USBLP_QUIRK_BIDIR }, /* HP DeskJet 830C */
218 { 0x03f0, 0x0504, USBLP_QUIRK_BIDIR }, /* HP DeskJet 885C */
219 { 0x03f0, 0x0604, USBLP_QUIRK_BIDIR }, /* HP DeskJet 840C */
220 { 0x03f0, 0x0804, USBLP_QUIRK_BIDIR }, /* HP DeskJet 816C */
221 { 0x03f0, 0x1104, USBLP_QUIRK_BIDIR }, /* HP Deskjet 959C */
222 { 0x0409, 0xefbe, USBLP_QUIRK_BIDIR }, /* NEC Picty900 (HP OEM) */
223 { 0x0409, 0xbef4, USBLP_QUIRK_BIDIR }, /* NEC Picty760 (HP OEM) */
224 { 0x0409, 0xf0be, USBLP_QUIRK_BIDIR }, /* NEC Picty920 (HP OEM) */
225 { 0x0409, 0xf1be, USBLP_QUIRK_BIDIR }, /* NEC Picty800 (HP OEM) */
Martin Williges4f45d0382006-12-28 20:52:10 +0100226 { 0x0482, 0x0010, USBLP_QUIRK_BIDIR }, /* Kyocera Mita FS 820, by zut <kernel@zut.de> */
Alan Stern5ec71db2007-03-16 15:53:07 -0400227 { 0x04b8, 0x0202, USBLP_QUIRK_BAD_CLASS }, /* Seiko Epson Receipt Printer M129C */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 { 0, 0 }
229};
230
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700231static int usblp_wwait(struct usblp *usblp, int nonblock);
232static int usblp_wtest(struct usblp *usblp, int nonblock);
233static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock);
234static int usblp_rtest(struct usblp *usblp, int nonblock);
235static int usblp_submit_read(struct usblp *usblp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236static int usblp_select_alts(struct usblp *usblp);
237static int usblp_set_protocol(struct usblp *usblp, int protocol);
238static int usblp_cache_device_id_string(struct usblp *usblp);
239
240/* forward reference to make our lives easier */
241static struct usb_driver usblp_driver;
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100242static DEFINE_MUTEX(usblp_mutex); /* locks the existence of usblp's */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244/*
245 * Functions for usblp control messages.
246 */
247
248static int usblp_ctrl_msg(struct usblp *usblp, int request, int type, int dir, int recip, int value, void *buf, int len)
249{
250 int retval;
251 int index = usblp->ifnum;
252
253 /* High byte has the interface index.
254 Low byte has the alternate setting.
255 */
256 if ((request == USBLP_REQ_GET_ID) && (type == USB_TYPE_CLASS)) {
257 index = (usblp->ifnum<<8)|usblp->protocol[usblp->current_protocol].alt_setting;
258 }
259
260 retval = usb_control_msg(usblp->dev,
261 dir ? usb_rcvctrlpipe(usblp->dev, 0) : usb_sndctrlpipe(usblp->dev, 0),
262 request, type | dir | recip, value, index, buf, len, USBLP_WRITE_TIMEOUT);
263 dbg("usblp_control_msg: rq: 0x%02x dir: %d recip: %d value: %d idx: %d len: %#x result: %d",
264 request, !!dir, recip, value, index, len, retval);
265 return retval < 0 ? retval : 0;
266}
267
268#define usblp_read_status(usblp, status)\
269 usblp_ctrl_msg(usblp, USBLP_REQ_GET_STATUS, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, 0, status, 1)
270#define usblp_get_id(usblp, config, id, maxlen)\
271 usblp_ctrl_msg(usblp, USBLP_REQ_GET_ID, USB_TYPE_CLASS, USB_DIR_IN, USB_RECIP_INTERFACE, config, id, maxlen)
272#define usblp_reset(usblp)\
273 usblp_ctrl_msg(usblp, USBLP_REQ_RESET, USB_TYPE_CLASS, USB_DIR_OUT, USB_RECIP_OTHER, 0, NULL, 0)
274
275#define usblp_hp_channel_change_request(usblp, channel, buffer) \
276 usblp_ctrl_msg(usblp, USBLP_REQ_HP_CHANNEL_CHANGE_REQUEST, USB_TYPE_VENDOR, USB_DIR_IN, USB_RECIP_INTERFACE, channel, buffer, 1)
277
278/*
279 * See the description for usblp_select_alts() below for the usage
280 * explanation. Look into your /proc/bus/usb/devices and dmesg in
281 * case of any trouble.
282 */
283static int proto_bias = -1;
284
285/*
286 * URB callback.
287 */
288
David Howells7d12e782006-10-05 14:55:46 +0100289static void usblp_bulk_read(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290{
291 struct usblp *usblp = urb->context;
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700292 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700294 if (usblp->present && usblp->used) {
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700295 if (status)
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700296 printk(KERN_WARNING "usblp%d: "
297 "nonzero read bulk status received: %d\n",
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700298 usblp->minor, status);
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700299 }
300 spin_lock(&usblp->lock);
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700301 if (status < 0)
302 usblp->rstatus = status;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700303 else
304 usblp->rstatus = urb->actual_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 usblp->rcomplete = 1;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700306 wake_up(&usblp->rwait);
307 spin_unlock(&usblp->lock);
308
309 usb_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310}
311
David Howells7d12e782006-10-05 14:55:46 +0100312static void usblp_bulk_write(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
314 struct usblp *usblp = urb->context;
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700315 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700317 if (usblp->present && usblp->used) {
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700318 if (status)
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700319 printk(KERN_WARNING "usblp%d: "
320 "nonzero write bulk status received: %d\n",
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700321 usblp->minor, status);
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700322 }
323 spin_lock(&usblp->lock);
Greg Kroah-Hartman18ac3012007-07-18 10:58:02 -0700324 if (status < 0)
325 usblp->wstatus = status;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700326 else
327 usblp->wstatus = urb->actual_length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 usblp->wcomplete = 1;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700329 wake_up(&usblp->wwait);
330 spin_unlock(&usblp->lock);
331
332 /* XXX Use usb_setup_bulk_urb when available. Talk to Marcel. */
333 kfree(urb->transfer_buffer);
334 urb->transfer_buffer = NULL; /* Not refcounted, so to be safe... */
335 usb_free_urb(urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336}
337
338/*
339 * Get and print printer errors.
340 */
341
Arjan van de Ven4c4c9432005-11-29 09:43:42 +0100342static const char *usblp_messages[] = { "ok", "out of paper", "off-line", "on fire" };
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
344static int usblp_check_status(struct usblp *usblp, int err)
345{
346 unsigned char status, newerr = 0;
347 int error;
348
349 error = usblp_read_status (usblp, usblp->statusbuf);
350 if (error < 0) {
Randy Dunlap0bc8e002005-07-31 20:41:19 -0700351 if (printk_ratelimit())
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700352 printk(KERN_ERR
353 "usblp%d: error %d reading printer status\n",
Randy Dunlap0bc8e002005-07-31 20:41:19 -0700354 usblp->minor, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 return 0;
356 }
357
358 status = *usblp->statusbuf;
359
360 if (~status & LP_PERRORP)
361 newerr = 3;
362 if (status & LP_POUTPA)
363 newerr = 1;
364 if (~status & LP_PSELECD)
365 newerr = 2;
366
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700367 if (newerr != err) {
368 printk(KERN_INFO "usblp%d: %s\n",
369 usblp->minor, usblp_messages[newerr]);
370 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371
372 return newerr;
373}
374
Oliver Neukum516077c2006-10-05 09:04:11 +0200375static int handle_bidir (struct usblp *usblp)
376{
377 if (usblp->bidir && usblp->used && !usblp->sleeping) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700378 if (usblp_submit_read(usblp) < 0)
Oliver Neukum516077c2006-10-05 09:04:11 +0200379 return -EIO;
Oliver Neukum516077c2006-10-05 09:04:11 +0200380 }
Oliver Neukum516077c2006-10-05 09:04:11 +0200381 return 0;
382}
383
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384/*
385 * File op functions.
386 */
387
388static int usblp_open(struct inode *inode, struct file *file)
389{
390 int minor = iminor(inode);
391 struct usblp *usblp;
392 struct usb_interface *intf;
393 int retval;
394
395 if (minor < 0)
396 return -ENODEV;
397
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100398 mutex_lock (&usblp_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399
400 retval = -ENODEV;
401 intf = usb_find_interface(&usblp_driver, minor);
402 if (!intf) {
403 goto out;
404 }
405 usblp = usb_get_intfdata (intf);
406 if (!usblp || !usblp->dev || !usblp->present)
407 goto out;
408
409 retval = -EBUSY;
410 if (usblp->used)
411 goto out;
412
413 /*
414 * TODO: need to implement LP_ABORTOPEN + O_NONBLOCK as in drivers/char/lp.c ???
415 * This is #if 0-ed because we *don't* want to fail an open
416 * just because the printer is off-line.
417 */
418#if 0
419 if ((retval = usblp_check_status(usblp, 0))) {
420 retval = retval > 1 ? -EIO : -ENOSPC;
421 goto out;
422 }
423#else
424 retval = 0;
425#endif
426
Oliver Neukumd0532182007-01-18 15:06:07 +0100427 retval = usb_autopm_get_interface(intf);
428 if (retval < 0)
429 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 usblp->used = 1;
431 file->private_data = usblp;
432
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 usblp->wcomplete = 1; /* we begin writeable */
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700434 usblp->wstatus = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435 usblp->rcomplete = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436
Oliver Neukum516077c2006-10-05 09:04:11 +0200437 if (handle_bidir(usblp) < 0) {
Pete Zaitcev97cb95d2007-05-24 21:59:19 -0700438 usblp->used = 0;
Oliver Neukum516077c2006-10-05 09:04:11 +0200439 file->private_data = NULL;
440 retval = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 }
442out:
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100443 mutex_unlock (&usblp_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 return retval;
445}
446
447static void usblp_cleanup (struct usblp *usblp)
448{
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700449 printk(KERN_INFO "usblp%d: removed\n", usblp->minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700451 kfree(usblp->readbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 kfree (usblp->device_id_string);
453 kfree (usblp->statusbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454 kfree (usblp);
455}
456
457static void usblp_unlink_urbs(struct usblp *usblp)
458{
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700459 usb_kill_anchored_urbs(&usblp->urbs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460}
461
462static int usblp_release(struct inode *inode, struct file *file)
463{
464 struct usblp *usblp = file->private_data;
465
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100466 mutex_lock (&usblp_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 usblp->used = 0;
468 if (usblp->present) {
469 usblp_unlink_urbs(usblp);
Oliver Neukumd0532182007-01-18 15:06:07 +0100470 usb_autopm_put_interface(usblp->intf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 } else /* finish cleanup from disconnect */
472 usblp_cleanup (usblp);
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100473 mutex_unlock (&usblp_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 return 0;
475}
476
477/* No kernel lock - fine */
478static unsigned int usblp_poll(struct file *file, struct poll_table_struct *wait)
479{
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700480 int ret;
481 unsigned long flags;
482
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 struct usblp *usblp = file->private_data;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700484 /* Should we check file->f_mode & FMODE_WRITE before poll_wait()? */
485 poll_wait(file, &usblp->rwait, wait);
486 poll_wait(file, &usblp->wwait, wait);
487 spin_lock_irqsave(&usblp->lock, flags);
488 ret = ((!usblp->bidir || !usblp->rcomplete) ? 0 : POLLIN | POLLRDNORM)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 | (!usblp->wcomplete ? 0 : POLLOUT | POLLWRNORM);
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700490 spin_unlock_irqrestore(&usblp->lock, flags);
491 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492}
493
Pete Zaitcev318e4792005-12-21 17:03:24 -0800494static long usblp_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495{
496 struct usblp *usblp = file->private_data;
497 int length, err, i;
498 unsigned char newChannel;
499 int status;
500 int twoints[2];
501 int retval = 0;
502
Oliver Neukum8e422662006-12-03 09:46:35 +0100503 mutex_lock (&usblp->mut);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if (!usblp->present) {
505 retval = -ENODEV;
506 goto done;
507 }
508
Oliver Neukum516077c2006-10-05 09:04:11 +0200509 if (usblp->sleeping) {
510 retval = -ENODEV;
511 goto done;
512 }
513
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514 dbg("usblp_ioctl: cmd=0x%x (%c nr=%d len=%d dir=%d)", cmd, _IOC_TYPE(cmd),
515 _IOC_NR(cmd), _IOC_SIZE(cmd), _IOC_DIR(cmd) );
516
517 if (_IOC_TYPE(cmd) == 'P') /* new-style ioctl number */
518
519 switch (_IOC_NR(cmd)) {
520
521 case IOCNR_GET_DEVICE_ID: /* get the DEVICE_ID string */
522 if (_IOC_DIR(cmd) != _IOC_READ) {
523 retval = -EINVAL;
524 goto done;
525 }
526
527 length = usblp_cache_device_id_string(usblp);
528 if (length < 0) {
529 retval = length;
530 goto done;
531 }
532 if (length > _IOC_SIZE(cmd))
533 length = _IOC_SIZE(cmd); /* truncate */
534
535 if (copy_to_user((void __user *) arg,
536 usblp->device_id_string,
537 (unsigned long) length)) {
538 retval = -EFAULT;
539 goto done;
540 }
541
542 break;
543
544 case IOCNR_GET_PROTOCOLS:
545 if (_IOC_DIR(cmd) != _IOC_READ ||
546 _IOC_SIZE(cmd) < sizeof(twoints)) {
547 retval = -EINVAL;
548 goto done;
549 }
550
551 twoints[0] = usblp->current_protocol;
552 twoints[1] = 0;
553 for (i = USBLP_FIRST_PROTOCOL;
554 i <= USBLP_LAST_PROTOCOL; i++) {
555 if (usblp->protocol[i].alt_setting >= 0)
556 twoints[1] |= (1<<i);
557 }
558
559 if (copy_to_user((void __user *)arg,
560 (unsigned char *)twoints,
561 sizeof(twoints))) {
562 retval = -EFAULT;
563 goto done;
564 }
565
566 break;
567
568 case IOCNR_SET_PROTOCOL:
569 if (_IOC_DIR(cmd) != _IOC_WRITE) {
570 retval = -EINVAL;
571 goto done;
572 }
573
574#ifdef DEBUG
575 if (arg == -10) {
576 usblp_dump(usblp);
577 break;
578 }
579#endif
580
581 usblp_unlink_urbs(usblp);
582 retval = usblp_set_protocol(usblp, arg);
583 if (retval < 0) {
584 usblp_set_protocol(usblp,
585 usblp->current_protocol);
586 }
587 break;
588
589 case IOCNR_HP_SET_CHANNEL:
590 if (_IOC_DIR(cmd) != _IOC_WRITE ||
591 le16_to_cpu(usblp->dev->descriptor.idVendor) != 0x03F0 ||
592 usblp->quirks & USBLP_QUIRK_BIDIR) {
593 retval = -EINVAL;
594 goto done;
595 }
596
597 err = usblp_hp_channel_change_request(usblp,
598 arg, &newChannel);
599 if (err < 0) {
600 err("usblp%d: error = %d setting "
601 "HP channel",
602 usblp->minor, err);
603 retval = -EIO;
604 goto done;
605 }
606
607 dbg("usblp%d requested/got HP channel %ld/%d",
608 usblp->minor, arg, newChannel);
609 break;
610
611 case IOCNR_GET_BUS_ADDRESS:
612 if (_IOC_DIR(cmd) != _IOC_READ ||
613 _IOC_SIZE(cmd) < sizeof(twoints)) {
614 retval = -EINVAL;
615 goto done;
616 }
617
618 twoints[0] = usblp->dev->bus->busnum;
619 twoints[1] = usblp->dev->devnum;
620 if (copy_to_user((void __user *)arg,
621 (unsigned char *)twoints,
622 sizeof(twoints))) {
623 retval = -EFAULT;
624 goto done;
625 }
626
627 dbg("usblp%d is bus=%d, device=%d",
628 usblp->minor, twoints[0], twoints[1]);
629 break;
630
631 case IOCNR_GET_VID_PID:
632 if (_IOC_DIR(cmd) != _IOC_READ ||
633 _IOC_SIZE(cmd) < sizeof(twoints)) {
634 retval = -EINVAL;
635 goto done;
636 }
637
638 twoints[0] = le16_to_cpu(usblp->dev->descriptor.idVendor);
639 twoints[1] = le16_to_cpu(usblp->dev->descriptor.idProduct);
640 if (copy_to_user((void __user *)arg,
641 (unsigned char *)twoints,
642 sizeof(twoints))) {
643 retval = -EFAULT;
644 goto done;
645 }
646
647 dbg("usblp%d is VID=0x%4.4X, PID=0x%4.4X",
648 usblp->minor, twoints[0], twoints[1]);
649 break;
650
651 case IOCNR_SOFT_RESET:
652 if (_IOC_DIR(cmd) != _IOC_NONE) {
653 retval = -EINVAL;
654 goto done;
655 }
656 retval = usblp_reset(usblp);
657 break;
658 default:
659 retval = -ENOTTY;
660 }
661 else /* old-style ioctl value */
662 switch (cmd) {
663
664 case LPGETSTATUS:
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700665 if ((retval = usblp_read_status(usblp, usblp->statusbuf))) {
Randy Dunlap0bc8e002005-07-31 20:41:19 -0700666 if (printk_ratelimit())
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700667 printk(KERN_ERR "usblp%d:"
668 "failed reading printer status (%d)\n",
669 usblp->minor, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670 retval = -EIO;
671 goto done;
672 }
673 status = *usblp->statusbuf;
674 if (copy_to_user ((void __user *)arg, &status, sizeof(int)))
675 retval = -EFAULT;
676 break;
677
678 default:
679 retval = -ENOTTY;
680 }
681
682done:
Oliver Neukum8e422662006-12-03 09:46:35 +0100683 mutex_unlock (&usblp->mut);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 return retval;
685}
686
687static ssize_t usblp_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
688{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 struct usblp *usblp = file->private_data;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700690 char *writebuf;
691 struct urb *writeurb;
692 int rv;
693 int transfer_length;
694 ssize_t writecount = 0;
695
696 if (mutex_lock_interruptible(&usblp->wmut)) {
697 rv = -EINTR;
698 goto raise_biglock;
699 }
700 if ((rv = usblp_wwait(usblp, !!(file->f_flags & O_NONBLOCK))) < 0)
701 goto raise_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
703 while (writecount < count) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700704 /*
705 * Step 1: Submit next block.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 */
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700707 if ((transfer_length = count - writecount) > USBLP_BUF_SIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 transfer_length = USBLP_BUF_SIZE;
709
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700710 rv = -ENOMEM;
711 if ((writebuf = kmalloc(USBLP_BUF_SIZE, GFP_KERNEL)) == NULL)
712 goto raise_buf;
713 if ((writeurb = usb_alloc_urb(0, GFP_KERNEL)) == NULL)
714 goto raise_urb;
715 usb_fill_bulk_urb(writeurb, usblp->dev,
716 usb_sndbulkpipe(usblp->dev,
717 usblp->protocol[usblp->current_protocol].epwrite->bEndpointAddress),
718 writebuf, transfer_length, usblp_bulk_write, usblp);
719 usb_anchor_urb(writeurb, &usblp->urbs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700721 if (copy_from_user(writebuf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 buffer + writecount, transfer_length)) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700723 rv = -EFAULT;
724 goto raise_badaddr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 }
726
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700727 spin_lock_irq(&usblp->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 usblp->wcomplete = 0;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700729 spin_unlock_irq(&usblp->lock);
730 if ((rv = usb_submit_urb(writeurb, GFP_KERNEL)) < 0) {
731 usblp->wstatus = 0;
732 spin_lock_irq(&usblp->lock);
Oliver Neukum6c8df792006-10-28 11:36:59 +0200733 usblp->wcomplete = 1;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700734 wake_up(&usblp->wwait);
735 spin_unlock_irq(&usblp->lock);
736 if (rv != -ENOMEM)
737 rv = -EIO;
738 goto raise_submit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 }
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700740
741 /*
742 * Step 2: Wait for transfer to end, collect results.
743 */
744 rv = usblp_wwait(usblp, !!(file->f_flags&O_NONBLOCK));
745 if (rv < 0) {
Pete Zaitcev10e48522007-07-10 20:09:58 -0700746 if (rv == -EAGAIN) {
747 /* Presume that it's going to complete well. */
748 writecount += transfer_length;
749 }
750 /* Leave URB dangling, to be cleaned on close. */
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700751 goto collect_error;
752 }
753
754 if (usblp->wstatus < 0) {
755 usblp_check_status(usblp, 0);
756 rv = -EIO;
757 goto collect_error;
758 }
759 /*
760 * This is critical: it must be our URB, not other writer's.
761 * The wmut exists mainly to cover us here.
762 */
763 writecount += usblp->wstatus;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 }
765
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700766 mutex_unlock(&usblp->wmut);
767 return writecount;
768
769raise_submit:
770raise_badaddr:
771 usb_unanchor_urb(writeurb);
772 usb_free_urb(writeurb);
773raise_urb:
774 kfree(writebuf);
775raise_buf:
776raise_wait:
777collect_error: /* Out of raise sequence */
778 mutex_unlock(&usblp->wmut);
779raise_biglock:
780 return writecount ? writecount : rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781}
782
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700783/*
784 * Notice that we fail to restart in a few cases: on EFAULT, on restart
785 * error, etc. This is the historical behaviour. In all such cases we return
786 * EIO, and applications loop in order to get the new read going.
787 */
788static ssize_t usblp_read(struct file *file, char __user *buffer, size_t len, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789{
790 struct usblp *usblp = file->private_data;
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700791 ssize_t count;
792 ssize_t avail;
793 int rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
795 if (!usblp->bidir)
796 return -EINVAL;
797
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700798 rv = usblp_rwait_and_lock(usblp, !!(file->f_flags & O_NONBLOCK));
799 if (rv < 0)
800 return rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700802 if ((avail = usblp->rstatus) < 0) {
803 printk(KERN_ERR "usblp%d: error %d reading from printer\n",
804 usblp->minor, (int)avail);
805 usblp_submit_read(usblp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 count = -EIO;
807 goto done;
808 }
809
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700810 count = len < avail - usblp->readcount ? len : avail - usblp->readcount;
811 if (count != 0 &&
812 copy_to_user(buffer, usblp->readbuf + usblp->readcount, count)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 count = -EFAULT;
814 goto done;
815 }
816
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700817 if ((usblp->readcount += count) == avail) {
818 if (usblp_submit_read(usblp) < 0) {
819 /* We don't want to leak USB return codes into errno. */
820 if (count == 0)
821 count = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 goto done;
823 }
824 }
825
826done:
Oliver Neukum8e422662006-12-03 09:46:35 +0100827 mutex_unlock (&usblp->mut);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 return count;
829}
830
831/*
Pete Zaitcev317c67b2007-06-21 12:44:56 -0700832 * Wait for the write path to come idle.
833 * This is called under the ->wmut, so the idle path stays idle.
834 *
835 * Our write path has a peculiar property: it does not buffer like a tty,
836 * but waits for the write to succeed. This allows our ->release to bug out
837 * without waiting for writes to drain. But it obviously does not work
838 * when O_NONBLOCK is set. So, applications setting O_NONBLOCK must use
839 * select(2) or poll(2) to wait for the buffer to drain before closing.
840 * Alternatively, set blocking mode with fcntl and issue a zero-size write.
841 *
842 * Old v0.13 code had a non-functional timeout for wait_event(). Someone forgot
843 * to check the return code for timeout expiration, so it had no effect.
844 * Apparently, it was intended to check for error conditons, such as out
845 * of paper. It is going to return when we settle things with CUPS. XXX
846 */
847static int usblp_wwait(struct usblp *usblp, int nonblock)
848{
849 DECLARE_WAITQUEUE(waita, current);
850 int rc;
851
852 add_wait_queue(&usblp->wwait, &waita);
853 for (;;) {
854 if (mutex_lock_interruptible(&usblp->mut)) {
855 rc = -EINTR;
856 break;
857 }
858 set_current_state(TASK_INTERRUPTIBLE);
859 if ((rc = usblp_wtest(usblp, nonblock)) < 0) {
860 mutex_unlock(&usblp->mut);
861 break;
862 }
863 mutex_unlock(&usblp->mut);
864 if (rc == 0)
865 break;
866 schedule();
867 }
868 set_current_state(TASK_RUNNING);
869 remove_wait_queue(&usblp->wwait, &waita);
870 return rc;
871}
872
873static int usblp_wtest(struct usblp *usblp, int nonblock)
874{
875 unsigned long flags;
876
877 if (!usblp->present)
878 return -ENODEV;
879 if (signal_pending(current))
880 return -EINTR;
881 spin_lock_irqsave(&usblp->lock, flags);
882 if (usblp->wcomplete) {
883 spin_unlock_irqrestore(&usblp->lock, flags);
884 return 0;
885 }
886 spin_unlock_irqrestore(&usblp->lock, flags);
887 if (usblp->sleeping)
888 return -ENODEV;
889 if (nonblock)
890 return -EAGAIN;
891 return 1;
892}
893
894/*
895 * Wait for read bytes to become available. This probably should have been
896 * called usblp_r_lock_and_wait(), because we lock first. But it's a traditional
897 * name for functions which lock and return.
898 *
899 * We do not use wait_event_interruptible because it makes locking iffy.
900 */
901static int usblp_rwait_and_lock(struct usblp *usblp, int nonblock)
902{
903 DECLARE_WAITQUEUE(waita, current);
904 int rc;
905
906 add_wait_queue(&usblp->rwait, &waita);
907 for (;;) {
908 if (mutex_lock_interruptible(&usblp->mut)) {
909 rc = -EINTR;
910 break;
911 }
912 set_current_state(TASK_INTERRUPTIBLE);
913 if ((rc = usblp_rtest(usblp, nonblock)) < 0) {
914 mutex_unlock(&usblp->mut);
915 break;
916 }
917 if (rc == 0) /* Keep it locked */
918 break;
919 mutex_unlock(&usblp->mut);
920 schedule();
921 }
922 set_current_state(TASK_RUNNING);
923 remove_wait_queue(&usblp->rwait, &waita);
924 return rc;
925}
926
927static int usblp_rtest(struct usblp *usblp, int nonblock)
928{
929 unsigned long flags;
930
931 if (!usblp->present)
932 return -ENODEV;
933 if (signal_pending(current))
934 return -EINTR;
935 spin_lock_irqsave(&usblp->lock, flags);
936 if (usblp->rcomplete) {
937 spin_unlock_irqrestore(&usblp->lock, flags);
938 return 0;
939 }
940 spin_unlock_irqrestore(&usblp->lock, flags);
941 if (usblp->sleeping)
942 return -ENODEV;
943 if (nonblock)
944 return -EAGAIN;
945 return 1;
946}
947
948/*
949 * Please check ->bidir and other such things outside for now.
950 */
951static int usblp_submit_read(struct usblp *usblp)
952{
953 struct urb *urb;
954 unsigned long flags;
955 int rc;
956
957 rc = -ENOMEM;
958 if ((urb = usb_alloc_urb(0, GFP_KERNEL)) == NULL)
959 goto raise_urb;
960
961 usb_fill_bulk_urb(urb, usblp->dev,
962 usb_rcvbulkpipe(usblp->dev,
963 usblp->protocol[usblp->current_protocol].epread->bEndpointAddress),
964 usblp->readbuf, USBLP_BUF_SIZE_IN,
965 usblp_bulk_read, usblp);
966 usb_anchor_urb(urb, &usblp->urbs);
967
968 spin_lock_irqsave(&usblp->lock, flags);
969 usblp->readcount = 0; /* XXX Why here? */
970 usblp->rcomplete = 0;
971 spin_unlock_irqrestore(&usblp->lock, flags);
972 if ((rc = usb_submit_urb(urb, GFP_KERNEL)) < 0) {
973 dbg("error submitting urb (%d)", rc);
974 spin_lock_irqsave(&usblp->lock, flags);
975 usblp->rstatus = rc;
976 usblp->rcomplete = 1;
977 spin_unlock_irqrestore(&usblp->lock, flags);
978 goto raise_submit;
979 }
980
981 return 0;
982
983raise_submit:
984 usb_unanchor_urb(urb);
985 usb_free_urb(urb);
986raise_urb:
987 return rc;
988}
989
990/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 * Checks for printers that have quirks, such as requiring unidirectional
992 * communication but reporting bidirectional; currently some HP printers
993 * have this flaw (HP 810, 880, 895, etc.), or needing an init string
994 * sent at each open (like some Epsons).
995 * Returns 1 if found, 0 if not found.
996 *
997 * HP recommended that we use the bidirectional interface but
998 * don't attempt any bulk IN transfers from the IN endpoint.
999 * Here's some more detail on the problem:
1000 * The problem is not that it isn't bidirectional though. The problem
1001 * is that if you request a device ID, or status information, while
1002 * the buffers are full, the return data will end up in the print data
1003 * buffer. For example if you make sure you never request the device ID
1004 * while you are sending print data, and you don't try to query the
1005 * printer status every couple of milliseconds, you will probably be OK.
1006 */
1007static unsigned int usblp_quirks (__u16 vendor, __u16 product)
1008{
1009 int i;
1010
1011 for (i = 0; quirk_printers[i].vendorId; i++) {
1012 if (vendor == quirk_printers[i].vendorId &&
1013 product == quirk_printers[i].productId)
1014 return quirk_printers[i].quirks;
1015 }
1016 return 0;
1017}
1018
Luiz Fernando N. Capitulino066202d2006-08-05 20:37:11 -03001019static const struct file_operations usblp_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 .owner = THIS_MODULE,
1021 .read = usblp_read,
1022 .write = usblp_write,
1023 .poll = usblp_poll,
Pete Zaitcev318e4792005-12-21 17:03:24 -08001024 .unlocked_ioctl = usblp_ioctl,
1025 .compat_ioctl = usblp_ioctl,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 .open = usblp_open,
1027 .release = usblp_release,
1028};
1029
1030static struct usb_class_driver usblp_class = {
Greg Kroah-Hartmand6e5bcf2005-06-20 21:15:16 -07001031 .name = "lp%d",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 .fops = &usblp_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 .minor_base = USBLP_MINOR_BASE,
1034};
1035
David Woodhousea9714c82005-12-23 16:41:41 +00001036static ssize_t usblp_show_ieee1284_id(struct device *dev, struct device_attribute *attr, char *buf)
1037{
1038 struct usb_interface *intf = to_usb_interface(dev);
1039 struct usblp *usblp = usb_get_intfdata (intf);
1040
1041 if (usblp->device_id_string[0] == 0 &&
1042 usblp->device_id_string[1] == 0)
1043 return 0;
1044
1045 return sprintf(buf, "%s", usblp->device_id_string+2);
1046}
1047
1048static DEVICE_ATTR(ieee1284_id, S_IRUGO, usblp_show_ieee1284_id, NULL);
1049
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050static int usblp_probe(struct usb_interface *intf,
1051 const struct usb_device_id *id)
1052{
1053 struct usb_device *dev = interface_to_usbdev (intf);
1054 struct usblp *usblp = NULL;
1055 int protocol;
1056 int retval;
1057
1058 /* Malloc and start initializing usblp structure so we can use it
1059 * directly. */
Oliver Neukum8e695cd2006-01-07 21:35:20 +01001060 if (!(usblp = kzalloc(sizeof(struct usblp), GFP_KERNEL))) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001061 retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 goto abort;
1063 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 usblp->dev = dev;
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001065 mutex_init(&usblp->wmut);
Oliver Neukum8e422662006-12-03 09:46:35 +01001066 mutex_init (&usblp->mut);
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001067 spin_lock_init(&usblp->lock);
1068 init_waitqueue_head(&usblp->rwait);
1069 init_waitqueue_head(&usblp->wwait);
1070 init_usb_anchor(&usblp->urbs);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 usblp->ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
1072 usblp->intf = intf;
1073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 /* Malloc device ID string buffer to the largest expected length,
1075 * since we can re-query it on an ioctl and a dynamic string
1076 * could change in length. */
1077 if (!(usblp->device_id_string = kmalloc(USBLP_DEVICE_ID_SIZE, GFP_KERNEL))) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001078 retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 goto abort;
1080 }
1081
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001082 /*
1083 * Allocate read buffer. We somewhat wastefully
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 * malloc both regardless of bidirectionality, because the
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001085 * alternate setting can be changed later via an ioctl.
1086 */
1087 if (!(usblp->readbuf = kmalloc(USBLP_BUF_SIZE_IN, GFP_KERNEL))) {
1088 retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 goto abort;
1090 }
1091
1092 /* Allocate buffer for printer status */
1093 usblp->statusbuf = kmalloc(STATUS_BUF_SIZE, GFP_KERNEL);
1094 if (!usblp->statusbuf) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001095 retval = -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 goto abort;
1097 }
1098
1099 /* Lookup quirks for this printer. */
1100 usblp->quirks = usblp_quirks(
1101 le16_to_cpu(dev->descriptor.idVendor),
1102 le16_to_cpu(dev->descriptor.idProduct));
1103
1104 /* Analyze and pick initial alternate settings and endpoints. */
1105 protocol = usblp_select_alts(usblp);
1106 if (protocol < 0) {
1107 dbg("incompatible printer-class device 0x%4.4X/0x%4.4X",
1108 le16_to_cpu(dev->descriptor.idVendor),
1109 le16_to_cpu(dev->descriptor.idProduct));
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001110 retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 goto abort;
1112 }
1113
1114 /* Setup the selected alternate setting and endpoints. */
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001115 if (usblp_set_protocol(usblp, protocol) < 0) {
1116 retval = -ENODEV; /* ->probe isn't ->ioctl */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117 goto abort;
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001118 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119
1120 /* Retrieve and store the device ID string. */
1121 usblp_cache_device_id_string(usblp);
Greg Kroah-Hartman96cede52006-08-28 11:43:25 -07001122 retval = device_create_file(&intf->dev, &dev_attr_ieee1284_id);
1123 if (retval)
1124 goto abort_intfdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125
1126#ifdef DEBUG
1127 usblp_check_status(usblp, 0);
1128#endif
1129
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 usb_set_intfdata (intf, usblp);
1131
1132 usblp->present = 1;
1133
1134 retval = usb_register_dev(intf, &usblp_class);
1135 if (retval) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001136 printk(KERN_ERR "usblp: Not able to get a minor"
1137 " (base %u, slice default): %d\n",
1138 USBLP_MINOR_BASE, retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 goto abort_intfdata;
1140 }
1141 usblp->minor = intf->minor;
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001142 printk(KERN_INFO "usblp%d: USB %sdirectional printer dev %d "
1143 "if %d alt %d proto %d vid 0x%4.4X pid 0x%4.4X\n",
David Woodhousea9714c82005-12-23 16:41:41 +00001144 usblp->minor, usblp->bidir ? "Bi" : "Uni", dev->devnum,
1145 usblp->ifnum,
1146 usblp->protocol[usblp->current_protocol].alt_setting,
1147 usblp->current_protocol,
1148 le16_to_cpu(usblp->dev->descriptor.idVendor),
1149 le16_to_cpu(usblp->dev->descriptor.idProduct));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150
1151 return 0;
1152
1153abort_intfdata:
1154 usb_set_intfdata (intf, NULL);
David Woodhousea9714c82005-12-23 16:41:41 +00001155 device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156abort:
1157 if (usblp) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001158 kfree(usblp->readbuf);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 kfree(usblp->statusbuf);
1160 kfree(usblp->device_id_string);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 kfree(usblp);
1162 }
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001163 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164}
1165
1166/*
1167 * We are a "new" style driver with usb_device_id table,
1168 * but our requirements are too intricate for simple match to handle.
1169 *
1170 * The "proto_bias" option may be used to specify the preferred protocol
1171 * for all USB printers (1=7/1/1, 2=7/1/2, 3=7/1/3). If the device
1172 * supports the preferred protocol, then we bind to it.
1173 *
1174 * The best interface for us is 7/1/2, because it is compatible
1175 * with a stream of characters. If we find it, we bind to it.
1176 *
1177 * Note that the people from hpoj.sourceforge.net need to be able to
1178 * bind to 7/1/3 (MLC/1284.4), so we provide them ioctls for this purpose.
1179 *
1180 * Failing 7/1/2, we look for 7/1/3, even though it's probably not
1181 * stream-compatible, because this matches the behaviour of the old code.
1182 *
1183 * If nothing else, we bind to 7/1/1 - the unidirectional interface.
1184 */
1185static int usblp_select_alts(struct usblp *usblp)
1186{
1187 struct usb_interface *if_alt;
1188 struct usb_host_interface *ifd;
1189 struct usb_endpoint_descriptor *epd, *epwrite, *epread;
1190 int p, i, e;
1191
1192 if_alt = usblp->intf;
1193
1194 for (p = 0; p < USBLP_MAX_PROTOCOLS; p++)
1195 usblp->protocol[p].alt_setting = -1;
1196
1197 /* Find out what we have. */
1198 for (i = 0; i < if_alt->num_altsetting; i++) {
1199 ifd = &if_alt->altsetting[i];
1200
1201 if (ifd->desc.bInterfaceClass != 7 || ifd->desc.bInterfaceSubClass != 1)
Alan Stern5ec71db2007-03-16 15:53:07 -04001202 if (!(usblp->quirks & USBLP_QUIRK_BAD_CLASS))
1203 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204
1205 if (ifd->desc.bInterfaceProtocol < USBLP_FIRST_PROTOCOL ||
1206 ifd->desc.bInterfaceProtocol > USBLP_LAST_PROTOCOL)
1207 continue;
1208
1209 /* Look for bulk OUT and IN endpoints. */
1210 epwrite = epread = NULL;
1211 for (e = 0; e < ifd->desc.bNumEndpoints; e++) {
1212 epd = &ifd->endpoint[e].desc;
1213
Luiz Fernando N. Capitulino5bc66d52006-09-27 11:58:53 -07001214 if (usb_endpoint_is_bulk_out(epd))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 if (!epwrite)
1216 epwrite = epd;
1217
Luiz Fernando N. Capitulino5bc66d52006-09-27 11:58:53 -07001218 if (usb_endpoint_is_bulk_in(epd))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219 if (!epread)
1220 epread = epd;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 }
1222
1223 /* Ignore buggy hardware without the right endpoints. */
1224 if (!epwrite || (ifd->desc.bInterfaceProtocol > 1 && !epread))
1225 continue;
1226
1227 /* Turn off reads for 7/1/1 (unidirectional) interfaces
1228 * and buggy bidirectional printers. */
1229 if (ifd->desc.bInterfaceProtocol == 1) {
1230 epread = NULL;
1231 } else if (usblp->quirks & USBLP_QUIRK_BIDIR) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001232 printk(KERN_INFO "usblp%d: Disabling reads from "
1233 "problematic bidirectional printer\n",
1234 usblp->minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 epread = NULL;
1236 }
1237
1238 usblp->protocol[ifd->desc.bInterfaceProtocol].alt_setting =
1239 ifd->desc.bAlternateSetting;
1240 usblp->protocol[ifd->desc.bInterfaceProtocol].epwrite = epwrite;
1241 usblp->protocol[ifd->desc.bInterfaceProtocol].epread = epread;
1242 }
1243
1244 /* If our requested protocol is supported, then use it. */
1245 if (proto_bias >= USBLP_FIRST_PROTOCOL &&
1246 proto_bias <= USBLP_LAST_PROTOCOL &&
1247 usblp->protocol[proto_bias].alt_setting != -1)
1248 return proto_bias;
1249
1250 /* Ordering is important here. */
1251 if (usblp->protocol[2].alt_setting != -1)
1252 return 2;
1253 if (usblp->protocol[1].alt_setting != -1)
1254 return 1;
1255 if (usblp->protocol[3].alt_setting != -1)
1256 return 3;
1257
1258 /* If nothing is available, then don't bind to this device. */
1259 return -1;
1260}
1261
1262static int usblp_set_protocol(struct usblp *usblp, int protocol)
1263{
1264 int r, alts;
1265
1266 if (protocol < USBLP_FIRST_PROTOCOL || protocol > USBLP_LAST_PROTOCOL)
1267 return -EINVAL;
1268
1269 alts = usblp->protocol[protocol].alt_setting;
1270 if (alts < 0)
1271 return -EINVAL;
1272 r = usb_set_interface(usblp->dev, usblp->ifnum, alts);
1273 if (r < 0) {
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001274 printk(KERN_ERR "usblp: can't set desired altsetting %d on interface %d\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 alts, usblp->ifnum);
1276 return r;
1277 }
1278
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 usblp->bidir = (usblp->protocol[protocol].epread != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 usblp->current_protocol = protocol;
1281 dbg("usblp%d set protocol %d", usblp->minor, protocol);
1282 return 0;
1283}
1284
1285/* Retrieves and caches device ID string.
1286 * Returns length, including length bytes but not null terminator.
1287 * On error, returns a negative errno value. */
1288static int usblp_cache_device_id_string(struct usblp *usblp)
1289{
1290 int err, length;
1291
1292 err = usblp_get_id(usblp, 0, usblp->device_id_string, USBLP_DEVICE_ID_SIZE - 1);
1293 if (err < 0) {
1294 dbg("usblp%d: error = %d reading IEEE-1284 Device ID string",
1295 usblp->minor, err);
1296 usblp->device_id_string[0] = usblp->device_id_string[1] = '\0';
1297 return -EIO;
1298 }
1299
1300 /* First two bytes are length in big-endian.
1301 * They count themselves, and we copy them into
1302 * the user's buffer. */
1303 length = be16_to_cpu(*((__be16 *)usblp->device_id_string));
1304 if (length < 2)
1305 length = 2;
1306 else if (length >= USBLP_DEVICE_ID_SIZE)
1307 length = USBLP_DEVICE_ID_SIZE - 1;
1308 usblp->device_id_string[length] = '\0';
1309
1310 dbg("usblp%d Device ID string [len=%d]=\"%s\"",
1311 usblp->minor, length, &usblp->device_id_string[2]);
1312
1313 return length;
1314}
1315
1316static void usblp_disconnect(struct usb_interface *intf)
1317{
1318 struct usblp *usblp = usb_get_intfdata (intf);
1319
1320 usb_deregister_dev(intf, &usblp_class);
1321
1322 if (!usblp || !usblp->dev) {
1323 err("bogus disconnect");
1324 BUG ();
1325 }
1326
David Woodhousea9714c82005-12-23 16:41:41 +00001327 device_remove_file(&intf->dev, &dev_attr_ieee1284_id);
1328
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01001329 mutex_lock (&usblp_mutex);
Oliver Neukum8e422662006-12-03 09:46:35 +01001330 mutex_lock (&usblp->mut);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 usblp->present = 0;
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001332 wake_up(&usblp->wwait);
1333 wake_up(&usblp->rwait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 usb_set_intfdata (intf, NULL);
1335
1336 usblp_unlink_urbs(usblp);
Oliver Neukum8e422662006-12-03 09:46:35 +01001337 mutex_unlock (&usblp->mut);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338
1339 if (!usblp->used)
1340 usblp_cleanup (usblp);
Arjan van de Ven4186ecf2006-01-11 15:55:29 +01001341 mutex_unlock (&usblp_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342}
1343
Oliver Neukum516077c2006-10-05 09:04:11 +02001344static int usblp_suspend (struct usb_interface *intf, pm_message_t message)
1345{
1346 struct usblp *usblp = usb_get_intfdata (intf);
1347
Oliver Neukum516077c2006-10-05 09:04:11 +02001348 /* we take no more IO */
1349 usblp->sleeping = 1;
Oliver Neukum516077c2006-10-05 09:04:11 +02001350 usblp_unlink_urbs(usblp);
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001351#if 0 /* XXX Do we want this? What if someone is reading, should we fail? */
1352 /* not strictly necessary, but just in case */
1353 wake_up(&usblp->wwait);
1354 wake_up(&usblp->rwait);
1355#endif
Oliver Neukum516077c2006-10-05 09:04:11 +02001356
1357 return 0;
1358}
1359
1360static int usblp_resume (struct usb_interface *intf)
1361{
1362 struct usblp *usblp = usb_get_intfdata (intf);
1363 int r;
1364
Oliver Neukum516077c2006-10-05 09:04:11 +02001365 usblp->sleeping = 0;
1366 r = handle_bidir (usblp);
1367
Oliver Neukum516077c2006-10-05 09:04:11 +02001368 return r;
1369}
1370
Linus Torvalds1da177e2005-04-16 15:20:36 -07001371static struct usb_device_id usblp_ids [] = {
1372 { USB_DEVICE_INFO(7, 1, 1) },
1373 { USB_DEVICE_INFO(7, 1, 2) },
1374 { USB_DEVICE_INFO(7, 1, 3) },
1375 { USB_INTERFACE_INFO(7, 1, 1) },
1376 { USB_INTERFACE_INFO(7, 1, 2) },
1377 { USB_INTERFACE_INFO(7, 1, 3) },
Alan Stern5ec71db2007-03-16 15:53:07 -04001378 { USB_DEVICE(0x04b8, 0x0202) }, /* Seiko Epson Receipt Printer M129C */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379 { } /* Terminating entry */
1380};
1381
1382MODULE_DEVICE_TABLE (usb, usblp_ids);
1383
1384static struct usb_driver usblp_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001385 .name = "usblp",
1386 .probe = usblp_probe,
1387 .disconnect = usblp_disconnect,
Oliver Neukum516077c2006-10-05 09:04:11 +02001388 .suspend = usblp_suspend,
1389 .resume = usblp_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 .id_table = usblp_ids,
Oliver Neukumd0532182007-01-18 15:06:07 +01001391 .supports_autosuspend = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392};
1393
1394static int __init usblp_init(void)
1395{
Pete Zaitcev317c67b2007-06-21 12:44:56 -07001396 return usb_register(&usblp_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397}
1398
1399static void __exit usblp_exit(void)
1400{
1401 usb_deregister(&usblp_driver);
1402}
1403
1404module_init(usblp_init);
1405module_exit(usblp_exit);
1406
1407MODULE_AUTHOR( DRIVER_AUTHOR );
1408MODULE_DESCRIPTION( DRIVER_DESC );
1409module_param(proto_bias, int, S_IRUGO | S_IWUSR);
1410MODULE_PARM_DESC(proto_bias, "Favourite protocol number");
1411MODULE_LICENSE("GPL");