ucom.c revision 1.33 1 /* $NetBSD: ucom.c,v 1.33 2001/01/23 17:35:58 augustss Exp $ */
2
3 /*
4 * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Lennart Augustsson (lennart (at) augustsson.net) at
9 * Carlstedt Research & Technology.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39 /*
40 * This code is very heavily based on the 16550 driver, com.c.
41 */
42
43 #include <sys/param.h>
44 #include <sys/systm.h>
45 #include <sys/kernel.h>
46 #include <sys/ioctl.h>
47 #include <sys/conf.h>
48 #include <sys/tty.h>
49 #include <sys/file.h>
50 #include <sys/select.h>
51 #include <sys/proc.h>
52 #include <sys/vnode.h>
53 #include <sys/device.h>
54 #include <sys/poll.h>
55 #if defined(__NetBSD__)
56 #include "rnd.h"
57 #if NRND > 0
58 #include <sys/rnd.h>
59 #endif
60 #endif
61
62 #include <dev/usb/usb.h>
63
64 #include <dev/usb/usbdi.h>
65 #include <dev/usb/usbdi_util.h>
66 #include <dev/usb/usbdevs.h>
67 #include <dev/usb/usb_quirks.h>
68
69 #include <dev/usb/ucomvar.h>
70
71 #include "ucom.h"
72
73 #if NUCOM > 0
74
75 #ifdef UCOM_DEBUG
76 #define DPRINTFN(n, x) if (ucomdebug > (n)) logprintf x
77 int ucomdebug = 0;
78 #else
79 #define DPRINTFN(n, x)
80 #endif
81 #define DPRINTF(x) DPRINTFN(0, x)
82
83 #define UCOMUNIT_MASK 0x3ffff
84 #define UCOMDIALOUT_MASK 0x80000
85 #define UCOMCALLUNIT_MASK 0x40000
86
87 #define UCOMUNIT(x) (minor(x) & UCOMUNIT_MASK)
88 #define UCOMDIALOUT(x) (minor(x) & UCOMDIALOUT_MASK)
89 #define UCOMCALLUNIT(x) (minor(x) & UCOMCALLUNIT_MASK)
90
91 struct ucom_softc {
92 USBBASEDEVICE sc_dev; /* base device */
93
94 usbd_device_handle sc_udev; /* USB device */
95
96 usbd_interface_handle sc_iface; /* data interface */
97
98 int sc_bulkin_no; /* bulk in endpoint address */
99 usbd_pipe_handle sc_bulkin_pipe; /* bulk in pipe */
100 usbd_xfer_handle sc_ixfer; /* read request */
101 u_char *sc_ibuf; /* read buffer */
102 u_int sc_ibufsize; /* read buffer size */
103 u_int sc_ibufsizepad; /* read buffer size padded */
104
105 int sc_bulkout_no; /* bulk out endpoint address */
106 usbd_pipe_handle sc_bulkout_pipe;/* bulk out pipe */
107 usbd_xfer_handle sc_oxfer; /* write request */
108 u_char *sc_obuf; /* write buffer */
109 u_int sc_obufsize; /* write buffer size */
110 u_int sc_opkthdrlen; /* header length of
111 * output packet */
112
113 struct ucom_methods *sc_methods;
114 void *sc_parent;
115 int sc_portno;
116
117 struct tty *sc_tty; /* our tty */
118 u_char sc_lsr;
119 u_char sc_msr;
120 u_char sc_mcr;
121 u_char sc_tx_stopped;
122 int sc_swflags;
123
124 u_char sc_opening; /* lock during open */
125 int sc_refcnt;
126 u_char sc_dying; /* disconnecting */
127
128 #if defined(__NetBSD__) && NRND > 0
129 rndsource_element_t sc_rndsource; /* random source */
130 #endif
131 };
132
133 cdev_decl(ucom);
134
135 Static void ucom_cleanup(struct ucom_softc *);
136 Static void ucom_hwiflow(struct ucom_softc *);
137 Static int ucomparam(struct tty *, struct termios *);
138 Static void ucomstart(struct tty *);
139 Static void ucom_shutdown(struct ucom_softc *);
140 Static int ucom_do_ioctl(struct ucom_softc *, u_long, caddr_t,
141 int, struct proc *);
142 Static void ucom_dtr(struct ucom_softc *, int);
143 Static void ucom_rts(struct ucom_softc *, int);
144 Static void ucom_break(struct ucom_softc *, int);
145 Static usbd_status ucomstartread(struct ucom_softc *);
146 Static void ucomreadcb(usbd_xfer_handle, usbd_private_handle, usbd_status);
147 Static void ucomwritecb(usbd_xfer_handle, usbd_private_handle, usbd_status);
148 Static void tiocm_to_ucom(struct ucom_softc *, u_long, int);
149 Static int ucom_to_tiocm(struct ucom_softc *);
150
151 USB_DECLARE_DRIVER(ucom);
152
153 USB_MATCH(ucom)
154 {
155 return (1);
156 }
157
158 USB_ATTACH(ucom)
159 {
160 struct ucom_softc *sc = (struct ucom_softc *)self;
161 struct ucom_attach_args *uca = aux;
162 struct tty *tp;
163
164 if (uca->portno != UCOM_UNK_PORTNO)
165 printf(": portno %d", uca->portno);
166 printf("\n");
167
168 sc->sc_udev = uca->device;
169 sc->sc_iface = uca->iface;
170 sc->sc_bulkout_no = uca->bulkout;
171 sc->sc_bulkin_no = uca->bulkin;
172 sc->sc_ibufsize = uca->ibufsize;
173 sc->sc_ibufsizepad = uca->ibufsizepad;
174 sc->sc_obufsize = uca->obufsize;
175 sc->sc_opkthdrlen = uca->opkthdrlen;
176 sc->sc_methods = uca->methods;
177 sc->sc_parent = uca->arg;
178 sc->sc_portno = uca->portno;
179
180 tp = ttymalloc();
181 tp->t_oproc = ucomstart;
182 tp->t_param = ucomparam;
183 sc->sc_tty = tp;
184
185 DPRINTF(("ucom_attach: tty_attach %p\n", tp));
186 tty_attach(tp);
187
188 #if defined(__NetBSD__) && NRND > 0
189 rnd_attach_source(&sc->sc_rndsource, USBDEVNAME(sc->sc_dev),
190 RND_TYPE_TTY, 0);
191 #endif
192
193 USB_ATTACH_SUCCESS_RETURN;
194 }
195
196 USB_DETACH(ucom)
197 {
198 struct ucom_softc *sc = (struct ucom_softc *)self;
199 int maj, mn;
200 int s;
201
202 DPRINTF(("ucom_detach: sc=%p flags=%d tp=%p\n",
203 sc, flags, sc->sc_tty));
204
205 sc->sc_dying = 1;
206
207 if (sc->sc_bulkin_pipe != NULL)
208 usbd_abort_pipe(sc->sc_bulkin_pipe);
209 if (sc->sc_bulkout_pipe != NULL)
210 usbd_abort_pipe(sc->sc_bulkout_pipe);
211
212 s = splusb();
213 if (--sc->sc_refcnt >= 0) {
214 /* The abort above should wake sleepers. */
215 /* Wait for processes to go away. */
216 usb_detach_wait(USBDEV(sc->sc_dev));
217 }
218 splx(s);
219
220 /* locate the major number */
221 for (maj = 0; maj < nchrdev; maj++)
222 if (cdevsw[maj].d_open == ucomopen)
223 break;
224
225 /* Nuke the vnodes for any open instances. */
226 mn = self->dv_unit;
227 DPRINTF(("ucom_detach: maj=%d mn=%d\n", maj, mn));
228 vdevgone(maj, mn, mn, VCHR);
229 vdevgone(maj, mn | UCOMDIALOUT_MASK, mn | UCOMDIALOUT_MASK, VCHR);
230 vdevgone(maj, mn | UCOMCALLUNIT_MASK, mn | UCOMCALLUNIT_MASK, VCHR);
231
232 /* Detach and free the tty. */
233 if (sc->sc_tty != NULL) {
234 tty_detach(sc->sc_tty);
235 ttyfree(sc->sc_tty);
236 sc->sc_tty = NULL;
237 }
238
239 /* Detach the random source */
240 #if defined(__NetBSD__) && NRND > 0
241 rnd_detach_source(&sc->sc_rndsource);
242 #endif
243
244 return (0);
245 }
246
247 #if defined(__NetBSD__) || defined(__OpenBSD__)
248 int
249 ucom_activate(device_ptr_t self, enum devact act)
250 {
251 struct ucom_softc *sc = (struct ucom_softc *)self;
252
253 switch (act) {
254 case DVACT_ACTIVATE:
255 return (EOPNOTSUPP);
256 break;
257
258 case DVACT_DEACTIVATE:
259 sc->sc_dying = 1;
260 break;
261 }
262 return (0);
263 }
264 #endif
265
266 void
267 ucom_shutdown(struct ucom_softc *sc)
268 {
269 struct tty *tp = sc->sc_tty;
270
271 DPRINTF(("ucom_shutdown\n"));
272 /*
273 * Hang up if necessary. Wait a bit, so the other side has time to
274 * notice even if we immediately open the port again.
275 */
276 if (ISSET(tp->t_cflag, HUPCL)) {
277 ucom_dtr(sc, 0);
278 (void)tsleep(sc, TTIPRI, ttclos, hz);
279 }
280 }
281
282 int
283 ucomopen(dev_t dev, int flag, int mode, struct proc *p)
284 {
285 int unit = UCOMUNIT(dev);
286 usbd_status err;
287 struct ucom_softc *sc;
288 struct tty *tp;
289 int s;
290 int error;
291
292 if (unit >= ucom_cd.cd_ndevs)
293 return (ENXIO);
294 sc = ucom_cd.cd_devs[unit];
295 if (sc == NULL)
296 return (ENXIO);
297
298 if (sc->sc_dying)
299 return (EIO);
300
301 if (ISSET(sc->sc_dev.dv_flags, DVF_ACTIVE) == 0)
302 return (ENXIO);
303
304 tp = sc->sc_tty;
305
306 DPRINTF(("ucomopen: unit=%d, tp=%p\n", unit, tp));
307
308 if (ISSET(tp->t_state, TS_ISOPEN) &&
309 ISSET(tp->t_state, TS_XCLUDE) &&
310 p->p_ucred->cr_uid != 0)
311 return (EBUSY);
312
313 s = spltty();
314
315 /*
316 * Do the following iff this is a first open.
317 */
318 while (sc->sc_opening)
319 tsleep(&sc->sc_opening, PRIBIO, "ucomop", 0);
320
321 if (sc->sc_dying) {
322 splx(s);
323 return (EIO);
324 }
325 sc->sc_opening = 1;
326
327 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
328 struct termios t;
329
330 tp->t_dev = dev;
331
332 if (sc->sc_methods->ucom_open != NULL) {
333 error = sc->sc_methods->ucom_open(sc->sc_parent,
334 sc->sc_portno);
335 if (error) {
336 ucom_cleanup(sc);
337 sc->sc_opening = 0;
338 wakeup(&sc->sc_opening);
339 splx(s);
340 return (error);
341 }
342 }
343
344 ucom_status_change(sc);
345
346 /*
347 * Initialize the termios status to the defaults. Add in the
348 * sticky bits from TIOCSFLAGS.
349 */
350 t.c_ispeed = 0;
351 t.c_ospeed = TTYDEF_SPEED;
352 t.c_cflag = TTYDEF_CFLAG;
353 if (ISSET(sc->sc_swflags, TIOCFLAG_CLOCAL))
354 SET(t.c_cflag, CLOCAL);
355 if (ISSET(sc->sc_swflags, TIOCFLAG_CRTSCTS))
356 SET(t.c_cflag, CRTSCTS);
357 if (ISSET(sc->sc_swflags, TIOCFLAG_MDMBUF))
358 SET(t.c_cflag, MDMBUF);
359 /* Make sure ucomparam() will do something. */
360 tp->t_ospeed = 0;
361 (void) ucomparam(tp, &t);
362 tp->t_iflag = TTYDEF_IFLAG;
363 tp->t_oflag = TTYDEF_OFLAG;
364 tp->t_lflag = TTYDEF_LFLAG;
365 ttychars(tp);
366 ttsetwater(tp);
367
368 /*
369 * Turn on DTR. We must always do this, even if carrier is not
370 * present, because otherwise we'd have to use TIOCSDTR
371 * immediately after setting CLOCAL, which applications do not
372 * expect. We always assert DTR while the device is open
373 * unless explicitly requested to deassert it.
374 */
375 ucom_dtr(sc, 1);
376
377 /* XXX CLR(sc->sc_rx_flags, RX_ANY_BLOCK);*/
378 ucom_hwiflow(sc);
379
380 DPRINTF(("ucomopen: open pipes in=%d out=%d\n",
381 sc->sc_bulkin_no, sc->sc_bulkout_no));
382
383 /* Open the bulk pipes */
384 err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin_no, 0,
385 &sc->sc_bulkin_pipe);
386 if (err) {
387 DPRINTF(("%s: open bulk out error (addr %d), err=%s\n",
388 USBDEVNAME(sc->sc_dev), sc->sc_bulkin_no,
389 usbd_errstr(err)));
390 error = EIO;
391 goto fail_0;
392 }
393 err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout_no,
394 USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
395 if (err) {
396 DPRINTF(("%s: open bulk in error (addr %d), err=%s\n",
397 USBDEVNAME(sc->sc_dev), sc->sc_bulkout_no,
398 usbd_errstr(err)));
399 error = EIO;
400 goto fail_1;
401 }
402
403 /* Allocate a request and an input buffer and start reading. */
404 sc->sc_ixfer = usbd_alloc_xfer(sc->sc_udev);
405 if (sc->sc_ixfer == NULL) {
406 error = ENOMEM;
407 goto fail_2;
408 }
409
410 sc->sc_ibuf = usbd_alloc_buffer(sc->sc_ixfer,
411 sc->sc_ibufsizepad);
412 if (sc->sc_ibuf == NULL) {
413 error = ENOMEM;
414 goto fail_3;
415 }
416
417 sc->sc_oxfer = usbd_alloc_xfer(sc->sc_udev);
418 if (sc->sc_oxfer == NULL) {
419 error = ENOMEM;
420 goto fail_3;
421 }
422
423 sc->sc_obuf = usbd_alloc_buffer(sc->sc_oxfer,
424 sc->sc_obufsize +
425 sc->sc_opkthdrlen);
426 if (sc->sc_obuf == NULL) {
427 error = ENOMEM;
428 goto fail_4;
429 }
430
431 ucomstartread(sc);
432 }
433 sc->sc_opening = 0;
434 wakeup(&sc->sc_opening);
435 splx(s);
436
437 error = ttyopen(tp, UCOMDIALOUT(dev), ISSET(flag, O_NONBLOCK));
438 if (error)
439 goto bad;
440
441 error = (*tp->t_linesw->l_open)(dev, tp);
442 if (error)
443 goto bad;
444
445 return (0);
446
447 fail_4:
448 usbd_free_xfer(sc->sc_oxfer);
449 fail_3:
450 usbd_free_xfer(sc->sc_ixfer);
451 fail_2:
452 usbd_close_pipe(sc->sc_bulkout_pipe);
453 fail_1:
454 usbd_close_pipe(sc->sc_bulkin_pipe);
455 fail_0:
456 sc->sc_opening = 0;
457 wakeup(&sc->sc_opening);
458 splx(s);
459 return (error);
460
461 bad:
462 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
463 /*
464 * We failed to open the device, and nobody else had it opened.
465 * Clean up the state as appropriate.
466 */
467 ucom_cleanup(sc);
468 }
469
470 return (error);
471 }
472
473 int
474 ucomclose(dev_t dev, int flag, int mode, struct proc *p)
475 {
476 struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
477 struct tty *tp = sc->sc_tty;
478
479 DPRINTF(("ucomclose: unit=%d\n", UCOMUNIT(dev)));
480 if (!ISSET(tp->t_state, TS_ISOPEN))
481 return (0);
482
483 sc->sc_refcnt++;
484
485 (*tp->t_linesw->l_close)(tp, flag);
486 ttyclose(tp);
487
488 if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
489 /*
490 * Although we got a last close, the device may still be in
491 * use; e.g. if this was the dialout node, and there are still
492 * processes waiting for carrier on the non-dialout node.
493 */
494 ucom_cleanup(sc);
495 }
496
497 if (sc->sc_methods->ucom_close != NULL)
498 sc->sc_methods->ucom_close(sc->sc_parent, sc->sc_portno);
499
500 if (--sc->sc_refcnt < 0)
501 usb_detach_wakeup(USBDEV(sc->sc_dev));
502
503 return (0);
504 }
505
506 int
507 ucomread(dev_t dev, struct uio *uio, int flag)
508 {
509 struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
510 struct tty *tp = sc->sc_tty;
511 int error;
512
513 if (sc->sc_dying)
514 return (EIO);
515
516 sc->sc_refcnt++;
517 error = ((*tp->t_linesw->l_read)(tp, uio, flag));
518 if (--sc->sc_refcnt < 0)
519 usb_detach_wakeup(USBDEV(sc->sc_dev));
520 return (error);
521 }
522
523 int
524 ucomwrite(dev_t dev, struct uio *uio, int flag)
525 {
526 struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
527 struct tty *tp = sc->sc_tty;
528 int error;
529
530 if (sc->sc_dying)
531 return (EIO);
532
533 sc->sc_refcnt++;
534 error = ((*tp->t_linesw->l_write)(tp, uio, flag));
535 if (--sc->sc_refcnt < 0)
536 usb_detach_wakeup(USBDEV(sc->sc_dev));
537 return (error);
538 }
539
540 struct tty *
541 ucomtty(dev_t dev)
542 {
543 struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
544 struct tty *tp = sc->sc_tty;
545
546 return (tp);
547 }
548
549 int
550 ucomioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
551 {
552 struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(dev)];
553 int error;
554
555 sc->sc_refcnt++;
556 error = ucom_do_ioctl(sc, cmd, data, flag, p);
557 if (--sc->sc_refcnt < 0)
558 usb_detach_wakeup(USBDEV(sc->sc_dev));
559 return (error);
560 }
561
562 Static int
563 ucom_do_ioctl(struct ucom_softc *sc, u_long cmd, caddr_t data,
564 int flag, struct proc *p)
565 {
566 struct tty *tp = sc->sc_tty;
567 int error;
568 int s;
569
570 if (sc->sc_dying)
571 return (EIO);
572
573 DPRINTF(("ucomioctl: cmd=0x%08lx\n", cmd));
574
575 error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, p);
576 if (error >= 0)
577 return (error);
578
579 error = ttioctl(tp, cmd, data, flag, p);
580 if (error >= 0)
581 return (error);
582
583 if (sc->sc_methods->ucom_ioctl != NULL) {
584 error = sc->sc_methods->ucom_ioctl(sc->sc_parent,
585 sc->sc_portno, cmd, data, flag, p);
586 if (error >= 0)
587 return (error);
588 }
589
590 error = 0;
591
592 DPRINTF(("ucomioctl: our cmd=0x%08lx\n", cmd));
593 s = spltty();
594
595 switch (cmd) {
596 case TIOCSBRK:
597 ucom_break(sc, 1);
598 break;
599
600 case TIOCCBRK:
601 ucom_break(sc, 0);
602 break;
603
604 case TIOCSDTR:
605 ucom_dtr(sc, 1);
606 break;
607
608 case TIOCCDTR:
609 ucom_dtr(sc, 0);
610 break;
611
612 case TIOCGFLAGS:
613 *(int *)data = sc->sc_swflags;
614 break;
615
616 case TIOCSFLAGS:
617 error = suser(p->p_ucred, &p->p_acflag);
618 if (error)
619 break;
620 sc->sc_swflags = *(int *)data;
621 break;
622
623 case TIOCMSET:
624 case TIOCMBIS:
625 case TIOCMBIC:
626 tiocm_to_ucom(sc, cmd, *(int *)data);
627 break;
628
629 case TIOCMGET:
630 *(int *)data = ucom_to_tiocm(sc);
631 break;
632
633 default:
634 error = ENOTTY;
635 break;
636 }
637
638 splx(s);
639
640 return (error);
641 }
642
643 Static void
644 tiocm_to_ucom(struct ucom_softc *sc, u_long how, int ttybits)
645 {
646 u_char combits;
647
648 combits = 0;
649 if (ISSET(ttybits, TIOCM_DTR))
650 SET(combits, UMCR_DTR);
651 if (ISSET(ttybits, TIOCM_RTS))
652 SET(combits, UMCR_RTS);
653
654 switch (how) {
655 case TIOCMBIC:
656 CLR(sc->sc_mcr, combits);
657 break;
658
659 case TIOCMBIS:
660 SET(sc->sc_mcr, combits);
661 break;
662
663 case TIOCMSET:
664 CLR(sc->sc_mcr, UMCR_DTR | UMCR_RTS);
665 SET(sc->sc_mcr, combits);
666 break;
667 }
668
669 if (how == TIOCMSET || ISSET(combits, UMCR_DTR))
670 ucom_dtr(sc, (sc->sc_mcr & UMCR_DTR) != 0);
671 if (how == TIOCMSET || ISSET(combits, UMCR_RTS))
672 ucom_rts(sc, (sc->sc_mcr & UMCR_RTS) != 0);
673 }
674
675 Static int
676 ucom_to_tiocm(struct ucom_softc *sc)
677 {
678 u_char combits;
679 int ttybits = 0;
680
681 combits = sc->sc_mcr;
682 if (ISSET(combits, UMCR_DTR))
683 SET(ttybits, TIOCM_DTR);
684 if (ISSET(combits, UMCR_RTS))
685 SET(ttybits, TIOCM_RTS);
686
687 combits = sc->sc_msr;
688 if (ISSET(combits, UMSR_DCD))
689 SET(ttybits, TIOCM_CD);
690 if (ISSET(combits, UMSR_CTS))
691 SET(ttybits, TIOCM_CTS);
692 if (ISSET(combits, UMSR_DSR))
693 SET(ttybits, TIOCM_DSR);
694 if (ISSET(combits, UMSR_RI | UMSR_TERI))
695 SET(ttybits, TIOCM_RI);
696
697 #if 0
698 XXX;
699 if (sc->sc_ier != 0)
700 SET(ttybits, TIOCM_LE);
701 #endif
702
703 return (ttybits);
704 }
705
706 Static void
707 ucom_break(sc, onoff)
708 struct ucom_softc *sc;
709 int onoff;
710 {
711 DPRINTF(("ucom_break: onoff=%d\n", onoff));
712
713 if (sc->sc_methods->ucom_set != NULL)
714 sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
715 UCOM_SET_BREAK, onoff);
716 }
717
718 Static void
719 ucom_dtr(struct ucom_softc *sc, int onoff)
720 {
721 DPRINTF(("ucom_dtr: onoff=%d\n", onoff));
722
723 if (sc->sc_methods->ucom_set != NULL)
724 sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
725 UCOM_SET_DTR, onoff);
726 }
727
728 Static void
729 ucom_rts(struct ucom_softc *sc, int onoff)
730 {
731 DPRINTF(("ucom_rts: onoff=%d\n", onoff));
732
733 if (sc->sc_methods->ucom_set != NULL)
734 sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
735 UCOM_SET_RTS, onoff);
736 }
737
738 void
739 ucom_status_change(struct ucom_softc *sc)
740 {
741 struct tty *tp = sc->sc_tty;
742 u_char old_msr;
743
744 if (sc->sc_methods->ucom_get_status != NULL) {
745 old_msr = sc->sc_msr;
746 sc->sc_methods->ucom_get_status(sc->sc_parent, sc->sc_portno,
747 &sc->sc_lsr, &sc->sc_msr);
748 if (ISSET((sc->sc_msr ^ old_msr), UMSR_DCD))
749 (*tp->t_linesw->l_modem)(tp,
750 ISSET(sc->sc_msr, UMSR_DCD));
751 } else {
752 sc->sc_lsr = 0;
753 sc->sc_msr = 0;
754 }
755 }
756
757 Static int
758 ucomparam(struct tty *tp, struct termios *t)
759 {
760 struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(tp->t_dev)];
761 int error;
762
763 if (sc->sc_dying)
764 return (EIO);
765
766 /* Check requested parameters. */
767 if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
768 return (EINVAL);
769
770 /*
771 * For the console, always force CLOCAL and !HUPCL, so that the port
772 * is always active.
773 */
774 if (ISSET(sc->sc_swflags, TIOCFLAG_SOFTCAR)) {
775 SET(t->c_cflag, CLOCAL);
776 CLR(t->c_cflag, HUPCL);
777 }
778
779 /*
780 * If there were no changes, don't do anything. This avoids dropping
781 * input and improves performance when all we did was frob things like
782 * VMIN and VTIME.
783 */
784 if (tp->t_ospeed == t->c_ospeed &&
785 tp->t_cflag == t->c_cflag)
786 return (0);
787
788 /* XXX lcr = ISSET(sc->sc_lcr, LCR_SBREAK) | cflag2lcr(t->c_cflag); */
789
790 /* And copy to tty. */
791 tp->t_ispeed = 0;
792 tp->t_ospeed = t->c_ospeed;
793 tp->t_cflag = t->c_cflag;
794
795 if (sc->sc_methods->ucom_param != NULL) {
796 error = sc->sc_methods->ucom_param(sc->sc_parent, sc->sc_portno,
797 t);
798 if (error)
799 return (error);
800 }
801
802 /* XXX worry about CHWFLOW */
803
804 /*
805 * Update the tty layer's idea of the carrier bit, in case we changed
806 * CLOCAL or MDMBUF. We don't hang up here; we only do that by
807 * explicit request.
808 */
809 DPRINTF(("ucomparam: l_modem\n"));
810 (void) (*tp->t_linesw->l_modem)(tp, 1 /* XXX carrier */ );
811
812 #if 0
813 XXX what if the hardware is not open
814 if (!ISSET(t->c_cflag, CHWFLOW)) {
815 if (sc->sc_tx_stopped) {
816 sc->sc_tx_stopped = 0;
817 ucomstart(tp);
818 }
819 }
820 #endif
821
822 return (0);
823 }
824
825 /*
826 * (un)block input via hw flowcontrol
827 */
828 Static void
829 ucom_hwiflow(struct ucom_softc *sc)
830 {
831 DPRINTF(("ucom_hwiflow:\n"));
832 #if 0
833 XXX
834 bus_space_tag_t iot = sc->sc_iot;
835 bus_space_handle_t ioh = sc->sc_ioh;
836
837 if (sc->sc_mcr_rts == 0)
838 return;
839
840 if (ISSET(sc->sc_rx_flags, RX_ANY_BLOCK)) {
841 CLR(sc->sc_mcr, sc->sc_mcr_rts);
842 CLR(sc->sc_mcr_active, sc->sc_mcr_rts);
843 } else {
844 SET(sc->sc_mcr, sc->sc_mcr_rts);
845 SET(sc->sc_mcr_active, sc->sc_mcr_rts);
846 }
847 bus_space_write_1(iot, ioh, com_mcr, sc->sc_mcr_active);
848 #endif
849 }
850
851 Static void
852 ucomstart(struct tty *tp)
853 {
854 struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(tp->t_dev)];
855 usbd_status err;
856 int s;
857 u_char *data;
858 int cnt;
859
860 if (sc->sc_dying)
861 return;
862
863 s = spltty();
864 if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) {
865 DPRINTFN(4,("ucomstart: no go, state=0x%x\n", tp->t_state));
866 goto out;
867 }
868 if (sc->sc_tx_stopped)
869 goto out;
870
871 if (tp->t_outq.c_cc <= tp->t_lowat) {
872 if (ISSET(tp->t_state, TS_ASLEEP)) {
873 CLR(tp->t_state, TS_ASLEEP);
874 wakeup(&tp->t_outq);
875 }
876 selwakeup(&tp->t_wsel);
877 if (tp->t_outq.c_cc == 0)
878 goto out;
879 }
880
881 /* Grab the first contiguous region of buffer space. */
882 data = tp->t_outq.c_cf;
883 cnt = ndqb(&tp->t_outq, 0);
884
885 if (cnt == 0) {
886 DPRINTF(("ucomstart: cnt==0\n"));
887 goto out;
888 }
889
890 SET(tp->t_state, TS_BUSY);
891
892 if (cnt > sc->sc_obufsize) {
893 DPRINTF(("ucomstart: big buffer %d chars\n", cnt));
894 cnt = sc->sc_obufsize;
895 }
896 if (sc->sc_methods->ucom_write != NULL)
897 sc->sc_methods->ucom_write(sc->sc_parent, sc->sc_portno,
898 sc->sc_obuf, data, &cnt);
899 else
900 memcpy(sc->sc_obuf, data, cnt);
901
902 DPRINTFN(4,("ucomstart: %d chars\n", cnt));
903 usbd_setup_xfer(sc->sc_oxfer, sc->sc_bulkout_pipe,
904 (usbd_private_handle)sc, sc->sc_obuf, cnt,
905 USBD_NO_COPY, USBD_NO_TIMEOUT, ucomwritecb);
906 /* What can we do on error? */
907 err = usbd_transfer(sc->sc_oxfer);
908 #ifdef DIAGNOSTIC
909 if (err != USBD_IN_PROGRESS)
910 printf("ucomstart: err=%s\n", usbd_errstr(err));
911 #endif
912
913 out:
914 splx(s);
915 }
916
917 void
918 ucomstop(struct tty *tp, int flag)
919 {
920 DPRINTF(("ucomstop: flag=%d\n", flag));
921 #if 0
922 /*struct ucom_softc *sc = ucom_cd.cd_devs[UCOMUNIT(tp->t_dev)];*/
923 int s;
924
925 s = spltty();
926 if (ISSET(tp->t_state, TS_BUSY)) {
927 DPRINTF(("ucomstop: XXX\n"));
928 /* sc->sc_tx_stopped = 1; */
929 if (!ISSET(tp->t_state, TS_TTSTOP))
930 SET(tp->t_state, TS_FLUSH);
931 }
932 splx(s);
933 #endif
934 }
935
936 Static void
937 ucomwritecb(usbd_xfer_handle xfer, usbd_private_handle p, usbd_status status)
938 {
939 struct ucom_softc *sc = (struct ucom_softc *)p;
940 struct tty *tp = sc->sc_tty;
941 u_int32_t cc;
942 int s;
943
944 DPRINTFN(5,("ucomwritecb: status=%d\n", status));
945
946 if (status == USBD_CANCELLED)
947 return;
948
949 if (status) {
950 DPRINTF(("ucomwritecb: status=%d\n", status));
951 usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
952 /* XXX we should restart after some delay. */
953 return;
954 }
955
956 usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL);
957 #if defined(__NetBSD__) && NRND > 0
958 rnd_add_uint32(&sc->sc_rndsource, cc);
959 #endif
960 DPRINTFN(5,("ucomwritecb: cc=%d\n", cc));
961 /* convert from USB bytes to tty bytes */
962 cc -= sc->sc_opkthdrlen;
963
964 s = spltty();
965 CLR(tp->t_state, TS_BUSY);
966 if (ISSET(tp->t_state, TS_FLUSH))
967 CLR(tp->t_state, TS_FLUSH);
968 else
969 ndflush(&tp->t_outq, cc);
970 (*tp->t_linesw->l_start)(tp);
971 splx(s);
972 }
973
974 Static usbd_status
975 ucomstartread(struct ucom_softc *sc)
976 {
977 usbd_status err;
978
979 DPRINTFN(5,("ucomstartread: start\n"));
980 usbd_setup_xfer(sc->sc_ixfer, sc->sc_bulkin_pipe,
981 (usbd_private_handle)sc,
982 sc->sc_ibuf, sc->sc_ibufsize,
983 USBD_SHORT_XFER_OK | USBD_NO_COPY,
984 USBD_NO_TIMEOUT, ucomreadcb);
985 err = usbd_transfer(sc->sc_ixfer);
986 if (err != USBD_IN_PROGRESS) {
987 DPRINTF(("ucomstartread: err=%s\n", usbd_errstr(err)));
988 return (err);
989 }
990 return (USBD_NORMAL_COMPLETION);
991 }
992
993 Static void
994 ucomreadcb(usbd_xfer_handle xfer, usbd_private_handle p, usbd_status status)
995 {
996 struct ucom_softc *sc = (struct ucom_softc *)p;
997 struct tty *tp = sc->sc_tty;
998 int (*rint)(int c, struct tty *tp) = tp->t_linesw->l_rint;
999 usbd_status err;
1000 u_int32_t cc;
1001 u_char *cp;
1002 int s;
1003
1004 if (status == USBD_CANCELLED)
1005 return;
1006
1007 if (status) {
1008 DPRINTF(("ucomreadcb: status=%d\n", status));
1009 usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
1010 /* XXX we should restart after some delay. */
1011 return;
1012 }
1013
1014 usbd_get_xfer_status(xfer, NULL, (void **)&cp, &cc, NULL);
1015 #if defined(__NetBSD__) && NRND > 0
1016 rnd_add_uint32(&sc->sc_rndsource, cc);
1017 #endif
1018 DPRINTFN(5,("ucomreadcb: got %d chars, tp=%p\n", cc, tp));
1019 if (sc->sc_methods->ucom_read != NULL)
1020 sc->sc_methods->ucom_read(sc->sc_parent, sc->sc_portno,
1021 &cp, &cc);
1022
1023 s = spltty();
1024 /* Give characters to tty layer. */
1025 while (cc-- > 0) {
1026 DPRINTFN(7,("ucomreadcb: char=0x%02x\n", *cp));
1027 if ((*rint)(*cp++, tp) == -1) {
1028 /* XXX what should we do? */
1029 printf("%s: lost %d chars\n", USBDEVNAME(sc->sc_dev),
1030 cc);
1031 break;
1032 }
1033 }
1034 splx(s);
1035
1036 err = ucomstartread(sc);
1037 if (err) {
1038 printf("%s: read start failed\n", USBDEVNAME(sc->sc_dev));
1039 /* XXX what should we dow now? */
1040 }
1041 }
1042
1043 Static void
1044 ucom_cleanup(struct ucom_softc *sc)
1045 {
1046 DPRINTF(("ucom_cleanup: closing pipes\n"));
1047
1048 ucom_shutdown(sc);
1049 if (sc->sc_bulkin_pipe != NULL) {
1050 usbd_abort_pipe(sc->sc_bulkin_pipe);
1051 usbd_close_pipe(sc->sc_bulkin_pipe);
1052 sc->sc_bulkin_pipe = NULL;
1053 }
1054 if (sc->sc_bulkout_pipe != NULL) {
1055 usbd_abort_pipe(sc->sc_bulkout_pipe);
1056 usbd_close_pipe(sc->sc_bulkout_pipe);
1057 sc->sc_bulkout_pipe = NULL;
1058 }
1059 if (sc->sc_ixfer != NULL) {
1060 usbd_free_xfer(sc->sc_ixfer);
1061 sc->sc_ixfer = NULL;
1062 }
1063 if (sc->sc_oxfer != NULL) {
1064 usbd_free_xfer(sc->sc_oxfer);
1065 sc->sc_oxfer = NULL;
1066 }
1067 }
1068
1069 #endif /* NUCOM > 0 */
1070
1071 int
1072 ucomprint(void *aux, const char *pnp)
1073 {
1074
1075 if (pnp)
1076 printf("ucom at %s\n", pnp);
1077 return (UNCONF);
1078 }
1079
1080 int
1081 ucomsubmatch(struct device *parent, struct cfdata *cf, void *aux)
1082 {
1083 struct ucom_attach_args *uca = aux;
1084
1085 if (uca->portno != UCOM_UNK_PORTNO &&
1086 cf->ucomcf_portno != UCOM_UNK_PORTNO &&
1087 cf->ucomcf_portno != uca->portno)
1088 return (0);
1089 return ((*cf->cf_attach->ca_match)(parent, cf, aux));
1090 }
1091