Annotation of sys/dev/usb/uscanner.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: uscanner.c,v 1.35 2007/06/14 10:11:16 mbalmer Exp $ */
! 2: /* $NetBSD: uscanner.c,v 1.40 2003/01/27 00:32:44 wiz Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 2000 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Lennart Augustsson (lennart@augustsson.net) at
! 10: * Carlstedt Research & Technology
! 11: * and Nick Hibma (n_hibma@qubesoft.com).
! 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: #include <sys/param.h>
! 44: #include <sys/systm.h>
! 45: #include <sys/kernel.h>
! 46: #include <sys/malloc.h>
! 47: #include <sys/device.h>
! 48: #include <sys/tty.h>
! 49: #include <sys/file.h>
! 50: #include <sys/selinfo.h>
! 51: #include <sys/proc.h>
! 52: #include <sys/vnode.h>
! 53: #include <sys/poll.h>
! 54: #include <sys/conf.h>
! 55:
! 56: #include <dev/usb/usb.h>
! 57: #include <dev/usb/usbdi.h>
! 58: #include <dev/usb/usbdi_util.h>
! 59:
! 60: #include <dev/usb/usbdevs.h>
! 61:
! 62: #ifdef USCANNER_DEBUG
! 63: #define DPRINTF(x) do { if (uscannerdebug) printf x; } while (0)
! 64: #define DPRINTFN(n,x) do { if (uscannerdebug>(n)) printf x; } while (0)
! 65: int uscannerdebug = 0;
! 66: #else
! 67: #define DPRINTF(x)
! 68: #define DPRINTFN(n,x)
! 69: #endif
! 70:
! 71: struct uscan_info {
! 72: struct usb_devno devno;
! 73: u_int flags;
! 74: #define USC_KEEP_OPEN 1
! 75: };
! 76:
! 77: /* Table of scanners that may work with this driver. */
! 78: static const struct uscan_info uscanner_devs[] = {
! 79: /* Acer Peripherals */
! 80: {{ USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_320U }, 0 },
! 81: {{ USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_640U }, 0 },
! 82: {{ USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_620U }, 0 },
! 83: {{ USB_VENDOR_ACERP, USB_PRODUCT_ACERP_ACERSCAN_C310U }, 0 },
! 84:
! 85: /* AGFA */
! 86: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1236U }, 0 },
! 87: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1212U }, 0 },
! 88: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCAN1212U2 }, 0 },
! 89: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANTOUCH }, 0 },
! 90: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE40 }, 0 },
! 91: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE50 }, 0 },
! 92: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE20 }, 0 },
! 93: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE25 }, 0 },
! 94: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE26 }, 0 },
! 95: {{ USB_VENDOR_AGFA, USB_PRODUCT_AGFA_SNAPSCANE52 }, 0 },
! 96:
! 97: /* Avision */
! 98: {{ USB_VENDOR_AVISION, USB_PRODUCT_AVISION_1200U }, 0 },
! 99:
! 100: /* Canon */
! 101: {{ USB_VENDOR_CANON, USB_PRODUCT_CANON_N656U }, 0 },
! 102: {{ USB_VENDOR_CANON, USB_PRODUCT_CANON_N670U }, 0 },
! 103: {{ USB_VENDOR_CANON, USB_PRODUCT_CANON_N1220U }, 0 },
! 104: {{ USB_VENDOR_CANON, USB_PRODUCT_CANON_N1240U }, 0 },
! 105:
! 106: /* Kye */
! 107: {{ USB_VENDOR_KYE, USB_PRODUCT_KYE_VIVIDPRO }, 0 },
! 108:
! 109: /* HP */
! 110: {{ USB_VENDOR_HP, USB_PRODUCT_HP_2200C }, 0 },
! 111: {{ USB_VENDOR_HP, USB_PRODUCT_HP_3300C }, 0 },
! 112: {{ USB_VENDOR_HP, USB_PRODUCT_HP_3400CSE }, 0 },
! 113: {{ USB_VENDOR_HP, USB_PRODUCT_HP_4100C }, 0 },
! 114: {{ USB_VENDOR_HP, USB_PRODUCT_HP_4200C }, 0 },
! 115: {{ USB_VENDOR_HP, USB_PRODUCT_HP_4300C }, 0 },
! 116: {{ USB_VENDOR_HP, USB_PRODUCT_HP_S20 }, 0 },
! 117: {{ USB_VENDOR_HP, USB_PRODUCT_HP_5200C }, 0 },
! 118: #if 0
! 119: /* Handled by usscanner */
! 120: {{ USB_VENDOR_HP, USB_PRODUCT_HP_5300C }, 0 },
! 121: #endif
! 122: {{ USB_VENDOR_HP, USB_PRODUCT_HP_6200C }, 0 },
! 123: {{ USB_VENDOR_HP, USB_PRODUCT_HP_6300C }, 0 },
! 124:
! 125: #if 0
! 126: /* XXX Should be handled by usscanner */
! 127: /* Microtek */
! 128: {{ USB_VENDOR_SCANLOGIC, USB_PRODUCT_SCANLOGIC_336CX }, 0 },
! 129: {{ USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_X6U }, 0 },
! 130: {{ USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_336CX }, 0 },
! 131: {{ USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_336CX2 }, 0 },
! 132: {{ USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_C6 }, 0 },
! 133: {{ USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6USL }, 0 },
! 134: {{ USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6USL2 }, 0 },
! 135: {{ USB_VENDOR_MICROTEK, USB_PRODUCT_MICROTEK_V6UL }, 0 },
! 136: #endif
! 137:
! 138: /* Mustek */
! 139: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200CU }, 0 },
! 140: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_BEARPAW1200F }, 0 },
! 141: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_600USB }, 0 },
! 142: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_600CU }, 0 },
! 143: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200USB }, 0 },
! 144: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200UB }, 0 },
! 145: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200USBPLUS }, 0 },
! 146: {{ USB_VENDOR_MUSTEK, USB_PRODUCT_MUSTEK_1200CUPLUS }, 0 },
! 147:
! 148: /* National */
! 149: {{ USB_VENDOR_NATIONAL, USB_PRODUCT_NATIONAL_BEARPAW1200 }, 0 },
! 150: {{ USB_VENDOR_NATIONAL, USB_PRODUCT_NATIONAL_BEARPAW2400 }, 0 },
! 151:
! 152: /* Primax */
! 153: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2X300 }, 0 },
! 154: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E300 }, 0 },
! 155: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2300 }, 0 },
! 156: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E3002 }, 0 },
! 157: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_9600 }, 0 },
! 158: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_600U }, 0 },
! 159: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_6200 }, 0 },
! 160: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_19200 }, 0 },
! 161: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_1200U }, 0 },
! 162: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G600 }, 0 },
! 163: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_636I }, 0 },
! 164: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2600 }, 0 },
! 165: {{ USB_VENDOR_PRIMAX, USB_PRODUCT_PRIMAX_G2E600 }, 0 },
! 166:
! 167: /* Epson */
! 168: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_636 }, 0 },
! 169: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_610 }, 0 },
! 170: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1200 }, 0 },
! 171: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1240 }, 0 },
! 172: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1260 }, 0 },
! 173: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1600 }, 0 },
! 174: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1640 }, 0 },
! 175: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1660 }, 0 },
! 176: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_640U }, 0 },
! 177: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_1650 }, 0 },
! 178: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_2400 }, 0 },
! 179: {{ USB_VENDOR_EPSON, USB_PRODUCT_EPSON_GT9700F }, USC_KEEP_OPEN },
! 180:
! 181: /* UMAX */
! 182: {{ USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA1220U }, 0 },
! 183: {{ USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA1236U }, 0 },
! 184: {{ USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2000U }, 0 },
! 185: {{ USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA2200U }, 0 },
! 186: {{ USB_VENDOR_UMAX, USB_PRODUCT_UMAX_ASTRA3400 }, 0 },
! 187:
! 188: /* Visioneer */
! 189: {{ USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_3000 }, 0 },
! 190: {{ USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_5300 }, 0 },
! 191: {{ USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_7600 }, 0 },
! 192: {{ USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_6100 }, 0 },
! 193: {{ USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_6200 }, 0 },
! 194: {{ USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_8100 }, 0 },
! 195: {{ USB_VENDOR_VISIONEER, USB_PRODUCT_VISIONEER_8600 }, 0 },
! 196:
! 197: /* Ultima */
! 198: {{ USB_VENDOR_ULTIMA, USB_PRODUCT_ULTIMA_1200UBPLUS }, 0 },
! 199:
! 200: };
! 201: #define uscanner_lookup(v, p) ((const struct uscan_info *)usb_lookup(uscanner_devs, v, p))
! 202:
! 203: #define USCANNER_BUFFERSIZE 1024
! 204:
! 205: struct uscanner_softc {
! 206: struct device sc_dev; /* base device */
! 207: usbd_device_handle sc_udev;
! 208: usbd_interface_handle sc_iface;
! 209:
! 210: u_int sc_dev_flags;
! 211:
! 212: usbd_pipe_handle sc_bulkin_pipe;
! 213: int sc_bulkin;
! 214: usbd_xfer_handle sc_bulkin_xfer;
! 215: void *sc_bulkin_buffer;
! 216: int sc_bulkin_bufferlen;
! 217: int sc_bulkin_datalen;
! 218:
! 219: usbd_pipe_handle sc_bulkout_pipe;
! 220: int sc_bulkout;
! 221: usbd_xfer_handle sc_bulkout_xfer;
! 222: void *sc_bulkout_buffer;
! 223: int sc_bulkout_bufferlen;
! 224: int sc_bulkout_datalen;
! 225:
! 226: struct selinfo sc_selq;
! 227:
! 228: u_char sc_state;
! 229: #define USCANNER_OPEN 0x01 /* opened */
! 230:
! 231: int sc_refcnt;
! 232: u_char sc_dying;
! 233: };
! 234:
! 235: int uscanner_do_read(struct uscanner_softc *, struct uio *, int);
! 236: int uscanner_do_write(struct uscanner_softc *, struct uio *, int);
! 237: void uscanner_do_close(struct uscanner_softc *);
! 238:
! 239: #define USCANNERUNIT(n) (minor(n))
! 240:
! 241: int uscanner_match(struct device *, void *, void *);
! 242: void uscanner_attach(struct device *, struct device *, void *);
! 243: int uscanner_detach(struct device *, int);
! 244: int uscanner_activate(struct device *, enum devact);
! 245:
! 246: struct cfdriver uscanner_cd = {
! 247: NULL, "uscanner", DV_DULL
! 248: };
! 249:
! 250: const struct cfattach uscanner_ca = {
! 251: sizeof(struct uscanner_softc),
! 252: uscanner_match,
! 253: uscanner_attach,
! 254: uscanner_detach,
! 255: uscanner_activate,
! 256: };
! 257:
! 258: int
! 259: uscanner_match(struct device *parent, void *match, void *aux)
! 260: {
! 261: struct usb_attach_arg *uaa = aux;
! 262:
! 263: if (uaa->iface != NULL)
! 264: return UMATCH_NONE;
! 265:
! 266: return (uscanner_lookup(uaa->vendor, uaa->product) != NULL ?
! 267: UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
! 268: }
! 269:
! 270: void
! 271: uscanner_attach(struct device *parent, struct device *self, void *aux)
! 272: {
! 273: struct uscanner_softc *sc = (struct uscanner_softc *)self;
! 274: struct usb_attach_arg *uaa = aux;
! 275: usb_interface_descriptor_t *id = 0;
! 276: usb_endpoint_descriptor_t *ed, *ed_bulkin = NULL, *ed_bulkout = NULL;
! 277: char *devinfop;
! 278: int i;
! 279: usbd_status err;
! 280:
! 281: devinfop = usbd_devinfo_alloc(uaa->device, 0);
! 282: printf("\n%s: %s\n", sc->sc_dev.dv_xname, devinfop);
! 283: usbd_devinfo_free(devinfop);
! 284:
! 285: sc->sc_dev_flags = uscanner_lookup(uaa->vendor, uaa->product)->flags;
! 286:
! 287: sc->sc_udev = uaa->device;
! 288:
! 289: err = usbd_set_config_no(uaa->device, 1, 1); /* XXX */
! 290: if (err) {
! 291: printf("%s: setting config no failed\n",
! 292: sc->sc_dev.dv_xname);
! 293: return;
! 294: }
! 295:
! 296: /* XXX We only check the first interface */
! 297: err = usbd_device2interface_handle(sc->sc_udev, 0, &sc->sc_iface);
! 298: if (!err && sc->sc_iface)
! 299: id = usbd_get_interface_descriptor(sc->sc_iface);
! 300: if (err || id == 0) {
! 301: printf("%s: could not get interface descriptor, err=%d,id=%p\n",
! 302: sc->sc_dev.dv_xname, err, id);
! 303: return;
! 304: }
! 305:
! 306: /* Find the two first bulk endpoints */
! 307: for (i = 0 ; i < id->bNumEndpoints; i++) {
! 308: ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
! 309: if (ed == 0) {
! 310: printf("%s: could not read endpoint descriptor\n",
! 311: sc->sc_dev.dv_xname);
! 312: return;
! 313: }
! 314:
! 315: if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
! 316: && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
! 317: ed_bulkin = ed;
! 318: } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT
! 319: && (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
! 320: ed_bulkout = ed;
! 321: }
! 322:
! 323: if (ed_bulkin && ed_bulkout) /* found all we need */
! 324: break;
! 325: }
! 326:
! 327: /* Verify that we goething sensible */
! 328: if (ed_bulkin == NULL || ed_bulkout == NULL) {
! 329: printf("%s: bulk-in and/or bulk-out endpoint not found\n",
! 330: sc->sc_dev.dv_xname);
! 331: return;
! 332: }
! 333:
! 334: sc->sc_bulkin = ed_bulkin->bEndpointAddress;
! 335: sc->sc_bulkout = ed_bulkout->bEndpointAddress;
! 336:
! 337: usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
! 338: &sc->sc_dev);
! 339: }
! 340:
! 341: int
! 342: uscanneropen(dev_t dev, int flag, int mode, struct proc *p)
! 343: {
! 344: struct uscanner_softc *sc;
! 345: int unit = USCANNERUNIT(dev);
! 346: usbd_status err;
! 347:
! 348: if (unit >= uscanner_cd.cd_ndevs)
! 349: return (ENXIO);
! 350: sc = uscanner_cd.cd_devs[unit];
! 351: if (sc == NULL)
! 352: return (ENXIO);
! 353:
! 354: DPRINTFN(5, ("uscanneropen: flag=%d, mode=%d, unit=%d\n",
! 355: flag, mode, unit));
! 356:
! 357: if (sc->sc_dying)
! 358: return (ENXIO);
! 359:
! 360: if (sc->sc_state & USCANNER_OPEN)
! 361: return (EBUSY);
! 362:
! 363: sc->sc_state |= USCANNER_OPEN;
! 364:
! 365: sc->sc_bulkin_buffer = malloc(USCANNER_BUFFERSIZE, M_USBDEV, M_WAITOK);
! 366: sc->sc_bulkout_buffer = malloc(USCANNER_BUFFERSIZE, M_USBDEV, M_WAITOK);
! 367: /* No need to check buffers for NULL since we have WAITOK */
! 368:
! 369: sc->sc_bulkin_bufferlen = USCANNER_BUFFERSIZE;
! 370: sc->sc_bulkout_bufferlen = USCANNER_BUFFERSIZE;
! 371:
! 372: /* We have decided on which endpoints to use, now open the pipes */
! 373: if (sc->sc_bulkin_pipe == NULL) {
! 374: err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin,
! 375: USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe);
! 376: if (err) {
! 377: printf("%s: cannot open bulk-in pipe (addr %d)\n",
! 378: sc->sc_dev.dv_xname, sc->sc_bulkin);
! 379: uscanner_do_close(sc);
! 380: return (EIO);
! 381: }
! 382: }
! 383: if (sc->sc_bulkout_pipe == NULL) {
! 384: err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout,
! 385: USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
! 386: if (err) {
! 387: printf("%s: cannot open bulk-out pipe (addr %d)\n",
! 388: sc->sc_dev.dv_xname, sc->sc_bulkout);
! 389: uscanner_do_close(sc);
! 390: return (EIO);
! 391: }
! 392: }
! 393:
! 394: sc->sc_bulkin_xfer = usbd_alloc_xfer(sc->sc_udev);
! 395: if (sc->sc_bulkin_xfer == NULL) {
! 396: uscanner_do_close(sc);
! 397: return (ENOMEM);
! 398: }
! 399: sc->sc_bulkout_xfer = usbd_alloc_xfer(sc->sc_udev);
! 400: if (sc->sc_bulkout_xfer == NULL) {
! 401: uscanner_do_close(sc);
! 402: return (ENOMEM);
! 403: }
! 404:
! 405: return (0); /* success */
! 406: }
! 407:
! 408: int
! 409: uscannerclose(dev_t dev, int flag, int mode, struct proc *p)
! 410: {
! 411: struct uscanner_softc *sc;
! 412:
! 413: sc = uscanner_cd.cd_devs[USCANNERUNIT(dev)];
! 414:
! 415: DPRINTFN(5, ("uscannerclose: flag=%d, mode=%d, unit=%d\n",
! 416: flag, mode, USCANNERUNIT(dev)));
! 417:
! 418: #ifdef DIAGNOSTIC
! 419: if (!(sc->sc_state & USCANNER_OPEN)) {
! 420: printf("uscannerclose: not open\n");
! 421: return (EINVAL);
! 422: }
! 423: #endif
! 424:
! 425: uscanner_do_close(sc);
! 426:
! 427: return (0);
! 428: }
! 429:
! 430: void
! 431: uscanner_do_close(struct uscanner_softc *sc)
! 432: {
! 433: if (sc->sc_bulkin_xfer) {
! 434: usbd_free_xfer(sc->sc_bulkin_xfer);
! 435: sc->sc_bulkin_xfer = NULL;
! 436: }
! 437: if (sc->sc_bulkout_xfer) {
! 438: usbd_free_xfer(sc->sc_bulkout_xfer);
! 439: sc->sc_bulkout_xfer = NULL;
! 440: }
! 441:
! 442: if (!(sc->sc_dev_flags & USC_KEEP_OPEN)) {
! 443: if (sc->sc_bulkin_pipe != NULL) {
! 444: usbd_abort_pipe(sc->sc_bulkin_pipe);
! 445: usbd_close_pipe(sc->sc_bulkin_pipe);
! 446: sc->sc_bulkin_pipe = NULL;
! 447: }
! 448: if (sc->sc_bulkout_pipe != NULL) {
! 449: usbd_abort_pipe(sc->sc_bulkout_pipe);
! 450: usbd_close_pipe(sc->sc_bulkout_pipe);
! 451: sc->sc_bulkout_pipe = NULL;
! 452: }
! 453: }
! 454:
! 455: if (sc->sc_bulkin_buffer) {
! 456: free(sc->sc_bulkin_buffer, M_USBDEV);
! 457: sc->sc_bulkin_buffer = NULL;
! 458: }
! 459: if (sc->sc_bulkout_buffer) {
! 460: free(sc->sc_bulkout_buffer, M_USBDEV);
! 461: sc->sc_bulkout_buffer = NULL;
! 462: }
! 463:
! 464: sc->sc_state &= ~USCANNER_OPEN;
! 465: }
! 466:
! 467: int
! 468: uscanner_do_read(struct uscanner_softc *sc, struct uio *uio, int flag)
! 469: {
! 470: u_int32_t n, tn;
! 471: usbd_status err;
! 472: int error = 0;
! 473:
! 474: DPRINTFN(5, ("%s: uscannerread\n", sc->sc_dev.dv_xname));
! 475:
! 476: if (sc->sc_dying)
! 477: return (EIO);
! 478:
! 479: while ((n = min(sc->sc_bulkin_bufferlen, uio->uio_resid)) != 0) {
! 480: DPRINTFN(1, ("uscannerread: start transfer %d bytes\n",n));
! 481: tn = n;
! 482:
! 483: err = usbd_bulk_transfer(
! 484: sc->sc_bulkin_xfer, sc->sc_bulkin_pipe,
! 485: USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT,
! 486: sc->sc_bulkin_buffer, &tn,
! 487: "uscnrb");
! 488: if (err) {
! 489: if (err == USBD_INTERRUPTED)
! 490: error = EINTR;
! 491: else if (err == USBD_TIMEOUT)
! 492: error = ETIMEDOUT;
! 493: else
! 494: error = EIO;
! 495: break;
! 496: }
! 497: DPRINTFN(1, ("uscannerread: got %d bytes\n", tn));
! 498: error = uiomove(sc->sc_bulkin_buffer, tn, uio);
! 499: if (error || tn < n)
! 500: break;
! 501: }
! 502:
! 503: return (error);
! 504: }
! 505:
! 506: int
! 507: uscannerread(dev_t dev, struct uio *uio, int flag)
! 508: {
! 509: struct uscanner_softc *sc;
! 510: int error;
! 511:
! 512: sc = uscanner_cd.cd_devs[USCANNERUNIT(dev)];
! 513:
! 514: sc->sc_refcnt++;
! 515: error = uscanner_do_read(sc, uio, flag);
! 516: if (--sc->sc_refcnt < 0)
! 517: usb_detach_wakeup(&sc->sc_dev);
! 518:
! 519: return (error);
! 520: }
! 521:
! 522: int
! 523: uscanner_do_write(struct uscanner_softc *sc, struct uio *uio, int flag)
! 524: {
! 525: u_int32_t n;
! 526: int error = 0;
! 527: usbd_status err;
! 528:
! 529: DPRINTFN(5, ("%s: uscanner_do_write\n", sc->sc_dev.dv_xname));
! 530:
! 531: if (sc->sc_dying)
! 532: return (EIO);
! 533:
! 534: while ((n = min(sc->sc_bulkout_bufferlen, uio->uio_resid)) != 0) {
! 535: error = uiomove(sc->sc_bulkout_buffer, n, uio);
! 536: if (error)
! 537: break;
! 538: DPRINTFN(1, ("uscanner_do_write: transfer %d bytes\n", n));
! 539: err = usbd_bulk_transfer(
! 540: sc->sc_bulkout_xfer, sc->sc_bulkout_pipe,
! 541: 0, USBD_NO_TIMEOUT,
! 542: sc->sc_bulkout_buffer, &n,
! 543: "uscnwb");
! 544: if (err) {
! 545: if (err == USBD_INTERRUPTED)
! 546: error = EINTR;
! 547: else
! 548: error = EIO;
! 549: break;
! 550: }
! 551: }
! 552:
! 553: return (error);
! 554: }
! 555:
! 556: int
! 557: uscannerwrite(dev_t dev, struct uio *uio, int flag)
! 558: {
! 559: struct uscanner_softc *sc;
! 560: int error;
! 561:
! 562: sc = uscanner_cd.cd_devs[USCANNERUNIT(dev)];
! 563:
! 564: sc->sc_refcnt++;
! 565: error = uscanner_do_write(sc, uio, flag);
! 566: if (--sc->sc_refcnt < 0)
! 567: usb_detach_wakeup(&sc->sc_dev);
! 568: return (error);
! 569: }
! 570:
! 571: int
! 572: uscanner_activate(struct device *self, enum devact act)
! 573: {
! 574: struct uscanner_softc *sc = (struct uscanner_softc *)self;
! 575:
! 576: switch (act) {
! 577: case DVACT_ACTIVATE:
! 578: break;
! 579:
! 580: case DVACT_DEACTIVATE:
! 581: sc->sc_dying = 1;
! 582: break;
! 583: }
! 584: return (0);
! 585: }
! 586:
! 587: int
! 588: uscanner_detach(struct device *self, int flags)
! 589: {
! 590: struct uscanner_softc *sc = (struct uscanner_softc *)self;
! 591: int s;
! 592: int maj, mn;
! 593:
! 594: DPRINTF(("uscanner_detach: sc=%p flags=%d\n", sc, flags));
! 595:
! 596: sc->sc_dying = 1;
! 597: sc->sc_dev_flags = 0; /* make close really close device */
! 598:
! 599: /* Abort all pipes. Causes processes waiting for transfer to wake. */
! 600: if (sc->sc_bulkin_pipe != NULL)
! 601: usbd_abort_pipe(sc->sc_bulkin_pipe);
! 602: if (sc->sc_bulkout_pipe != NULL)
! 603: usbd_abort_pipe(sc->sc_bulkout_pipe);
! 604:
! 605: s = splusb();
! 606: if (--sc->sc_refcnt >= 0) {
! 607: /* Wait for processes to go away. */
! 608: usb_detach_wait(&sc->sc_dev);
! 609: }
! 610: splx(s);
! 611:
! 612: /* locate the major number */
! 613: for (maj = 0; maj < nchrdev; maj++)
! 614: if (cdevsw[maj].d_open == uscanneropen)
! 615: break;
! 616:
! 617: /* Nuke the vnodes for any open instances (calls close). */
! 618: mn = self->dv_unit * USB_MAX_ENDPOINTS;
! 619: vdevgone(maj, mn, mn + USB_MAX_ENDPOINTS - 1, VCHR);
! 620: usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
! 621: &sc->sc_dev);
! 622:
! 623: return (0);
! 624: }
! 625:
! 626: int
! 627: uscannerpoll(dev_t dev, int events, struct proc *p)
! 628: {
! 629: struct uscanner_softc *sc;
! 630: int revents = 0;
! 631:
! 632: sc = uscanner_cd.cd_devs[USCANNERUNIT(dev)];
! 633:
! 634: if (sc->sc_dying)
! 635: return (POLLERR);
! 636:
! 637: /*
! 638: * We have no easy way of determining if a read will
! 639: * yield any data or a write will happen.
! 640: * Pretend they will.
! 641: */
! 642: revents |= events &
! 643: (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM);
! 644:
! 645: return (revents);
! 646: }
! 647:
! 648: int
! 649: uscannerioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
! 650: {
! 651: return (EINVAL);
! 652: }
! 653:
! 654: void filt_uscannerdetach(struct knote *);
! 655: int uscannerkqfilter(dev_t, struct knote *);
! 656:
! 657: void
! 658: filt_uscannerdetach(struct knote *kn)
! 659: {
! 660: struct uscanner_softc *sc = (void *)kn->kn_hook;
! 661:
! 662: SLIST_REMOVE(&sc->sc_selq.si_note, kn, knote, kn_selnext);
! 663: }
! 664:
! 665: struct filterops uscanner_seltrue_filtops =
! 666: { 1, NULL, filt_uscannerdetach, filt_seltrue };
! 667:
! 668: int
! 669: uscannerkqfilter(dev_t dev, struct knote *kn)
! 670: {
! 671: struct uscanner_softc *sc;
! 672: struct klist *klist;
! 673:
! 674: sc = uscanner_cd.cd_devs[USCANNERUNIT(dev)];
! 675:
! 676: if (sc->sc_dying)
! 677: return (1);
! 678:
! 679: switch (kn->kn_filter) {
! 680: case EVFILT_READ:
! 681: case EVFILT_WRITE:
! 682: /*
! 683: * We have no easy way of determining if a read will
! 684: * yield any data or a write will happen.
! 685: * Pretend they will.
! 686: */
! 687: klist = &sc->sc_selq.si_note;
! 688: kn->kn_fop = &uscanner_seltrue_filtops;
! 689: break;
! 690:
! 691: default:
! 692: return (1);
! 693: }
! 694:
! 695: kn->kn_hook = (void *)sc;
! 696:
! 697: SLIST_INSERT_HEAD(klist, kn, kn_selnext);
! 698:
! 699: return (0);
! 700: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to uscanner.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / usb