Annotation of sys/dev/usb/ulpt.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ulpt.c,v 1.32 2007/06/14 10:11:16 mbalmer Exp $ */
! 2: /* $NetBSD: ulpt.c,v 1.57 2003/01/05 10:19:42 scw Exp $ */
! 3: /* $FreeBSD: src/sys/dev/usb/ulpt.c,v 1.24 1999/11/17 22:33:44 n_hibma Exp $ */
! 4:
! 5: /*
! 6: * Copyright (c) 1998 The NetBSD Foundation, Inc.
! 7: * All rights reserved.
! 8: *
! 9: * This code is derived from software contributed to The NetBSD Foundation
! 10: * by Lennart Augustsson (lennart@augustsson.net) at
! 11: * Carlstedt Research & Technology.
! 12: *
! 13: * Redistribution and use in source and binary forms, with or without
! 14: * modification, are permitted provided that the following conditions
! 15: * are met:
! 16: * 1. Redistributions of source code must retain the above copyright
! 17: * notice, this list of conditions and the following disclaimer.
! 18: * 2. Redistributions in binary form must reproduce the above copyright
! 19: * notice, this list of conditions and the following disclaimer in the
! 20: * documentation and/or other materials provided with the distribution.
! 21: * 3. All advertising materials mentioning features or use of this software
! 22: * must display the following acknowledgement:
! 23: * This product includes software developed by the NetBSD
! 24: * Foundation, Inc. and its contributors.
! 25: * 4. Neither the name of The NetBSD Foundation nor the names of its
! 26: * contributors may be used to endorse or promote products derived
! 27: * from this software without specific prior written permission.
! 28: *
! 29: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
! 30: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
! 31: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
! 32: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
! 33: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
! 34: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
! 35: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
! 36: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
! 37: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
! 38: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 39: * POSSIBILITY OF SUCH DAMAGE.
! 40: */
! 41:
! 42: /*
! 43: * Printer Class spec:
! 44: * http://www.usb.org/developers/devclass_docs/usbprint11.pdf
! 45: */
! 46:
! 47: #include <sys/param.h>
! 48: #include <sys/systm.h>
! 49: #include <sys/proc.h>
! 50: #include <sys/kernel.h>
! 51: #include <sys/device.h>
! 52: #include <sys/ioctl.h>
! 53: #include <sys/uio.h>
! 54: #include <sys/conf.h>
! 55: #include <sys/vnode.h>
! 56: #include <sys/syslog.h>
! 57:
! 58: #include <dev/usb/usb.h>
! 59: #include <dev/usb/usbdi.h>
! 60: #include <dev/usb/usbdi_util.h>
! 61: #include <dev/usb/usbdevs.h>
! 62: #include <dev/usb/usb_quirks.h>
! 63:
! 64: #define TIMEOUT hz*16 /* wait up to 16 seconds for a ready */
! 65: #define STEP hz/4
! 66:
! 67: #define LPTPRI (PZERO+8)
! 68: #define ULPT_BSIZE 16384
! 69:
! 70: #ifdef ULPT_DEBUG
! 71: #define DPRINTF(x) do { if (ulptdebug) printf x; } while (0)
! 72: #define DPRINTFN(n,x) do { if (ulptdebug>(n)) printf x; } while (0)
! 73: int ulptdebug = 0;
! 74: #else
! 75: #define DPRINTF(x)
! 76: #define DPRINTFN(n,x)
! 77: #endif
! 78:
! 79: #define UR_GET_DEVICE_ID 0
! 80: #define UR_GET_PORT_STATUS 1
! 81: #define UR_SOFT_RESET 2
! 82:
! 83: #define LPS_NERR 0x08 /* printer no error */
! 84: #define LPS_SELECT 0x10 /* printer selected */
! 85: #define LPS_NOPAPER 0x20 /* printer out of paper */
! 86: #define LPS_INVERT (LPS_SELECT|LPS_NERR)
! 87: #define LPS_MASK (LPS_SELECT|LPS_NERR|LPS_NOPAPER)
! 88:
! 89: struct ulpt_softc {
! 90: struct device sc_dev;
! 91: usbd_device_handle sc_udev; /* device */
! 92: usbd_interface_handle sc_iface; /* interface */
! 93: int sc_ifaceno;
! 94:
! 95: int sc_out;
! 96: usbd_pipe_handle sc_out_pipe; /* bulk out pipe */
! 97:
! 98: int sc_in;
! 99: usbd_pipe_handle sc_in_pipe; /* bulk in pipe */
! 100: usbd_xfer_handle sc_in_xfer1;
! 101: usbd_xfer_handle sc_in_xfer2;
! 102: u_char sc_junk[64]; /* somewhere to dump input */
! 103:
! 104: u_char sc_state;
! 105: #define ULPT_OPEN 0x01 /* device is open */
! 106: #define ULPT_OBUSY 0x02 /* printer is busy doing output */
! 107: #define ULPT_INIT 0x04 /* waiting to initialize for open */
! 108: u_char sc_flags;
! 109: #define ULPT_NOPRIME 0x40 /* don't prime on open */
! 110: u_char sc_laststatus;
! 111:
! 112: int sc_refcnt;
! 113: u_char sc_dying;
! 114: };
! 115:
! 116: void ulpt_disco(void *);
! 117:
! 118: int ulpt_do_write(struct ulpt_softc *, struct uio *uio, int);
! 119: int ulpt_status(struct ulpt_softc *);
! 120: void ulpt_reset(struct ulpt_softc *);
! 121: int ulpt_statusmsg(u_char, struct ulpt_softc *);
! 122:
! 123: #if 0
! 124: void ieee1284_print_id(char *);
! 125: #endif
! 126:
! 127: #define ULPTUNIT(s) (minor(s) & 0x1f)
! 128: #define ULPTFLAGS(s) (minor(s) & 0xe0)
! 129:
! 130:
! 131: int ulpt_match(struct device *, void *, void *);
! 132: void ulpt_attach(struct device *, struct device *, void *);
! 133: int ulpt_detach(struct device *, int);
! 134: int ulpt_activate(struct device *, enum devact);
! 135:
! 136: struct cfdriver ulpt_cd = {
! 137: NULL, "ulpt", DV_DULL
! 138: };
! 139:
! 140: const struct cfattach ulpt_ca = {
! 141: sizeof(struct ulpt_softc),
! 142: ulpt_match,
! 143: ulpt_attach,
! 144: ulpt_detach,
! 145: ulpt_activate,
! 146: };
! 147:
! 148: int
! 149: ulpt_match(struct device *parent, void *match, void *aux)
! 150: {
! 151: struct usb_attach_arg *uaa = aux;
! 152: usb_interface_descriptor_t *id;
! 153:
! 154: DPRINTFN(10,("ulpt_match\n"));
! 155: if (uaa->iface == NULL)
! 156: return (UMATCH_NONE);
! 157: id = usbd_get_interface_descriptor(uaa->iface);
! 158: if (id != NULL &&
! 159: id->bInterfaceClass == UICLASS_PRINTER &&
! 160: id->bInterfaceSubClass == UISUBCLASS_PRINTER &&
! 161: ((id->bInterfaceProtocol == UIPROTO_PRINTER_UNI) ||
! 162: (id->bInterfaceProtocol == UIPROTO_PRINTER_BI) ||
! 163: (id->bInterfaceProtocol == UIPROTO_PRINTER_1284)))
! 164: return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);
! 165: return (UMATCH_NONE);
! 166: }
! 167:
! 168: void
! 169: ulpt_attach(struct device *parent, struct device *self, void *aux)
! 170: {
! 171: struct ulpt_softc *sc = (struct ulpt_softc *)self;
! 172: struct usb_attach_arg *uaa = aux;
! 173: usbd_device_handle dev = uaa->device;
! 174: usbd_interface_handle iface = uaa->iface;
! 175: usb_interface_descriptor_t *ifcd = usbd_get_interface_descriptor(iface);
! 176: usb_interface_descriptor_t *id, *iend;
! 177: usb_config_descriptor_t *cdesc;
! 178: usbd_status err;
! 179: char *devinfop;
! 180: usb_endpoint_descriptor_t *ed;
! 181: u_int8_t epcount;
! 182: int i, altno;
! 183:
! 184: DPRINTFN(10,("ulpt_attach: sc=%p\n", sc));
! 185:
! 186: devinfop = usbd_devinfo_alloc(dev, 0);
! 187: printf("\n%s: %s, iclass %d/%d\n", sc->sc_dev.dv_xname,
! 188: devinfop, ifcd->bInterfaceClass, ifcd->bInterfaceSubClass);
! 189: usbd_devinfo_free(devinfop);
! 190:
! 191: /* XXX
! 192: * Stepping through the alternate settings needs to be abstracted out.
! 193: */
! 194: cdesc = usbd_get_config_descriptor(dev);
! 195: if (cdesc == NULL) {
! 196: printf("%s: failed to get configuration descriptor\n",
! 197: sc->sc_dev.dv_xname);
! 198: return;
! 199: }
! 200: iend = (usb_interface_descriptor_t *)
! 201: ((char *)cdesc + UGETW(cdesc->wTotalLength));
! 202: #ifdef DIAGNOSTIC
! 203: if (ifcd < (usb_interface_descriptor_t *)cdesc ||
! 204: ifcd >= iend)
! 205: panic("ulpt: iface desc out of range");
! 206: #endif
! 207: /* Step through all the descriptors looking for bidir mode */
! 208: for (id = ifcd, altno = 0;
! 209: id < iend;
! 210: id = (void *)((char *)id + id->bLength)) {
! 211: if (id->bDescriptorType == UDESC_INTERFACE &&
! 212: id->bInterfaceNumber == ifcd->bInterfaceNumber) {
! 213: if (id->bInterfaceClass == UICLASS_PRINTER &&
! 214: id->bInterfaceSubClass == UISUBCLASS_PRINTER &&
! 215: (id->bInterfaceProtocol == UIPROTO_PRINTER_BI /*||
! 216: id->bInterfaceProtocol == UIPROTO_PRINTER_1284*/))
! 217: goto found;
! 218: altno++;
! 219: }
! 220: }
! 221: id = ifcd; /* not found, use original */
! 222: found:
! 223: if (id != ifcd) {
! 224: /* Found a new bidir setting */
! 225: DPRINTF(("ulpt_attach: set altno = %d\n", altno));
! 226: err = usbd_set_interface(iface, altno);
! 227: if (err) {
! 228: printf("%s: setting alternate interface failed\n",
! 229: sc->sc_dev.dv_xname);
! 230: sc->sc_dying = 1;
! 231: return;
! 232: }
! 233: }
! 234:
! 235: epcount = 0;
! 236: (void)usbd_endpoint_count(iface, &epcount);
! 237:
! 238: sc->sc_in = -1;
! 239: sc->sc_out = -1;
! 240: for (i = 0; i < epcount; i++) {
! 241: ed = usbd_interface2endpoint_descriptor(iface, i);
! 242: if (ed == NULL) {
! 243: printf("%s: couldn't get ep %d\n",
! 244: sc->sc_dev.dv_xname, i);
! 245: return;
! 246: }
! 247: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
! 248: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
! 249: sc->sc_in = ed->bEndpointAddress;
! 250: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
! 251: UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
! 252: sc->sc_out = ed->bEndpointAddress;
! 253: }
! 254: }
! 255: if (sc->sc_out == -1) {
! 256: printf("%s: could not find bulk out endpoint\n",
! 257: sc->sc_dev.dv_xname);
! 258: sc->sc_dying = 1;
! 259: return;
! 260: }
! 261:
! 262: if (usbd_get_quirks(dev)->uq_flags & UQ_BROKEN_BIDIR) {
! 263: /* This device doesn't handle reading properly. */
! 264: sc->sc_in = -1;
! 265: }
! 266:
! 267: printf("%s: using %s-directional mode\n", sc->sc_dev.dv_xname,
! 268: sc->sc_in >= 0 ? "bi" : "uni");
! 269:
! 270: DPRINTFN(10, ("ulpt_attach: bulk=%d\n", sc->sc_out));
! 271:
! 272: sc->sc_iface = iface;
! 273: sc->sc_ifaceno = id->bInterfaceNumber;
! 274: sc->sc_udev = dev;
! 275:
! 276: #if 0
! 277: /*
! 278: * This code is disabled because for some mysterious reason it causes
! 279: * printing not to work. But only sometimes, and mostly with
! 280: * UHCI and less often with OHCI. *sigh*
! 281: */
! 282: {
! 283: usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev);
! 284: usb_device_request_t req;
! 285: int len, alen;
! 286:
! 287: req.bmRequestType = UT_READ_CLASS_INTERFACE;
! 288: req.bRequest = UR_GET_DEVICE_ID;
! 289: USETW(req.wValue, cd->bConfigurationValue);
! 290: USETW2(req.wIndex, id->bInterfaceNumber, id->bAlternateSetting);
! 291: USETW(req.wLength, DEVINFOSIZE - 1);
! 292: err = usbd_do_request_flags(dev, &req, devinfop, USBD_SHORT_XFER_OK,
! 293: &alen, USBD_DEFAULT_TIMEOUT);
! 294: if (err) {
! 295: printf("%s: cannot get device id\n", sc->sc_dev.dv_xname);
! 296: } else if (alen <= 2) {
! 297: printf("%s: empty device id, no printer connected?\n",
! 298: sc->sc_dev.dv_xname);
! 299: } else {
! 300: /* devinfop now contains an IEEE-1284 device ID */
! 301: len = ((devinfop[0] & 0xff) << 8) | (devinfop[1] & 0xff);
! 302: if (len > DEVINFOSIZE - 3)
! 303: len = DEVINFOSIZE - 3;
! 304: devinfo[len] = 0;
! 305: printf("%s: device id <", sc->sc_dev.dv_xname);
! 306: ieee1284_print_id(devinfop+2);
! 307: printf(">\n");
! 308: }
! 309: }
! 310: #endif
! 311: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
! 312: &sc->sc_dev);
! 313: }
! 314:
! 315: int
! 316: ulpt_activate(struct device *self, enum devact act)
! 317: {
! 318: struct ulpt_softc *sc = (struct ulpt_softc *)self;
! 319:
! 320: switch (act) {
! 321: case DVACT_ACTIVATE:
! 322: break;
! 323:
! 324: case DVACT_DEACTIVATE:
! 325: sc->sc_dying = 1;
! 326: break;
! 327: }
! 328: return (0);
! 329: }
! 330:
! 331: int
! 332: ulpt_detach(struct device *self, int flags)
! 333: {
! 334: struct ulpt_softc *sc = (struct ulpt_softc *)self;
! 335: int s;
! 336: int maj, mn;
! 337:
! 338: DPRINTF(("ulpt_detach: sc=%p\n", sc));
! 339:
! 340: sc->sc_dying = 1;
! 341: if (sc->sc_out_pipe != NULL)
! 342: usbd_abort_pipe(sc->sc_out_pipe);
! 343: if (sc->sc_in_pipe != NULL)
! 344: usbd_abort_pipe(sc->sc_in_pipe);
! 345:
! 346: s = splusb();
! 347: if (--sc->sc_refcnt >= 0) {
! 348: /* There is noone to wake, aborting the pipe is enough */
! 349: /* Wait for processes to go away. */
! 350: usb_detach_wait(&sc->sc_dev);
! 351: }
! 352: splx(s);
! 353:
! 354: /* locate the major number */
! 355: for (maj = 0; maj < nchrdev; maj++)
! 356: if (cdevsw[maj].d_open == ulptopen)
! 357: break;
! 358:
! 359: /* Nuke the vnodes for any open instances (calls close). */
! 360: mn = self->dv_unit;
! 361: vdevgone(maj, mn, mn, VCHR);
! 362: vdevgone(maj, mn | ULPT_NOPRIME , mn | ULPT_NOPRIME, VCHR);
! 363:
! 364: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
! 365: &sc->sc_dev);
! 366:
! 367: return (0);
! 368: }
! 369:
! 370: int
! 371: ulpt_status(struct ulpt_softc *sc)
! 372: {
! 373: usb_device_request_t req;
! 374: usbd_status err;
! 375: u_char status;
! 376:
! 377: req.bmRequestType = UT_READ_CLASS_INTERFACE;
! 378: req.bRequest = UR_GET_PORT_STATUS;
! 379: USETW(req.wValue, 0);
! 380: USETW(req.wIndex, sc->sc_ifaceno);
! 381: USETW(req.wLength, 1);
! 382: err = usbd_do_request(sc->sc_udev, &req, &status);
! 383: DPRINTFN(1, ("ulpt_status: status=0x%02x err=%d\n", status, err));
! 384: if (!err)
! 385: return (status);
! 386: else
! 387: return (0);
! 388: }
! 389:
! 390: void
! 391: ulpt_reset(struct ulpt_softc *sc)
! 392: {
! 393: usb_device_request_t req;
! 394:
! 395: DPRINTFN(1, ("ulpt_reset\n"));
! 396: req.bRequest = UR_SOFT_RESET;
! 397: USETW(req.wValue, 0);
! 398: USETW(req.wIndex, sc->sc_ifaceno);
! 399: USETW(req.wLength, 0);
! 400:
! 401: /*
! 402: * There was a mistake in the USB printer 1.0 spec that gave the
! 403: * request type as UT_WRITE_CLASS_OTHER; it should have been
! 404: * UT_WRITE_CLASS_INTERFACE. Many printers use the old one,
! 405: * so we try both.
! 406: */
! 407: req.bmRequestType = UT_WRITE_CLASS_OTHER;
! 408: if (usbd_do_request(sc->sc_udev, &req, 0)) { /* 1.0 */
! 409: req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
! 410: (void)usbd_do_request(sc->sc_udev, &req, 0); /* 1.1 */
! 411: }
! 412: }
! 413:
! 414: static void
! 415: ulpt_input(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
! 416: {
! 417: struct ulpt_softc *sc = priv;
! 418:
! 419: DPRINTFN(2,("ulpt_input: got some data\n"));
! 420: /* Do it again. */
! 421: if (xfer == sc->sc_in_xfer1)
! 422: usbd_transfer(sc->sc_in_xfer2);
! 423: else
! 424: usbd_transfer(sc->sc_in_xfer1);
! 425: }
! 426:
! 427: int ulptusein = 1;
! 428:
! 429: /*
! 430: * Reset the printer, then wait until it's selected and not busy.
! 431: */
! 432: int
! 433: ulptopen(dev_t dev, int flag, int mode, struct proc *p)
! 434: {
! 435: u_char flags = ULPTFLAGS(dev);
! 436: struct ulpt_softc *sc;
! 437: usbd_status err;
! 438: int spin, error;
! 439:
! 440: if (ULPTUNIT(dev) >= ulpt_cd.cd_ndevs)
! 441: return (ENXIO);
! 442: sc = ulpt_cd.cd_devs[ULPTUNIT(dev)];
! 443: if (sc == NULL)
! 444: return (ENXIO);
! 445:
! 446: if (sc == NULL || sc->sc_iface == NULL || sc->sc_dying)
! 447: return (ENXIO);
! 448:
! 449: if (sc->sc_state)
! 450: return (EBUSY);
! 451:
! 452: sc->sc_state = ULPT_INIT;
! 453: sc->sc_flags = flags;
! 454: DPRINTF(("ulptopen: flags=0x%x\n", (unsigned)flags));
! 455:
! 456: error = 0;
! 457: sc->sc_refcnt++;
! 458:
! 459: if ((flags & ULPT_NOPRIME) == 0)
! 460: ulpt_reset(sc);
! 461:
! 462: for (spin = 0; (ulpt_status(sc) & LPS_SELECT) == 0; spin += STEP) {
! 463: DPRINTF(("ulpt_open: waiting a while\n"));
! 464: if (spin >= TIMEOUT) {
! 465: error = EBUSY;
! 466: sc->sc_state = 0;
! 467: goto done;
! 468: }
! 469:
! 470: /* wait 1/4 second, give up if we get a signal */
! 471: error = tsleep((caddr_t)sc, LPTPRI | PCATCH, "ulptop", STEP);
! 472: if (error != EWOULDBLOCK) {
! 473: sc->sc_state = 0;
! 474: goto done;
! 475: }
! 476:
! 477: if (sc->sc_dying) {
! 478: error = ENXIO;
! 479: sc->sc_state = 0;
! 480: goto done;
! 481: }
! 482: }
! 483:
! 484: err = usbd_open_pipe(sc->sc_iface, sc->sc_out, 0, &sc->sc_out_pipe);
! 485: if (err) {
! 486: sc->sc_state = 0;
! 487: error = EIO;
! 488: goto done;
! 489: }
! 490: if (ulptusein && sc->sc_in != -1) {
! 491: DPRINTF(("ulpt_open: open input pipe\n"));
! 492: err = usbd_open_pipe(sc->sc_iface, sc->sc_in,0,&sc->sc_in_pipe);
! 493: if (err) {
! 494: error = EIO;
! 495: usbd_close_pipe(sc->sc_out_pipe);
! 496: sc->sc_out_pipe = NULL;
! 497: sc->sc_state = 0;
! 498: goto done;
! 499: }
! 500: sc->sc_in_xfer1 = usbd_alloc_xfer(sc->sc_udev);
! 501: sc->sc_in_xfer2 = usbd_alloc_xfer(sc->sc_udev);
! 502: if (sc->sc_in_xfer1 == NULL || sc->sc_in_xfer2 == NULL) {
! 503: error = ENOMEM;
! 504: if (sc->sc_in_xfer1 != NULL) {
! 505: usbd_free_xfer(sc->sc_in_xfer1);
! 506: sc->sc_in_xfer1 = NULL;
! 507: }
! 508: if (sc->sc_in_xfer2 != NULL) {
! 509: usbd_free_xfer(sc->sc_in_xfer2);
! 510: sc->sc_in_xfer2 = NULL;
! 511: }
! 512: usbd_close_pipe(sc->sc_out_pipe);
! 513: sc->sc_out_pipe = NULL;
! 514: usbd_close_pipe(sc->sc_in_pipe);
! 515: sc->sc_in_pipe = NULL;
! 516: sc->sc_state = 0;
! 517: goto done;
! 518: }
! 519: usbd_setup_xfer(sc->sc_in_xfer1, sc->sc_in_pipe, sc,
! 520: sc->sc_junk, sizeof sc->sc_junk, USBD_SHORT_XFER_OK,
! 521: USBD_NO_TIMEOUT, ulpt_input);
! 522: usbd_setup_xfer(sc->sc_in_xfer2, sc->sc_in_pipe, sc,
! 523: sc->sc_junk, sizeof sc->sc_junk, USBD_SHORT_XFER_OK,
! 524: USBD_NO_TIMEOUT, ulpt_input);
! 525: usbd_transfer(sc->sc_in_xfer1); /* ignore failed start */
! 526: }
! 527:
! 528: sc->sc_state = ULPT_OPEN;
! 529:
! 530: done:
! 531: if (--sc->sc_refcnt < 0)
! 532: usb_detach_wakeup(&sc->sc_dev);
! 533:
! 534: DPRINTF(("ulptopen: done, error=%d\n", error));
! 535: return (error);
! 536: }
! 537:
! 538: int
! 539: ulpt_statusmsg(u_char status, struct ulpt_softc *sc)
! 540: {
! 541: u_char new;
! 542:
! 543: status = (status ^ LPS_INVERT) & LPS_MASK;
! 544: new = status & ~sc->sc_laststatus;
! 545: sc->sc_laststatus = status;
! 546:
! 547: if (new & LPS_SELECT)
! 548: log(LOG_NOTICE, "%s: offline\n", sc->sc_dev.dv_xname);
! 549: else if (new & LPS_NOPAPER)
! 550: log(LOG_NOTICE, "%s: out of paper\n", sc->sc_dev.dv_xname);
! 551: else if (new & LPS_NERR)
! 552: log(LOG_NOTICE, "%s: output error\n", sc->sc_dev.dv_xname);
! 553:
! 554: return (status);
! 555: }
! 556:
! 557: int
! 558: ulptclose(dev_t dev, int flag, int mode, struct proc *p)
! 559: {
! 560: struct ulpt_softc *sc;
! 561:
! 562: sc = ulpt_cd.cd_devs[ULPTUNIT(dev)];
! 563:
! 564: if (sc->sc_state != ULPT_OPEN)
! 565: /* We are being forced to close before the open completed. */
! 566: return (0);
! 567:
! 568: if (sc->sc_out_pipe != NULL) {
! 569: usbd_close_pipe(sc->sc_out_pipe);
! 570: sc->sc_out_pipe = NULL;
! 571: }
! 572: if (sc->sc_in_pipe != NULL) {
! 573: usbd_abort_pipe(sc->sc_in_pipe);
! 574: usbd_close_pipe(sc->sc_in_pipe);
! 575: sc->sc_in_pipe = NULL;
! 576: if (sc->sc_in_xfer1 != NULL) {
! 577: usbd_free_xfer(sc->sc_in_xfer1);
! 578: sc->sc_in_xfer1 = NULL;
! 579: }
! 580: if (sc->sc_in_xfer2 != NULL) {
! 581: usbd_free_xfer(sc->sc_in_xfer2);
! 582: sc->sc_in_xfer2 = NULL;
! 583: }
! 584: }
! 585:
! 586: sc->sc_state = 0;
! 587:
! 588: DPRINTF(("ulptclose: closed\n"));
! 589: return (0);
! 590: }
! 591:
! 592: int
! 593: ulpt_do_write(struct ulpt_softc *sc, struct uio *uio, int flags)
! 594: {
! 595: u_int32_t n;
! 596: int error = 0;
! 597: void *bufp;
! 598: usbd_xfer_handle xfer;
! 599: usbd_status err;
! 600:
! 601: DPRINTF(("ulptwrite\n"));
! 602: xfer = usbd_alloc_xfer(sc->sc_udev);
! 603: if (xfer == NULL)
! 604: return (ENOMEM);
! 605: bufp = usbd_alloc_buffer(xfer, ULPT_BSIZE);
! 606: if (bufp == NULL) {
! 607: usbd_free_xfer(xfer);
! 608: return (ENOMEM);
! 609: }
! 610: while ((n = min(ULPT_BSIZE, uio->uio_resid)) != 0) {
! 611: ulpt_statusmsg(ulpt_status(sc), sc);
! 612: error = uiomove(bufp, n, uio);
! 613: if (error)
! 614: break;
! 615: DPRINTFN(1, ("ulptwrite: transfer %d bytes\n", n));
! 616: err = usbd_bulk_transfer(xfer, sc->sc_out_pipe, USBD_NO_COPY,
! 617: USBD_NO_TIMEOUT, bufp, &n, "ulptwr");
! 618: if (err) {
! 619: DPRINTF(("ulptwrite: error=%d\n", err));
! 620: error = EIO;
! 621: break;
! 622: }
! 623: }
! 624: usbd_free_xfer(xfer);
! 625:
! 626: return (error);
! 627: }
! 628:
! 629: int
! 630: ulptwrite(dev_t dev, struct uio *uio, int flags)
! 631: {
! 632: struct ulpt_softc *sc;
! 633: int error;
! 634:
! 635: sc = ulpt_cd.cd_devs[ULPTUNIT(dev)];
! 636:
! 637: if (sc->sc_dying)
! 638: return (EIO);
! 639:
! 640: sc->sc_refcnt++;
! 641: error = ulpt_do_write(sc, uio, flags);
! 642: if (--sc->sc_refcnt < 0)
! 643: usb_detach_wakeup(&sc->sc_dev);
! 644: return (error);
! 645: }
! 646:
! 647: int
! 648: ulptioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
! 649: {
! 650: int error = 0;
! 651:
! 652: switch (cmd) {
! 653: default:
! 654: error = ENODEV;
! 655: }
! 656:
! 657: return (error);
! 658: }
! 659:
! 660: #if 0
! 661: /* XXX This does not belong here. */
! 662: /*
! 663: * Print select parts of a IEEE 1284 device ID.
! 664: */
! 665: void
! 666: ieee1284_print_id(char *str)
! 667: {
! 668: char *p, *q;
! 669:
! 670: for (p = str-1; p; p = strchr(p, ';')) {
! 671: p++; /* skip ';' */
! 672: if (strncmp(p, "MFG:", 4) == 0 ||
! 673: strncmp(p, "MANUFACTURER:", 14) == 0 ||
! 674: strncmp(p, "MDL:", 4) == 0 ||
! 675: strncmp(p, "MODEL:", 6) == 0) {
! 676: q = strchr(p, ';');
! 677: if (q)
! 678: printf("%.*s", (int)(q - p + 1), p);
! 679: }
! 680: }
! 681: }
! 682: #endif
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ulpt.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb