sys/dev/usb/ubser.c

   1 /*-
   2  * Copyright (c) 2004 Bernd Walter <ticso@freebsd.org>
   3  *
   4  * $URL: https://devel.bwct.de/svn/projects/ubser/ubser.c $
   5  * $Date: 2004-02-29 01:53:10 +0100 (Sun, 29 Feb 2004) $
   6  * $Author: ticso $
   7  * $Rev: 1127 $
   8  */
   9
  10 /*-
  11  * Copyright (c) 2001-2002, Shunsuke Akiyama <akiyama@jp.FreeBSD.org>.
  12  * All rights reserved.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions
  16  * are met:
  17  * 1. Redistributions of source code must retain the above copyright
  18  *    notice, this list of conditions and the following disclaimer.
  19  * 2. Redistributions in binary form must reproduce the above copyright
  20  *    notice, this list of conditions and the following disclaimer in the
  21  *    documentation and/or other materials provided with the distribution.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  */
  35
  36 /*-
  37  * Copyright (c) 2000 The NetBSD Foundation, Inc.
  38  * All rights reserved.
  39  *
  40  * This code is derived from software contributed to The NetBSD Foundation
  41  * by Lennart Augustsson (lennart@augustsson.net).
  42  *
  43  * Redistribution and use in source and binary forms, with or without
  44  * modification, are permitted provided that the following conditions
  45  * are met:
  46  * 1. Redistributions of source code must retain the above copyright
  47  *    notice, this list of conditions and the following disclaimer.
  48  * 2. Redistributions in binary form must reproduce the above copyright
  49  *    notice, this list of conditions and the following disclaimer in the
  50  *    documentation and/or other materials provided with the distribution.
  51  * 3. All advertising materials mentioning features or use of this software
  52  *    must display the following acknowledgement:
  53  *        This product includes software developed by the NetBSD
  54  *        Foundation, Inc. and its contributors.
  55  * 4. Neither the name of The NetBSD Foundation nor the names of its
  56  *    contributors may be used to endorse or promote products derived
  57  *    from this software without specific prior written permission.
  58  *
  59  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  60  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  61  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  62  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  63  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  64  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  65  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  66  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  67  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  68  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  69  * POSSIBILITY OF SUCH DAMAGE.
  70  */
  71
  72 #include <sys/cdefs.h>
  73 __FBSDID("$FreeBSD$");
  74
  75 /*
  76  * BWCT serial adapter driver
  77  */
  78
  79 #include <sys/cdefs.h>
  80
  81 #include <sys/param.h>
  82 #include <sys/systm.h>
  83 #include <sys/kernel.h>
  84 #include <sys/module.h>
  85 #include <sys/malloc.h>
  86 #include <sys/bus.h>
  87 #include <sys/ioccom.h>
  88 #include <sys/fcntl.h>
  89 #include <sys/conf.h>
  90 #include <sys/serial.h>
  91 #include <sys/tty.h>
  92 #include <sys/clist.h>
  93 #include <sys/file.h>
  94
  95 #include <sys/selinfo.h>
  96
  97 #include <sys/sysctl.h>
  98
  99 #include <dev/usb/usb.h>
 100 #include <dev/usb/usbhid.h>
 101
 102 #include <dev/usb/usbdi.h>
 103 #include <dev/usb/usbdi_util.h>
 104 #include "usbdevs.h"
 105
 106 #include <dev/usb/ubser.h>
 107
 108 #ifdef USB_DEBUG
 109 static int ubserdebug = 0;
 110 SYSCTL_NODE(_hw_usb, OID_AUTO, ubser, CTLFLAG_RW, 0, "USB ubser");
 111 SYSCTL_INT(_hw_usb_ubser, OID_AUTO, debug, CTLFLAG_RW,
 112            &ubserdebug, 0, "ubser debug level");
 113 #define DPRINTF(x)      do { \
 114                                 if (ubserdebug) \
 115                                         printf x; \
 116                         } while (0)
 117
 118 #define DPRINTFN(n, x)  do { \
 119                                 if (ubserdebug > (n)) \
 120                                         printf x; \
 121                         } while (0)
 122 #else
 123 #define DPRINTF(x)
 124 #define DPRINTFN(n,x)
 125 #endif
 126
 127 #define ISSET(t, f)     ((t) & (f))
 128 #define SET(t, f)       (t) |= (f)
 129 #define CLR(t, f)       (t) &= ~((unsigned)(f))
 130
 131 struct ubser_port {
 132         int                      p_port;
 133         struct ubser_softc      *p_sc;
 134         usbd_xfer_handle         p_oxfer;       /* write request */
 135         u_char                  *p_obuf;        /* write buffer */
 136         struct tty              *p_tty;
 137 };
 138
 139 struct ubser_softc {
 140         device_t                sc_dev;
 141         usbd_device_handle      sc_udev;
 142         usbd_interface_handle   sc_iface;       /* data interface */
 143         int                     sc_ifaceno;
 144
 145         int                     sc_refcnt;
 146         u_char                  sc_dying;
 147         u_char                  sc_opening;
 148         int                     sc_state;
 149         uint8_t                 sc_numser;
 150
 151         int                     sc_bulkin_no;   /* bulk in endpoint address */
 152         usbd_pipe_handle        sc_bulkin_pipe; /* bulk in pipe */
 153         usbd_xfer_handle        sc_ixfer;       /* read request */
 154         u_char                  *sc_ibuf;       /* read buffer */
 155         u_int                   sc_ibufsize;    /* read buffer size */
 156         u_int                   sc_ibufsizepad; /* read buffer size padded */
 157
 158         int                     sc_bulkout_no;  /* bulk out endpoint address */
 159         usbd_pipe_handle        sc_bulkout_pipe;/* bulk out pipe */
 160         u_int                   sc_obufsize;    /* write buffer size */
 161         u_int                   sc_opkthdrlen;  /* header length of
 162                                                    output packet */
 163
 164         struct ubser_port       *sc_port;
 165 };
 166
 167 static int ubserparam(struct tty *, struct termios *);
 168 static void ubserstart(struct tty *);
 169 static void ubserstop(struct tty *, int);
 170 static usbd_status ubserstartread(struct ubser_softc *);
 171 static void ubserreadcb(usbd_xfer_handle, usbd_private_handle, usbd_status);
 172 static void ubserwritecb(usbd_xfer_handle, usbd_private_handle, usbd_status);
 173 static void ubser_cleanup(struct ubser_softc *sc);
 174
 175 static t_break_t        ubserbreak;
 176 static t_open_t         ubseropen;
 177 static t_close_t        ubserclose;
 178 static t_modem_t        ubsermodem;
 179
 180 static device_probe_t ubser_match;
 181 static device_attach_t ubser_attach;
 182 static device_detach_t ubser_detach;
 183
 184 static device_method_t ubser_methods[] = {
 185         /* Device interface */
 186         DEVMETHOD(device_probe,         ubser_match),
 187         DEVMETHOD(device_attach,        ubser_attach),
 188         DEVMETHOD(device_detach,        ubser_detach),
 189
 190         { 0, 0 }
 191 };
 192
 193 static driver_t ubser_driver = {
 194         "ubser",
 195         ubser_methods,
 196         sizeof(struct ubser_softc)
 197 };
 198
 199 static devclass_t ubser_devclass;
 200
 201 static int
 202 ubser_match(device_t self)
 203 {
 204         struct usb_attach_arg *uaa = device_get_ivars(self);
 205         usb_string_descriptor_t us;
 206         usb_interface_descriptor_t *id;
 207         usb_device_descriptor_t *dd;
 208         int err, size;
 209
 210         if (uaa->iface == NULL)
 211                 return (UMATCH_NONE);
 212
 213         DPRINTFN(20,("ubser: vendor=0x%x, product=0x%x\n",
 214                      uaa->vendor, uaa->product));
 215
 216         dd = usbd_get_device_descriptor(uaa->device);
 217         if (dd == NULL) {
 218                 printf("ubser: failed to get device descriptor\n");
 219                 return (UMATCH_NONE);
 220         }
 221
 222         id = usbd_get_interface_descriptor(uaa->iface);
 223         if (id == NULL) {
 224                 printf("ubser: failed to get interface descriptor\n");
 225                 return (UMATCH_NONE);
 226         }
 227
 228         err = usbd_get_string_desc(uaa->device, dd->iManufacturer, 0, &us,
 229             &size);
 230         if (err != 0)
 231                 return (UMATCH_NONE);
 232
 233         /* check if this is a BWCT vendor specific ubser interface */
 234         if (strcmp((char*)us.bString, "B\0W\0C\0T\0") == 0 &&
 235             id->bInterfaceClass == 0xff && id->bInterfaceSubClass == 0x00)
 236                 return (UMATCH_VENDOR_IFACESUBCLASS);
 237
 238         return (UMATCH_NONE);
 239 }
 240
 241 static int
 242 ubser_attach(device_t self)
 243 {
 244         struct ubser_softc *sc = device_get_softc(self);
 245         struct usb_attach_arg *uaa = device_get_ivars(self);
 246         usbd_device_handle udev = uaa->device;
 247         usb_endpoint_descriptor_t *ed;
 248         usb_interface_descriptor_t *id;
 249         usb_device_request_t req;
 250         struct tty *tp;
 251         usbd_status err;
 252         int i;
 253         int alen;
 254         uint8_t epcount;
 255         struct ubser_port *pp;
 256
 257         sc->sc_dev = self;
 258
 259         DPRINTFN(10,("\nubser_attach: sc=%p\n", sc));
 260
 261         sc->sc_udev = udev = uaa->device;
 262         sc->sc_iface = uaa->iface;
 263         sc->sc_numser = 0;
 264         sc->sc_port = NULL;
 265
 266         /* get interface index */
 267         id = usbd_get_interface_descriptor(uaa->iface);
 268         if (id == NULL) {
 269                 printf("ubser: failed to get interface descriptor\n");
 270                 return (UMATCH_NONE);
 271         }
 272         sc->sc_ifaceno = id->bInterfaceNumber;
 273
 274         /* get number of serials */
 275         req.bmRequestType = UT_READ_VENDOR_INTERFACE;
 276         req.bRequest = VENDOR_GET_NUMSER;
 277         USETW(req.wValue, 0);
 278         USETW(req.wIndex, sc->sc_ifaceno);
 279         USETW(req.wLength, 1);
 280         err = usbd_do_request_flags(udev, &req, &sc->sc_numser,
 281             USBD_SHORT_XFER_OK, &alen, USBD_DEFAULT_TIMEOUT);
 282         if (err) {
 283                 device_printf(self, "failed to get number of serials\n");
 284                 goto bad;
 285         } else if (alen != 1) {
 286                 device_printf(self, "bogus answer on get_numser\n");
 287                 goto bad;
 288         }
 289         if (sc->sc_numser > MAX_SER)
 290                 sc->sc_numser = MAX_SER;
 291         device_printf(self, "found %i serials\n", sc->sc_numser);
 292
 293         sc->sc_port = malloc(sizeof(*sc->sc_port) * sc->sc_numser,
 294             M_USBDEV, M_WAITOK);
 295
 296         /* find our bulk endpoints */
 297         epcount = 0;
 298         (void)usbd_endpoint_count(sc->sc_iface, &epcount);
 299         sc->sc_bulkin_no = -1;
 300         sc->sc_bulkout_no = -1;
 301         for (i = 0; i < epcount; i++) {
 302                 ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
 303                 if (ed == NULL) {
 304                         device_printf(self, "couldn't get ep %d\n", i);
 305                         return ENXIO;
 306                 }
 307                 if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 308                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 309                         sc->sc_bulkin_no = ed->bEndpointAddress;
 310                         sc->sc_ibufsizepad = UGETW(ed->wMaxPacketSize);
 311                         sc->sc_ibufsizepad = UGETW(ed->wMaxPacketSize) - 1;
 312                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
 313                     UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
 314                         sc->sc_bulkout_no = ed->bEndpointAddress;
 315                         sc->sc_obufsize = UGETW(ed->wMaxPacketSize) - 1;
 316                         sc->sc_opkthdrlen = 1;
 317                 }
 318         }
 319         if (sc->sc_bulkin_no == -1 || sc->sc_bulkout_no == -1) {
 320                 device_printf(self, "could not find bulk in/out endpoint\n");
 321                 sc->sc_dying = 1;
 322                 goto bad;
 323         }
 324
 325         /* Open the bulk pipes */
 326         /* Bulk-in pipe */
 327         err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin_no, 0,
 328                              &sc->sc_bulkin_pipe);
 329         if (err) {
 330                 device_printf(self, "open bulk in error (addr %d): %s\n",
 331                     sc->sc_bulkin_no, usbd_errstr(err));
 332                 goto fail_0;
 333         }
 334         /* Bulk-out pipe */
 335         err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout_no,
 336                              USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
 337         if (err) {
 338                 device_printf(self, "open bulk out error (addr %d): %s\n",
 339                     sc->sc_bulkout_no, usbd_errstr(err));
 340                 goto fail_1;
 341         }
 342
 343         /* Allocate a request and an input buffer */
 344         sc->sc_ixfer = usbd_alloc_xfer(sc->sc_udev);
 345         if (sc->sc_ixfer == NULL) {
 346                 goto fail_2;
 347         }
 348
 349         sc->sc_ibuf = usbd_alloc_buffer(sc->sc_ixfer,
 350                                         sc->sc_ibufsizepad);
 351         if (sc->sc_ibuf == NULL) {
 352                 goto fail_3;
 353         }
 354
 355         for (i = 0; i < sc->sc_numser; i++) {
 356                 pp = &sc->sc_port[i];
 357                 pp->p_port = i;
 358                 pp->p_sc = sc;
 359                 tp = pp->p_tty = ttyalloc();
 360                 tp->t_sc = pp;
 361                 DPRINTF(("ubser_attach: tty_attach tp = %p\n", tp));
 362                 tp->t_oproc = ubserstart;
 363                 tp->t_param = ubserparam;
 364                 tp->t_stop = ubserstop;
 365                 tp->t_break = ubserbreak;
 366                 tp->t_open = ubseropen;
 367                 tp->t_close = ubserclose;
 368                 tp->t_modem = ubsermodem;
 369                 ttycreate(tp, 0, "y%r%r", device_get_unit(sc->sc_dev), i);
 370         }
 371
 372
 373         for (i = 0; i < sc->sc_numser; i++) {
 374                 sc->sc_port[i].p_oxfer = NULL;
 375                 sc->sc_port[i].p_obuf = NULL;
 376         }
 377         for (i = 0; i < sc->sc_numser; i++) {
 378                 sc->sc_port[i].p_oxfer = usbd_alloc_xfer(sc->sc_udev);
 379                 if (sc->sc_port[i].p_oxfer == NULL) {
 380                         goto fail_4;
 381                 }
 382
 383                 sc->sc_port[i].p_obuf = usbd_alloc_buffer(sc->sc_port[i].p_oxfer,
 384                                                 sc->sc_obufsize +
 385                                                 sc->sc_opkthdrlen);
 386                 if (sc->sc_port[i].p_obuf == NULL) {
 387                         goto fail_4;
 388                 }
 389         }
 390
 391         ubserstartread(sc);
 392         return 0;
 393
 394 fail_4:
 395         for (i = 0; i < sc->sc_numser; i++) {
 396                 if (sc->sc_port[i].p_oxfer != NULL) {
 397                         usbd_free_xfer(sc->sc_port[i].p_oxfer);
 398                         sc->sc_port[i].p_oxfer = NULL;
 399                 }
 400         }
 401 fail_3:
 402         usbd_free_xfer(sc->sc_ixfer);
 403         sc->sc_ixfer = NULL;
 404 fail_2:
 405         usbd_close_pipe(sc->sc_bulkout_pipe);
 406         sc->sc_bulkout_pipe = NULL;
 407 fail_1:
 408         usbd_close_pipe(sc->sc_bulkin_pipe);
 409         sc->sc_bulkin_pipe = NULL;
 410 fail_0:
 411         sc->sc_opening = 0;
 412         wakeup(&sc->sc_opening);
 413
 414 bad:
 415         ubser_cleanup(sc);
 416         if (sc->sc_port != NULL) {
 417                 for (i = 0; i < sc->sc_numser; i++) {
 418                         pp = &sc->sc_port[i];
 419                         if (pp->p_tty != NULL)
 420                                 ttyfree(pp->p_tty);
 421                 }
 422                 free(sc->sc_port, M_USBDEV);
 423                 sc->sc_port = NULL;
 424         }
 425
 426         DPRINTF(("ubser_attach: ATTACH ERROR\n"));
 427         return ENXIO;
 428 }
 429
 430 static int
 431 ubser_detach(device_t self)
 432 {
 433         struct ubser_softc *sc = device_get_softc(self);
 434         int i;
 435         struct ubser_port *pp;
 436
 437         DPRINTF(("ubser_detach: sc=%p\n", sc));
 438
 439         sc->sc_dying = 1;
 440         for (i = 0; i < sc->sc_numser; i++) {
 441                 pp = &sc->sc_port[i];
 442                 if (pp->p_tty != NULL)
 443                         ttygone(pp->p_tty);
 444         }
 445
 446         if (sc->sc_bulkin_pipe != NULL)
 447                 usbd_abort_pipe(sc->sc_bulkin_pipe);
 448         if (sc->sc_bulkout_pipe != NULL)
 449                 usbd_abort_pipe(sc->sc_bulkout_pipe);
 450
 451         if (sc->sc_port != NULL) {
 452                 for (i = 0; i < sc->sc_numser; i++) {
 453                         pp = &sc->sc_port[i];
 454                         if (pp->p_tty != NULL)
 455                                 ttyfree(pp->p_tty);
 456                 }
 457                 free(sc->sc_port, M_USBDEV);
 458                 sc->sc_port = NULL;
 459         }
 460
 461         if (--sc->sc_refcnt >= 0) {
 462                 /* Wait for processes to go away. */
 463                 usb_detach_wait(sc->sc_dev);
 464         }
 465
 466         return (0);
 467 }
 468
 469 static int
 470 ubserparam(struct tty *tp, struct termios *t)
 471 {
 472         struct ubser_softc *sc;
 473         struct ubser_port *pp;
 474
 475         pp = tp->t_sc;
 476         sc = pp->p_sc;
 477
 478         if (sc->sc_dying)
 479                 return (EIO);
 480
 481         DPRINTF(("ubserparam: sc = %p\n", sc));
 482
 483         /*
 484          * The firmware on our devices can only do 8n1@9600bps
 485          * without handshake.
 486          * We refuse to accept other configurations.
 487          */
 488
 489         /* enshure 9600bps */
 490         switch (t->c_ospeed) {
 491         case 9600:
 492                 break;
 493         default:
 494                 return (EINVAL);
 495         }
 496
 497         /* 2 stop bits not possible */
 498         if (ISSET(t->c_cflag, CSTOPB))
 499                 return (EINVAL);
 500
 501         /* XXX parity handling not possible with current firmware */
 502         if (ISSET(t->c_cflag, PARENB))
 503                 return (EINVAL);
 504
 505         /* we can only do 8 data bits */
 506         switch (ISSET(t->c_cflag, CSIZE)) {
 507         case CS8:
 508                 break;
 509         default:
 510                 return (EINVAL);
 511         }
 512
 513         /* we can't do any kind of hardware handshaking */
 514         if ((t->c_cflag &
 515             (CRTS_IFLOW | CDTR_IFLOW |CDSR_OFLOW |CCAR_OFLOW)) != 0)
 516                 return (EINVAL);
 517
 518         /*
 519          * XXX xon/xoff not supported by the firmware!
 520          * This is handled within FreeBSD only and may overflow buffers
 521          * because of delayed reaction due to device buffering.
 522          */
 523
 524         ttsetwater(tp);
 525
 526         return (0);
 527 }
 528
 529 static void
 530 ubserstart(struct tty *tp)
 531 {
 532         struct ubser_softc *sc;
 533         struct ubser_port *pp;
 534         struct cblock *cbp;
 535         usbd_status err;
 536         u_char *data;
 537         int cnt;
 538         uint8_t serial;
 539
 540         pp = tp->t_sc;
 541         sc = pp->p_sc;
 542         serial = pp->p_port;
 543         DPRINTF(("ubserstart: sc = %p, tp = %p\n", sc, tp));
 544
 545         if (sc->sc_dying)
 546                 return;
 547
 548         if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) {
 549                 ttwwakeup(tp);
 550                 DPRINTF(("ubserstart: stopped\n"));
 551                 return;
 552         }
 553
 554         if (tp->t_outq.c_cc <= tp->t_olowat) {
 555                 if (ISSET(tp->t_state, TS_SO_OLOWAT)) {
 556                         CLR(tp->t_state, TS_SO_OLOWAT);
 557                         wakeup(TSA_OLOWAT(tp));
 558                 }
 559                 selwakeuppri(&tp->t_wsel, TTIPRI);
 560                 if (tp->t_outq.c_cc == 0) {
 561                         if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==
 562                             TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
 563                                 CLR(tp->t_state, TS_SO_OCOMPLETE);
 564                                 wakeup(TSA_OCOMPLETE(tp));
 565                         }
 566                         return;
 567                 }
 568         }
 569
 570         /* Grab the first contiguous region of buffer space. */
 571         data = tp->t_outq.c_cf;
 572         cbp = (struct cblock *) ((intptr_t) tp->t_outq.c_cf & ~CROUND);
 573         cnt = min((char *) (cbp+1) - tp->t_outq.c_cf, tp->t_outq.c_cc);
 574
 575         if (cnt == 0) {
 576                 DPRINTF(("ubserstart: cnt == 0\n"));
 577                 return;
 578         }
 579
 580         SET(tp->t_state, TS_BUSY);
 581
 582         if (cnt + sc->sc_opkthdrlen > sc->sc_obufsize) {
 583                 DPRINTF(("ubserstart: big buffer %d chars\n", cnt));
 584                 cnt = sc->sc_obufsize;
 585         }
 586         sc->sc_port[serial].p_obuf[0] = serial;
 587         memcpy(sc->sc_port[serial].p_obuf + sc->sc_opkthdrlen, data, cnt);
 588
 589
 590         DPRINTF(("ubserstart: %d chars\n", cnt));
 591         usbd_setup_xfer(sc->sc_port[serial].p_oxfer, sc->sc_bulkout_pipe,
 592                         (usbd_private_handle)tp, sc->sc_port[serial].p_obuf,
 593                         cnt + sc->sc_opkthdrlen,
 594                         USBD_NO_COPY, USBD_NO_TIMEOUT, ubserwritecb);
 595         /* What can we do on error? */
 596         err = usbd_transfer(sc->sc_port[serial].p_oxfer);
 597         if (err != USBD_IN_PROGRESS)
 598                 printf("ubserstart: err=%s\n", usbd_errstr(err));
 599
 600         ttwwakeup(tp);
 601 }
 602
 603 static void
 604 ubserstop(struct tty *tp, int flag)
 605 {
 606         struct ubser_softc *sc;
 607
 608         sc = tp->t_sc;
 609
 610         DPRINTF(("ubserstop: %d\n", flag));
 611
 612         if (flag & FWRITE) {
 613                 DPRINTF(("ubserstop: write\n"));
 614                 if (ISSET(tp->t_state, TS_BUSY)) {
 615                         /* XXX do what? */
 616                         if (!ISSET(tp->t_state, TS_TTSTOP))
 617                                 SET(tp->t_state, TS_FLUSH);
 618                 }
 619         }
 620
 621         DPRINTF(("ubserstop: done\n"));
 622 }
 623
 624 static void
 625 ubserwritecb(usbd_xfer_handle xfer, usbd_private_handle p, usbd_status status)
 626 {
 627         struct tty *tp;
 628         struct ubser_softc *sc;
 629         struct ubser_port *pp;
 630         u_int32_t cc;
 631
 632         tp = (struct tty *)p;
 633         pp = tp->t_sc;
 634         sc = pp->p_sc;
 635
 636         DPRINTF(("ubserwritecb: status = %d\n", status));
 637
 638         if (status == USBD_CANCELLED || sc->sc_dying)
 639                 goto error;
 640
 641         if (status != USBD_NORMAL_COMPLETION) {
 642                 device_printf(sc->sc_dev, "ubserwritecb: %s\n",
 643                     usbd_errstr(status));
 644                 if (status == USBD_STALLED)
 645                         usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
 646                 /* XXX we should restart after some delay. */
 647                 goto error;
 648         }
 649
 650         usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL);
 651         DPRINTF(("ubserwritecb: cc = %d\n", cc));
 652         if (cc <= sc->sc_opkthdrlen) {
 653                 device_printf(sc->sc_dev, "sent size too small, cc = %d\n",
 654                     cc);
 655                 goto error;
 656         }
 657
 658         /* convert from USB bytes to tty bytes */
 659         cc -= sc->sc_opkthdrlen;
 660
 661         CLR(tp->t_state, TS_BUSY);
 662         if (ISSET(tp->t_state, TS_FLUSH))
 663                 CLR(tp->t_state, TS_FLUSH);
 664         else
 665                 ndflush(&tp->t_outq, cc);
 666         ttyld_start(tp);
 667
 668         return;
 669
 670 error:
 671         CLR(tp->t_state, TS_BUSY);
 672         return;
 673 }
 674
 675 static usbd_status
 676 ubserstartread(struct ubser_softc *sc)
 677 {
 678         usbd_status err;
 679
 680         DPRINTF(("ubserstartread: start\n"));
 681
 682         if (sc->sc_bulkin_pipe == NULL)
 683                 return (USBD_NORMAL_COMPLETION);
 684
 685         usbd_setup_xfer(sc->sc_ixfer, sc->sc_bulkin_pipe,
 686                         (usbd_private_handle)sc,
 687                         sc->sc_ibuf, sc->sc_ibufsizepad,
 688                         USBD_SHORT_XFER_OK | USBD_NO_COPY,
 689                         USBD_NO_TIMEOUT, ubserreadcb);
 690
 691         err = usbd_transfer(sc->sc_ixfer);
 692         if (err != USBD_IN_PROGRESS) {
 693                 DPRINTF(("ubserstartread: err = %s\n", usbd_errstr(err)));
 694                 return (err);
 695         }
 696
 697         return (USBD_NORMAL_COMPLETION);
 698 }
 699
 700 static void
 701 ubserreadcb(usbd_xfer_handle xfer, usbd_private_handle p, usbd_status status)
 702 {
 703         struct ubser_softc *sc = (struct ubser_softc *)p;
 704         struct tty *tp;
 705         usbd_status err;
 706         u_int32_t cc;
 707         u_char *cp;
 708         int lostcc;
 709
 710         if (status == USBD_IOERROR) {
 711                 device_printf(sc->sc_dev, "ubserreadcb: %s - restarting\n",
 712                     usbd_errstr(status));
 713                 goto resubmit;
 714         }
 715
 716         DPRINTF(("ubserreadcb: status = %d\n", status));
 717
 718         if (status != USBD_NORMAL_COMPLETION) {
 719                 if (status != USBD_CANCELLED) {
 720                         device_printf(sc->sc_dev, "ubserreadcb: %s\n",
 721                             usbd_errstr(status));
 722                 }
 723                 if (status == USBD_STALLED)
 724                         usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
 725                 return;
 726         }
 727
 728         usbd_get_xfer_status(xfer, NULL, (void **)&cp, &cc, NULL);
 729
 730         DPRINTF(("ubserreadcb: got %d bytes from device\n", cc));
 731         if (cc == 0)
 732                 goto resubmit;
 733
 734         if (cc > sc->sc_ibufsizepad) {
 735                 device_printf(sc->sc_dev, "invalid receive data size, %d chars\n",
 736                     cc);
 737                 goto resubmit;
 738         }
 739
 740         /* parse header */
 741         if (cc < 1)
 742                 goto resubmit;
 743         DPRINTF(("ubserreadcb: got %d chars for serial %d\n", cc - 1, *cp));
 744         tp = sc->sc_port[*cp].p_tty;
 745         cp++;
 746         cc--;
 747
 748         if (cc < 1)
 749                 goto resubmit;
 750
 751         if (!(tp->t_state & TS_ISOPEN)) /* drop data for unused serials */
 752                 goto resubmit;
 753
 754         if (tp->t_state & TS_CAN_BYPASS_L_RINT) {
 755                 if (tp->t_rawq.c_cc + cc > tp->t_ihiwat
 756                     && (tp->t_iflag & IXOFF)
 757                     && !(tp->t_state & TS_TBLOCK))
 758                         ttyblock(tp);
 759                 lostcc = b_to_q((char *)cp, cc, &tp->t_rawq);
 760                 tp->t_rawcc += cc;
 761                 ttwakeup(tp);
 762                 if (tp->t_state & TS_TTSTOP
 763                     && (tp->t_iflag & IXANY
 764                         || tp->t_cc[VSTART] == tp->t_cc[VSTOP])) {
 765                         tp->t_state &= ~TS_TTSTOP;
 766                         tp->t_lflag &= ~FLUSHO;
 767                         ubserstart(tp);
 768                 }
 769                 if (lostcc > 0)
 770                         device_printf(sc->sc_dev, "lost %d chars\n", lostcc);
 771         } else {
 772                 /* Give characters to tty layer. */
 773                 while (cc > 0) {
 774                         DPRINTFN(7, ("ubserreadcb: char = 0x%02x\n", *cp));
 775                         if (ttyld_rint(tp, *cp) == -1) {
 776                                 /* XXX what should we do? */
 777                                 device_printf(sc->sc_dev, "lost %d chars\n",
 778                                     cc);
 779                                 break;
 780                         }
 781                         cc--;
 782                         cp++;
 783                 }
 784         }
 785
 786 resubmit:
 787         err = ubserstartread(sc);
 788         if (err) {
 789                 device_printf(sc->sc_dev, "read start failed\n");
 790                 /* XXX what should we do now? */
 791         }
 792
 793 }
 794
 795 static void
 796 ubser_cleanup(struct ubser_softc *sc)
 797 {
 798         int i;
 799         struct ubser_port *pp;
 800
 801         DPRINTF(("ubser_cleanup: closing pipes\n"));
 802
 803         if (sc->sc_bulkin_pipe != NULL) {
 804                 usbd_abort_pipe(sc->sc_bulkin_pipe);
 805                 usbd_close_pipe(sc->sc_bulkin_pipe);
 806                 sc->sc_bulkin_pipe = NULL;
 807         }
 808         if (sc->sc_bulkout_pipe != NULL) {
 809                 usbd_abort_pipe(sc->sc_bulkout_pipe);
 810                 usbd_close_pipe(sc->sc_bulkout_pipe);
 811                 sc->sc_bulkout_pipe = NULL;
 812         }
 813         if (sc->sc_ixfer != NULL) {
 814                 usbd_free_xfer(sc->sc_ixfer);
 815                 sc->sc_ixfer = NULL;
 816         }
 817         for (i = 0; i < sc->sc_numser; i++) {
 818                 pp = &sc->sc_port[i];
 819                 if (pp->p_oxfer != NULL) {
 820                         usbd_free_xfer(pp->p_oxfer);
 821                         pp->p_oxfer = NULL;
 822                 }
 823         }
 824 }
 825
 826 static int
 827 ubseropen(struct tty *tp, struct cdev *dev)
 828 {
 829         struct ubser_softc *sc;
 830         struct ubser_port *pp;
 831
 832         pp = tp->t_sc;
 833         sc = pp->p_sc;
 834
 835         sc->sc_refcnt++;        /* XXX: wrong refcnt on error later on */
 836         return (0);
 837 }
 838
 839 static void
 840 ubserclose(struct tty *tp)
 841 {
 842         struct ubser_softc *sc;
 843         struct ubser_port *pp;
 844
 845         pp = tp->t_sc;
 846         sc = pp->p_sc;
 847         if (--sc->sc_refcnt < 0)
 848                 usb_detach_wakeup(sc->sc_dev);
 849 }
 850
 851 static void
 852 ubserbreak(struct tty *tp, int sig)
 853 {
 854         usb_device_request_t req;
 855         struct ubser_softc *sc;
 856         struct ubser_port *pp;
 857         int error;
 858         int alen;
 859
 860         pp = tp->t_sc;
 861         sc = pp->p_sc;
 862         if (sig) {
 863                 DPRINTF(("ubser_break: TIOCSBRK\n"));
 864                 req.bmRequestType = UT_READ_VENDOR_INTERFACE;
 865                 req.bRequest = VENDOR_SET_BREAK;
 866                 USETW(req.wValue, pp->p_port);
 867                 USETW(req.wIndex, sc->sc_ifaceno);
 868                 USETW(req.wLength, 0);
 869                 error = usbd_do_request_flags(sc->sc_udev, &req, &sc->sc_numser,
 870                     USBD_SHORT_XFER_OK, &alen, USBD_DEFAULT_TIMEOUT);
 871         }
 872 }
 873
 874 static int
 875 ubsermodem(struct tty *tp, int sigon, int sigoff)
 876 {
 877
 878         return (SER_DTR | SER_RTS | SER_DCD);
 879 }
 880
 881 MODULE_DEPEND(ubser, usb, 1, 1, 1);
 882 DRIVER_MODULE(ubser, uhub, ubser_driver, ubser_devclass, usbd_driver_load, 0);