Home | History | Annotate | Line # | Download | only in usb
ucom.c revision 1.108.2.25
      1  1.108.2.25     skrll /*	$NetBSD: ucom.c,v 1.108.2.25 2016/10/27 12:30:54 skrll Exp $	*/
      2         1.1  augustss 
      3         1.1  augustss /*
      4        1.22  augustss  * Copyright (c) 1998, 2000 The NetBSD Foundation, Inc.
      5         1.1  augustss  * All rights reserved.
      6         1.1  augustss  *
      7         1.1  augustss  * This code is derived from software contributed to The NetBSD Foundation
      8        1.23  augustss  * by Lennart Augustsson (lennart (at) augustsson.net) at
      9         1.1  augustss  * Carlstedt Research & Technology.
     10         1.1  augustss  *
     11         1.1  augustss  * Redistribution and use in source and binary forms, with or without
     12         1.1  augustss  * modification, are permitted provided that the following conditions
     13         1.1  augustss  * are met:
     14         1.1  augustss  * 1. Redistributions of source code must retain the above copyright
     15         1.1  augustss  *    notice, this list of conditions and the following disclaimer.
     16         1.1  augustss  * 2. Redistributions in binary form must reproduce the above copyright
     17         1.1  augustss  *    notice, this list of conditions and the following disclaimer in the
     18         1.1  augustss  *    documentation and/or other materials provided with the distribution.
     19         1.1  augustss  *
     20         1.1  augustss  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     21         1.1  augustss  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     22         1.1  augustss  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     23         1.1  augustss  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     24         1.1  augustss  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     25         1.1  augustss  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     26         1.1  augustss  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     27         1.1  augustss  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     28         1.1  augustss  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     29         1.1  augustss  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     30         1.1  augustss  * POSSIBILITY OF SUCH DAMAGE.
     31         1.1  augustss  */
     32        1.22  augustss /*
     33        1.22  augustss  * This code is very heavily based on the 16550 driver, com.c.
     34        1.22  augustss  */
     35        1.40     lukem 
     36        1.40     lukem #include <sys/cdefs.h>
     37  1.108.2.25     skrll __KERNEL_RCSID(0, "$NetBSD: ucom.c,v 1.108.2.25 2016/10/27 12:30:54 skrll Exp $");
     38         1.1  augustss 
     39         1.1  augustss #include <sys/param.h>
     40         1.1  augustss #include <sys/systm.h>
     41         1.1  augustss #include <sys/kernel.h>
     42         1.1  augustss #include <sys/ioctl.h>
     43         1.3  augustss #include <sys/conf.h>
     44         1.1  augustss #include <sys/tty.h>
     45         1.1  augustss #include <sys/file.h>
     46         1.1  augustss #include <sys/select.h>
     47         1.1  augustss #include <sys/proc.h>
     48         1.1  augustss #include <sys/vnode.h>
     49        1.12  augustss #include <sys/device.h>
     50         1.1  augustss #include <sys/poll.h>
     51        1.82    martin #include <sys/queue.h>
     52        1.63      elad #include <sys/kauth.h>
     53   1.108.2.7     skrll #include <sys/sysctl.h>
     54       1.106       gdt #include <sys/timepps.h>
     55   1.108.2.6     skrll #include <sys/rndsource.h>
     56         1.1  augustss 
     57         1.1  augustss #include <dev/usb/usb.h>
     58         1.1  augustss 
     59         1.1  augustss #include <dev/usb/usbdi.h>
     60         1.1  augustss #include <dev/usb/usbdi_util.h>
     61         1.1  augustss #include <dev/usb/usbdevs.h>
     62         1.1  augustss #include <dev/usb/usb_quirks.h>
     63   1.108.2.7     skrll #include <dev/usb/usbhist.h>
     64         1.1  augustss 
     65        1.12  augustss #include <dev/usb/ucomvar.h>
     66        1.12  augustss 
     67        1.13  augustss #include "ucom.h"
     68        1.13  augustss 
     69        1.53  drochner #include "locators.h"
     70        1.53  drochner 
     71        1.13  augustss #if NUCOM > 0
     72        1.13  augustss 
     73   1.108.2.7     skrll #ifdef USB_DEBUG
     74   1.108.2.7     skrll #ifndef UCOM_DEBUG
     75   1.108.2.7     skrll #define ucomdebug 0
     76         1.1  augustss #else
     77   1.108.2.7     skrll int ucomdebug = 0;
     78   1.108.2.7     skrll 
     79   1.108.2.7     skrll SYSCTL_SETUP(sysctl_hw_ucom_setup, "sysctl hw.ucom setup")
     80   1.108.2.7     skrll {
     81   1.108.2.7     skrll         int err;
     82   1.108.2.7     skrll         const struct sysctlnode *rnode;
     83   1.108.2.7     skrll         const struct sysctlnode *cnode;
     84   1.108.2.7     skrll 
     85   1.108.2.7     skrll         err = sysctl_createv(clog, 0, NULL, &rnode,
     86   1.108.2.7     skrll             CTLFLAG_PERMANENT, CTLTYPE_NODE, "ucom",
     87   1.108.2.7     skrll             SYSCTL_DESCR("ucom global controls"),
     88   1.108.2.7     skrll             NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL);
     89   1.108.2.7     skrll 
     90   1.108.2.7     skrll         if (err)
     91   1.108.2.7     skrll                 goto fail;
     92   1.108.2.7     skrll 
     93   1.108.2.7     skrll         /* control debugging printfs */
     94   1.108.2.7     skrll         err = sysctl_createv(clog, 0, &rnode, &cnode,
     95   1.108.2.7     skrll             CTLFLAG_PERMANENT|CTLFLAG_READWRITE, CTLTYPE_INT,
     96   1.108.2.7     skrll             "debug", SYSCTL_DESCR("Enable debugging output"),
     97   1.108.2.7     skrll             NULL, 0, &ucomdebug, sizeof(ucomdebug), CTL_CREATE, CTL_EOL);
     98   1.108.2.7     skrll         if (err)
     99   1.108.2.7     skrll                 goto fail;
    100   1.108.2.7     skrll 
    101   1.108.2.7     skrll         return;
    102   1.108.2.7     skrll fail:
    103   1.108.2.7     skrll         aprint_error("%s: sysctl_createv failed (err = %d)\n", __func__, err);
    104   1.108.2.7     skrll }
    105   1.108.2.7     skrll 
    106   1.108.2.7     skrll #endif /* UCOM_DEBUG */
    107   1.108.2.7     skrll #endif /* USB_DEBUG */
    108   1.108.2.7     skrll 
    109   1.108.2.7     skrll #define DPRINTF(FMT,A,B,C,D)    USBHIST_LOGN(ucomdebug,1,FMT,A,B,C,D)
    110   1.108.2.7     skrll #define DPRINTFN(N,FMT,A,B,C,D) USBHIST_LOGN(ucomdebug,N,FMT,A,B,C,D)
    111   1.108.2.7     skrll #define UCOMHIST_FUNC()         USBHIST_FUNC()
    112   1.108.2.7     skrll #define UCOMHIST_CALLED(name)   USBHIST_CALLED(ucomdebug)
    113        1.12  augustss 
    114       1.108  christos #define	UCOMCALLUNIT_MASK	TTCALLUNIT_MASK
    115       1.108  christos #define	UCOMUNIT_MASK		TTUNIT_MASK
    116       1.108  christos #define	UCOMDIALOUT_MASK	TTDIALOUT_MASK
    117       1.108  christos 
    118       1.108  christos #define	UCOMCALLUNIT(x)		TTCALLUNIT(x)
    119       1.108  christos #define	UCOMUNIT(x)		TTUNIT(x)
    120       1.108  christos #define	UCOMDIALOUT(x)		TTDIALOUT(x)
    121        1.12  augustss 
    122        1.82    martin /*
    123        1.82    martin  * XXX: We can submit multiple input/output buffers to the usb stack
    124        1.82    martin  * to improve throughput, but the usb stack is too lame to deal with this
    125        1.82    martin  * in a number of places.
    126        1.82    martin  */
    127        1.82    martin #define	UCOM_IN_BUFFS	1
    128        1.82    martin #define	UCOM_OUT_BUFFS	1
    129        1.82    martin 
    130        1.82    martin struct ucom_buffer {
    131        1.82    martin 	SIMPLEQ_ENTRY(ucom_buffer) ub_link;
    132   1.108.2.5     skrll 	struct usbd_xfer *ub_xfer;
    133        1.82    martin 	u_char *ub_data;
    134        1.82    martin 	u_int ub_len;
    135        1.82    martin 	u_int ub_index;
    136        1.82    martin };
    137        1.82    martin 
    138         1.1  augustss struct ucom_softc {
    139        1.85    dyoung 	device_t		sc_dev;		/* base device */
    140        1.12  augustss 
    141  1.108.2.21     skrll 	struct usbd_device	*sc_udev;	/* USB device */
    142  1.108.2.21     skrll 	struct usbd_interface	*sc_iface;	/* data interface */
    143        1.12  augustss 
    144        1.12  augustss 	int			sc_bulkin_no;	/* bulk in endpoint address */
    145  1.108.2.21     skrll 	struct usbd_pipe	*sc_bulkin_pipe;	/* bulk in pipe */
    146        1.19  augustss 	u_int			sc_ibufsize;	/* read buffer size */
    147        1.22  augustss 	u_int			sc_ibufsizepad;	/* read buffer size padded */
    148        1.82    martin 	struct ucom_buffer	sc_ibuff[UCOM_IN_BUFFS];
    149        1.82    martin 	SIMPLEQ_HEAD(, ucom_buffer) sc_ibuff_empty;
    150        1.82    martin 	SIMPLEQ_HEAD(, ucom_buffer) sc_ibuff_full;
    151        1.12  augustss 
    152        1.12  augustss 	int			sc_bulkout_no;	/* bulk out endpoint address */
    153  1.108.2.21     skrll 	struct usbd_pipe	*sc_bulkout_pipe;/* bulk out pipe */
    154        1.19  augustss 	u_int			sc_obufsize;	/* write buffer size */
    155        1.82    martin 	u_int			sc_opkthdrlen;	/* header length of */
    156        1.82    martin 	struct ucom_buffer	sc_obuff[UCOM_OUT_BUFFS];
    157        1.82    martin 	SIMPLEQ_HEAD(, ucom_buffer) sc_obuff_free;
    158        1.82    martin 	SIMPLEQ_HEAD(, ucom_buffer) sc_obuff_full;
    159        1.82    martin 
    160  1.108.2.15     skrll 	struct usbd_pipe	*sc_ipipe;
    161  1.108.2.15     skrll 	struct usbd_xfer	*sc_ixfer;
    162  1.108.2.15     skrll 	struct usbd_pipe	*sc_opipe;
    163  1.108.2.15     skrll 	struct usbd_xfer	*sc_oxfer;
    164  1.108.2.15     skrll 
    165        1.82    martin 	void			*sc_si;
    166        1.12  augustss 
    167        1.90  jakllsch 	const struct ucom_methods *sc_methods;
    168        1.12  augustss 	void                    *sc_parent;
    169        1.12  augustss 	int			sc_portno;
    170        1.12  augustss 
    171        1.12  augustss 	struct tty		*sc_tty;	/* our tty */
    172        1.12  augustss 	u_char			sc_lsr;
    173        1.12  augustss 	u_char			sc_msr;
    174        1.12  augustss 	u_char			sc_mcr;
    175        1.82    martin 	volatile u_char		sc_rx_stopped;
    176        1.82    martin 	u_char			sc_rx_unblock;
    177        1.12  augustss 	u_char			sc_tx_stopped;
    178        1.12  augustss 	int			sc_swflags;
    179        1.12  augustss 
    180        1.12  augustss 	u_char			sc_opening;	/* lock during open */
    181  1.108.2.14     skrll 	u_char			sc_closing;	/* lock during close */
    182        1.17  augustss 	int			sc_refcnt;
    183  1.108.2.22     skrll 	bool			sc_dying;	/* disconnecting */
    184        1.31  explorer 
    185       1.106       gdt 	struct pps_state	sc_pps_state;	/* pps state */
    186       1.106       gdt 
    187   1.108.2.8     skrll 	krndsource_t		sc_rndsource;	/* random source */
    188   1.108.2.8     skrll 
    189  1.108.2.12     skrll 	kmutex_t		sc_lock;
    190   1.108.2.8     skrll 	kcondvar_t		sc_opencv;
    191   1.108.2.8     skrll 	kcondvar_t		sc_detachcv;
    192         1.1  augustss };
    193         1.1  augustss 
    194        1.44   gehenna dev_type_open(ucomopen);
    195        1.44   gehenna dev_type_close(ucomclose);
    196        1.44   gehenna dev_type_read(ucomread);
    197        1.44   gehenna dev_type_write(ucomwrite);
    198        1.44   gehenna dev_type_ioctl(ucomioctl);
    199        1.44   gehenna dev_type_stop(ucomstop);
    200        1.44   gehenna dev_type_tty(ucomtty);
    201        1.44   gehenna dev_type_poll(ucompoll);
    202        1.44   gehenna 
    203        1.44   gehenna const struct cdevsw ucom_cdevsw = {
    204       1.103  dholland 	.d_open = ucomopen,
    205       1.103  dholland 	.d_close = ucomclose,
    206       1.103  dholland 	.d_read = ucomread,
    207       1.103  dholland 	.d_write = ucomwrite,
    208       1.103  dholland 	.d_ioctl = ucomioctl,
    209       1.103  dholland 	.d_stop = ucomstop,
    210       1.103  dholland 	.d_tty = ucomtty,
    211       1.103  dholland 	.d_poll = ucompoll,
    212       1.103  dholland 	.d_mmap = nommap,
    213       1.103  dholland 	.d_kqfilter = ttykqfilter,
    214       1.105  dholland 	.d_discard = nodiscard,
    215   1.108.2.8     skrll 	.d_flag = D_TTY | D_MPSAFE
    216        1.44   gehenna };
    217        1.12  augustss 
    218        1.82    martin static void	ucom_cleanup(struct ucom_softc *);
    219        1.82    martin static int	ucomparam(struct tty *, struct termios *);
    220        1.82    martin static int	ucomhwiflow(struct tty *, int);
    221        1.82    martin static void	ucomstart(struct tty *);
    222        1.82    martin static void	ucom_shutdown(struct ucom_softc *);
    223        1.82    martin static int	ucom_do_ioctl(struct ucom_softc *, u_long, void *,
    224        1.60  christos 			      int, struct lwp *);
    225        1.82    martin static void	ucom_dtr(struct ucom_softc *, int);
    226        1.82    martin static void	ucom_rts(struct ucom_softc *, int);
    227        1.82    martin static void	ucom_break(struct ucom_softc *, int);
    228        1.82    martin static void	tiocm_to_ucom(struct ucom_softc *, u_long, int);
    229        1.82    martin static int	ucom_to_tiocm(struct ucom_softc *);
    230        1.82    martin 
    231        1.82    martin static void	ucom_submit_write(struct ucom_softc *, struct ucom_buffer *);
    232        1.82    martin static void	ucom_write_status(struct ucom_softc *, struct ucom_buffer *,
    233  1.108.2.23     skrll 		    usbd_status);
    234        1.82    martin 
    235   1.108.2.5     skrll static void	ucomwritecb(struct usbd_xfer *, void *, usbd_status);
    236        1.82    martin static void	ucom_read_complete(struct ucom_softc *);
    237        1.82    martin static usbd_status ucomsubmitread(struct ucom_softc *, struct ucom_buffer *);
    238        1.82    martin static void	ucom_softintr(void *);
    239         1.1  augustss 
    240        1.85    dyoung int ucom_match(device_t, cfdata_t, void *);
    241        1.85    dyoung void ucom_attach(device_t, device_t, void *);
    242        1.85    dyoung int ucom_detach(device_t, int);
    243        1.85    dyoung int ucom_activate(device_t, enum devact);
    244        1.85    dyoung extern struct cfdriver ucom_cd;
    245        1.85    dyoung CFATTACH_DECL_NEW(ucom, sizeof(struct ucom_softc), ucom_match, ucom_attach,
    246        1.85    dyoung     ucom_detach, ucom_activate);
    247         1.1  augustss 
    248        1.85    dyoung int
    249        1.85    dyoung ucom_match(device_t parent, cfdata_t match, void *aux)
    250         1.1  augustss {
    251   1.108.2.3     skrll 	return 1;
    252         1.1  augustss }
    253         1.1  augustss 
    254        1.85    dyoung void
    255        1.85    dyoung ucom_attach(device_t parent, device_t self, void *aux)
    256         1.1  augustss {
    257        1.77      cube 	struct ucom_softc *sc = device_private(self);
    258  1.108.2.13     skrll 	struct ucom_attach_args *ucaa = aux;
    259        1.12  augustss 
    260   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    261   1.108.2.7     skrll 
    262  1.108.2.13     skrll 	if (ucaa->ucaa_info != NULL)
    263  1.108.2.13     skrll 		aprint_normal(": %s", ucaa->ucaa_info);
    264        1.83     pooka 	aprint_normal("\n");
    265        1.12  augustss 
    266  1.108.2.13     skrll 	prop_dictionary_set_int32(device_properties(self), "port",
    267  1.108.2.13     skrll 	    ucaa->ucaa_portno);
    268  1.108.2.10     skrll 
    269  1.108.2.17     skrll 	//KASSERT(ucaa->ucaa_bulkin != -1 || (ucaa->ucaa_ipipe && ucaa->ucaa_ixfer));
    270  1.108.2.17     skrll 	//KASSERT(ucaa->ucaa_bulkout != -1 || (ucaa->ucaa_opipe && ucaa->ucaa_oxfer));
    271  1.108.2.15     skrll 
    272        1.77      cube 	sc->sc_dev = self;
    273  1.108.2.13     skrll 	sc->sc_udev = ucaa->ucaa_device;
    274  1.108.2.13     skrll 	sc->sc_iface = ucaa->ucaa_iface;
    275  1.108.2.13     skrll 	sc->sc_bulkout_no = ucaa->ucaa_bulkout;
    276  1.108.2.13     skrll 	sc->sc_bulkin_no = ucaa->ucaa_bulkin;
    277  1.108.2.13     skrll 	sc->sc_ibufsize = ucaa->ucaa_ibufsize;
    278  1.108.2.13     skrll 	sc->sc_ibufsizepad = ucaa->ucaa_ibufsizepad;
    279  1.108.2.13     skrll 	sc->sc_obufsize = ucaa->ucaa_obufsize;
    280  1.108.2.13     skrll 	sc->sc_opkthdrlen = ucaa->ucaa_opkthdrlen;
    281  1.108.2.13     skrll 	sc->sc_methods = ucaa->ucaa_methods;
    282  1.108.2.13     skrll 	sc->sc_parent = ucaa->ucaa_arg;
    283  1.108.2.13     skrll 	sc->sc_portno = ucaa->ucaa_portno;
    284        1.12  augustss 
    285        1.82    martin 	sc->sc_lsr = 0;
    286        1.82    martin 	sc->sc_msr = 0;
    287        1.82    martin 	sc->sc_mcr = 0;
    288        1.82    martin 	sc->sc_tx_stopped = 0;
    289        1.82    martin 	sc->sc_swflags = 0;
    290        1.82    martin 	sc->sc_opening = 0;
    291  1.108.2.14     skrll 	sc->sc_closing = 0;
    292        1.82    martin 	sc->sc_refcnt = 0;
    293  1.108.2.22     skrll 	sc->sc_dying = false;
    294        1.82    martin 
    295   1.108.2.8     skrll 	sc->sc_si = softint_establish(SOFTINT_USB, ucom_softintr, sc);
    296  1.108.2.12     skrll 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
    297   1.108.2.8     skrll 	cv_init(&sc->sc_opencv, "ucomopen");
    298   1.108.2.8     skrll 	cv_init(&sc->sc_detachcv, "ucomdtch");
    299        1.82    martin 
    300   1.108.2.9     skrll 	SIMPLEQ_INIT(&sc->sc_ibuff_empty);
    301   1.108.2.9     skrll 	SIMPLEQ_INIT(&sc->sc_ibuff_full);
    302   1.108.2.9     skrll 	SIMPLEQ_INIT(&sc->sc_obuff_free);
    303   1.108.2.9     skrll 	SIMPLEQ_INIT(&sc->sc_obuff_full);
    304   1.108.2.9     skrll 
    305   1.108.2.9     skrll 	memset(sc->sc_ibuff, 0, sizeof(sc->sc_ibuff));
    306   1.108.2.9     skrll 	memset(sc->sc_obuff, 0, sizeof(sc->sc_obuff));
    307   1.108.2.9     skrll 
    308   1.108.2.9     skrll 	DPRINTF("open pipes in=%d out=%d", sc->sc_bulkin_no, sc->sc_bulkout_no,
    309   1.108.2.9     skrll 	    0, 0);
    310   1.108.2.9     skrll 
    311   1.108.2.9     skrll 	struct ucom_buffer *ub;
    312   1.108.2.9     skrll 	usbd_status err;
    313   1.108.2.9     skrll 	int error;
    314   1.108.2.9     skrll 
    315  1.108.2.15     skrll 	if (sc->sc_bulkin_no != -1) {
    316  1.108.2.15     skrll 		/* Open the bulk pipes */
    317  1.108.2.15     skrll 		err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin_no,
    318  1.108.2.15     skrll 		    USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe);
    319  1.108.2.15     skrll 		if (err) {
    320  1.108.2.15     skrll 			DPRINTF("open bulk in error (addr %d), err=%d",
    321  1.108.2.15     skrll 			    sc->sc_bulkin_no, err, 0, 0);
    322  1.108.2.15     skrll 			error = EIO;
    323  1.108.2.15     skrll 			goto fail_0;
    324  1.108.2.15     skrll 		}
    325  1.108.2.15     skrll 		/* Allocate input buffers */
    326  1.108.2.15     skrll 		for (ub = &sc->sc_ibuff[0]; ub != &sc->sc_ibuff[UCOM_IN_BUFFS];
    327  1.108.2.15     skrll 		    ub++) {
    328  1.108.2.15     skrll 			error = usbd_create_xfer(sc->sc_bulkin_pipe,
    329  1.108.2.15     skrll 			    sc->sc_ibufsizepad, USBD_SHORT_XFER_OK, 0,
    330  1.108.2.15     skrll 			    &ub->ub_xfer);
    331  1.108.2.15     skrll 			if (error)
    332  1.108.2.15     skrll 				goto fail_1;
    333  1.108.2.15     skrll 			ub->ub_data = usbd_get_buffer(ub->ub_xfer);
    334  1.108.2.15     skrll 		}
    335  1.108.2.15     skrll 
    336   1.108.2.9     skrll 	}
    337   1.108.2.9     skrll 
    338  1.108.2.15     skrll 	if (sc->sc_bulkout_no != -1) {
    339  1.108.2.15     skrll 		err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout_no,
    340  1.108.2.15     skrll 		    USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);
    341  1.108.2.15     skrll 		if (err) {
    342  1.108.2.15     skrll 			DPRINTF("open bulk out error (addr %d), err=%d",
    343  1.108.2.15     skrll 			    sc->sc_bulkout_no, err, 0, 0);
    344  1.108.2.15     skrll 			error = EIO;
    345  1.108.2.15     skrll 			goto fail_1;
    346  1.108.2.15     skrll 		}
    347  1.108.2.15     skrll 		for (ub = &sc->sc_obuff[0]; ub != &sc->sc_obuff[UCOM_OUT_BUFFS];
    348  1.108.2.15     skrll 		    ub++) {
    349  1.108.2.15     skrll 			error = usbd_create_xfer(sc->sc_bulkout_pipe,
    350  1.108.2.15     skrll 			    sc->sc_obufsize, 0, 0, &ub->ub_xfer);
    351  1.108.2.15     skrll 			if (error)
    352  1.108.2.15     skrll 				goto fail_2;
    353  1.108.2.15     skrll 			ub->ub_data = usbd_get_buffer(ub->ub_xfer);
    354  1.108.2.15     skrll 			SIMPLEQ_INSERT_TAIL(&sc->sc_obuff_free, ub, ub_link);
    355  1.108.2.15     skrll 		}
    356   1.108.2.9     skrll 	}
    357   1.108.2.9     skrll 
    358  1.108.2.15     skrll 	if (sc->sc_ipipe && sc->sc_ixfer) {
    359  1.108.2.15     skrll 		ub = &sc->sc_ibuff[0];
    360  1.108.2.15     skrll 		ub->ub_data = usbd_get_buffer(sc->sc_ixfer);
    361  1.108.2.15     skrll 		SIMPLEQ_INSERT_TAIL(&sc->sc_ibuff_empty, ub, ub_link);
    362  1.108.2.15     skrll 	}
    363  1.108.2.15     skrll 	if (sc->sc_opipe && sc->sc_oxfer) {
    364  1.108.2.15     skrll 		ub = &sc->sc_obuff[0];
    365  1.108.2.15     skrll 		ub->ub_data = usbd_get_buffer(sc->sc_oxfer);
    366   1.108.2.9     skrll 		SIMPLEQ_INSERT_TAIL(&sc->sc_obuff_free, ub, ub_link);
    367   1.108.2.9     skrll 	}
    368   1.108.2.9     skrll 
    369  1.108.2.20     skrll 	struct tty *tp = tty_alloc();
    370        1.12  augustss 	tp->t_oproc = ucomstart;
    371        1.12  augustss 	tp->t_param = ucomparam;
    372        1.82    martin 	tp->t_hwiflow = ucomhwiflow;
    373        1.12  augustss 	sc->sc_tty = tp;
    374        1.12  augustss 
    375   1.108.2.7     skrll 	DPRINTF("tty_attach %p", tp, 0, 0, 0);
    376        1.12  augustss 	tty_attach(tp);
    377        1.12  augustss 
    378        1.85    dyoung 	rnd_attach_source(&sc->sc_rndsource, device_xname(sc->sc_dev),
    379       1.107       tls 			  RND_TYPE_TTY, RND_FLAG_DEFAULT);
    380        1.31  explorer 
    381        1.74       smb 	if (!pmf_device_register(self, NULL, NULL))
    382        1.74       smb 		aprint_error_dev(self, "couldn't establish power handler\n");
    383        1.85    dyoung 	return;
    384   1.108.2.9     skrll 
    385   1.108.2.9     skrll fail_2:
    386  1.108.2.15     skrll 	for (ub = &sc->sc_obuff[0]; ub != &sc->sc_obuff[UCOM_OUT_BUFFS];
    387   1.108.2.9     skrll 	    ub++) {
    388   1.108.2.9     skrll 		if (ub->ub_xfer)
    389   1.108.2.9     skrll 			usbd_destroy_xfer(ub->ub_xfer);
    390   1.108.2.9     skrll 	}
    391  1.108.2.15     skrll 
    392  1.108.2.15     skrll 	usbd_close_pipe(sc->sc_bulkout_pipe);
    393  1.108.2.15     skrll 
    394  1.108.2.15     skrll fail_1:
    395  1.108.2.15     skrll 	for (ub = &sc->sc_ibuff[0]; ub != &sc->sc_ibuff[UCOM_IN_BUFFS];
    396   1.108.2.9     skrll 	    ub++) {
    397   1.108.2.9     skrll 		if (ub->ub_xfer)
    398   1.108.2.9     skrll 			usbd_destroy_xfer(ub->ub_xfer);
    399   1.108.2.9     skrll 	}
    400   1.108.2.9     skrll 	usbd_close_pipe(sc->sc_bulkin_pipe);
    401   1.108.2.9     skrll 
    402   1.108.2.9     skrll fail_0:
    403   1.108.2.9     skrll 	aprint_error_dev(self, "attach failed, error=%d\n", error);
    404   1.108.2.9     skrll 
    405   1.108.2.9     skrll 	return;
    406        1.12  augustss }
    407        1.12  augustss 
    408        1.85    dyoung int
    409        1.85    dyoung ucom_detach(device_t self, int flags)
    410        1.12  augustss {
    411        1.77      cube 	struct ucom_softc *sc = device_private(self);
    412        1.36  augustss 	struct tty *tp = sc->sc_tty;
    413        1.12  augustss 	int maj, mn;
    414   1.108.2.8     skrll 	int i;
    415        1.12  augustss 
    416   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    417   1.108.2.7     skrll 
    418   1.108.2.7     skrll 	DPRINTF("sc=%p flags=%d tp=%p", sc, flags, tp, 0);
    419  1.108.2.23     skrll 	DPRINTF("... pipe=%d,%d", sc->sc_bulkin_no, sc->sc_bulkout_no, 0, 0);
    420        1.12  augustss 
    421  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    422  1.108.2.22     skrll 	sc->sc_dying = true;
    423  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    424   1.108.2.8     skrll 
    425        1.74       smb 	pmf_device_deregister(self);
    426        1.12  augustss 
    427        1.33  augustss 	if (sc->sc_bulkin_pipe != NULL)
    428        1.33  augustss 		usbd_abort_pipe(sc->sc_bulkin_pipe);
    429        1.33  augustss 	if (sc->sc_bulkout_pipe != NULL)
    430        1.33  augustss 		usbd_abort_pipe(sc->sc_bulkout_pipe);
    431        1.12  augustss 
    432  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    433   1.108.2.8     skrll 	while (sc->sc_refcnt > 0) {
    434        1.35  augustss 		/* Wake up anyone waiting */
    435        1.36  augustss 		if (tp != NULL) {
    436        1.71        ad 			mutex_spin_enter(&tty_lock);
    437        1.36  augustss 			CLR(tp->t_state, TS_CARR_ON);
    438        1.36  augustss 			CLR(tp->t_cflag, CLOCAL | MDMBUF);
    439        1.36  augustss 			ttyflush(tp, FREAD|FWRITE);
    440        1.71        ad 			mutex_spin_exit(&tty_lock);
    441        1.36  augustss 		}
    442        1.17  augustss 		/* Wait for processes to go away. */
    443  1.108.2.24     skrll 		if (cv_timedwait(&sc->sc_detachcv, &sc->sc_lock, hz * 60)) {
    444  1.108.2.24     skrll 			printf("%s: %s didn't detach\n", __func__,
    445  1.108.2.24     skrll 			    device_xname(sc->sc_dev));
    446  1.108.2.24     skrll 		}
    447        1.17  augustss 	}
    448        1.82    martin 
    449        1.82    martin 	softint_disestablish(sc->sc_si);
    450  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    451        1.12  augustss 
    452        1.12  augustss 	/* locate the major number */
    453        1.44   gehenna 	maj = cdevsw_lookup_major(&ucom_cdevsw);
    454        1.12  augustss 
    455        1.12  augustss 	/* Nuke the vnodes for any open instances. */
    456        1.62   thorpej 	mn = device_unit(self);
    457  1.108.2.19     skrll 	DPRINTF("maj=%d mn=%d", maj, mn, 0, 0);
    458        1.12  augustss 	vdevgone(maj, mn, mn, VCHR);
    459        1.22  augustss 	vdevgone(maj, mn | UCOMDIALOUT_MASK, mn | UCOMDIALOUT_MASK, VCHR);
    460        1.22  augustss 	vdevgone(maj, mn | UCOMCALLUNIT_MASK, mn | UCOMCALLUNIT_MASK, VCHR);
    461        1.12  augustss 
    462        1.12  augustss 	/* Detach and free the tty. */
    463        1.36  augustss 	if (tp != NULL) {
    464        1.36  augustss 		tty_detach(tp);
    465        1.87     rmind 		tty_free(tp);
    466        1.33  augustss 		sc->sc_tty = NULL;
    467        1.33  augustss 	}
    468        1.12  augustss 
    469        1.82    martin 	for (i = 0; i < UCOM_IN_BUFFS; i++) {
    470        1.82    martin 		if (sc->sc_ibuff[i].ub_xfer != NULL)
    471   1.108.2.9     skrll 			usbd_destroy_xfer(sc->sc_ibuff[i].ub_xfer);
    472        1.82    martin 	}
    473        1.82    martin 
    474        1.82    martin 	for (i = 0; i < UCOM_OUT_BUFFS; i++) {
    475        1.82    martin 		if (sc->sc_obuff[i].ub_xfer != NULL)
    476   1.108.2.9     skrll 			usbd_destroy_xfer(sc->sc_obuff[i].ub_xfer);
    477        1.82    martin 	}
    478        1.82    martin 
    479  1.108.2.11     skrll 	if (sc->sc_bulkin_pipe != NULL) {
    480  1.108.2.11     skrll 		usbd_close_pipe(sc->sc_bulkin_pipe);
    481  1.108.2.11     skrll 		sc->sc_bulkin_pipe = NULL;
    482  1.108.2.11     skrll 	}
    483  1.108.2.11     skrll 
    484  1.108.2.11     skrll 	if (sc->sc_bulkout_pipe != NULL) {
    485  1.108.2.11     skrll 		usbd_close_pipe(sc->sc_bulkout_pipe);
    486  1.108.2.11     skrll 		sc->sc_bulkout_pipe = NULL;
    487  1.108.2.11     skrll 	}
    488  1.108.2.11     skrll 
    489        1.31  explorer 	/* Detach the random source */
    490        1.31  explorer 	rnd_detach_source(&sc->sc_rndsource);
    491        1.31  explorer 
    492  1.108.2.12     skrll 	mutex_destroy(&sc->sc_lock);
    493   1.108.2.8     skrll 	cv_destroy(&sc->sc_opencv);
    494   1.108.2.8     skrll 	cv_destroy(&sc->sc_detachcv);
    495   1.108.2.8     skrll 
    496   1.108.2.3     skrll 	return 0;
    497        1.12  augustss }
    498        1.12  augustss 
    499        1.12  augustss int
    500        1.85    dyoung ucom_activate(device_t self, enum devact act)
    501        1.12  augustss {
    502        1.77      cube 	struct ucom_softc *sc = device_private(self);
    503        1.12  augustss 
    504   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    505   1.108.2.7     skrll 
    506   1.108.2.7     skrll 	DPRINTFN(5, "%d", act, 0, 0, 0);
    507        1.34  augustss 
    508        1.12  augustss 	switch (act) {
    509        1.12  augustss 	case DVACT_DEACTIVATE:
    510  1.108.2.12     skrll 		mutex_enter(&sc->sc_lock);
    511  1.108.2.22     skrll 		sc->sc_dying = true;
    512  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    513        1.81    dyoung 		return 0;
    514        1.81    dyoung 	default:
    515        1.81    dyoung 		return EOPNOTSUPP;
    516        1.12  augustss 	}
    517        1.12  augustss }
    518        1.12  augustss 
    519        1.12  augustss void
    520        1.24  augustss ucom_shutdown(struct ucom_softc *sc)
    521        1.12  augustss {
    522        1.12  augustss 	struct tty *tp = sc->sc_tty;
    523        1.12  augustss 
    524   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    525   1.108.2.7     skrll 
    526  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
    527        1.12  augustss 	/*
    528        1.12  augustss 	 * Hang up if necessary.  Wait a bit, so the other side has time to
    529        1.12  augustss 	 * notice even if we immediately open the port again.
    530        1.12  augustss 	 */
    531        1.12  augustss 	if (ISSET(tp->t_cflag, HUPCL)) {
    532        1.12  augustss 		ucom_dtr(sc, 0);
    533   1.108.2.8     skrll 		/* XXX will only timeout */
    534  1.108.2.12     skrll 		(void) kpause(ttclos, false, hz, &sc->sc_lock);
    535        1.12  augustss 	}
    536        1.12  augustss }
    537        1.12  augustss 
    538        1.12  augustss int
    539        1.69  christos ucomopen(dev_t dev, int flag, int mode, struct lwp *l)
    540        1.12  augustss {
    541  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    542  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    543        1.82    martin 	struct ucom_buffer *ub;
    544        1.12  augustss 	int error;
    545        1.43  augustss 
    546   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    547   1.108.2.7     skrll 
    548        1.12  augustss 	if (sc == NULL)
    549   1.108.2.3     skrll 		return ENXIO;
    550        1.12  augustss 
    551  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    552   1.108.2.8     skrll 	if (sc->sc_dying) {
    553  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    554   1.108.2.3     skrll 		return EIO;
    555   1.108.2.8     skrll 	}
    556        1.12  augustss 
    557   1.108.2.8     skrll 	if (!device_is_active(sc->sc_dev)) {
    558  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    559   1.108.2.3     skrll 		return ENXIO;
    560   1.108.2.8     skrll 	}
    561        1.12  augustss 
    562  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    563        1.12  augustss 
    564  1.108.2.19     skrll 	DPRINTF("unit=%d, tp=%p", unit, tp, 0, 0);
    565        1.12  augustss 
    566   1.108.2.8     skrll 	if (kauth_authorize_device_tty(l->l_cred, KAUTH_DEVICE_TTY_OPEN, tp)) {
    567  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    568   1.108.2.3     skrll 		return EBUSY;
    569   1.108.2.8     skrll 	}
    570        1.12  augustss 
    571        1.12  augustss 	/*
    572  1.108.2.14     skrll 	 * Wait while the device is initialized by the
    573  1.108.2.14     skrll 	 * first opener or cleaned up by the last closer.
    574        1.12  augustss 	 */
    575  1.108.2.14     skrll 	while (sc->sc_opening || sc->sc_closing) {
    576  1.108.2.12     skrll 		error = cv_wait_sig(&sc->sc_opencv, &sc->sc_lock);
    577        1.17  augustss 
    578   1.108.2.8     skrll 		if (error) {
    579  1.108.2.12     skrll 			mutex_exit(&sc->sc_lock);
    580   1.108.2.8     skrll 			return error;
    581   1.108.2.8     skrll 		}
    582        1.17  augustss 	}
    583   1.108.2.8     skrll 
    584        1.12  augustss 	sc->sc_opening = 1;
    585        1.43  augustss 
    586        1.12  augustss 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    587        1.12  augustss 		struct termios t;
    588        1.12  augustss 
    589        1.12  augustss 		tp->t_dev = dev;
    590        1.12  augustss 
    591        1.22  augustss 		if (sc->sc_methods->ucom_open != NULL) {
    592        1.22  augustss 			error = sc->sc_methods->ucom_open(sc->sc_parent,
    593        1.22  augustss 							  sc->sc_portno);
    594        1.22  augustss 			if (error) {
    595        1.22  augustss 				ucom_cleanup(sc);
    596        1.26    toshii 				sc->sc_opening = 0;
    597   1.108.2.8     skrll 				cv_signal(&sc->sc_opencv);
    598  1.108.2.12     skrll 				mutex_exit(&sc->sc_lock);
    599   1.108.2.3     skrll 				return error;
    600        1.22  augustss 			}
    601        1.22  augustss 		}
    602        1.22  augustss 
    603        1.12  augustss 		ucom_status_change(sc);
    604        1.12  augustss 
    605       1.106       gdt 		/* Clear PPS capture state on first open. */
    606       1.106       gdt 		mutex_spin_enter(&timecounter_lock);
    607       1.106       gdt 		memset(&sc->sc_pps_state, 0, sizeof(sc->sc_pps_state));
    608       1.106       gdt 		sc->sc_pps_state.ppscap = PPS_CAPTUREASSERT | PPS_CAPTURECLEAR;
    609       1.106       gdt 		pps_init(&sc->sc_pps_state);
    610       1.106       gdt 		mutex_spin_exit(&timecounter_lock);
    611       1.106       gdt 
    612        1.12  augustss 		/*
    613        1.12  augustss 		 * Initialize the termios status to the defaults.  Add in the
    614        1.12  augustss 		 * sticky bits from TIOCSFLAGS.
    615        1.12  augustss 		 */
    616        1.12  augustss 		t.c_ispeed = 0;
    617        1.12  augustss 		t.c_ospeed = TTYDEF_SPEED;
    618        1.12  augustss 		t.c_cflag = TTYDEF_CFLAG;
    619        1.12  augustss 		if (ISSET(sc->sc_swflags, TIOCFLAG_CLOCAL))
    620        1.12  augustss 			SET(t.c_cflag, CLOCAL);
    621        1.12  augustss 		if (ISSET(sc->sc_swflags, TIOCFLAG_CRTSCTS))
    622        1.12  augustss 			SET(t.c_cflag, CRTSCTS);
    623        1.12  augustss 		if (ISSET(sc->sc_swflags, TIOCFLAG_MDMBUF))
    624        1.12  augustss 			SET(t.c_cflag, MDMBUF);
    625        1.12  augustss 		/* Make sure ucomparam() will do something. */
    626        1.12  augustss 		tp->t_ospeed = 0;
    627        1.12  augustss 		(void) ucomparam(tp, &t);
    628        1.12  augustss 		tp->t_iflag = TTYDEF_IFLAG;
    629        1.12  augustss 		tp->t_oflag = TTYDEF_OFLAG;
    630        1.12  augustss 		tp->t_lflag = TTYDEF_LFLAG;
    631        1.12  augustss 		ttychars(tp);
    632        1.12  augustss 		ttsetwater(tp);
    633        1.12  augustss 
    634        1.12  augustss 		/*
    635        1.12  augustss 		 * Turn on DTR.  We must always do this, even if carrier is not
    636        1.12  augustss 		 * present, because otherwise we'd have to use TIOCSDTR
    637        1.12  augustss 		 * immediately after setting CLOCAL, which applications do not
    638        1.12  augustss 		 * expect.  We always assert DTR while the device is open
    639        1.64      gson 		 * unless explicitly requested to deassert it.  Ditto RTS.
    640        1.12  augustss 		 */
    641        1.12  augustss 		ucom_dtr(sc, 1);
    642       1.102  jakllsch 		ucom_rts(sc, 1);
    643        1.12  augustss 
    644        1.82    martin 		sc->sc_rx_unblock = 0;
    645        1.82    martin 		sc->sc_rx_stopped = 0;
    646        1.82    martin 		sc->sc_tx_stopped = 0;
    647        1.82    martin 
    648  1.108.2.15     skrll 		/*
    649  1.108.2.15     skrll 		 * ucomsubmitread handles bulk vs other
    650  1.108.2.15     skrll 		 */
    651        1.82    martin 		for (ub = &sc->sc_ibuff[0]; ub != &sc->sc_ibuff[UCOM_IN_BUFFS];
    652        1.82    martin 		    ub++) {
    653        1.82    martin 			if (ucomsubmitread(sc, ub) != USBD_NORMAL_COMPLETION) {
    654        1.82    martin 				error = EIO;
    655        1.82    martin 				goto fail_2;
    656        1.82    martin 			}
    657        1.28    toshii 		}
    658        1.12  augustss 	}
    659        1.12  augustss 	sc->sc_opening = 0;
    660   1.108.2.8     skrll 	cv_signal(&sc->sc_opencv);
    661  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    662        1.12  augustss 
    663        1.12  augustss 	error = ttyopen(tp, UCOMDIALOUT(dev), ISSET(flag, O_NONBLOCK));
    664        1.12  augustss 	if (error)
    665        1.12  augustss 		goto bad;
    666        1.12  augustss 
    667        1.32       eeh 	error = (*tp->t_linesw->l_open)(dev, tp);
    668        1.12  augustss 	if (error)
    669        1.12  augustss 		goto bad;
    670        1.12  augustss 
    671   1.108.2.3     skrll 	return 0;
    672        1.26    toshii 
    673        1.26    toshii fail_2:
    674  1.108.2.15     skrll 	if (sc->sc_bulkin_no != -1)
    675  1.108.2.15     skrll 		usbd_abort_pipe(sc->sc_bulkin_pipe);
    676  1.108.2.15     skrll 	if (sc->sc_bulkout_no != -1)
    677  1.108.2.15     skrll 		usbd_abort_pipe(sc->sc_bulkout_pipe);
    678        1.82    martin 
    679  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    680        1.26    toshii 	sc->sc_opening = 0;
    681   1.108.2.8     skrll 	cv_signal(&sc->sc_opencv);
    682  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    683   1.108.2.8     skrll 
    684   1.108.2.3     skrll 	return error;
    685        1.12  augustss 
    686        1.12  augustss bad:
    687   1.108.2.8     skrll 	mutex_spin_enter(&tty_lock);
    688        1.82    martin 	CLR(tp->t_state, TS_BUSY);
    689        1.12  augustss 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    690        1.12  augustss 		/*
    691        1.12  augustss 		 * We failed to open the device, and nobody else had it opened.
    692        1.12  augustss 		 * Clean up the state as appropriate.
    693        1.12  augustss 		 */
    694        1.12  augustss 		ucom_cleanup(sc);
    695        1.12  augustss 	}
    696   1.108.2.8     skrll 	mutex_spin_exit(&tty_lock);
    697        1.12  augustss 
    698   1.108.2.3     skrll 	return error;
    699        1.12  augustss }
    700        1.12  augustss 
    701        1.12  augustss int
    702        1.69  christos ucomclose(dev_t dev, int flag, int mode, struct lwp *l)
    703        1.12  augustss {
    704  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    705  1.108.2.25     skrll 	struct ucom_softc *sc = device_lookup_private(&ucom_cd, unit);
    706        1.12  augustss 
    707   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    708   1.108.2.7     skrll 
    709   1.108.2.7     skrll 	DPRINTF("unit=%d", UCOMUNIT(dev), 0, 0, 0);
    710       1.101  jakllsch 
    711       1.101  jakllsch 	if (sc == NULL)
    712       1.101  jakllsch 		return 0;
    713       1.101  jakllsch 
    714  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    715  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    716       1.101  jakllsch 
    717  1.108.2.14     skrll 	while (sc->sc_closing)
    718  1.108.2.14     skrll 		cv_wait(&sc->sc_opencv, &sc->sc_lock);
    719  1.108.2.14     skrll 	sc->sc_closing = 1;
    720  1.108.2.14     skrll 
    721   1.108.2.8     skrll 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
    722   1.108.2.8     skrll 		goto out;
    723   1.108.2.8     skrll 	}
    724        1.12  augustss 
    725        1.17  augustss 	sc->sc_refcnt++;
    726        1.17  augustss 
    727        1.32       eeh 	(*tp->t_linesw->l_close)(tp, flag);
    728        1.12  augustss 	ttyclose(tp);
    729        1.12  augustss 
    730        1.12  augustss 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    731        1.12  augustss 		/*
    732        1.12  augustss 		 * Although we got a last close, the device may still be in
    733        1.12  augustss 		 * use; e.g. if this was the dialout node, and there are still
    734        1.12  augustss 		 * processes waiting for carrier on the non-dialout node.
    735        1.12  augustss 		 */
    736        1.12  augustss 		ucom_cleanup(sc);
    737        1.12  augustss 	}
    738        1.12  augustss 
    739        1.14  augustss 	if (sc->sc_methods->ucom_close != NULL)
    740        1.14  augustss 		sc->sc_methods->ucom_close(sc->sc_parent, sc->sc_portno);
    741        1.14  augustss 
    742        1.17  augustss 	if (--sc->sc_refcnt < 0)
    743  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    744   1.108.2.8     skrll 
    745   1.108.2.8     skrll out:
    746  1.108.2.14     skrll 	sc->sc_closing = 0;
    747  1.108.2.14     skrll 	cv_signal(&sc->sc_opencv);
    748  1.108.2.14     skrll 
    749  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    750        1.17  augustss 
    751   1.108.2.3     skrll 	return 0;
    752        1.12  augustss }
    753        1.43  augustss 
    754        1.12  augustss int
    755        1.24  augustss ucomread(dev_t dev, struct uio *uio, int flag)
    756        1.12  augustss {
    757  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    758  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    759        1.17  augustss 	int error;
    760        1.12  augustss 
    761   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    762   1.108.2.7     skrll 
    763   1.108.2.8     skrll 	if (sc == NULL)
    764   1.108.2.8     skrll 		return EIO;
    765   1.108.2.8     skrll 
    766  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    767   1.108.2.8     skrll 	if (sc->sc_dying) {
    768  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    769   1.108.2.3     skrll 		return EIO;
    770   1.108.2.8     skrll 	}
    771        1.43  augustss 
    772  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    773       1.101  jakllsch 
    774        1.17  augustss 	sc->sc_refcnt++;
    775  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    776  1.108.2.23     skrll 
    777        1.32       eeh 	error = ((*tp->t_linesw->l_read)(tp, uio, flag));
    778   1.108.2.8     skrll 
    779  1.108.2.23     skrll 	mutex_enter(&sc->sc_lock);
    780        1.17  augustss 	if (--sc->sc_refcnt < 0)
    781  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    782  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    783   1.108.2.8     skrll 
    784   1.108.2.3     skrll 	return error;
    785        1.12  augustss }
    786        1.43  augustss 
    787        1.12  augustss int
    788        1.24  augustss ucomwrite(dev_t dev, struct uio *uio, int flag)
    789        1.12  augustss {
    790  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    791  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    792        1.17  augustss 	int error;
    793        1.12  augustss 
    794   1.108.2.8     skrll 	if (sc == NULL)
    795   1.108.2.8     skrll 		return EIO;
    796   1.108.2.8     skrll 
    797  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    798   1.108.2.8     skrll 	if (sc->sc_dying) {
    799  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    800   1.108.2.3     skrll 		return EIO;
    801   1.108.2.8     skrll 	}
    802        1.43  augustss 
    803  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    804       1.101  jakllsch 
    805        1.17  augustss 	sc->sc_refcnt++;
    806  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    807  1.108.2.23     skrll 
    808        1.32       eeh 	error = ((*tp->t_linesw->l_write)(tp, uio, flag));
    809  1.108.2.23     skrll 
    810  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    811        1.38       scw 	if (--sc->sc_refcnt < 0)
    812  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    813  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    814   1.108.2.8     skrll 
    815   1.108.2.3     skrll 	return error;
    816        1.38       scw }
    817        1.38       scw 
    818        1.38       scw int
    819        1.60  christos ucompoll(dev_t dev, int events, struct lwp *l)
    820        1.38       scw {
    821  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    822  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    823        1.38       scw 
    824   1.108.2.8     skrll 	if (sc == NULL)
    825   1.108.2.3     skrll 		return POLLHUP;
    826        1.43  augustss 
    827  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    828   1.108.2.8     skrll 	if (sc->sc_dying) {
    829  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    830   1.108.2.8     skrll 		return POLLHUP;
    831   1.108.2.8     skrll 	}
    832  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    833        1.94  jakllsch 
    834        1.38       scw 	sc->sc_refcnt++;
    835  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    836  1.108.2.23     skrll 
    837  1.108.2.25     skrll 	int revents = ((*tp->t_linesw->l_poll)(tp, events, l));
    838  1.108.2.23     skrll 
    839  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    840        1.17  augustss 	if (--sc->sc_refcnt < 0)
    841  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    842  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    843   1.108.2.8     skrll 
    844   1.108.2.3     skrll 	return revents;
    845        1.12  augustss }
    846        1.12  augustss 
    847        1.12  augustss struct tty *
    848        1.24  augustss ucomtty(dev_t dev)
    849        1.12  augustss {
    850  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    851  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    852        1.12  augustss 
    853   1.108.2.4     skrll 	return sc != NULL ? sc->sc_tty : NULL;
    854        1.12  augustss }
    855        1.12  augustss 
    856        1.12  augustss int
    857        1.70  christos ucomioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
    858        1.12  augustss {
    859  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    860  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    861        1.17  augustss 	int error;
    862        1.17  augustss 
    863   1.108.2.8     skrll 	if (sc == NULL)
    864   1.108.2.3     skrll 		return EIO;
    865       1.101  jakllsch 
    866  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    867   1.108.2.8     skrll 	if (sc->sc_dying) {
    868  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    869   1.108.2.8     skrll 		return EIO;
    870   1.108.2.8     skrll 	}
    871   1.108.2.8     skrll 
    872        1.17  augustss 	sc->sc_refcnt++;
    873  1.108.2.18     skrll 	mutex_exit(&sc->sc_lock);
    874  1.108.2.23     skrll 
    875        1.60  christos 	error = ucom_do_ioctl(sc, cmd, data, flag, l);
    876  1.108.2.23     skrll 
    877  1.108.2.18     skrll 	mutex_enter(&sc->sc_lock);
    878        1.17  augustss 	if (--sc->sc_refcnt < 0)
    879  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    880  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    881  1.108.2.23     skrll 
    882   1.108.2.3     skrll 	return error;
    883        1.17  augustss }
    884        1.17  augustss 
    885        1.82    martin static int
    886  1.108.2.23     skrll ucom_do_ioctl(struct ucom_softc *sc, u_long cmd, void *data, int flag,
    887  1.108.2.23     skrll     struct lwp *l)
    888        1.17  augustss {
    889        1.12  augustss 	struct tty *tp = sc->sc_tty;
    890        1.12  augustss 	int error;
    891        1.12  augustss 
    892   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    893   1.108.2.7     skrll 
    894   1.108.2.7     skrll 	DPRINTF("cmd=0x%08lx", cmd, 0, 0, 0);
    895        1.12  augustss 
    896        1.60  christos 	error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
    897        1.42    atatat 	if (error != EPASSTHROUGH)
    898   1.108.2.3     skrll 		return error;
    899        1.12  augustss 
    900        1.60  christos 	error = ttioctl(tp, cmd, data, flag, l);
    901        1.42    atatat 	if (error != EPASSTHROUGH)
    902   1.108.2.3     skrll 		return error;
    903        1.12  augustss 
    904        1.12  augustss 	if (sc->sc_methods->ucom_ioctl != NULL) {
    905        1.12  augustss 		error = sc->sc_methods->ucom_ioctl(sc->sc_parent,
    906  1.108.2.23     skrll 		    sc->sc_portno, cmd, data, flag, l->l_proc);
    907        1.42    atatat 		if (error != EPASSTHROUGH)
    908   1.108.2.3     skrll 			return error;
    909        1.12  augustss 	}
    910        1.12  augustss 
    911        1.12  augustss 	error = 0;
    912        1.12  augustss 
    913   1.108.2.7     skrll 	DPRINTF("our cmd=0x%08lx", cmd, 0, 0, 0);
    914   1.108.2.8     skrll 	//mutex_enter(&tty_lock);
    915        1.12  augustss 
    916        1.12  augustss 	switch (cmd) {
    917        1.12  augustss 	case TIOCSBRK:
    918        1.12  augustss 		ucom_break(sc, 1);
    919        1.12  augustss 		break;
    920        1.12  augustss 
    921        1.12  augustss 	case TIOCCBRK:
    922        1.12  augustss 		ucom_break(sc, 0);
    923        1.12  augustss 		break;
    924        1.12  augustss 
    925        1.12  augustss 	case TIOCSDTR:
    926        1.12  augustss 		ucom_dtr(sc, 1);
    927        1.12  augustss 		break;
    928        1.12  augustss 
    929        1.12  augustss 	case TIOCCDTR:
    930        1.12  augustss 		ucom_dtr(sc, 0);
    931        1.12  augustss 		break;
    932        1.12  augustss 
    933        1.12  augustss 	case TIOCGFLAGS:
    934  1.108.2.18     skrll 		mutex_enter(&sc->sc_lock);
    935        1.12  augustss 		*(int *)data = sc->sc_swflags;
    936  1.108.2.18     skrll 		mutex_exit(&sc->sc_lock);
    937        1.12  augustss 		break;
    938        1.12  augustss 
    939        1.12  augustss 	case TIOCSFLAGS:
    940        1.67      elad 		error = kauth_authorize_device_tty(l->l_cred,
    941        1.67      elad 		    KAUTH_DEVICE_TTY_PRIVSET, tp);
    942        1.12  augustss 		if (error)
    943        1.12  augustss 			break;
    944  1.108.2.18     skrll 		mutex_enter(&sc->sc_lock);
    945        1.12  augustss 		sc->sc_swflags = *(int *)data;
    946  1.108.2.18     skrll 		mutex_exit(&sc->sc_lock);
    947        1.12  augustss 		break;
    948        1.12  augustss 
    949        1.12  augustss 	case TIOCMSET:
    950        1.12  augustss 	case TIOCMBIS:
    951        1.12  augustss 	case TIOCMBIC:
    952        1.12  augustss 		tiocm_to_ucom(sc, cmd, *(int *)data);
    953        1.12  augustss 		break;
    954        1.12  augustss 
    955        1.12  augustss 	case TIOCMGET:
    956        1.12  augustss 		*(int *)data = ucom_to_tiocm(sc);
    957        1.12  augustss 		break;
    958        1.12  augustss 
    959       1.106       gdt 	case PPS_IOC_CREATE:
    960       1.106       gdt 	case PPS_IOC_DESTROY:
    961       1.106       gdt 	case PPS_IOC_GETPARAMS:
    962       1.106       gdt 	case PPS_IOC_SETPARAMS:
    963       1.106       gdt 	case PPS_IOC_GETCAP:
    964       1.106       gdt 	case PPS_IOC_FETCH:
    965       1.106       gdt #ifdef PPS_SYNC
    966       1.106       gdt 	case PPS_IOC_KCBIND:
    967       1.106       gdt #endif
    968       1.106       gdt 		mutex_spin_enter(&timecounter_lock);
    969       1.106       gdt 		error = pps_ioctl(cmd, data, &sc->sc_pps_state);
    970       1.106       gdt 		mutex_spin_exit(&timecounter_lock);
    971       1.106       gdt 		break;
    972       1.106       gdt 
    973        1.12  augustss 	default:
    974        1.42    atatat 		error = EPASSTHROUGH;
    975        1.12  augustss 		break;
    976        1.12  augustss 	}
    977        1.12  augustss 
    978   1.108.2.8     skrll 	//mutex_exit(&tty_lock);
    979        1.12  augustss 
    980   1.108.2.3     skrll 	return error;
    981        1.12  augustss }
    982        1.12  augustss 
    983        1.82    martin static void
    984        1.29    toshii tiocm_to_ucom(struct ucom_softc *sc, u_long how, int ttybits)
    985        1.12  augustss {
    986        1.12  augustss 	u_char combits;
    987         1.3  augustss 
    988        1.12  augustss 	combits = 0;
    989        1.12  augustss 	if (ISSET(ttybits, TIOCM_DTR))
    990        1.12  augustss 		SET(combits, UMCR_DTR);
    991        1.12  augustss 	if (ISSET(ttybits, TIOCM_RTS))
    992        1.12  augustss 		SET(combits, UMCR_RTS);
    993        1.43  augustss 
    994  1.108.2.18     skrll 	mutex_enter(&sc->sc_lock);
    995        1.12  augustss 	switch (how) {
    996        1.12  augustss 	case TIOCMBIC:
    997        1.12  augustss 		CLR(sc->sc_mcr, combits);
    998        1.12  augustss 		break;
    999        1.12  augustss 
   1000        1.12  augustss 	case TIOCMBIS:
   1001        1.12  augustss 		SET(sc->sc_mcr, combits);
   1002        1.12  augustss 		break;
   1003        1.12  augustss 
   1004        1.12  augustss 	case TIOCMSET:
   1005        1.12  augustss 		CLR(sc->sc_mcr, UMCR_DTR | UMCR_RTS);
   1006        1.12  augustss 		SET(sc->sc_mcr, combits);
   1007        1.12  augustss 		break;
   1008        1.12  augustss 	}
   1009  1.108.2.18     skrll 	mutex_exit(&sc->sc_lock);
   1010        1.12  augustss 
   1011        1.27    toshii 	if (how == TIOCMSET || ISSET(combits, UMCR_DTR))
   1012        1.27    toshii 		ucom_dtr(sc, (sc->sc_mcr & UMCR_DTR) != 0);
   1013        1.27    toshii 	if (how == TIOCMSET || ISSET(combits, UMCR_RTS))
   1014        1.27    toshii 		ucom_rts(sc, (sc->sc_mcr & UMCR_RTS) != 0);
   1015        1.12  augustss }
   1016        1.12  augustss 
   1017        1.82    martin static int
   1018        1.24  augustss ucom_to_tiocm(struct ucom_softc *sc)
   1019        1.12  augustss {
   1020        1.12  augustss 	u_char combits;
   1021        1.12  augustss 	int ttybits = 0;
   1022        1.12  augustss 
   1023  1.108.2.18     skrll 	mutex_enter(&sc->sc_lock);
   1024        1.12  augustss 	combits = sc->sc_mcr;
   1025        1.12  augustss 	if (ISSET(combits, UMCR_DTR))
   1026        1.12  augustss 		SET(ttybits, TIOCM_DTR);
   1027        1.12  augustss 	if (ISSET(combits, UMCR_RTS))
   1028        1.12  augustss 		SET(ttybits, TIOCM_RTS);
   1029        1.12  augustss 
   1030        1.12  augustss 	combits = sc->sc_msr;
   1031        1.12  augustss 	if (ISSET(combits, UMSR_DCD))
   1032        1.12  augustss 		SET(ttybits, TIOCM_CD);
   1033        1.12  augustss 	if (ISSET(combits, UMSR_CTS))
   1034        1.12  augustss 		SET(ttybits, TIOCM_CTS);
   1035        1.12  augustss 	if (ISSET(combits, UMSR_DSR))
   1036        1.12  augustss 		SET(ttybits, TIOCM_DSR);
   1037        1.12  augustss 	if (ISSET(combits, UMSR_RI | UMSR_TERI))
   1038        1.12  augustss 		SET(ttybits, TIOCM_RI);
   1039        1.12  augustss 
   1040        1.12  augustss #if 0
   1041        1.12  augustss XXX;
   1042        1.12  augustss 	if (sc->sc_ier != 0)
   1043        1.12  augustss 		SET(ttybits, TIOCM_LE);
   1044        1.12  augustss #endif
   1045  1.108.2.18     skrll 	mutex_exit(&sc->sc_lock);
   1046        1.12  augustss 
   1047   1.108.2.3     skrll 	return ttybits;
   1048        1.12  augustss }
   1049        1.12  augustss 
   1050        1.82    martin static void
   1051        1.77      cube ucom_break(struct ucom_softc *sc, int onoff)
   1052        1.12  augustss {
   1053   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1054   1.108.2.7     skrll 
   1055   1.108.2.7     skrll 	DPRINTF("onoff=%d", onoff, 0, 0, 0);
   1056        1.12  augustss 
   1057        1.14  augustss 	if (sc->sc_methods->ucom_set != NULL)
   1058        1.14  augustss 		sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
   1059        1.14  augustss 		    UCOM_SET_BREAK, onoff);
   1060        1.12  augustss }
   1061        1.12  augustss 
   1062        1.82    martin static void
   1063        1.24  augustss ucom_dtr(struct ucom_softc *sc, int onoff)
   1064        1.12  augustss {
   1065   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1066   1.108.2.7     skrll 
   1067   1.108.2.7     skrll 	DPRINTF("onoff=%d", onoff, 0, 0, 0);
   1068        1.12  augustss 
   1069        1.14  augustss 	if (sc->sc_methods->ucom_set != NULL)
   1070        1.43  augustss 		sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
   1071        1.14  augustss 		    UCOM_SET_DTR, onoff);
   1072        1.12  augustss }
   1073        1.12  augustss 
   1074        1.82    martin static void
   1075        1.24  augustss ucom_rts(struct ucom_softc *sc, int onoff)
   1076        1.12  augustss {
   1077   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1078   1.108.2.7     skrll 
   1079   1.108.2.7     skrll 	DPRINTF("onoff=%d", onoff, 0, 0, 0);
   1080        1.12  augustss 
   1081        1.14  augustss 	if (sc->sc_methods->ucom_set != NULL)
   1082        1.43  augustss 		sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
   1083        1.14  augustss 		    UCOM_SET_RTS, onoff);
   1084        1.12  augustss }
   1085        1.12  augustss 
   1086        1.22  augustss void
   1087        1.24  augustss ucom_status_change(struct ucom_softc *sc)
   1088        1.12  augustss {
   1089        1.27    toshii 	struct tty *tp = sc->sc_tty;
   1090        1.27    toshii 	u_char old_msr;
   1091        1.27    toshii 
   1092        1.14  augustss 	if (sc->sc_methods->ucom_get_status != NULL) {
   1093        1.27    toshii 		old_msr = sc->sc_msr;
   1094        1.14  augustss 		sc->sc_methods->ucom_get_status(sc->sc_parent, sc->sc_portno,
   1095        1.14  augustss 		    &sc->sc_lsr, &sc->sc_msr);
   1096       1.106       gdt 		if (ISSET((sc->sc_msr ^ old_msr), UMSR_DCD)) {
   1097       1.106       gdt 			mutex_spin_enter(&timecounter_lock);
   1098       1.106       gdt 			pps_capture(&sc->sc_pps_state);
   1099       1.106       gdt 			pps_event(&sc->sc_pps_state,
   1100       1.106       gdt 			    (sc->sc_msr & UMSR_DCD) ?
   1101       1.106       gdt 			    PPS_CAPTUREASSERT :
   1102       1.106       gdt 			    PPS_CAPTURECLEAR);
   1103       1.106       gdt 			mutex_spin_exit(&timecounter_lock);
   1104       1.106       gdt 
   1105        1.32       eeh 			(*tp->t_linesw->l_modem)(tp,
   1106        1.27    toshii 			    ISSET(sc->sc_msr, UMSR_DCD));
   1107       1.106       gdt 		}
   1108        1.14  augustss 	} else {
   1109        1.14  augustss 		sc->sc_lsr = 0;
   1110        1.54  augustss 		/* Assume DCD is present, if we have no chance to check it. */
   1111        1.54  augustss 		sc->sc_msr = UMSR_DCD;
   1112        1.14  augustss 	}
   1113        1.12  augustss }
   1114        1.12  augustss 
   1115        1.82    martin static int
   1116        1.24  augustss ucomparam(struct tty *tp, struct termios *t)
   1117        1.12  augustss {
   1118  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1119  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1120        1.14  augustss 	int error;
   1121        1.12  augustss 
   1122   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1123   1.108.2.7     skrll 
   1124       1.101  jakllsch 	if (sc == NULL || sc->sc_dying)
   1125   1.108.2.3     skrll 		return EIO;
   1126        1.12  augustss 
   1127        1.12  augustss 	/* Check requested parameters. */
   1128        1.12  augustss 	if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
   1129   1.108.2.3     skrll 		return EINVAL;
   1130        1.12  augustss 
   1131        1.12  augustss 	/*
   1132        1.12  augustss 	 * For the console, always force CLOCAL and !HUPCL, so that the port
   1133        1.12  augustss 	 * is always active.
   1134        1.12  augustss 	 */
   1135        1.12  augustss 	if (ISSET(sc->sc_swflags, TIOCFLAG_SOFTCAR)) {
   1136        1.12  augustss 		SET(t->c_cflag, CLOCAL);
   1137        1.12  augustss 		CLR(t->c_cflag, HUPCL);
   1138        1.12  augustss 	}
   1139        1.12  augustss 
   1140        1.12  augustss 	/*
   1141        1.12  augustss 	 * If there were no changes, don't do anything.  This avoids dropping
   1142        1.12  augustss 	 * input and improves performance when all we did was frob things like
   1143        1.12  augustss 	 * VMIN and VTIME.
   1144        1.12  augustss 	 */
   1145        1.12  augustss 	if (tp->t_ospeed == t->c_ospeed &&
   1146        1.12  augustss 	    tp->t_cflag == t->c_cflag)
   1147   1.108.2.3     skrll 		return 0;
   1148        1.12  augustss 
   1149        1.30  augustss 	/* XXX lcr = ISSET(sc->sc_lcr, LCR_SBREAK) | cflag2lcr(t->c_cflag); */
   1150        1.12  augustss 
   1151        1.12  augustss 	/* And copy to tty. */
   1152        1.12  augustss 	tp->t_ispeed = 0;
   1153        1.12  augustss 	tp->t_ospeed = t->c_ospeed;
   1154        1.12  augustss 	tp->t_cflag = t->c_cflag;
   1155        1.12  augustss 
   1156        1.14  augustss 	if (sc->sc_methods->ucom_param != NULL) {
   1157        1.14  augustss 		error = sc->sc_methods->ucom_param(sc->sc_parent, sc->sc_portno,
   1158        1.14  augustss 			    t);
   1159        1.14  augustss 		if (error)
   1160   1.108.2.3     skrll 			return error;
   1161        1.14  augustss 	}
   1162        1.12  augustss 
   1163        1.30  augustss 	/* XXX worry about CHWFLOW */
   1164        1.12  augustss 
   1165        1.12  augustss 	/*
   1166        1.12  augustss 	 * Update the tty layer's idea of the carrier bit, in case we changed
   1167        1.12  augustss 	 * CLOCAL or MDMBUF.  We don't hang up here; we only do that by
   1168        1.12  augustss 	 * explicit request.
   1169        1.12  augustss 	 */
   1170   1.108.2.7     skrll 	DPRINTF("l_modem", 0, 0, 0, 0);
   1171        1.54  augustss 	(void) (*tp->t_linesw->l_modem)(tp, ISSET(sc->sc_msr, UMSR_DCD));
   1172        1.12  augustss 
   1173        1.12  augustss #if 0
   1174        1.12  augustss XXX what if the hardware is not open
   1175        1.12  augustss 	if (!ISSET(t->c_cflag, CHWFLOW)) {
   1176        1.12  augustss 		if (sc->sc_tx_stopped) {
   1177        1.12  augustss 			sc->sc_tx_stopped = 0;
   1178        1.12  augustss 			ucomstart(tp);
   1179        1.12  augustss 		}
   1180        1.12  augustss 	}
   1181        1.12  augustss #endif
   1182        1.12  augustss 
   1183   1.108.2.3     skrll 	return 0;
   1184        1.12  augustss }
   1185        1.12  augustss 
   1186        1.82    martin static int
   1187        1.82    martin ucomhwiflow(struct tty *tp, int block)
   1188        1.12  augustss {
   1189  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1190  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1191        1.82    martin 	int old;
   1192        1.12  augustss 
   1193       1.101  jakllsch 	if (sc == NULL)
   1194   1.108.2.3     skrll 		return 0;
   1195       1.101  jakllsch 
   1196  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1197        1.82    martin 	old = sc->sc_rx_stopped;
   1198        1.82    martin 	sc->sc_rx_stopped = (u_char)block;
   1199        1.12  augustss 
   1200        1.82    martin 	if (old && !block) {
   1201        1.82    martin 		sc->sc_rx_unblock = 1;
   1202        1.82    martin 		softint_schedule(sc->sc_si);
   1203        1.12  augustss 	}
   1204  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1205        1.82    martin 
   1206   1.108.2.3     skrll 	return 1;
   1207         1.1  augustss }
   1208         1.3  augustss 
   1209        1.82    martin static void
   1210        1.24  augustss ucomstart(struct tty *tp)
   1211        1.12  augustss {
   1212  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1213  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1214        1.82    martin 	struct ucom_buffer *ub;
   1215        1.12  augustss 	u_char *data;
   1216        1.12  augustss 	int cnt;
   1217        1.12  augustss 
   1218   1.108.2.8     skrll 	if (sc == NULL)
   1219        1.12  augustss 		return;
   1220        1.12  augustss 
   1221  1.108.2.12     skrll 	KASSERT(&sc->sc_lock);
   1222   1.108.2.8     skrll 	KASSERT(mutex_owned(&tty_lock));
   1223   1.108.2.8     skrll 	if (sc->sc_dying) {
   1224   1.108.2.8     skrll 		return;
   1225   1.108.2.8     skrll 	}
   1226   1.108.2.8     skrll 
   1227        1.84  christos 	if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP))
   1228        1.12  augustss 		goto out;
   1229        1.12  augustss 	if (sc->sc_tx_stopped)
   1230        1.12  augustss 		goto out;
   1231        1.12  augustss 
   1232        1.82    martin 	if (!ttypull(tp))
   1233        1.73        ad 		goto out;
   1234        1.12  augustss 
   1235        1.12  augustss 	/* Grab the first contiguous region of buffer space. */
   1236        1.12  augustss 	data = tp->t_outq.c_cf;
   1237        1.12  augustss 	cnt = ndqb(&tp->t_outq, 0);
   1238        1.12  augustss 
   1239        1.84  christos 	if (cnt == 0)
   1240        1.12  augustss 		goto out;
   1241        1.12  augustss 
   1242        1.82    martin 	ub = SIMPLEQ_FIRST(&sc->sc_obuff_free);
   1243       1.100   mlelstv 	if (ub == NULL) {
   1244       1.100   mlelstv 		SET(tp->t_state, TS_BUSY);
   1245       1.100   mlelstv 		goto out;
   1246       1.100   mlelstv 	}
   1247   1.108.2.8     skrll 
   1248        1.82    martin 	SIMPLEQ_REMOVE_HEAD(&sc->sc_obuff_free, ub_link);
   1249        1.12  augustss 
   1250        1.82    martin 	if (SIMPLEQ_FIRST(&sc->sc_obuff_free) == NULL)
   1251        1.82    martin 		SET(tp->t_state, TS_BUSY);
   1252        1.82    martin 
   1253        1.82    martin 	if (cnt > sc->sc_obufsize)
   1254        1.19  augustss 		cnt = sc->sc_obufsize;
   1255        1.82    martin 
   1256        1.22  augustss 	if (sc->sc_methods->ucom_write != NULL)
   1257        1.22  augustss 		sc->sc_methods->ucom_write(sc->sc_parent, sc->sc_portno,
   1258        1.82    martin 					   ub->ub_data, data, &cnt);
   1259        1.22  augustss 	else
   1260        1.82    martin 		memcpy(ub->ub_data, data, cnt);
   1261        1.82    martin 
   1262        1.82    martin 	ub->ub_len = cnt;
   1263        1.82    martin 	ub->ub_index = 0;
   1264        1.12  augustss 
   1265        1.82    martin 	SIMPLEQ_INSERT_TAIL(&sc->sc_obuff_full, ub, ub_link);
   1266        1.82    martin 
   1267        1.82    martin 	softint_schedule(sc->sc_si);
   1268         1.3  augustss 
   1269        1.82    martin  out:
   1270   1.108.2.8     skrll 	return;
   1271        1.12  augustss }
   1272        1.12  augustss 
   1273        1.21    itojun void
   1274        1.69  christos ucomstop(struct tty *tp, int flag)
   1275        1.12  augustss {
   1276        1.19  augustss #if 0
   1277  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1278  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1279        1.12  augustss 
   1280  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1281   1.108.2.8     skrll 	mutex_spin_enter(&tty_lock);
   1282        1.12  augustss 	if (ISSET(tp->t_state, TS_BUSY)) {
   1283   1.108.2.8     skrll 		/* obuff_full -> obuff_free? */
   1284        1.19  augustss 		/* sc->sc_tx_stopped = 1; */
   1285        1.12  augustss 		if (!ISSET(tp->t_state, TS_TTSTOP))
   1286        1.12  augustss 			SET(tp->t_state, TS_FLUSH);
   1287        1.12  augustss 	}
   1288   1.108.2.8     skrll 	mutex_spin_exit(&tty_lock);
   1289  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1290        1.19  augustss #endif
   1291        1.12  augustss }
   1292        1.12  augustss 
   1293        1.82    martin static void
   1294        1.82    martin ucom_write_status(struct ucom_softc *sc, struct ucom_buffer *ub,
   1295        1.82    martin     usbd_status err)
   1296        1.82    martin {
   1297        1.82    martin 	struct tty *tp = sc->sc_tty;
   1298        1.82    martin 	uint32_t cc = ub->ub_len;
   1299        1.82    martin 
   1300  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1301   1.108.2.8     skrll 
   1302        1.82    martin 	switch (err) {
   1303        1.82    martin 	case USBD_IN_PROGRESS:
   1304        1.82    martin 		ub->ub_index = ub->ub_len;
   1305        1.82    martin 		break;
   1306        1.82    martin 	case USBD_STALLED:
   1307        1.82    martin 		ub->ub_index = 0;
   1308        1.82    martin 		softint_schedule(sc->sc_si);
   1309        1.82    martin 		break;
   1310        1.82    martin 	case USBD_NORMAL_COMPLETION:
   1311        1.82    martin 		usbd_get_xfer_status(ub->ub_xfer, NULL, NULL, &cc, NULL);
   1312        1.82    martin 		rnd_add_uint32(&sc->sc_rndsource, cc);
   1313        1.82    martin 		/*FALLTHROUGH*/
   1314        1.82    martin 	default:
   1315        1.82    martin 		SIMPLEQ_REMOVE_HEAD(&sc->sc_obuff_full, ub_link);
   1316        1.82    martin 		SIMPLEQ_INSERT_TAIL(&sc->sc_obuff_free, ub, ub_link);
   1317        1.82    martin 		cc -= sc->sc_opkthdrlen;
   1318        1.82    martin 
   1319       1.100   mlelstv 		mutex_spin_enter(&tty_lock);
   1320        1.82    martin 		CLR(tp->t_state, TS_BUSY);
   1321        1.82    martin 		if (ISSET(tp->t_state, TS_FLUSH))
   1322        1.82    martin 			CLR(tp->t_state, TS_FLUSH);
   1323        1.82    martin 		else
   1324        1.82    martin 			ndflush(&tp->t_outq, cc);
   1325       1.100   mlelstv 		mutex_spin_exit(&tty_lock);
   1326        1.82    martin 
   1327        1.82    martin 		if (err != USBD_CANCELLED && err != USBD_IOERROR &&
   1328        1.82    martin 		    !sc->sc_dying) {
   1329        1.82    martin 			if ((ub = SIMPLEQ_FIRST(&sc->sc_obuff_full)) != NULL)
   1330        1.82    martin 				ucom_submit_write(sc, ub);
   1331        1.82    martin 
   1332   1.108.2.8     skrll 			mutex_spin_enter(&tty_lock);
   1333        1.82    martin 			(*tp->t_linesw->l_start)(tp);
   1334   1.108.2.8     skrll 			mutex_spin_exit(&tty_lock);
   1335        1.82    martin 		}
   1336        1.82    martin 		break;
   1337        1.82    martin 	}
   1338        1.82    martin }
   1339        1.82    martin 
   1340        1.82    martin static void
   1341        1.82    martin ucom_submit_write(struct ucom_softc *sc, struct ucom_buffer *ub)
   1342        1.82    martin {
   1343        1.82    martin 
   1344  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1345   1.108.2.8     skrll 
   1346   1.108.2.9     skrll 	usbd_setup_xfer(ub->ub_xfer, sc, ub->ub_data, ub->ub_len,
   1347   1.108.2.2     skrll 	    0, USBD_NO_TIMEOUT, ucomwritecb);
   1348        1.82    martin 
   1349        1.82    martin 	ucom_write_status(sc, ub, usbd_transfer(ub->ub_xfer));
   1350        1.82    martin }
   1351        1.82    martin 
   1352        1.82    martin static void
   1353   1.108.2.5     skrll ucomwritecb(struct usbd_xfer *xfer, void *p, usbd_status status)
   1354        1.12  augustss {
   1355        1.12  augustss 	struct ucom_softc *sc = (struct ucom_softc *)p;
   1356        1.82    martin 
   1357  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1358        1.82    martin 	ucom_write_status(sc, SIMPLEQ_FIRST(&sc->sc_obuff_full), status);
   1359  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1360        1.82    martin 
   1361        1.82    martin }
   1362        1.82    martin 
   1363        1.82    martin static void
   1364        1.82    martin ucom_softintr(void *arg)
   1365        1.82    martin {
   1366        1.82    martin 	struct ucom_softc *sc = arg;
   1367        1.12  augustss 
   1368  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1369  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
   1370   1.108.2.8     skrll 	mutex_enter(&tty_lock);
   1371   1.108.2.8     skrll 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
   1372   1.108.2.8     skrll 		mutex_exit(&tty_lock);
   1373  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1374        1.82    martin 		return;
   1375   1.108.2.8     skrll 	}
   1376   1.108.2.8     skrll 	mutex_exit(&tty_lock);
   1377        1.12  augustss 
   1378  1.108.2.20     skrll 	struct ucom_buffer *ub = SIMPLEQ_FIRST(&sc->sc_obuff_full);
   1379        1.82    martin 
   1380        1.82    martin 	if (ub != NULL && ub->ub_index == 0)
   1381        1.82    martin 		ucom_submit_write(sc, ub);
   1382        1.12  augustss 
   1383        1.82    martin 	if (sc->sc_rx_unblock)
   1384        1.82    martin 		ucom_read_complete(sc);
   1385        1.12  augustss 
   1386  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1387        1.82    martin }
   1388        1.82    martin 
   1389        1.82    martin static void
   1390        1.82    martin ucom_read_complete(struct ucom_softc *sc)
   1391        1.82    martin {
   1392        1.82    martin 	int (*rint)(int, struct tty *);
   1393        1.82    martin 	struct ucom_buffer *ub;
   1394        1.82    martin 	struct tty *tp;
   1395   1.108.2.8     skrll 
   1396  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1397        1.82    martin 
   1398        1.82    martin 	tp = sc->sc_tty;
   1399        1.82    martin 	rint = tp->t_linesw->l_rint;
   1400        1.82    martin 	ub = SIMPLEQ_FIRST(&sc->sc_ibuff_full);
   1401        1.39  augustss 
   1402        1.82    martin 	while (ub != NULL && !sc->sc_rx_stopped) {
   1403        1.82    martin 
   1404   1.108.2.8     skrll 		/* XXX ttyinput takes tty_lock */
   1405        1.82    martin 		while (ub->ub_index < ub->ub_len && !sc->sc_rx_stopped) {
   1406        1.82    martin 			/* Give characters to tty layer. */
   1407        1.82    martin 			if ((*rint)(ub->ub_data[ub->ub_index], tp) == -1) {
   1408        1.82    martin 				/* Overflow: drop remainder */
   1409        1.82    martin 				ub->ub_index = ub->ub_len;
   1410        1.82    martin 			} else
   1411        1.82    martin 				ub->ub_index++;
   1412        1.82    martin 		}
   1413        1.82    martin 
   1414        1.82    martin 		if (ub->ub_index == ub->ub_len) {
   1415        1.82    martin 			SIMPLEQ_REMOVE_HEAD(&sc->sc_ibuff_full, ub_link);
   1416        1.82    martin 
   1417        1.82    martin 			ucomsubmitread(sc, ub);
   1418        1.82    martin 
   1419        1.82    martin 			ub = SIMPLEQ_FIRST(&sc->sc_ibuff_full);
   1420        1.82    martin 		}
   1421        1.82    martin 	}
   1422        1.82    martin 
   1423        1.82    martin 	sc->sc_rx_unblock = (ub != NULL);
   1424        1.12  augustss }
   1425        1.12  augustss 
   1426        1.82    martin static usbd_status
   1427        1.82    martin ucomsubmitread(struct ucom_softc *sc, struct ucom_buffer *ub)
   1428        1.12  augustss {
   1429        1.12  augustss 	usbd_status err;
   1430        1.12  augustss 
   1431  1.108.2.15     skrll 	if (sc->sc_bulkin_no != -1) {
   1432  1.108.2.15     skrll 		usbd_setup_xfer(ub->ub_xfer, sc, ub->ub_data, sc->sc_ibufsize,
   1433  1.108.2.15     skrll 		    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, ucomreadcb);
   1434  1.108.2.15     skrll 
   1435  1.108.2.15     skrll 		if ((err = usbd_transfer(ub->ub_xfer)) != USBD_IN_PROGRESS) {
   1436  1.108.2.15     skrll 			/* XXX: Recover from this, please! */
   1437  1.108.2.15     skrll 			printf("%s: err=%s\n", __func__, usbd_errstr(err));
   1438  1.108.2.15     skrll 			return err;
   1439  1.108.2.15     skrll 		}
   1440        1.12  augustss 	}
   1441        1.82    martin 
   1442        1.82    martin 	SIMPLEQ_INSERT_TAIL(&sc->sc_ibuff_empty, ub, ub_link);
   1443        1.82    martin 
   1444   1.108.2.3     skrll 	return USBD_NORMAL_COMPLETION;
   1445        1.12  augustss }
   1446        1.43  augustss 
   1447  1.108.2.15     skrll void
   1448   1.108.2.5     skrll ucomreadcb(struct usbd_xfer *xfer, void *p, usbd_status status)
   1449        1.12  augustss {
   1450        1.12  augustss 	struct ucom_softc *sc = (struct ucom_softc *)p;
   1451        1.12  augustss 	struct tty *tp = sc->sc_tty;
   1452        1.82    martin 	struct ucom_buffer *ub;
   1453   1.108.2.1     skrll 	uint32_t cc;
   1454        1.12  augustss 	u_char *cp;
   1455        1.12  augustss 
   1456   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1457   1.108.2.7     skrll 
   1458  1.108.2.14     skrll 	if (status == USBD_CANCELLED)
   1459  1.108.2.14     skrll 		return;
   1460        1.34  augustss 
   1461  1.108.2.14     skrll 	mutex_enter(&sc->sc_lock);
   1462  1.108.2.14     skrll 	if (status == USBD_IOERROR ||
   1463        1.34  augustss 	    sc->sc_dying) {
   1464   1.108.2.7     skrll 		DPRINTF("dying", 0, 0, 0, 0);
   1465        1.34  augustss 		/* Send something to wake upper layer */
   1466  1.108.2.14     skrll 		(tp->t_linesw->l_rint)('\n', tp);
   1467  1.108.2.14     skrll 		mutex_spin_enter(&tty_lock);	/* XXX */
   1468  1.108.2.14     skrll 		ttwakeup(tp);
   1469  1.108.2.14     skrll 		mutex_spin_exit(&tty_lock);	/* XXX */
   1470  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1471        1.12  augustss 		return;
   1472        1.34  augustss 	}
   1473        1.12  augustss 
   1474  1.108.2.14     skrll 	ub = SIMPLEQ_FIRST(&sc->sc_ibuff_empty);
   1475  1.108.2.14     skrll 	SIMPLEQ_REMOVE_HEAD(&sc->sc_ibuff_empty, ub_link);
   1476  1.108.2.14     skrll 
   1477        1.82    martin 	if (status == USBD_STALLED) {
   1478  1.108.2.15     skrll 		if (sc->sc_bulkin_no != -1)
   1479  1.108.2.15     skrll 			usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
   1480  1.108.2.15     skrll 		if (sc->sc_ipipe)
   1481  1.108.2.15     skrll 			usbd_clear_endpoint_stall_async(sc->sc_ipipe);
   1482        1.82    martin 		ucomsubmitread(sc, ub);
   1483  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1484        1.82    martin 		return;
   1485        1.82    martin 	}
   1486        1.82    martin 
   1487        1.82    martin 	if (status != USBD_NORMAL_COMPLETION) {
   1488        1.82    martin 		printf("ucomreadcb: wonky status=%s\n", usbd_errstr(status));
   1489  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1490        1.12  augustss 		return;
   1491        1.12  augustss 	}
   1492        1.12  augustss 
   1493        1.48   thorpej 	usbd_get_xfer_status(xfer, NULL, (void *)&cp, &cc, NULL);
   1494        1.82    martin 
   1495        1.95  jakllsch #ifdef UCOM_DEBUG
   1496        1.95  jakllsch 	/* This is triggered by uslsa(4) occasionally. */
   1497        1.95  jakllsch 	if ((ucomdebug > 0) && (cc == 0)) {
   1498        1.95  jakllsch 		device_printf(sc->sc_dev, "ucomreadcb: zero length xfer!\n");
   1499        1.82    martin 	}
   1500        1.95  jakllsch #endif
   1501        1.82    martin 
   1502        1.82    martin 	KDASSERT(cp == ub->ub_data);
   1503        1.82    martin 
   1504        1.31  explorer 	rnd_add_uint32(&sc->sc_rndsource, cc);
   1505        1.82    martin 
   1506        1.82    martin 	if (sc->sc_opening) {
   1507        1.82    martin 		ucomsubmitread(sc, ub);
   1508  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1509        1.82    martin 		return;
   1510        1.82    martin 	}
   1511        1.82    martin 
   1512  1.108.2.16     skrll 	ub->ub_data = usbd_get_buffer(xfer);
   1513        1.82    martin 	if (sc->sc_methods->ucom_read != NULL) {
   1514        1.22  augustss 		sc->sc_methods->ucom_read(sc->sc_parent, sc->sc_portno,
   1515        1.82    martin 		    &cp, &cc);
   1516        1.82    martin 		ub->ub_index = (u_int)(cp - ub->ub_data);
   1517        1.82    martin 	} else
   1518        1.82    martin 		ub->ub_index = 0;
   1519        1.82    martin 
   1520        1.82    martin 	ub->ub_len = cc;
   1521        1.22  augustss 
   1522        1.82    martin 	SIMPLEQ_INSERT_TAIL(&sc->sc_ibuff_full, ub, ub_link);
   1523        1.12  augustss 
   1524        1.82    martin 	ucom_read_complete(sc);
   1525  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1526        1.12  augustss }
   1527        1.12  augustss 
   1528        1.82    martin static void
   1529        1.24  augustss ucom_cleanup(struct ucom_softc *sc)
   1530        1.12  augustss {
   1531        1.82    martin 
   1532   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1533   1.108.2.7     skrll 
   1534   1.108.2.9     skrll 	DPRINTF("aborting pipes", 0, 0, 0, 0);
   1535        1.12  augustss 
   1536  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1537   1.108.2.8     skrll 
   1538        1.12  augustss 	ucom_shutdown(sc);
   1539        1.33  augustss 	if (sc->sc_bulkin_pipe != NULL) {
   1540  1.108.2.14     skrll 		usbd_abort_pipe(sc->sc_bulkin_pipe);
   1541        1.33  augustss 	}
   1542        1.33  augustss 	if (sc->sc_bulkout_pipe != NULL) {
   1543  1.108.2.14     skrll 		usbd_abort_pipe(sc->sc_bulkout_pipe);
   1544        1.33  augustss 	}
   1545        1.12  augustss }
   1546        1.13  augustss 
   1547        1.13  augustss #endif /* NUCOM > 0 */
   1548        1.12  augustss 
   1549        1.20  augustss int
   1550        1.24  augustss ucomprint(void *aux, const char *pnp)
   1551        1.12  augustss {
   1552  1.108.2.13     skrll 	struct ucom_attach_args *ucaa = aux;
   1553        1.12  augustss 
   1554        1.12  augustss 	if (pnp)
   1555        1.49   thorpej 		aprint_normal("ucom at %s", pnp);
   1556  1.108.2.13     skrll 	if (ucaa->ucaa_portno != UCOM_UNK_PORTNO)
   1557  1.108.2.13     skrll 		aprint_normal(" portno %d", ucaa->ucaa_portno);
   1558   1.108.2.3     skrll 	return UNCONF;
   1559        1.12  augustss }
   1560        1.12  augustss 
   1561        1.20  augustss int
   1562        1.77      cube ucomsubmatch(device_t parent, cfdata_t cf,
   1563        1.69  christos 	     const int *ldesc, void *aux)
   1564        1.12  augustss {
   1565  1.108.2.13     skrll 	struct ucom_attach_args *ucaa = aux;
   1566        1.12  augustss 
   1567  1.108.2.13     skrll 	if (ucaa->ucaa_portno != UCOM_UNK_PORTNO &&
   1568        1.53  drochner 	    cf->cf_loc[UCOMBUSCF_PORTNO] != UCOMBUSCF_PORTNO_DEFAULT &&
   1569  1.108.2.13     skrll 	    cf->cf_loc[UCOMBUSCF_PORTNO] != ucaa->ucaa_portno)
   1570   1.108.2.3     skrll 		return 0;
   1571   1.108.2.3     skrll 	return config_match(parent, cf, aux);
   1572        1.12  augustss }
   1573