Diff for /src/sys/dev/usbmisc/ulpt/ulpt.c between versions 1.6 and 1.7

version 1.6, 2003/12/29 06:42:17 version 1.7, 2003/12/30 01:01:47
Line 1 Line 1
 /*  /*
 * $NetBSD: ulpt.c,v 1.29 1999/11/17 23:00:50 augustss Exp $ * $NetBSD: ulpt.c,v 1.55 2002/10/23 09:14:01 jdolecek Exp $
 * $FreeBSD: src/sys/dev/usb/ulpt.c,v 1.26.2.14 2003/06/22 13:54:30 iedowse Exp $ * $FreeBSD: src/sys/dev/usb/ulpt.c,v 1.59 2003/09/28 20:48:13 phk Exp $
  * $DragonFly$   * $DragonFly$
  */   */
   
Line 42 Line 42
  */   */
   
 /*  /*
 * Printer Class spec: http://www.usb.org/developers/data/usbprn10.pdf * Printer Class spec: http://www.usb.org/developers/data/devclass/usbprint109.PDF
  */   */
   
 /* XXX Note in the manpage the ULPT_NOPRIME version of the printer */  
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/proc.h>  #include <sys/proc.h>
Line 55 Line 53
 #include <sys/device.h>  #include <sys/device.h>
 #include <sys/ioctl.h>  #include <sys/ioctl.h>
 #elif defined(__FreeBSD__)  #elif defined(__FreeBSD__)
   #include <sys/ioccom.h>
 #include <sys/module.h>  #include <sys/module.h>
 #include <sys/bus.h>  #include <sys/bus.h>
 #endif  #endif
 #include <sys/uio.h>  #include <sys/uio.h>
 #include <sys/conf.h>  #include <sys/conf.h>
 #include <sys/vnode.h>  
 #include <sys/syslog.h>  #include <sys/syslog.h>
 #include <sys/sysctl.h>  #include <sys/sysctl.h>
   
 #include <bus/usb/usb.h>  #include <bus/usb/usb.h>
 #include <bus/usb/usbdi.h>  #include <bus/usb/usbdi.h>
 #include <bus/usb/usbdi_util.h>  #include <bus/usb/usbdi_util.h>
   #include <bus/usb/usbdevs.h>
   #include <bus/usb/usb_quirks.h>
   
 #define TIMEOUT         hz*16   /* wait up to 16 seconds for a ready */  #define TIMEOUT         hz*16   /* wait up to 16 seconds for a ready */
 #define STEP            hz/4  #define STEP            hz/4
Line 100  struct ulpt_softc { Line 100  struct ulpt_softc {
         usbd_device_handle sc_udev;     /* device */          usbd_device_handle sc_udev;     /* device */
         usbd_interface_handle sc_iface; /* interface */          usbd_interface_handle sc_iface; /* interface */
         int sc_ifaceno;          int sc_ifaceno;
        usbd_pipe_handle sc_bulkpipe;   /* bulk pipe */
        int sc_bulk;        int sc_out;
         usbd_pipe_handle sc_out_pipe;   /* bulk out pipe */
 
         int sc_in;
         usbd_pipe_handle sc_in_pipe;    /* bulk in pipe */
         usbd_xfer_handle sc_in_xfer1;
         usbd_xfer_handle sc_in_xfer2;
         u_char sc_junk[64];     /* somewhere to dump input */
   
         u_char sc_state;          u_char sc_state;
 #define ULPT_OPEN       0x01    /* device is open */  #define ULPT_OPEN       0x01    /* device is open */
Line 120  struct ulpt_softc { Line 127  struct ulpt_softc {
 #endif  #endif
 };  };
   
#if defined(__NetBSD__) || defined(__OpenBSD__)#if defined(__NetBSD__)
 dev_type_open(ulptopen);
 dev_type_close(ulptclose);
 dev_type_write(ulptwrite);
 dev_type_ioctl(ulptioctl);
 
 const struct cdevsw ulpt_cdevsw = {
         ulptopen, ulptclose, noread, ulptwrite, ulptioctl,
         nostop, notty, nopoll, nommap, nokqfilter,
 };
 #elif defined(__OpenBSD__)
 cdev_decl(ulpt);  cdev_decl(ulpt);
 #elif defined(__FreeBSD__)  #elif defined(__FreeBSD__)
 Static d_open_t ulptopen;  Static d_open_t ulptopen;
Line 157  int ulpt_status(struct ulpt_softc *); Line 174  int ulpt_status(struct ulpt_softc *);
 void ulpt_reset(struct ulpt_softc *);  void ulpt_reset(struct ulpt_softc *);
 int ulpt_statusmsg(u_char, struct ulpt_softc *);  int ulpt_statusmsg(u_char, struct ulpt_softc *);
   
   #if 0
 void ieee1284_print_id(char *);  void ieee1284_print_id(char *);
   #endif
   
 #define ULPTUNIT(s)     (minor(s) & 0x1f)  #define ULPTUNIT(s)     (minor(s) & 0x1f)
 #define ULPTFLAGS(s)    (minor(s) & 0xe0)  #define ULPTFLAGS(s)    (minor(s) & 0xe0)
Line 169  USB_MATCH(ulpt) Line 188  USB_MATCH(ulpt)
 {  {
         USB_MATCH_START(ulpt, uaa);          USB_MATCH_START(ulpt, uaa);
         usb_interface_descriptor_t *id;          usb_interface_descriptor_t *id;
        
         DPRINTFN(10,("ulpt_match\n"));          DPRINTFN(10,("ulpt_match\n"));
         if (uaa->iface == NULL)          if (uaa->iface == NULL)
                 return (UMATCH_NONE);                  return (UMATCH_NONE);
Line 178  USB_MATCH(ulpt) Line 197  USB_MATCH(ulpt)
             id->bInterfaceClass == UICLASS_PRINTER &&              id->bInterfaceClass == UICLASS_PRINTER &&
             id->bInterfaceSubClass == UISUBCLASS_PRINTER &&              id->bInterfaceSubClass == UISUBCLASS_PRINTER &&
             (id->bInterfaceProtocol == UIPROTO_PRINTER_UNI ||              (id->bInterfaceProtocol == UIPROTO_PRINTER_UNI ||
             id->bInterfaceProtocol == UIPROTO_PRINTER_BI))             id->bInterfaceProtocol == UIPROTO_PRINTER_BI ||
              id->bInterfaceProtocol == UIPROTO_PRINTER_1284))
                 return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);                  return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);
         return (UMATCH_NONE);          return (UMATCH_NONE);
 }  }
Line 188  USB_ATTACH(ulpt) Line 208  USB_ATTACH(ulpt)
         USB_ATTACH_START(ulpt, sc, uaa);          USB_ATTACH_START(ulpt, sc, uaa);
         usbd_device_handle dev = uaa->device;          usbd_device_handle dev = uaa->device;
         usbd_interface_handle iface = uaa->iface;          usbd_interface_handle iface = uaa->iface;
        usb_interface_descriptor_t *id = usbd_get_interface_descriptor(iface);        usb_interface_descriptor_t *ifcd = usbd_get_interface_descriptor(iface);
         usb_interface_descriptor_t *id, *iend;
         usb_config_descriptor_t *cdesc;
         usbd_status err;
         char devinfo[1024];          char devinfo[1024];
         usb_endpoint_descriptor_t *ed;          usb_endpoint_descriptor_t *ed;
        usbd_status err;        u_int8_t epcount;
                int i, altno;
 
         DPRINTFN(10,("ulpt_attach: sc=%p\n", sc));          DPRINTFN(10,("ulpt_attach: sc=%p\n", sc));
         usbd_devinfo(dev, 0, devinfo);          usbd_devinfo(dev, 0, devinfo);
         USB_ATTACH_SETUP;          USB_ATTACH_SETUP;
         printf("%s: %s, iclass %d/%d\n", USBDEVNAME(sc->sc_dev),          printf("%s: %s, iclass %d/%d\n", USBDEVNAME(sc->sc_dev),
               devinfo, id->bInterfaceClass, id->bInterfaceSubClass);               devinfo, ifcd->bInterfaceClass, ifcd->bInterfaceSubClass);
   
        /* Figure out which endpoint is the bulk out endpoint. */        /* XXX
        ed = usbd_interface2endpoint_descriptor(iface, 0);         * Stepping through the alternate settings needs to be abstracted out.
        if (ed == NULL)         */
                goto nobulk;        cdesc = usbd_get_config_descriptor(dev);
        if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_OUT ||        if (cdesc == NULL) {
            (ed->bmAttributes & UE_XFERTYPE) != UE_BULK) {                printf("%s: failed to get configuration descriptor\n",
                /* In case we are using a bidir protocol... */                       USBDEVNAME(sc->sc_dev));
                ed = usbd_interface2endpoint_descriptor(iface, 1);                USB_ATTACH_ERROR_RETURN;
                if (ed == NULL)        }
                        goto nobulk;        iend = (usb_interface_descriptor_t *)
                if (UE_GET_DIR(ed->bEndpointAddress) != UE_DIR_OUT ||                   ((char *)cdesc + UGETW(cdesc->wTotalLength));
                    (ed->bmAttributes & UE_XFERTYPE) != UE_BULK)#ifdef DIAGNOSTIC
                        goto nobulk;        if (ifcd < (usb_interface_descriptor_t *)cdesc ||
             ifcd >= iend)
                 panic("ulpt: iface desc out of range");
 #endif
         /* Step through all the descriptors looking for bidir mode */
         for (id = ifcd, altno = 0;
              id < iend;
              id = (void *)((char *)id + id->bLength)) {
                 if (id->bDescriptorType == UDESC_INTERFACE &&
                     id->bInterfaceNumber == ifcd->bInterfaceNumber) {
                         if (id->bInterfaceClass == UICLASS_PRINTER &&
                             id->bInterfaceSubClass == UISUBCLASS_PRINTER &&
                             (id->bInterfaceProtocol == UIPROTO_PRINTER_BI /* ||
                              id->bInterfaceProtocol == UIPROTO_PRINTER_1284 */))
                                 goto found;
                         altno++;
                 }
         }
         id = ifcd;              /* not found, use original */
  found:
         if (id != ifcd) {
                 /* Found a new bidir setting */
                 DPRINTF(("ulpt_attach: set altno = %d\n", altno));
                 err = usbd_set_interface(iface, altno);
                 if (err) {
                         printf("%s: setting alternate interface failed\n",
                                USBDEVNAME(sc->sc_dev));
                         sc->sc_dying = 1;
                         USB_ATTACH_ERROR_RETURN;
                 }
         }          }
         sc->sc_bulk = ed->bEndpointAddress;  
         DPRINTFN(10, ("ulpt_attach: bulk=%d\n", sc->sc_bulk));  
   
        sc->sc_iface = iface;        epcount = 0;
        err = usbd_interface2device_handle(iface, &sc->sc_udev);        (void)usbd_endpoint_count(iface, &epcount);
        if (err) {
         sc->sc_in = -1;
         sc->sc_out = -1;
         for (i = 0; i < epcount; i++) {
                 ed = usbd_interface2endpoint_descriptor(iface, i);
                 if (ed == NULL) {
                         printf("%s: couldn't get ep %d\n",
                             USBDEVNAME(sc->sc_dev), i);
                         USB_ATTACH_ERROR_RETURN;
                 }
                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
                         sc->sc_in = ed->bEndpointAddress;
                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
                            UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
                         sc->sc_out = ed->bEndpointAddress;
                 }
         }
         if (sc->sc_out == -1) {
                 printf("%s: could not find bulk out endpoint\n",
                     USBDEVNAME(sc->sc_dev));
                 sc->sc_dying = 1;                  sc->sc_dying = 1;
                 USB_ATTACH_ERROR_RETURN;                  USB_ATTACH_ERROR_RETURN;
         }          }
   
           if (usbd_get_quirks(dev)->uq_flags & UQ_BROKEN_BIDIR) {
                   /* This device doesn't handle reading properly. */
                   sc->sc_in = -1;
           }
   
           printf("%s: using %s-directional mode\n", USBDEVNAME(sc->sc_dev),
                  sc->sc_in >= 0 ? "bi" : "uni");
   
           DPRINTFN(10, ("ulpt_attach: bulk=%d\n", sc->sc_out));
   
           sc->sc_iface = iface;
         sc->sc_ifaceno = id->bInterfaceNumber;          sc->sc_ifaceno = id->bInterfaceNumber;
           sc->sc_udev = dev;
   
 #if 0  #if 0
 /*  /*
Line 241  USB_ATTACH(ulpt) Line 325  USB_ATTACH(ulpt)
         USETW2(req.wIndex, id->bInterfaceNumber, id->bAlternateSetting);          USETW2(req.wIndex, id->bInterfaceNumber, id->bAlternateSetting);
         USETW(req.wLength, sizeof devinfo - 1);          USETW(req.wLength, sizeof devinfo - 1);
         err = usbd_do_request_flags(dev, &req, devinfo, USBD_SHORT_XFER_OK,          err = usbd_do_request_flags(dev, &req, devinfo, USBD_SHORT_XFER_OK,
                  &alen);                  &alen, USBD_DEFAULT_TIMEOUT);
         if (err) {          if (err) {
                 printf("%s: cannot get device id\n", USBDEVNAME(sc->sc_dev));                  printf("%s: cannot get device id\n", USBDEVNAME(sc->sc_dev));
         } else if (alen <= 2) {          } else if (alen <= 2) {
Line 268  USB_ATTACH(ulpt) Line 352  USB_ATTACH(ulpt)
                 UID_ROOT, GID_OPERATOR, 0644, "unlpt%d", device_get_unit(self));                  UID_ROOT, GID_OPERATOR, 0644, "unlpt%d", device_get_unit(self));
 #endif  #endif
   
        USB_ATTACH_SUCCESS_RETURN;        usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
                            USBDEV(sc->sc_dev));
   
 nobulk:        USB_ATTACH_SUCCESS_RETURN;
        printf("%s: could not find bulk endpoint\n", USBDEVNAME(sc->sc_dev)); 
        sc->sc_dying = 1; 
        USB_ATTACH_ERROR_RETURN; 
 }  }
   
 #if defined(__NetBSD__) || defined(__OpenBSD__)  #if defined(__NetBSD__) || defined(__OpenBSD__)
Line 285  ulpt_activate(device_ptr_t self, enum de Line 367  ulpt_activate(device_ptr_t self, enum de
         switch (act) {          switch (act) {
         case DVACT_ACTIVATE:          case DVACT_ACTIVATE:
                 return (EOPNOTSUPP);                  return (EOPNOTSUPP);
                 break;  
   
         case DVACT_DEACTIVATE:          case DVACT_DEACTIVATE:
                 sc->sc_dying = 1;                  sc->sc_dying = 1;
Line 301  USB_DETACH(ulpt) Line 382  USB_DETACH(ulpt)
         int s;          int s;
 #if defined(__NetBSD__) || defined(__OpenBSD__)  #if defined(__NetBSD__) || defined(__OpenBSD__)
         int maj, mn;          int maj, mn;
 #elif defined(__FreeBSD__)  
         struct vnode *vp;  
 #endif  #endif
   
 #if defined(__NetBSD__) || defined(__OpenBSD__)  #if defined(__NetBSD__) || defined(__OpenBSD__)
Line 312  USB_DETACH(ulpt) Line 391  USB_DETACH(ulpt)
 #endif  #endif
   
         sc->sc_dying = 1;          sc->sc_dying = 1;
        if (sc->sc_bulkpipe != NULL)        if (sc->sc_out_pipe != NULL)
                usbd_abort_pipe(sc->sc_bulkpipe);                usbd_abort_pipe(sc->sc_out_pipe);
         if (sc->sc_in_pipe != NULL)
                 usbd_abort_pipe(sc->sc_in_pipe);
   
         s = splusb();          s = splusb();
         if (--sc->sc_refcnt >= 0) {          if (--sc->sc_refcnt >= 0) {
Line 325  USB_DETACH(ulpt) Line 406  USB_DETACH(ulpt)
   
 #if defined(__NetBSD__) || defined(__OpenBSD__)  #if defined(__NetBSD__) || defined(__OpenBSD__)
         /* locate the major number */          /* locate the major number */
   #if defined(__NetBSD__)
           maj = cdevsw_lookup_major(&ulpt_cdevsw);
   #elif defined(__OpenBSD__)
         for (maj = 0; maj < nchrdev; maj++)          for (maj = 0; maj < nchrdev; maj++)
                 if (cdevsw[maj].d_open == ulptopen)                  if (cdevsw[maj].d_open == ulptopen)
                         break;                          break;
   #endif
   
         /* Nuke the vnodes for any open instances (calls close). */          /* Nuke the vnodes for any open instances (calls close). */
         mn = self->dv_unit;          mn = self->dv_unit;
         vdevgone(maj, mn, mn, VCHR);          vdevgone(maj, mn, mn, VCHR);
 #elif defined(__FreeBSD__)  #elif defined(__FreeBSD__)
         vp = SLIST_FIRST(&sc->dev->si_hlist);  
         if (vp)  
                 VOP_REVOKE(vp, REVOKEALL);  
         vp = SLIST_FIRST(&sc->dev_noprime->si_hlist);  
         if (vp)  
                 VOP_REVOKE(vp, REVOKEALL);  
   
         destroy_dev(sc->dev);          destroy_dev(sc->dev);
         destroy_dev(sc->dev_noprime);          destroy_dev(sc->dev_noprime);
 #endif  #endif
   
           usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
                              USBDEV(sc->sc_dev));
   
         return (0);          return (0);
 }  }
   
Line 373  ulpt_reset(struct ulpt_softc *sc) Line 454  ulpt_reset(struct ulpt_softc *sc)
         usb_device_request_t req;          usb_device_request_t req;
   
         DPRINTFN(1, ("ulpt_reset\n"));          DPRINTFN(1, ("ulpt_reset\n"));
         req.bmRequestType = UT_WRITE_CLASS_OTHER;  
         req.bRequest = UR_SOFT_RESET;          req.bRequest = UR_SOFT_RESET;
         USETW(req.wValue, 0);          USETW(req.wValue, 0);
         USETW(req.wIndex, sc->sc_ifaceno);          USETW(req.wIndex, sc->sc_ifaceno);
         USETW(req.wLength, 0);          USETW(req.wLength, 0);
        (void)usbd_do_request(sc->sc_udev, &req, 0);
         /*
          * There was a mistake in the USB printer 1.0 spec that gave the
          * request type as UT_WRITE_CLASS_OTHER; it should have been
          * UT_WRITE_CLASS_INTERFACE.  Many printers use the old one,
          * so we try both.
          */
         req.bmRequestType = UT_WRITE_CLASS_OTHER;
         if (usbd_do_request(sc->sc_udev, &req, 0)) {    /* 1.0 */
                 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
                 (void)usbd_do_request(sc->sc_udev, &req, 0); /* 1.1 */
         }
 }  }
   
   static void
   ulpt_input(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status)
   {
           struct ulpt_softc *sc = priv;
           u_int32_t count;
   
           /* Don't loop on errors or 0-length input. */
           usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
           if (status != USBD_NORMAL_COMPLETION || count == 0)
                   return;
   
           DPRINTFN(2,("ulpt_input: got some data\n"));
           /* Do it again. */
           if (xfer == sc->sc_in_xfer1)
                   usbd_transfer(sc->sc_in_xfer2);
           else
                   usbd_transfer(sc->sc_in_xfer1);
   }
   
   int ulptusein = 1;
   
 /*  /*
  * Reset the printer, then wait until it's selected and not busy.   * Reset the printer, then wait until it's selected and not busy.
  */   */
Line 411  ulptopen(dev_t dev, int flag, int mode, Line 523  ulptopen(dev_t dev, int flag, int mode,
                         "\20\3POS_INIT\4POS_ACK\6PRIME_OPEN\7AUTOLF\10BYPASS");                          "\20\3POS_INIT\4POS_ACK\6PRIME_OPEN\7AUTOLF\10BYPASS");
 #endif  #endif
   
           error = 0;
           sc->sc_refcnt++;
   
         if ((flags & ULPT_NOPRIME) == 0) {          if ((flags & ULPT_NOPRIME) == 0) {
                 ulpt_reset(sc);                  ulpt_reset(sc);
                 if (sc->sc_dying) {                  if (sc->sc_dying) {
                           error = ENXIO;
                         sc->sc_state = 0;                          sc->sc_state = 0;
                        return (ENXIO);                        goto done;
                 }                  }
         }          }
   
         for (spin = 0; (ulpt_status(sc) & LPS_SELECT) == 0; spin += STEP) {          for (spin = 0; (ulpt_status(sc) & LPS_SELECT) == 0; spin += STEP) {
                   DPRINTF(("ulpt_open: waiting a while\n"));
                 if (spin >= TIMEOUT) {                  if (spin >= TIMEOUT) {
                           error = EBUSY;
                         sc->sc_state = 0;                          sc->sc_state = 0;
                        return (EBUSY);                        goto done;
                 }                  }
   
                 /* wait 1/4 second, give up if we get a signal */                  /* wait 1/4 second, give up if we get a signal */
                 error = tsleep((caddr_t)sc, PCATCH, "ulptop", STEP);                  error = tsleep((caddr_t)sc, PCATCH, "ulptop", STEP);
                 if (error != EWOULDBLOCK) {                  if (error != EWOULDBLOCK) {
                         sc->sc_state = 0;                          sc->sc_state = 0;
                        return (error);                        goto done;
                 }                  }
   
                 if (sc->sc_dying) {                  if (sc->sc_dying) {
                           error = ENXIO;
                         sc->sc_state = 0;                          sc->sc_state = 0;
                        return (ENXIO);                        goto done;
                 }                  }
         }          }
   
        err = usbd_open_pipe(sc->sc_iface, sc->sc_bulk, 0, &sc->sc_bulkpipe);        err = usbd_open_pipe(sc->sc_iface, sc->sc_out, 0, &sc->sc_out_pipe);
         if (err) {          if (err) {
                 sc->sc_state = 0;                  sc->sc_state = 0;
                return (EIO);                error = EIO;
                 goto done;
         }
 
         if (ulptusein && sc->sc_in != -1) {
                 DPRINTF(("ulpt_open: open input pipe\n"));
                 err = usbd_open_pipe(sc->sc_iface, sc->sc_in,0,&sc->sc_in_pipe);
                 if (err) {
                         error = EIO;
                         usbd_close_pipe(sc->sc_out_pipe);
                         sc->sc_out_pipe = NULL;
                         sc->sc_state = 0;
                         goto done;
                 }
                 sc->sc_in_xfer1 = usbd_alloc_xfer(sc->sc_udev);
                 sc->sc_in_xfer2 = usbd_alloc_xfer(sc->sc_udev);
                 if (sc->sc_in_xfer1 == NULL || sc->sc_in_xfer2 == NULL) {
                         error = ENOMEM;
                         if (sc->sc_in_xfer1 != NULL) {
                                 usbd_free_xfer(sc->sc_in_xfer1);
                                 sc->sc_in_xfer1 = NULL;
                         }
                         if (sc->sc_in_xfer2 != NULL) {
                                 usbd_free_xfer(sc->sc_in_xfer2);
                                 sc->sc_in_xfer2 = NULL;
                         }
                         usbd_close_pipe(sc->sc_out_pipe);
                         sc->sc_out_pipe = NULL;
                         usbd_close_pipe(sc->sc_in_pipe);
                         sc->sc_in_pipe = NULL;
                         sc->sc_state = 0;
                         goto done;
                 }
                 usbd_setup_xfer(sc->sc_in_xfer1, sc->sc_in_pipe, sc,
                     sc->sc_junk, sizeof sc->sc_junk, USBD_SHORT_XFER_OK,
                     USBD_NO_TIMEOUT, ulpt_input);
                 usbd_setup_xfer(sc->sc_in_xfer2, sc->sc_in_pipe, sc,
                     sc->sc_junk, sizeof sc->sc_junk, USBD_SHORT_XFER_OK,
                     USBD_NO_TIMEOUT, ulpt_input);
                 usbd_transfer(sc->sc_in_xfer1); /* ignore failed start */
         }          }
   
         sc->sc_state = ULPT_OPEN;          sc->sc_state = ULPT_OPEN;
   
        DPRINTF(("ulptopen: done\n"));done:
        return (0);        if (--sc->sc_refcnt < 0)
                 usb_detach_wakeup(USBDEV(sc->sc_dev));
 
         DPRINTF(("ulptopen: done, error=%d\n", error));
         return (error);
 }  }
   
 int  int
Line 481  ulptclose(dev_t dev, int flag, int mode, Line 642  ulptclose(dev_t dev, int flag, int mode,
                 /* We are being forced to close before the open completed. */                  /* We are being forced to close before the open completed. */
                 return (0);                  return (0);
   
        usbd_close_pipe(sc->sc_bulkpipe);        if (sc->sc_out_pipe != NULL) {
        sc->sc_bulkpipe = 0;                usbd_close_pipe(sc->sc_out_pipe);
                 sc->sc_out_pipe = NULL;
         }
         if (sc->sc_in_pipe != NULL) {
                 usbd_abort_pipe(sc->sc_in_pipe);
                 usbd_close_pipe(sc->sc_in_pipe);
                 sc->sc_in_pipe = NULL;
                 if (sc->sc_in_xfer1 != NULL) {
                         usbd_free_xfer(sc->sc_in_xfer1);
                         sc->sc_in_xfer1 = NULL;
                 }
                 if (sc->sc_in_xfer2 != NULL) {
                         usbd_free_xfer(sc->sc_in_xfer2);
                         sc->sc_in_xfer2 = NULL;
                 }
         }
   
         sc->sc_state = 0;          sc->sc_state = 0;
   
Line 514  ulpt_do_write(struct ulpt_softc *sc, str Line 690  ulpt_do_write(struct ulpt_softc *sc, str
                 if (error)                  if (error)
                         break;                          break;
                 DPRINTFN(1, ("ulptwrite: transfer %d bytes\n", n));                  DPRINTFN(1, ("ulptwrite: transfer %d bytes\n", n));
                err = usbd_bulk_transfer(xfer, sc->sc_bulkpipe, USBD_NO_COPY,                 err = usbd_bulk_transfer(xfer, sc->sc_out_pipe, USBD_NO_COPY,
                           USBD_NO_TIMEOUT, bufp, &n, "ulptwr");                            USBD_NO_TIMEOUT, bufp, &n, "ulptwr");
                 if (err) {                  if (err) {
                         DPRINTF(("ulptwrite: error=%d\n", err));                          DPRINTF(("ulptwrite: error=%d\n", err));
Line 561  ulptioctl(dev_t dev, u_long cmd, caddr_t Line 737  ulptioctl(dev_t dev, u_long cmd, caddr_t
 #if 0  #if 0
 /* XXX This does not belong here. */  /* XXX This does not belong here. */
 /*  /*
 * Print select parts of a IEEE 1284 device ID. * Print select parts of an IEEE 1284 device ID.
  */   */
 void  void
 ieee1284_print_id(char *str)  ieee1284_print_id(char *str)

Removed from v.1.6  
changed lines
  Added in v.1.7