1 /* $NetBSD: ulpt.c,v 1.27 1999/10/13 08:10:57 augustss Exp $ */
5 * Copyright (c) 1998 The NetBSD Foundation, Inc.
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Lennart Augustsson (augustss@carlstedt.se) at
10 * Carlstedt Research & Technology.
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. All advertising materials mentioning features or use of this software
21 * must display the following acknowledgement:
22 * This product includes software developed by the NetBSD
23 * Foundation, Inc. and its contributors.
24 * 4. Neither the name of The NetBSD Foundation nor the names of its
25 * contributors may be used to endorse or promote products derived
26 * from this software without specific prior written permission.
28 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
29 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
31 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
32 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
33 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
34 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
35 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
36 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
37 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
38 * POSSIBILITY OF SUCH DAMAGE.
42 * Printer Class spec: http://www.usb.org/developers/data/usbprn10.pdf
45 /* XXX Note in the manpage the ULPT_NOPRIME version of the printer */
47 #include <sys/param.h>
48 #include <sys/systm.h>
50 #include <sys/kernel.h>
51 #if defined(__NetBSD__)
52 #include <sys/device.h>
53 #include <sys/ioctl.h>
54 #elif defined(__FreeBSD__)
55 #include <sys/ioccom.h>
56 #include <sys/module.h>
61 #include <sys/vnode.h>
62 #include <sys/syslog.h>
64 #include <dev/usb/usb.h>
65 #include <dev/usb/usbdi.h>
66 #include <dev/usb/usbdi_util.h>
67 #include <dev/usb/usbdevs.h>
68 #include <dev/usb/usb_quirks.h>
70 #define TIMEOUT hz*16 /* wait up to 16 seconds for a ready */
73 #define LPTPRI (PZERO+8)
74 #define ULPT_BSIZE 16384
77 #define DPRINTF(x) if (ulptdebug) logprintf x
78 #define DPRINTFN(n,x) if (ulptdebug>(n)) logprintf x
85 #define UR_GET_DEVICE_ID 0
86 #define UR_GET_PORT_STATUS 1
87 #define UR_SOFT_RESET 2
89 #define LPS_NERR 0x08 /* printer no error */
90 #define LPS_SELECT 0x10 /* printer selected */
91 #define LPS_NOPAPER 0x20 /* printer out of paper */
92 #define LPS_INVERT (LPS_SELECT|LPS_NERR)
93 #define LPS_MASK (LPS_SELECT|LPS_NERR|LPS_NOPAPER)
97 usbd_device_handle sc_udev; /* device */
98 usbd_interface_handle sc_iface; /* interface */
100 usbd_pipe_handle sc_bulkpipe; /* bulk pipe */
104 #define ULPT_OPEN 0x01 /* device is open */
105 #define ULPT_OBUSY 0x02 /* printer is busy doing output */
106 #define ULPT_INIT 0x04 /* waiting to initialize for open */
108 #define ULPT_NOPRIME 0x40 /* don't prime on open */
109 u_char sc_laststatus;
114 #if defined(__FreeBSD__)
120 #if defined(__NetBSD__) || defined(__OpenBSD__)
122 #elif defined(__FreeBSD__)
123 static d_open_t ulptopen;
124 static d_close_t ulptclose;
125 static d_write_t ulptwrite;
126 static d_ioctl_t ulptioctl;
128 #define ULPT_CDEV_MAJOR 113
130 static struct cdevsw ulpt_cdevsw = {
132 /* close */ ulptclose,
134 /* write */ ulptwrite,
135 /* ioctl */ ulptioctl,
138 /* strategy */ nostrategy,
140 /* maj */ ULPT_CDEV_MAJOR,
148 void ulpt_disco __P((void *));
150 int ulpt_do_write __P((struct ulpt_softc *, struct uio *uio, int));
151 int ulpt_status __P((struct ulpt_softc *));
152 void ulpt_reset __P((struct ulpt_softc *));
153 int ulpt_statusmsg __P((u_char, struct ulpt_softc *));
155 void ieee1284_print_id __P((char *));
157 #define ULPTUNIT(s) (minor(s) & 0x1f)
158 #define ULPTFLAGS(s) (minor(s) & 0xe0)
161 USB_DECLARE_DRIVER(ulpt);
165 USB_MATCH_START(ulpt, uaa);
166 usb_interface_descriptor_t *id;
168 DPRINTFN(10,("ulpt_match\n"));
169 if (uaa->iface == NULL)
170 return (UMATCH_NONE);
171 id = usbd_get_interface_descriptor(uaa->iface);
173 id->bInterfaceClass == UCLASS_PRINTER &&
174 id->bInterfaceSubClass == USUBCLASS_PRINTER &&
175 (id->bInterfaceProtocol == UPROTO_PRINTER_UNI ||
176 id->bInterfaceProtocol == UPROTO_PRINTER_BI))
177 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);
178 return (UMATCH_NONE);
183 USB_ATTACH_START(ulpt, sc, uaa);
184 usbd_device_handle dev = uaa->device;
185 usbd_interface_handle iface = uaa->iface;
186 usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);
188 usb_endpoint_descriptor_t *ed;
191 DPRINTFN(10,("ulpt_attach: sc=%p\n", sc));
192 usbd_devinfo(dev, 0, devinfo);
194 printf("%s: %s, iclass %d/%d\n", USBDEVNAME(sc->sc_dev),
195 devinfo, id->bInterfaceClass, id->bInterfaceSubClass);
197 /* Figure out which endpoint is the bulk out endpoint. */
198 ed = usbd_interface2endpoint_descriptor(iface, 0);
201 if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_OUT ||
202 (ed->bmAttributes & UE_XFERTYPE) != UE_BULK) {
203 /* In case we are using a bidir protocol... */
204 ed = usbd_interface2endpoint_descriptor(iface, 1);
207 if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_OUT ||
208 (ed->bmAttributes & UE_XFERTYPE) != UE_BULK)
211 sc->sc_bulk = ed->bEndpointAddress;
212 DPRINTFN(10, ("ulpt_attach: bulk=%d\n", sc->sc_bulk));
214 sc->sc_iface = iface;
215 err = usbd_interface2device_handle(iface, &sc->sc_udev);
218 USB_ATTACH_ERROR_RETURN;
220 sc->sc_ifaceno = id->bInterfaceNumber;
224 * This code is disabled because for some mysterious it causes
225 * printing not to work. But only sometimes, and mostly with
226 * UHCI and less often with OHCI. *sigh*
229 usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev);
230 usb_device_request_t req;
233 req.bmRequestType = UT_READ_CLASS_INTERFACE;
234 req.bRequest = UR_GET_DEVICE_ID;
235 USETW(req.wValue, cd->bConfigurationValue);
236 USETW2(req.wIndex, id->bInterfaceNumber, id->bAlternateSetting);
237 USETW(req.wLength, sizeof devinfo - 1);
238 err = usbd_do_request_flags(dev, &req, devinfo, USBD_SHORT_XFER_OK,
241 printf("%s: cannot get device id\n", USBDEVNAME(sc->sc_dev));
242 } else if (alen <= 2) {
243 printf("%s: empty device id, no printer connected?\n",
244 USBDEVNAME(sc->sc_dev));
246 /* devinfo now contains an IEEE-1284 device ID */
247 len = ((devinfo[0] & 0xff) << 8) | (devinfo[1] & 0xff);
248 if (len > sizeof devinfo - 3)
249 len = sizeof devinfo - 3;
251 printf("%s: device id <", USBDEVNAME(sc->sc_dev));
252 ieee1284_print_id(devinfo+2);
258 #if defined(__FreeBSD__)
259 sc->dev = make_dev(&ulpt_cdevsw, device_get_unit(self),
260 UID_ROOT, GID_OPERATOR, 0644, "ulpt%d", device_get_unit(self));
261 sc->dev_noprime = make_dev(&ulpt_cdevsw,
262 device_get_unit(self)|ULPT_NOPRIME,
263 UID_ROOT, GID_OPERATOR, 0644, "unlpt%d", device_get_unit(self));
266 USB_ATTACH_SUCCESS_RETURN;
269 printf("%s: could not find bulk endpoint\n", USBDEVNAME(sc->sc_dev));
271 USB_ATTACH_ERROR_RETURN;
274 #if defined(__NetBSD__) || defined(__OpenBSD__)
276 ulpt_activate(self, act)
280 struct ulpt_softc *sc = (struct ulpt_softc *)self;
287 case DVACT_DEACTIVATE:
297 USB_DETACH_START(ulpt, sc);
299 #if defined(__NetBSD__) || defined(__OpenBSD__)
301 #elif defined(__FreeBSD__)
305 #if defined(__NetBSD__) || defined(__OpenBSD__)
306 DPRINTF(("ulpt_detach: sc=%p flags=%d\n", sc, flags));
307 #elif defined(__FreeBSD__)
308 DPRINTF(("ulpt_detach: sc=%p\n", sc));
312 if (sc->sc_bulkpipe != NULL)
313 usbd_abort_pipe(sc->sc_bulkpipe);
316 if (--sc->sc_refcnt >= 0) {
317 /* There is noone to wake, aborting the pipe is enough */
318 /* Wait for processes to go away. */
319 usb_detach_wait(USBDEV(sc->sc_dev));
323 #if defined(__NetBSD__) || defined(__OpenBSD__)
324 /* locate the major number */
325 for (maj = 0; maj < nchrdev; maj++)
326 if (cdevsw[maj].d_open == ulptopen)
329 /* Nuke the vnodes for any open instances (calls close). */
331 vdevgone(maj, mn, mn, VCHR);
332 #elif defined(__FreeBSD__)
333 vp = SLIST_FIRST(&sc->dev->si_hlist);
335 VOP_REVOKE(vp, REVOKEALL);
336 vp = SLIST_FIRST(&sc->dev_noprime->si_hlist);
338 VOP_REVOKE(vp, REVOKEALL);
340 destroy_dev(sc->dev);
341 destroy_dev(sc->dev_noprime);
349 struct ulpt_softc *sc;
351 usb_device_request_t req;
355 req.bmRequestType = UT_READ_CLASS_INTERFACE;
356 req.bRequest = UR_GET_PORT_STATUS;
357 USETW(req.wValue, 0);
358 USETW(req.wIndex, sc->sc_ifaceno);
359 USETW(req.wLength, 1);
360 err = usbd_do_request(sc->sc_udev, &req, &status);
361 DPRINTFN(1, ("ulpt_status: status=0x%02x err=%d\n", status, err));
370 struct ulpt_softc *sc;
372 usb_device_request_t req;
374 DPRINTFN(1, ("ulpt_reset\n"));
375 req.bmRequestType = UT_WRITE_CLASS_OTHER;
376 req.bRequest = UR_SOFT_RESET;
377 USETW(req.wValue, 0);
378 USETW(req.wIndex, sc->sc_ifaceno);
379 USETW(req.wLength, 0);
380 (void)usbd_do_request(sc->sc_udev, &req, 0);
384 * Reset the printer, then wait until it's selected and not busy.
387 ulptopen(dev, flag, mode, p)
393 u_char flags = ULPTFLAGS(dev);
394 struct ulpt_softc *sc;
398 USB_GET_SC_OPEN(ulpt, ULPTUNIT(dev), sc);
400 if (sc == NULL || sc->sc_iface == NULL || sc->sc_dying)
406 sc->sc_state = ULPT_INIT;
407 sc->sc_flags = flags;
408 DPRINTF(("ulptopen: flags=0x%x\n", (unsigned)flags));
410 #if defined(ULPT_DEBUG) && defined(__FreeBSD__)
411 /* Ignoring these flags might not be a good idea */
412 if ((flags & ~ULPT_NOPRIME) != 0)
413 printf("ulptopen: flags ignored: %b\n", flags,
414 "\20\3POS_INIT\4POS_ACK\6PRIME_OPEN\7AUTOLF\10BYPASS");
418 if ((flags & ULPT_NOPRIME) == 0)
421 for (spin = 0; (ulpt_status(sc) & LPS_SELECT) == 0; spin += STEP) {
422 if (spin >= TIMEOUT) {
427 /* wait 1/4 second, give up if we get a signal */
428 error = tsleep((caddr_t)sc, LPTPRI | PCATCH, "ulptop", STEP);
429 if (error != EWOULDBLOCK) {
435 err = usbd_open_pipe(sc->sc_iface, sc->sc_bulk, 0, &sc->sc_bulkpipe);
441 sc->sc_state = ULPT_OPEN;
443 DPRINTF(("ulptopen: done\n"));
448 ulpt_statusmsg(status, sc)
450 struct ulpt_softc *sc;
454 status = (status ^ LPS_INVERT) & LPS_MASK;
455 new = status & ~sc->sc_laststatus;
456 sc->sc_laststatus = status;
458 if (new & LPS_SELECT)
459 log(LOG_NOTICE, "%s: offline\n", USBDEVNAME(sc->sc_dev));
460 else if (new & LPS_NOPAPER)
461 log(LOG_NOTICE, "%s: out of paper\n", USBDEVNAME(sc->sc_dev));
462 else if (new & LPS_NERR)
463 log(LOG_NOTICE, "%s: output error\n", USBDEVNAME(sc->sc_dev));
469 ulptclose(dev, flag, mode, p)
475 struct ulpt_softc *sc;
477 USB_GET_SC(ulpt, ULPTUNIT(dev), sc);
479 if (sc->sc_state != ULPT_OPEN)
480 /* We are being forced to close before the open completed. */
483 usbd_close_pipe(sc->sc_bulkpipe);
488 DPRINTF(("ulptclose: closed\n"));
493 ulpt_do_write(sc, uio, flags)
494 struct ulpt_softc *sc;
501 usbd_xfer_handle xfer;
504 DPRINTF(("ulptwrite\n"));
505 xfer = usbd_alloc_request(sc->sc_udev);
508 bufp = usbd_alloc_buffer(xfer, ULPT_BSIZE);
510 usbd_free_request(xfer);
513 while ((n = min(ULPT_BSIZE, uio->uio_resid)) != 0) {
514 ulpt_statusmsg(ulpt_status(sc), sc);
515 error = uiomove(bufp, n, uio);
518 DPRINTFN(1, ("ulptwrite: transfer %d bytes\n", n));
519 err = usbd_bulk_transfer(xfer, sc->sc_bulkpipe, USBD_NO_COPY,
520 USBD_NO_TIMEOUT, bufp, &n, "ulptwr");
522 DPRINTF(("ulptwrite: error=%d\n", err));
527 usbd_free_request(xfer);
533 ulptwrite(dev, uio, flags)
538 struct ulpt_softc *sc;
541 USB_GET_SC(ulpt, ULPTUNIT(dev), sc);
547 error = ulpt_do_write(sc, uio, flags);
548 if (--sc->sc_refcnt < 0)
549 usb_detach_wakeup(USBDEV(sc->sc_dev));
554 ulptioctl(dev, cmd, data, flag, p)
572 /* XXX This does not belong here. */
574 * Print select parts of a IEEE 1284 device ID.
577 ieee1284_print_id(str)
582 for (p = str-1; p; p = strchr(p, ';')) {
584 if (strncmp(p, "MFG:", 4) == 0 ||
585 strncmp(p, "MANUFACTURER:", 14) == 0 ||
586 strncmp(p, "MDL:", 4) == 0 ||
587 strncmp(p, "MODEL:", 6) == 0) {
590 printf("%.*s", (int)(q - p + 1), p);
596 #if defined(__FreeBSD__)
597 DRIVER_MODULE(ulpt, uhub, ulpt_driver, ulpt_devclass, usbd_driver_load, 0);