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