Home | History | Annotate | Line # | Download | only in usb
ucom.c revision 1.108.2.27
      1  1.108.2.27     skrll /*	$NetBSD: ucom.c,v 1.108.2.27 2016/11/02 08:28:10 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.27     skrll __KERNEL_RCSID(0, "$NetBSD: ucom.c,v 1.108.2.27 2016/11/02 08:28:10 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.108.2.27     skrll static int	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 		tp->t_dev = dev;
    588        1.12  augustss 
    589        1.22  augustss 		if (sc->sc_methods->ucom_open != NULL) {
    590        1.22  augustss 			error = sc->sc_methods->ucom_open(sc->sc_parent,
    591        1.22  augustss 							  sc->sc_portno);
    592        1.22  augustss 			if (error) {
    593        1.22  augustss 				ucom_cleanup(sc);
    594        1.26    toshii 				sc->sc_opening = 0;
    595   1.108.2.8     skrll 				cv_signal(&sc->sc_opencv);
    596  1.108.2.12     skrll 				mutex_exit(&sc->sc_lock);
    597   1.108.2.3     skrll 				return error;
    598        1.22  augustss 			}
    599        1.22  augustss 		}
    600        1.22  augustss 
    601        1.12  augustss 		ucom_status_change(sc);
    602        1.12  augustss 
    603       1.106       gdt 		/* Clear PPS capture state on first open. */
    604       1.106       gdt 		mutex_spin_enter(&timecounter_lock);
    605       1.106       gdt 		memset(&sc->sc_pps_state, 0, sizeof(sc->sc_pps_state));
    606       1.106       gdt 		sc->sc_pps_state.ppscap = PPS_CAPTUREASSERT | PPS_CAPTURECLEAR;
    607       1.106       gdt 		pps_init(&sc->sc_pps_state);
    608       1.106       gdt 		mutex_spin_exit(&timecounter_lock);
    609       1.106       gdt 
    610        1.12  augustss 		/*
    611        1.12  augustss 		 * Initialize the termios status to the defaults.  Add in the
    612        1.12  augustss 		 * sticky bits from TIOCSFLAGS.
    613        1.12  augustss 		 */
    614  1.108.2.26     skrll 		struct termios t;
    615  1.108.2.26     skrll 
    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.108.2.27     skrll 			error = ucomsubmitread(sc, ub);
    654  1.108.2.27     skrll 			if (error)
    655        1.82    martin 				goto fail_2;
    656        1.28    toshii 		}
    657        1.12  augustss 	}
    658        1.12  augustss 	sc->sc_opening = 0;
    659   1.108.2.8     skrll 	cv_signal(&sc->sc_opencv);
    660  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    661        1.12  augustss 
    662        1.12  augustss 	error = ttyopen(tp, UCOMDIALOUT(dev), ISSET(flag, O_NONBLOCK));
    663        1.12  augustss 	if (error)
    664        1.12  augustss 		goto bad;
    665        1.12  augustss 
    666        1.32       eeh 	error = (*tp->t_linesw->l_open)(dev, tp);
    667        1.12  augustss 	if (error)
    668        1.12  augustss 		goto bad;
    669        1.12  augustss 
    670   1.108.2.3     skrll 	return 0;
    671        1.26    toshii 
    672        1.26    toshii fail_2:
    673  1.108.2.15     skrll 	if (sc->sc_bulkin_no != -1)
    674  1.108.2.15     skrll 		usbd_abort_pipe(sc->sc_bulkin_pipe);
    675  1.108.2.15     skrll 	if (sc->sc_bulkout_no != -1)
    676  1.108.2.15     skrll 		usbd_abort_pipe(sc->sc_bulkout_pipe);
    677        1.82    martin 
    678  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    679        1.26    toshii 	sc->sc_opening = 0;
    680   1.108.2.8     skrll 	cv_signal(&sc->sc_opencv);
    681  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    682   1.108.2.8     skrll 
    683   1.108.2.3     skrll 	return error;
    684        1.12  augustss 
    685        1.12  augustss bad:
    686   1.108.2.8     skrll 	mutex_spin_enter(&tty_lock);
    687        1.82    martin 	CLR(tp->t_state, TS_BUSY);
    688        1.12  augustss 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    689        1.12  augustss 		/*
    690        1.12  augustss 		 * We failed to open the device, and nobody else had it opened.
    691        1.12  augustss 		 * Clean up the state as appropriate.
    692        1.12  augustss 		 */
    693        1.12  augustss 		ucom_cleanup(sc);
    694        1.12  augustss 	}
    695   1.108.2.8     skrll 	mutex_spin_exit(&tty_lock);
    696        1.12  augustss 
    697   1.108.2.3     skrll 	return error;
    698        1.12  augustss }
    699        1.12  augustss 
    700        1.12  augustss int
    701        1.69  christos ucomclose(dev_t dev, int flag, int mode, struct lwp *l)
    702        1.12  augustss {
    703  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    704  1.108.2.25     skrll 	struct ucom_softc *sc = device_lookup_private(&ucom_cd, unit);
    705        1.12  augustss 
    706   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    707   1.108.2.7     skrll 
    708   1.108.2.7     skrll 	DPRINTF("unit=%d", UCOMUNIT(dev), 0, 0, 0);
    709       1.101  jakllsch 
    710       1.101  jakllsch 	if (sc == NULL)
    711       1.101  jakllsch 		return 0;
    712       1.101  jakllsch 
    713  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    714  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    715       1.101  jakllsch 
    716  1.108.2.14     skrll 	while (sc->sc_closing)
    717  1.108.2.14     skrll 		cv_wait(&sc->sc_opencv, &sc->sc_lock);
    718  1.108.2.14     skrll 	sc->sc_closing = 1;
    719  1.108.2.14     skrll 
    720   1.108.2.8     skrll 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
    721   1.108.2.8     skrll 		goto out;
    722   1.108.2.8     skrll 	}
    723        1.12  augustss 
    724        1.17  augustss 	sc->sc_refcnt++;
    725        1.17  augustss 
    726        1.32       eeh 	(*tp->t_linesw->l_close)(tp, flag);
    727        1.12  augustss 	ttyclose(tp);
    728        1.12  augustss 
    729        1.12  augustss 	if (!ISSET(tp->t_state, TS_ISOPEN) && tp->t_wopen == 0) {
    730        1.12  augustss 		/*
    731        1.12  augustss 		 * Although we got a last close, the device may still be in
    732        1.12  augustss 		 * use; e.g. if this was the dialout node, and there are still
    733        1.12  augustss 		 * processes waiting for carrier on the non-dialout node.
    734        1.12  augustss 		 */
    735        1.12  augustss 		ucom_cleanup(sc);
    736        1.12  augustss 	}
    737        1.12  augustss 
    738        1.14  augustss 	if (sc->sc_methods->ucom_close != NULL)
    739        1.14  augustss 		sc->sc_methods->ucom_close(sc->sc_parent, sc->sc_portno);
    740        1.14  augustss 
    741        1.17  augustss 	if (--sc->sc_refcnt < 0)
    742  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    743   1.108.2.8     skrll 
    744   1.108.2.8     skrll out:
    745  1.108.2.14     skrll 	sc->sc_closing = 0;
    746  1.108.2.14     skrll 	cv_signal(&sc->sc_opencv);
    747  1.108.2.14     skrll 
    748  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    749        1.17  augustss 
    750   1.108.2.3     skrll 	return 0;
    751        1.12  augustss }
    752        1.43  augustss 
    753        1.12  augustss int
    754        1.24  augustss ucomread(dev_t dev, struct uio *uio, int flag)
    755        1.12  augustss {
    756  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    757  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    758        1.17  augustss 	int error;
    759        1.12  augustss 
    760   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    761   1.108.2.7     skrll 
    762   1.108.2.8     skrll 	if (sc == NULL)
    763   1.108.2.8     skrll 		return EIO;
    764   1.108.2.8     skrll 
    765  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    766   1.108.2.8     skrll 	if (sc->sc_dying) {
    767  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    768   1.108.2.3     skrll 		return EIO;
    769   1.108.2.8     skrll 	}
    770        1.43  augustss 
    771  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    772       1.101  jakllsch 
    773        1.17  augustss 	sc->sc_refcnt++;
    774  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    775  1.108.2.23     skrll 
    776        1.32       eeh 	error = ((*tp->t_linesw->l_read)(tp, uio, flag));
    777   1.108.2.8     skrll 
    778  1.108.2.23     skrll 	mutex_enter(&sc->sc_lock);
    779        1.17  augustss 	if (--sc->sc_refcnt < 0)
    780  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    781  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    782   1.108.2.8     skrll 
    783   1.108.2.3     skrll 	return error;
    784        1.12  augustss }
    785        1.43  augustss 
    786        1.12  augustss int
    787        1.24  augustss ucomwrite(dev_t dev, struct uio *uio, int flag)
    788        1.12  augustss {
    789  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    790  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    791        1.17  augustss 	int error;
    792        1.12  augustss 
    793   1.108.2.8     skrll 	if (sc == NULL)
    794   1.108.2.8     skrll 		return EIO;
    795   1.108.2.8     skrll 
    796  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    797   1.108.2.8     skrll 	if (sc->sc_dying) {
    798  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    799   1.108.2.3     skrll 		return EIO;
    800   1.108.2.8     skrll 	}
    801        1.43  augustss 
    802  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    803       1.101  jakllsch 
    804        1.17  augustss 	sc->sc_refcnt++;
    805  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    806  1.108.2.23     skrll 
    807        1.32       eeh 	error = ((*tp->t_linesw->l_write)(tp, uio, flag));
    808  1.108.2.23     skrll 
    809  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    810        1.38       scw 	if (--sc->sc_refcnt < 0)
    811  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    812  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    813   1.108.2.8     skrll 
    814   1.108.2.3     skrll 	return error;
    815        1.38       scw }
    816        1.38       scw 
    817        1.38       scw int
    818        1.60  christos ucompoll(dev_t dev, int events, struct lwp *l)
    819        1.38       scw {
    820  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    821  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    822        1.38       scw 
    823   1.108.2.8     skrll 	if (sc == NULL)
    824   1.108.2.3     skrll 		return POLLHUP;
    825        1.43  augustss 
    826  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    827   1.108.2.8     skrll 	if (sc->sc_dying) {
    828  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    829   1.108.2.8     skrll 		return POLLHUP;
    830   1.108.2.8     skrll 	}
    831  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
    832        1.94  jakllsch 
    833        1.38       scw 	sc->sc_refcnt++;
    834  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    835  1.108.2.23     skrll 
    836  1.108.2.25     skrll 	int revents = ((*tp->t_linesw->l_poll)(tp, events, l));
    837  1.108.2.23     skrll 
    838  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    839        1.17  augustss 	if (--sc->sc_refcnt < 0)
    840  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    841  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    842   1.108.2.8     skrll 
    843   1.108.2.3     skrll 	return revents;
    844        1.12  augustss }
    845        1.12  augustss 
    846        1.12  augustss struct tty *
    847        1.24  augustss ucomtty(dev_t dev)
    848        1.12  augustss {
    849  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    850  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    851        1.12  augustss 
    852   1.108.2.4     skrll 	return sc != NULL ? sc->sc_tty : NULL;
    853        1.12  augustss }
    854        1.12  augustss 
    855        1.12  augustss int
    856        1.70  christos ucomioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
    857        1.12  augustss {
    858  1.108.2.25     skrll 	const int unit = UCOMUNIT(dev);
    859  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
    860        1.17  augustss 	int error;
    861        1.17  augustss 
    862   1.108.2.8     skrll 	if (sc == NULL)
    863   1.108.2.3     skrll 		return EIO;
    864       1.101  jakllsch 
    865  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
    866   1.108.2.8     skrll 	if (sc->sc_dying) {
    867  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
    868   1.108.2.8     skrll 		return EIO;
    869   1.108.2.8     skrll 	}
    870   1.108.2.8     skrll 
    871        1.17  augustss 	sc->sc_refcnt++;
    872  1.108.2.18     skrll 	mutex_exit(&sc->sc_lock);
    873  1.108.2.23     skrll 
    874        1.60  christos 	error = ucom_do_ioctl(sc, cmd, data, flag, l);
    875  1.108.2.23     skrll 
    876  1.108.2.18     skrll 	mutex_enter(&sc->sc_lock);
    877        1.17  augustss 	if (--sc->sc_refcnt < 0)
    878  1.108.2.24     skrll 		cv_broadcast(&sc->sc_detachcv);
    879  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
    880  1.108.2.23     skrll 
    881   1.108.2.3     skrll 	return error;
    882        1.17  augustss }
    883        1.17  augustss 
    884        1.82    martin static int
    885  1.108.2.23     skrll ucom_do_ioctl(struct ucom_softc *sc, u_long cmd, void *data, int flag,
    886  1.108.2.23     skrll     struct lwp *l)
    887        1.17  augustss {
    888        1.12  augustss 	struct tty *tp = sc->sc_tty;
    889        1.12  augustss 	int error;
    890        1.12  augustss 
    891   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
    892   1.108.2.7     skrll 
    893   1.108.2.7     skrll 	DPRINTF("cmd=0x%08lx", cmd, 0, 0, 0);
    894        1.12  augustss 
    895        1.60  christos 	error = (*tp->t_linesw->l_ioctl)(tp, cmd, data, flag, l);
    896        1.42    atatat 	if (error != EPASSTHROUGH)
    897   1.108.2.3     skrll 		return error;
    898        1.12  augustss 
    899        1.60  christos 	error = ttioctl(tp, cmd, data, flag, l);
    900        1.42    atatat 	if (error != EPASSTHROUGH)
    901   1.108.2.3     skrll 		return error;
    902        1.12  augustss 
    903        1.12  augustss 	if (sc->sc_methods->ucom_ioctl != NULL) {
    904        1.12  augustss 		error = sc->sc_methods->ucom_ioctl(sc->sc_parent,
    905  1.108.2.23     skrll 		    sc->sc_portno, cmd, data, flag, l->l_proc);
    906        1.42    atatat 		if (error != EPASSTHROUGH)
    907   1.108.2.3     skrll 			return error;
    908        1.12  augustss 	}
    909        1.12  augustss 
    910        1.12  augustss 	error = 0;
    911        1.12  augustss 
    912   1.108.2.7     skrll 	DPRINTF("our cmd=0x%08lx", cmd, 0, 0, 0);
    913   1.108.2.8     skrll 	//mutex_enter(&tty_lock);
    914        1.12  augustss 
    915        1.12  augustss 	switch (cmd) {
    916        1.12  augustss 	case TIOCSBRK:
    917        1.12  augustss 		ucom_break(sc, 1);
    918        1.12  augustss 		break;
    919        1.12  augustss 
    920        1.12  augustss 	case TIOCCBRK:
    921        1.12  augustss 		ucom_break(sc, 0);
    922        1.12  augustss 		break;
    923        1.12  augustss 
    924        1.12  augustss 	case TIOCSDTR:
    925        1.12  augustss 		ucom_dtr(sc, 1);
    926        1.12  augustss 		break;
    927        1.12  augustss 
    928        1.12  augustss 	case TIOCCDTR:
    929        1.12  augustss 		ucom_dtr(sc, 0);
    930        1.12  augustss 		break;
    931        1.12  augustss 
    932        1.12  augustss 	case TIOCGFLAGS:
    933  1.108.2.18     skrll 		mutex_enter(&sc->sc_lock);
    934        1.12  augustss 		*(int *)data = sc->sc_swflags;
    935  1.108.2.18     skrll 		mutex_exit(&sc->sc_lock);
    936        1.12  augustss 		break;
    937        1.12  augustss 
    938        1.12  augustss 	case TIOCSFLAGS:
    939        1.67      elad 		error = kauth_authorize_device_tty(l->l_cred,
    940        1.67      elad 		    KAUTH_DEVICE_TTY_PRIVSET, tp);
    941        1.12  augustss 		if (error)
    942        1.12  augustss 			break;
    943  1.108.2.18     skrll 		mutex_enter(&sc->sc_lock);
    944        1.12  augustss 		sc->sc_swflags = *(int *)data;
    945  1.108.2.18     skrll 		mutex_exit(&sc->sc_lock);
    946        1.12  augustss 		break;
    947        1.12  augustss 
    948        1.12  augustss 	case TIOCMSET:
    949        1.12  augustss 	case TIOCMBIS:
    950        1.12  augustss 	case TIOCMBIC:
    951        1.12  augustss 		tiocm_to_ucom(sc, cmd, *(int *)data);
    952        1.12  augustss 		break;
    953        1.12  augustss 
    954        1.12  augustss 	case TIOCMGET:
    955        1.12  augustss 		*(int *)data = ucom_to_tiocm(sc);
    956        1.12  augustss 		break;
    957        1.12  augustss 
    958       1.106       gdt 	case PPS_IOC_CREATE:
    959       1.106       gdt 	case PPS_IOC_DESTROY:
    960       1.106       gdt 	case PPS_IOC_GETPARAMS:
    961       1.106       gdt 	case PPS_IOC_SETPARAMS:
    962       1.106       gdt 	case PPS_IOC_GETCAP:
    963       1.106       gdt 	case PPS_IOC_FETCH:
    964       1.106       gdt #ifdef PPS_SYNC
    965       1.106       gdt 	case PPS_IOC_KCBIND:
    966       1.106       gdt #endif
    967       1.106       gdt 		mutex_spin_enter(&timecounter_lock);
    968       1.106       gdt 		error = pps_ioctl(cmd, data, &sc->sc_pps_state);
    969       1.106       gdt 		mutex_spin_exit(&timecounter_lock);
    970       1.106       gdt 		break;
    971       1.106       gdt 
    972        1.12  augustss 	default:
    973        1.42    atatat 		error = EPASSTHROUGH;
    974        1.12  augustss 		break;
    975        1.12  augustss 	}
    976        1.12  augustss 
    977   1.108.2.8     skrll 	//mutex_exit(&tty_lock);
    978        1.12  augustss 
    979   1.108.2.3     skrll 	return error;
    980        1.12  augustss }
    981        1.12  augustss 
    982        1.82    martin static void
    983        1.29    toshii tiocm_to_ucom(struct ucom_softc *sc, u_long how, int ttybits)
    984        1.12  augustss {
    985        1.12  augustss 	u_char combits;
    986         1.3  augustss 
    987        1.12  augustss 	combits = 0;
    988        1.12  augustss 	if (ISSET(ttybits, TIOCM_DTR))
    989        1.12  augustss 		SET(combits, UMCR_DTR);
    990        1.12  augustss 	if (ISSET(ttybits, TIOCM_RTS))
    991        1.12  augustss 		SET(combits, UMCR_RTS);
    992        1.43  augustss 
    993  1.108.2.18     skrll 	mutex_enter(&sc->sc_lock);
    994        1.12  augustss 	switch (how) {
    995        1.12  augustss 	case TIOCMBIC:
    996        1.12  augustss 		CLR(sc->sc_mcr, combits);
    997        1.12  augustss 		break;
    998        1.12  augustss 
    999        1.12  augustss 	case TIOCMBIS:
   1000        1.12  augustss 		SET(sc->sc_mcr, combits);
   1001        1.12  augustss 		break;
   1002        1.12  augustss 
   1003        1.12  augustss 	case TIOCMSET:
   1004        1.12  augustss 		CLR(sc->sc_mcr, UMCR_DTR | UMCR_RTS);
   1005        1.12  augustss 		SET(sc->sc_mcr, combits);
   1006        1.12  augustss 		break;
   1007        1.12  augustss 	}
   1008  1.108.2.18     skrll 	mutex_exit(&sc->sc_lock);
   1009        1.12  augustss 
   1010        1.27    toshii 	if (how == TIOCMSET || ISSET(combits, UMCR_DTR))
   1011        1.27    toshii 		ucom_dtr(sc, (sc->sc_mcr & UMCR_DTR) != 0);
   1012        1.27    toshii 	if (how == TIOCMSET || ISSET(combits, UMCR_RTS))
   1013        1.27    toshii 		ucom_rts(sc, (sc->sc_mcr & UMCR_RTS) != 0);
   1014        1.12  augustss }
   1015        1.12  augustss 
   1016        1.82    martin static int
   1017        1.24  augustss ucom_to_tiocm(struct ucom_softc *sc)
   1018        1.12  augustss {
   1019        1.12  augustss 	u_char combits;
   1020        1.12  augustss 	int ttybits = 0;
   1021        1.12  augustss 
   1022  1.108.2.18     skrll 	mutex_enter(&sc->sc_lock);
   1023        1.12  augustss 	combits = sc->sc_mcr;
   1024        1.12  augustss 	if (ISSET(combits, UMCR_DTR))
   1025        1.12  augustss 		SET(ttybits, TIOCM_DTR);
   1026        1.12  augustss 	if (ISSET(combits, UMCR_RTS))
   1027        1.12  augustss 		SET(ttybits, TIOCM_RTS);
   1028        1.12  augustss 
   1029        1.12  augustss 	combits = sc->sc_msr;
   1030        1.12  augustss 	if (ISSET(combits, UMSR_DCD))
   1031        1.12  augustss 		SET(ttybits, TIOCM_CD);
   1032        1.12  augustss 	if (ISSET(combits, UMSR_CTS))
   1033        1.12  augustss 		SET(ttybits, TIOCM_CTS);
   1034        1.12  augustss 	if (ISSET(combits, UMSR_DSR))
   1035        1.12  augustss 		SET(ttybits, TIOCM_DSR);
   1036        1.12  augustss 	if (ISSET(combits, UMSR_RI | UMSR_TERI))
   1037        1.12  augustss 		SET(ttybits, TIOCM_RI);
   1038        1.12  augustss 
   1039        1.12  augustss #if 0
   1040        1.12  augustss XXX;
   1041        1.12  augustss 	if (sc->sc_ier != 0)
   1042        1.12  augustss 		SET(ttybits, TIOCM_LE);
   1043        1.12  augustss #endif
   1044  1.108.2.18     skrll 	mutex_exit(&sc->sc_lock);
   1045        1.12  augustss 
   1046   1.108.2.3     skrll 	return ttybits;
   1047        1.12  augustss }
   1048        1.12  augustss 
   1049        1.82    martin static void
   1050        1.77      cube ucom_break(struct ucom_softc *sc, int onoff)
   1051        1.12  augustss {
   1052   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1053   1.108.2.7     skrll 
   1054   1.108.2.7     skrll 	DPRINTF("onoff=%d", onoff, 0, 0, 0);
   1055        1.12  augustss 
   1056        1.14  augustss 	if (sc->sc_methods->ucom_set != NULL)
   1057        1.14  augustss 		sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
   1058        1.14  augustss 		    UCOM_SET_BREAK, onoff);
   1059        1.12  augustss }
   1060        1.12  augustss 
   1061        1.82    martin static void
   1062        1.24  augustss ucom_dtr(struct ucom_softc *sc, int onoff)
   1063        1.12  augustss {
   1064   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1065   1.108.2.7     skrll 
   1066   1.108.2.7     skrll 	DPRINTF("onoff=%d", onoff, 0, 0, 0);
   1067        1.12  augustss 
   1068        1.14  augustss 	if (sc->sc_methods->ucom_set != NULL)
   1069        1.43  augustss 		sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
   1070        1.14  augustss 		    UCOM_SET_DTR, onoff);
   1071        1.12  augustss }
   1072        1.12  augustss 
   1073        1.82    martin static void
   1074        1.24  augustss ucom_rts(struct ucom_softc *sc, int onoff)
   1075        1.12  augustss {
   1076   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1077   1.108.2.7     skrll 
   1078   1.108.2.7     skrll 	DPRINTF("onoff=%d", onoff, 0, 0, 0);
   1079        1.12  augustss 
   1080        1.14  augustss 	if (sc->sc_methods->ucom_set != NULL)
   1081        1.43  augustss 		sc->sc_methods->ucom_set(sc->sc_parent, sc->sc_portno,
   1082        1.14  augustss 		    UCOM_SET_RTS, onoff);
   1083        1.12  augustss }
   1084        1.12  augustss 
   1085        1.22  augustss void
   1086        1.24  augustss ucom_status_change(struct ucom_softc *sc)
   1087        1.12  augustss {
   1088        1.27    toshii 	struct tty *tp = sc->sc_tty;
   1089        1.27    toshii 	u_char old_msr;
   1090        1.27    toshii 
   1091        1.14  augustss 	if (sc->sc_methods->ucom_get_status != NULL) {
   1092        1.27    toshii 		old_msr = sc->sc_msr;
   1093        1.14  augustss 		sc->sc_methods->ucom_get_status(sc->sc_parent, sc->sc_portno,
   1094        1.14  augustss 		    &sc->sc_lsr, &sc->sc_msr);
   1095       1.106       gdt 		if (ISSET((sc->sc_msr ^ old_msr), UMSR_DCD)) {
   1096       1.106       gdt 			mutex_spin_enter(&timecounter_lock);
   1097       1.106       gdt 			pps_capture(&sc->sc_pps_state);
   1098       1.106       gdt 			pps_event(&sc->sc_pps_state,
   1099       1.106       gdt 			    (sc->sc_msr & UMSR_DCD) ?
   1100       1.106       gdt 			    PPS_CAPTUREASSERT :
   1101       1.106       gdt 			    PPS_CAPTURECLEAR);
   1102       1.106       gdt 			mutex_spin_exit(&timecounter_lock);
   1103       1.106       gdt 
   1104        1.32       eeh 			(*tp->t_linesw->l_modem)(tp,
   1105        1.27    toshii 			    ISSET(sc->sc_msr, UMSR_DCD));
   1106       1.106       gdt 		}
   1107        1.14  augustss 	} else {
   1108        1.14  augustss 		sc->sc_lsr = 0;
   1109        1.54  augustss 		/* Assume DCD is present, if we have no chance to check it. */
   1110        1.54  augustss 		sc->sc_msr = UMSR_DCD;
   1111        1.14  augustss 	}
   1112        1.12  augustss }
   1113        1.12  augustss 
   1114        1.82    martin static int
   1115        1.24  augustss ucomparam(struct tty *tp, struct termios *t)
   1116        1.12  augustss {
   1117  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1118  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1119        1.14  augustss 	int error;
   1120        1.12  augustss 
   1121   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1122   1.108.2.7     skrll 
   1123       1.101  jakllsch 	if (sc == NULL || sc->sc_dying)
   1124   1.108.2.3     skrll 		return EIO;
   1125        1.12  augustss 
   1126        1.12  augustss 	/* Check requested parameters. */
   1127        1.12  augustss 	if (t->c_ispeed && t->c_ispeed != t->c_ospeed)
   1128   1.108.2.3     skrll 		return EINVAL;
   1129        1.12  augustss 
   1130        1.12  augustss 	/*
   1131        1.12  augustss 	 * For the console, always force CLOCAL and !HUPCL, so that the port
   1132        1.12  augustss 	 * is always active.
   1133        1.12  augustss 	 */
   1134        1.12  augustss 	if (ISSET(sc->sc_swflags, TIOCFLAG_SOFTCAR)) {
   1135        1.12  augustss 		SET(t->c_cflag, CLOCAL);
   1136        1.12  augustss 		CLR(t->c_cflag, HUPCL);
   1137        1.12  augustss 	}
   1138        1.12  augustss 
   1139        1.12  augustss 	/*
   1140        1.12  augustss 	 * If there were no changes, don't do anything.  This avoids dropping
   1141        1.12  augustss 	 * input and improves performance when all we did was frob things like
   1142        1.12  augustss 	 * VMIN and VTIME.
   1143        1.12  augustss 	 */
   1144        1.12  augustss 	if (tp->t_ospeed == t->c_ospeed &&
   1145        1.12  augustss 	    tp->t_cflag == t->c_cflag)
   1146   1.108.2.3     skrll 		return 0;
   1147        1.12  augustss 
   1148        1.30  augustss 	/* XXX lcr = ISSET(sc->sc_lcr, LCR_SBREAK) | cflag2lcr(t->c_cflag); */
   1149        1.12  augustss 
   1150        1.12  augustss 	/* And copy to tty. */
   1151        1.12  augustss 	tp->t_ispeed = 0;
   1152        1.12  augustss 	tp->t_ospeed = t->c_ospeed;
   1153        1.12  augustss 	tp->t_cflag = t->c_cflag;
   1154        1.12  augustss 
   1155        1.14  augustss 	if (sc->sc_methods->ucom_param != NULL) {
   1156        1.14  augustss 		error = sc->sc_methods->ucom_param(sc->sc_parent, sc->sc_portno,
   1157        1.14  augustss 			    t);
   1158        1.14  augustss 		if (error)
   1159   1.108.2.3     skrll 			return error;
   1160        1.14  augustss 	}
   1161        1.12  augustss 
   1162        1.30  augustss 	/* XXX worry about CHWFLOW */
   1163        1.12  augustss 
   1164        1.12  augustss 	/*
   1165        1.12  augustss 	 * Update the tty layer's idea of the carrier bit, in case we changed
   1166        1.12  augustss 	 * CLOCAL or MDMBUF.  We don't hang up here; we only do that by
   1167        1.12  augustss 	 * explicit request.
   1168        1.12  augustss 	 */
   1169   1.108.2.7     skrll 	DPRINTF("l_modem", 0, 0, 0, 0);
   1170        1.54  augustss 	(void) (*tp->t_linesw->l_modem)(tp, ISSET(sc->sc_msr, UMSR_DCD));
   1171        1.12  augustss 
   1172        1.12  augustss #if 0
   1173        1.12  augustss XXX what if the hardware is not open
   1174        1.12  augustss 	if (!ISSET(t->c_cflag, CHWFLOW)) {
   1175        1.12  augustss 		if (sc->sc_tx_stopped) {
   1176        1.12  augustss 			sc->sc_tx_stopped = 0;
   1177        1.12  augustss 			ucomstart(tp);
   1178        1.12  augustss 		}
   1179        1.12  augustss 	}
   1180        1.12  augustss #endif
   1181        1.12  augustss 
   1182   1.108.2.3     skrll 	return 0;
   1183        1.12  augustss }
   1184        1.12  augustss 
   1185        1.82    martin static int
   1186        1.82    martin ucomhwiflow(struct tty *tp, int block)
   1187        1.12  augustss {
   1188  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1189  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1190        1.82    martin 	int old;
   1191        1.12  augustss 
   1192       1.101  jakllsch 	if (sc == NULL)
   1193   1.108.2.3     skrll 		return 0;
   1194       1.101  jakllsch 
   1195  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1196        1.82    martin 	old = sc->sc_rx_stopped;
   1197        1.82    martin 	sc->sc_rx_stopped = (u_char)block;
   1198        1.12  augustss 
   1199        1.82    martin 	if (old && !block) {
   1200        1.82    martin 		sc->sc_rx_unblock = 1;
   1201        1.82    martin 		softint_schedule(sc->sc_si);
   1202        1.12  augustss 	}
   1203  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1204        1.82    martin 
   1205   1.108.2.3     skrll 	return 1;
   1206         1.1  augustss }
   1207         1.3  augustss 
   1208        1.82    martin static void
   1209        1.24  augustss ucomstart(struct tty *tp)
   1210        1.12  augustss {
   1211  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1212  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1213        1.82    martin 	struct ucom_buffer *ub;
   1214        1.12  augustss 	u_char *data;
   1215        1.12  augustss 	int cnt;
   1216        1.12  augustss 
   1217   1.108.2.8     skrll 	if (sc == NULL)
   1218        1.12  augustss 		return;
   1219        1.12  augustss 
   1220  1.108.2.12     skrll 	KASSERT(&sc->sc_lock);
   1221   1.108.2.8     skrll 	KASSERT(mutex_owned(&tty_lock));
   1222   1.108.2.8     skrll 	if (sc->sc_dying) {
   1223   1.108.2.8     skrll 		return;
   1224   1.108.2.8     skrll 	}
   1225   1.108.2.8     skrll 
   1226        1.84  christos 	if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP))
   1227        1.12  augustss 		goto out;
   1228        1.12  augustss 	if (sc->sc_tx_stopped)
   1229        1.12  augustss 		goto out;
   1230        1.12  augustss 
   1231        1.82    martin 	if (!ttypull(tp))
   1232        1.73        ad 		goto out;
   1233        1.12  augustss 
   1234        1.12  augustss 	/* Grab the first contiguous region of buffer space. */
   1235        1.12  augustss 	data = tp->t_outq.c_cf;
   1236        1.12  augustss 	cnt = ndqb(&tp->t_outq, 0);
   1237        1.12  augustss 
   1238        1.84  christos 	if (cnt == 0)
   1239        1.12  augustss 		goto out;
   1240        1.12  augustss 
   1241        1.82    martin 	ub = SIMPLEQ_FIRST(&sc->sc_obuff_free);
   1242       1.100   mlelstv 	if (ub == NULL) {
   1243       1.100   mlelstv 		SET(tp->t_state, TS_BUSY);
   1244       1.100   mlelstv 		goto out;
   1245       1.100   mlelstv 	}
   1246   1.108.2.8     skrll 
   1247        1.82    martin 	SIMPLEQ_REMOVE_HEAD(&sc->sc_obuff_free, ub_link);
   1248        1.12  augustss 
   1249        1.82    martin 	if (SIMPLEQ_FIRST(&sc->sc_obuff_free) == NULL)
   1250        1.82    martin 		SET(tp->t_state, TS_BUSY);
   1251        1.82    martin 
   1252        1.82    martin 	if (cnt > sc->sc_obufsize)
   1253        1.19  augustss 		cnt = sc->sc_obufsize;
   1254        1.82    martin 
   1255        1.22  augustss 	if (sc->sc_methods->ucom_write != NULL)
   1256        1.22  augustss 		sc->sc_methods->ucom_write(sc->sc_parent, sc->sc_portno,
   1257        1.82    martin 					   ub->ub_data, data, &cnt);
   1258        1.22  augustss 	else
   1259        1.82    martin 		memcpy(ub->ub_data, data, cnt);
   1260        1.82    martin 
   1261        1.82    martin 	ub->ub_len = cnt;
   1262        1.82    martin 	ub->ub_index = 0;
   1263        1.12  augustss 
   1264        1.82    martin 	SIMPLEQ_INSERT_TAIL(&sc->sc_obuff_full, ub, ub_link);
   1265        1.82    martin 
   1266        1.82    martin 	softint_schedule(sc->sc_si);
   1267         1.3  augustss 
   1268        1.82    martin  out:
   1269   1.108.2.8     skrll 	return;
   1270        1.12  augustss }
   1271        1.12  augustss 
   1272        1.21    itojun void
   1273        1.69  christos ucomstop(struct tty *tp, int flag)
   1274        1.12  augustss {
   1275        1.19  augustss #if 0
   1276  1.108.2.25     skrll 	const int unit = UCOMUNIT(tp->t_dev);
   1277  1.108.2.25     skrll 	struct ucom_softc * const sc = device_lookup_private(&ucom_cd, unit);
   1278        1.12  augustss 
   1279  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1280   1.108.2.8     skrll 	mutex_spin_enter(&tty_lock);
   1281        1.12  augustss 	if (ISSET(tp->t_state, TS_BUSY)) {
   1282   1.108.2.8     skrll 		/* obuff_full -> obuff_free? */
   1283        1.19  augustss 		/* sc->sc_tx_stopped = 1; */
   1284        1.12  augustss 		if (!ISSET(tp->t_state, TS_TTSTOP))
   1285        1.12  augustss 			SET(tp->t_state, TS_FLUSH);
   1286        1.12  augustss 	}
   1287   1.108.2.8     skrll 	mutex_spin_exit(&tty_lock);
   1288  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1289        1.19  augustss #endif
   1290        1.12  augustss }
   1291        1.12  augustss 
   1292        1.82    martin static void
   1293        1.82    martin ucom_write_status(struct ucom_softc *sc, struct ucom_buffer *ub,
   1294        1.82    martin     usbd_status err)
   1295        1.82    martin {
   1296        1.82    martin 	struct tty *tp = sc->sc_tty;
   1297        1.82    martin 	uint32_t cc = ub->ub_len;
   1298        1.82    martin 
   1299  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1300   1.108.2.8     skrll 
   1301        1.82    martin 	switch (err) {
   1302        1.82    martin 	case USBD_IN_PROGRESS:
   1303        1.82    martin 		ub->ub_index = ub->ub_len;
   1304        1.82    martin 		break;
   1305        1.82    martin 	case USBD_STALLED:
   1306        1.82    martin 		ub->ub_index = 0;
   1307        1.82    martin 		softint_schedule(sc->sc_si);
   1308        1.82    martin 		break;
   1309        1.82    martin 	case USBD_NORMAL_COMPLETION:
   1310        1.82    martin 		usbd_get_xfer_status(ub->ub_xfer, NULL, NULL, &cc, NULL);
   1311        1.82    martin 		rnd_add_uint32(&sc->sc_rndsource, cc);
   1312        1.82    martin 		/*FALLTHROUGH*/
   1313        1.82    martin 	default:
   1314        1.82    martin 		SIMPLEQ_REMOVE_HEAD(&sc->sc_obuff_full, ub_link);
   1315        1.82    martin 		SIMPLEQ_INSERT_TAIL(&sc->sc_obuff_free, ub, ub_link);
   1316        1.82    martin 		cc -= sc->sc_opkthdrlen;
   1317        1.82    martin 
   1318       1.100   mlelstv 		mutex_spin_enter(&tty_lock);
   1319        1.82    martin 		CLR(tp->t_state, TS_BUSY);
   1320        1.82    martin 		if (ISSET(tp->t_state, TS_FLUSH))
   1321        1.82    martin 			CLR(tp->t_state, TS_FLUSH);
   1322        1.82    martin 		else
   1323        1.82    martin 			ndflush(&tp->t_outq, cc);
   1324       1.100   mlelstv 		mutex_spin_exit(&tty_lock);
   1325        1.82    martin 
   1326        1.82    martin 		if (err != USBD_CANCELLED && err != USBD_IOERROR &&
   1327        1.82    martin 		    !sc->sc_dying) {
   1328        1.82    martin 			if ((ub = SIMPLEQ_FIRST(&sc->sc_obuff_full)) != NULL)
   1329        1.82    martin 				ucom_submit_write(sc, ub);
   1330        1.82    martin 
   1331   1.108.2.8     skrll 			mutex_spin_enter(&tty_lock);
   1332        1.82    martin 			(*tp->t_linesw->l_start)(tp);
   1333   1.108.2.8     skrll 			mutex_spin_exit(&tty_lock);
   1334        1.82    martin 		}
   1335        1.82    martin 		break;
   1336        1.82    martin 	}
   1337        1.82    martin }
   1338        1.82    martin 
   1339        1.82    martin static void
   1340        1.82    martin ucom_submit_write(struct ucom_softc *sc, struct ucom_buffer *ub)
   1341        1.82    martin {
   1342        1.82    martin 
   1343  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1344   1.108.2.8     skrll 
   1345   1.108.2.9     skrll 	usbd_setup_xfer(ub->ub_xfer, sc, ub->ub_data, ub->ub_len,
   1346   1.108.2.2     skrll 	    0, USBD_NO_TIMEOUT, ucomwritecb);
   1347        1.82    martin 
   1348        1.82    martin 	ucom_write_status(sc, ub, usbd_transfer(ub->ub_xfer));
   1349        1.82    martin }
   1350        1.82    martin 
   1351        1.82    martin static void
   1352   1.108.2.5     skrll ucomwritecb(struct usbd_xfer *xfer, void *p, usbd_status status)
   1353        1.12  augustss {
   1354        1.12  augustss 	struct ucom_softc *sc = (struct ucom_softc *)p;
   1355        1.82    martin 
   1356  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1357        1.82    martin 	ucom_write_status(sc, SIMPLEQ_FIRST(&sc->sc_obuff_full), status);
   1358  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1359        1.82    martin 
   1360        1.82    martin }
   1361        1.82    martin 
   1362        1.82    martin static void
   1363        1.82    martin ucom_softintr(void *arg)
   1364        1.82    martin {
   1365        1.82    martin 	struct ucom_softc *sc = arg;
   1366        1.12  augustss 
   1367  1.108.2.12     skrll 	mutex_enter(&sc->sc_lock);
   1368  1.108.2.20     skrll 	struct tty *tp = sc->sc_tty;
   1369   1.108.2.8     skrll 	mutex_enter(&tty_lock);
   1370   1.108.2.8     skrll 	if (!ISSET(tp->t_state, TS_ISOPEN)) {
   1371   1.108.2.8     skrll 		mutex_exit(&tty_lock);
   1372  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1373        1.82    martin 		return;
   1374   1.108.2.8     skrll 	}
   1375   1.108.2.8     skrll 	mutex_exit(&tty_lock);
   1376        1.12  augustss 
   1377  1.108.2.20     skrll 	struct ucom_buffer *ub = SIMPLEQ_FIRST(&sc->sc_obuff_full);
   1378        1.82    martin 
   1379        1.82    martin 	if (ub != NULL && ub->ub_index == 0)
   1380        1.82    martin 		ucom_submit_write(sc, ub);
   1381        1.12  augustss 
   1382        1.82    martin 	if (sc->sc_rx_unblock)
   1383        1.82    martin 		ucom_read_complete(sc);
   1384        1.12  augustss 
   1385  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1386        1.82    martin }
   1387        1.82    martin 
   1388        1.82    martin static void
   1389        1.82    martin ucom_read_complete(struct ucom_softc *sc)
   1390        1.82    martin {
   1391        1.82    martin 	int (*rint)(int, struct tty *);
   1392        1.82    martin 	struct ucom_buffer *ub;
   1393        1.82    martin 	struct tty *tp;
   1394   1.108.2.8     skrll 
   1395  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1396        1.82    martin 
   1397        1.82    martin 	tp = sc->sc_tty;
   1398        1.82    martin 	rint = tp->t_linesw->l_rint;
   1399        1.82    martin 	ub = SIMPLEQ_FIRST(&sc->sc_ibuff_full);
   1400        1.39  augustss 
   1401        1.82    martin 	while (ub != NULL && !sc->sc_rx_stopped) {
   1402        1.82    martin 
   1403   1.108.2.8     skrll 		/* XXX ttyinput takes tty_lock */
   1404        1.82    martin 		while (ub->ub_index < ub->ub_len && !sc->sc_rx_stopped) {
   1405        1.82    martin 			/* Give characters to tty layer. */
   1406        1.82    martin 			if ((*rint)(ub->ub_data[ub->ub_index], tp) == -1) {
   1407        1.82    martin 				/* Overflow: drop remainder */
   1408        1.82    martin 				ub->ub_index = ub->ub_len;
   1409        1.82    martin 			} else
   1410        1.82    martin 				ub->ub_index++;
   1411        1.82    martin 		}
   1412        1.82    martin 
   1413        1.82    martin 		if (ub->ub_index == ub->ub_len) {
   1414        1.82    martin 			SIMPLEQ_REMOVE_HEAD(&sc->sc_ibuff_full, ub_link);
   1415        1.82    martin 
   1416        1.82    martin 			ucomsubmitread(sc, ub);
   1417        1.82    martin 
   1418        1.82    martin 			ub = SIMPLEQ_FIRST(&sc->sc_ibuff_full);
   1419        1.82    martin 		}
   1420        1.82    martin 	}
   1421        1.82    martin 
   1422        1.82    martin 	sc->sc_rx_unblock = (ub != NULL);
   1423        1.12  augustss }
   1424        1.12  augustss 
   1425  1.108.2.27     skrll static int
   1426        1.82    martin ucomsubmitread(struct ucom_softc *sc, struct ucom_buffer *ub)
   1427        1.12  augustss {
   1428        1.12  augustss 	usbd_status err;
   1429        1.12  augustss 
   1430  1.108.2.15     skrll 	if (sc->sc_bulkin_no != -1) {
   1431  1.108.2.15     skrll 		usbd_setup_xfer(ub->ub_xfer, sc, ub->ub_data, sc->sc_ibufsize,
   1432  1.108.2.15     skrll 		    USBD_SHORT_XFER_OK, USBD_NO_TIMEOUT, ucomreadcb);
   1433  1.108.2.15     skrll 
   1434  1.108.2.15     skrll 		if ((err = usbd_transfer(ub->ub_xfer)) != USBD_IN_PROGRESS) {
   1435  1.108.2.15     skrll 			/* XXX: Recover from this, please! */
   1436  1.108.2.15     skrll 			printf("%s: err=%s\n", __func__, usbd_errstr(err));
   1437  1.108.2.27     skrll 			return EIO;
   1438  1.108.2.15     skrll 		}
   1439        1.12  augustss 	}
   1440        1.82    martin 
   1441        1.82    martin 	SIMPLEQ_INSERT_TAIL(&sc->sc_ibuff_empty, ub, ub_link);
   1442        1.82    martin 
   1443  1.108.2.27     skrll 	return 0;
   1444        1.12  augustss }
   1445        1.43  augustss 
   1446  1.108.2.15     skrll void
   1447   1.108.2.5     skrll ucomreadcb(struct usbd_xfer *xfer, void *p, usbd_status status)
   1448        1.12  augustss {
   1449        1.12  augustss 	struct ucom_softc *sc = (struct ucom_softc *)p;
   1450        1.12  augustss 	struct tty *tp = sc->sc_tty;
   1451        1.82    martin 	struct ucom_buffer *ub;
   1452   1.108.2.1     skrll 	uint32_t cc;
   1453        1.12  augustss 	u_char *cp;
   1454        1.12  augustss 
   1455   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1456   1.108.2.7     skrll 
   1457  1.108.2.14     skrll 	if (status == USBD_CANCELLED)
   1458  1.108.2.14     skrll 		return;
   1459        1.34  augustss 
   1460  1.108.2.14     skrll 	mutex_enter(&sc->sc_lock);
   1461  1.108.2.14     skrll 	if (status == USBD_IOERROR ||
   1462        1.34  augustss 	    sc->sc_dying) {
   1463   1.108.2.7     skrll 		DPRINTF("dying", 0, 0, 0, 0);
   1464        1.34  augustss 		/* Send something to wake upper layer */
   1465  1.108.2.14     skrll 		(tp->t_linesw->l_rint)('\n', tp);
   1466  1.108.2.14     skrll 		mutex_spin_enter(&tty_lock);	/* XXX */
   1467  1.108.2.14     skrll 		ttwakeup(tp);
   1468  1.108.2.14     skrll 		mutex_spin_exit(&tty_lock);	/* XXX */
   1469  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1470        1.12  augustss 		return;
   1471        1.34  augustss 	}
   1472        1.12  augustss 
   1473  1.108.2.14     skrll 	ub = SIMPLEQ_FIRST(&sc->sc_ibuff_empty);
   1474  1.108.2.14     skrll 	SIMPLEQ_REMOVE_HEAD(&sc->sc_ibuff_empty, ub_link);
   1475  1.108.2.14     skrll 
   1476        1.82    martin 	if (status == USBD_STALLED) {
   1477  1.108.2.15     skrll 		if (sc->sc_bulkin_no != -1)
   1478  1.108.2.15     skrll 			usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);
   1479  1.108.2.15     skrll 		if (sc->sc_ipipe)
   1480  1.108.2.15     skrll 			usbd_clear_endpoint_stall_async(sc->sc_ipipe);
   1481        1.82    martin 		ucomsubmitread(sc, ub);
   1482  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1483        1.82    martin 		return;
   1484        1.82    martin 	}
   1485        1.82    martin 
   1486        1.82    martin 	if (status != USBD_NORMAL_COMPLETION) {
   1487        1.82    martin 		printf("ucomreadcb: wonky status=%s\n", usbd_errstr(status));
   1488  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1489        1.12  augustss 		return;
   1490        1.12  augustss 	}
   1491        1.12  augustss 
   1492        1.48   thorpej 	usbd_get_xfer_status(xfer, NULL, (void *)&cp, &cc, NULL);
   1493        1.82    martin 
   1494        1.95  jakllsch #ifdef UCOM_DEBUG
   1495        1.95  jakllsch 	/* This is triggered by uslsa(4) occasionally. */
   1496        1.95  jakllsch 	if ((ucomdebug > 0) && (cc == 0)) {
   1497        1.95  jakllsch 		device_printf(sc->sc_dev, "ucomreadcb: zero length xfer!\n");
   1498        1.82    martin 	}
   1499        1.95  jakllsch #endif
   1500        1.82    martin 
   1501        1.82    martin 	KDASSERT(cp == ub->ub_data);
   1502        1.82    martin 
   1503        1.31  explorer 	rnd_add_uint32(&sc->sc_rndsource, cc);
   1504        1.82    martin 
   1505        1.82    martin 	if (sc->sc_opening) {
   1506        1.82    martin 		ucomsubmitread(sc, ub);
   1507  1.108.2.12     skrll 		mutex_exit(&sc->sc_lock);
   1508        1.82    martin 		return;
   1509        1.82    martin 	}
   1510        1.82    martin 
   1511  1.108.2.16     skrll 	ub->ub_data = usbd_get_buffer(xfer);
   1512        1.82    martin 	if (sc->sc_methods->ucom_read != NULL) {
   1513        1.22  augustss 		sc->sc_methods->ucom_read(sc->sc_parent, sc->sc_portno,
   1514        1.82    martin 		    &cp, &cc);
   1515        1.82    martin 		ub->ub_index = (u_int)(cp - ub->ub_data);
   1516        1.82    martin 	} else
   1517        1.82    martin 		ub->ub_index = 0;
   1518        1.82    martin 
   1519        1.82    martin 	ub->ub_len = cc;
   1520        1.22  augustss 
   1521        1.82    martin 	SIMPLEQ_INSERT_TAIL(&sc->sc_ibuff_full, ub, ub_link);
   1522        1.12  augustss 
   1523        1.82    martin 	ucom_read_complete(sc);
   1524  1.108.2.12     skrll 	mutex_exit(&sc->sc_lock);
   1525        1.12  augustss }
   1526        1.12  augustss 
   1527        1.82    martin static void
   1528        1.24  augustss ucom_cleanup(struct ucom_softc *sc)
   1529        1.12  augustss {
   1530        1.82    martin 
   1531   1.108.2.7     skrll 	UCOMHIST_FUNC(); UCOMHIST_CALLED();
   1532   1.108.2.7     skrll 
   1533   1.108.2.9     skrll 	DPRINTF("aborting pipes", 0, 0, 0, 0);
   1534        1.12  augustss 
   1535  1.108.2.12     skrll 	KASSERT(mutex_owned(&sc->sc_lock));
   1536   1.108.2.8     skrll 
   1537        1.12  augustss 	ucom_shutdown(sc);
   1538        1.33  augustss 	if (sc->sc_bulkin_pipe != NULL) {
   1539  1.108.2.14     skrll 		usbd_abort_pipe(sc->sc_bulkin_pipe);
   1540        1.33  augustss 	}
   1541        1.33  augustss 	if (sc->sc_bulkout_pipe != NULL) {
   1542  1.108.2.14     skrll 		usbd_abort_pipe(sc->sc_bulkout_pipe);
   1543        1.33  augustss 	}
   1544        1.12  augustss }
   1545        1.13  augustss 
   1546        1.13  augustss #endif /* NUCOM > 0 */
   1547        1.12  augustss 
   1548        1.20  augustss int
   1549        1.24  augustss ucomprint(void *aux, const char *pnp)
   1550        1.12  augustss {
   1551  1.108.2.13     skrll 	struct ucom_attach_args *ucaa = aux;
   1552        1.12  augustss 
   1553        1.12  augustss 	if (pnp)
   1554        1.49   thorpej 		aprint_normal("ucom at %s", pnp);
   1555  1.108.2.13     skrll 	if (ucaa->ucaa_portno != UCOM_UNK_PORTNO)
   1556  1.108.2.13     skrll 		aprint_normal(" portno %d", ucaa->ucaa_portno);
   1557   1.108.2.3     skrll 	return UNCONF;
   1558        1.12  augustss }
   1559        1.12  augustss 
   1560        1.20  augustss int
   1561        1.77      cube ucomsubmatch(device_t parent, cfdata_t cf,
   1562        1.69  christos 	     const int *ldesc, void *aux)
   1563        1.12  augustss {
   1564  1.108.2.13     skrll 	struct ucom_attach_args *ucaa = aux;
   1565        1.12  augustss 
   1566  1.108.2.13     skrll 	if (ucaa->ucaa_portno != UCOM_UNK_PORTNO &&
   1567        1.53  drochner 	    cf->cf_loc[UCOMBUSCF_PORTNO] != UCOMBUSCF_PORTNO_DEFAULT &&
   1568  1.108.2.13     skrll 	    cf->cf_loc[UCOMBUSCF_PORTNO] != ucaa->ucaa_portno)
   1569   1.108.2.3     skrll 		return 0;
   1570   1.108.2.3     skrll 	return config_match(parent, cf, aux);
   1571        1.12  augustss }
   1572