1 /* $NetBSD: umodem.c,v 1.45 2002/09/23 05:51:23 simonb Exp $ */
7 * Copyright (c) 2003, M. Warner Losh <imp@FreeBSD.org>.
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33 * Copyright (c) 1998 The NetBSD Foundation, Inc.
34 * All rights reserved.
36 * This code is derived from software contributed to The NetBSD Foundation
37 * by Lennart Augustsson (lennart@augustsson.net) at
38 * Carlstedt Research & Technology.
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
43 * 1. Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * 2. Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in the
47 * documentation and/or other materials provided with the distribution.
48 * 3. All advertising materials mentioning features or use of this software
49 * must display the following acknowledgement:
50 * This product includes software developed by the NetBSD
51 * Foundation, Inc. and its contributors.
52 * 4. Neither the name of The NetBSD Foundation nor the names of its
53 * contributors may be used to endorse or promote products derived
54 * from this software without specific prior written permission.
56 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
57 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
58 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
59 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
60 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
61 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
62 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
63 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
64 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
65 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
66 * POSSIBILITY OF SUCH DAMAGE.
70 * Comm Class spec: http://www.usb.org/developers/devclass_docs/usbccs10.pdf
71 * http://www.usb.org/developers/devclass_docs/usbcdc11.pdf
72 * http://www.usb.org/developers/devclass_docs/cdc_wmc10.zip
77 * - Add error recovery in various places; the big problem is what
78 * to do in a callback if there is an error.
79 * - Implement a Call Device for modems without multiplexed commands.
83 #include <sys/stdint.h>
84 #include <sys/stddef.h>
85 #include <sys/param.h>
86 #include <sys/queue.h>
87 #include <sys/types.h>
88 #include <sys/systm.h>
89 #include <sys/kernel.h>
91 #include <sys/module.h>
93 #include <sys/mutex.h>
94 #include <sys/condvar.h>
95 #include <sys/sysctl.h>
97 #include <sys/unistd.h>
98 #include <sys/callout.h>
99 #include <sys/malloc.h>
100 #include <sys/priv.h>
102 #include <dev/usb/usb.h>
103 #include <dev/usb/usbdi.h>
104 #include <dev/usb/usbdi_util.h>
105 #include <dev/usb/usbhid.h>
106 #include <dev/usb/usb_cdc.h>
109 #include <dev/usb/usb_ioctl.h>
111 #define USB_DEBUG_VAR umodem_debug
112 #include <dev/usb/usb_debug.h>
113 #include <dev/usb/usb_process.h>
114 #include <dev/usb/quirk/usb_quirk.h>
116 #include <dev/usb/serial/usb_serial.h>
119 static int umodem_debug = 0;
121 static SYSCTL_NODE(_hw_usb, OID_AUTO, umodem, CTLFLAG_RW, 0, "USB umodem");
122 SYSCTL_INT(_hw_usb_umodem, OID_AUTO, debug, CTLFLAG_RW,
123 &umodem_debug, 0, "Debug level");
126 static const STRUCT_USB_HOST_ID umodem_devs[] = {
127 /* Generic Modem class match */
128 {USB_IFACE_CLASS(UICLASS_CDC),
129 USB_IFACE_SUBCLASS(UISUBCLASS_ABSTRACT_CONTROL_MODEL),
130 USB_IFACE_PROTOCOL(UIPROTO_CDC_AT)},
131 /* Huawei Modem class match */
132 {USB_IFACE_CLASS(UICLASS_CDC),
133 USB_IFACE_SUBCLASS(UISUBCLASS_ABSTRACT_CONTROL_MODEL),
134 USB_IFACE_PROTOCOL(0xFF)},
135 /* Kyocera AH-K3001V */
136 {USB_VPI(USB_VENDOR_KYOCERA, USB_PRODUCT_KYOCERA_AHK3001V, 1)},
137 {USB_VPI(USB_VENDOR_SIERRA, USB_PRODUCT_SIERRA_MC5720, 1)},
138 {USB_VPI(USB_VENDOR_CURITEL, USB_PRODUCT_CURITEL_PC5740, 1)},
142 * As speeds for umodem devices increase, these numbers will need to
143 * be increased. They should be good for G3 speeds and below.
145 * TODO: The TTY buffers should be increased!
147 #define UMODEM_BUF_SIZE 1024
156 #define UMODEM_MODVER 1 /* module version */
158 struct umodem_softc {
159 struct ucom_super_softc sc_super_ucom;
160 struct ucom_softc sc_ucom;
162 struct usb_xfer *sc_xfer[UMODEM_N_TRANSFER];
163 struct usb_device *sc_udev;
168 uint8_t sc_lsr; /* local status register */
169 uint8_t sc_msr; /* modem status register */
170 uint8_t sc_ctrl_iface_no;
171 uint8_t sc_data_iface_no;
172 uint8_t sc_iface_index[2];
173 uint8_t sc_cm_over_data;
174 uint8_t sc_cm_cap; /* CM capabilities */
175 uint8_t sc_acm_cap; /* ACM capabilities */
178 static device_probe_t umodem_probe;
179 static device_attach_t umodem_attach;
180 static device_detach_t umodem_detach;
181 static void umodem_free_softc(struct umodem_softc *);
183 static usb_callback_t umodem_intr_callback;
184 static usb_callback_t umodem_write_callback;
185 static usb_callback_t umodem_read_callback;
187 static void umodem_free(struct ucom_softc *);
188 static void umodem_start_read(struct ucom_softc *);
189 static void umodem_stop_read(struct ucom_softc *);
190 static void umodem_start_write(struct ucom_softc *);
191 static void umodem_stop_write(struct ucom_softc *);
192 static void umodem_get_caps(struct usb_attach_arg *, uint8_t *, uint8_t *);
193 static void umodem_cfg_get_status(struct ucom_softc *, uint8_t *,
195 static int umodem_pre_param(struct ucom_softc *, struct termios *);
196 static void umodem_cfg_param(struct ucom_softc *, struct termios *);
197 static int umodem_ioctl(struct ucom_softc *, uint32_t, caddr_t, int,
199 static void umodem_cfg_set_dtr(struct ucom_softc *, uint8_t);
200 static void umodem_cfg_set_rts(struct ucom_softc *, uint8_t);
201 static void umodem_cfg_set_break(struct ucom_softc *, uint8_t);
202 static void *umodem_get_desc(struct usb_attach_arg *, uint8_t, uint8_t);
203 static usb_error_t umodem_set_comm_feature(struct usb_device *, uint8_t,
205 static void umodem_poll(struct ucom_softc *ucom);
206 static void umodem_find_data_iface(struct usb_attach_arg *uaa,
207 uint8_t, uint8_t *, uint8_t *);
209 static const struct usb_config umodem_config[UMODEM_N_TRANSFER] = {
213 .endpoint = UE_ADDR_ANY,
214 .direction = UE_DIR_OUT,
216 .bufsize = UMODEM_BUF_SIZE,
217 .flags = {.pipe_bof = 1,.force_short_xfer = 1,},
218 .callback = &umodem_write_callback,
223 .endpoint = UE_ADDR_ANY,
224 .direction = UE_DIR_IN,
226 .bufsize = UMODEM_BUF_SIZE,
227 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,},
228 .callback = &umodem_read_callback,
232 .type = UE_INTERRUPT,
233 .endpoint = UE_ADDR_ANY,
234 .direction = UE_DIR_IN,
236 .flags = {.pipe_bof = 1,.short_xfer_ok = 1,.no_pipe_ok = 1,},
237 .bufsize = 0, /* use wMaxPacketSize */
238 .callback = &umodem_intr_callback,
242 static const struct ucom_callback umodem_callback = {
243 .ucom_cfg_get_status = &umodem_cfg_get_status,
244 .ucom_cfg_set_dtr = &umodem_cfg_set_dtr,
245 .ucom_cfg_set_rts = &umodem_cfg_set_rts,
246 .ucom_cfg_set_break = &umodem_cfg_set_break,
247 .ucom_cfg_param = &umodem_cfg_param,
248 .ucom_pre_param = &umodem_pre_param,
249 .ucom_ioctl = &umodem_ioctl,
250 .ucom_start_read = &umodem_start_read,
251 .ucom_stop_read = &umodem_stop_read,
252 .ucom_start_write = &umodem_start_write,
253 .ucom_stop_write = &umodem_stop_write,
254 .ucom_poll = &umodem_poll,
255 .ucom_free = &umodem_free,
258 static device_method_t umodem_methods[] = {
259 DEVMETHOD(device_probe, umodem_probe),
260 DEVMETHOD(device_attach, umodem_attach),
261 DEVMETHOD(device_detach, umodem_detach),
265 static devclass_t umodem_devclass;
267 static driver_t umodem_driver = {
269 .methods = umodem_methods,
270 .size = sizeof(struct umodem_softc),
273 DRIVER_MODULE(umodem, uhub, umodem_driver, umodem_devclass, NULL, 0);
274 MODULE_DEPEND(umodem, ucom, 1, 1, 1);
275 MODULE_DEPEND(umodem, usb, 1, 1, 1);
276 MODULE_VERSION(umodem, UMODEM_MODVER);
279 umodem_probe(device_t dev)
281 struct usb_attach_arg *uaa = device_get_ivars(dev);
286 if (uaa->usb_mode != USB_MODE_HOST)
289 error = usbd_lookup_id_by_uaa(umodem_devs, sizeof(umodem_devs), uaa);
293 return (BUS_PROBE_GENERIC);
297 umodem_attach(device_t dev)
299 struct usb_attach_arg *uaa = device_get_ivars(dev);
300 struct umodem_softc *sc = device_get_softc(dev);
301 struct usb_cdc_cm_descriptor *cmd;
302 struct usb_cdc_union_descriptor *cud;
306 device_set_usb_desc(dev);
307 mtx_init(&sc->sc_mtx, "umodem", NULL, MTX_DEF);
308 ucom_ref(&sc->sc_super_ucom);
310 sc->sc_ctrl_iface_no = uaa->info.bIfaceNum;
311 sc->sc_iface_index[1] = uaa->info.bIfaceIndex;
312 sc->sc_udev = uaa->device;
314 umodem_get_caps(uaa, &sc->sc_cm_cap, &sc->sc_acm_cap);
316 /* get the data interface number */
318 cmd = umodem_get_desc(uaa, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM);
320 if ((cmd == NULL) || (cmd->bLength < sizeof(*cmd))) {
322 cud = usbd_find_descriptor(uaa->device, NULL,
323 uaa->info.bIfaceIndex, UDESC_CS_INTERFACE,
324 0xFF, UDESCSUB_CDC_UNION, 0xFF);
326 if ((cud == NULL) || (cud->bLength < sizeof(*cud))) {
327 DPRINTF("Missing descriptor. "
328 "Assuming data interface is next.\n");
329 if (sc->sc_ctrl_iface_no == 0xFF) {
332 uint8_t class_match = 0;
334 /* set default interface number */
335 sc->sc_data_iface_no = 0xFF;
337 /* try to find the data interface backwards */
338 umodem_find_data_iface(uaa,
339 uaa->info.bIfaceIndex - 1,
340 &sc->sc_data_iface_no, &class_match);
342 /* try to find the data interface forwards */
343 umodem_find_data_iface(uaa,
344 uaa->info.bIfaceIndex + 1,
345 &sc->sc_data_iface_no, &class_match);
347 /* check if nothing was found */
348 if (sc->sc_data_iface_no == 0xFF)
352 sc->sc_data_iface_no = cud->bSlaveInterface[0];
355 sc->sc_data_iface_no = cmd->bDataInterface;
358 device_printf(dev, "data interface %d, has %sCM over "
359 "data, has %sbreak\n",
360 sc->sc_data_iface_no,
361 sc->sc_cm_cap & USB_CDC_CM_OVER_DATA ? "" : "no ",
362 sc->sc_acm_cap & USB_CDC_ACM_HAS_BREAK ? "" : "no ");
364 /* get the data interface too */
367 struct usb_interface *iface;
368 struct usb_interface_descriptor *id;
370 iface = usbd_get_iface(uaa->device, i);
374 id = usbd_get_interface_descriptor(iface);
376 if (id && (id->bInterfaceNumber == sc->sc_data_iface_no)) {
377 sc->sc_iface_index[0] = i;
378 usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
382 device_printf(dev, "no data interface\n");
387 if (usb_test_quirk(uaa, UQ_ASSUME_CM_OVER_DATA)) {
388 sc->sc_cm_over_data = 1;
390 if (sc->sc_cm_cap & USB_CDC_CM_OVER_DATA) {
391 if (sc->sc_acm_cap & USB_CDC_ACM_HAS_FEATURE) {
393 error = umodem_set_comm_feature
394 (uaa->device, sc->sc_ctrl_iface_no,
395 UCDC_ABSTRACT_STATE, UCDC_DATA_MULTIPLEXED);
397 /* ignore any errors */
399 sc->sc_cm_over_data = 1;
402 error = usbd_transfer_setup(uaa->device,
403 sc->sc_iface_index, sc->sc_xfer,
404 umodem_config, UMODEM_N_TRANSFER,
410 /* clear stall at first run */
411 mtx_lock(&sc->sc_mtx);
412 usbd_xfer_set_stall(sc->sc_xfer[UMODEM_BULK_WR]);
413 usbd_xfer_set_stall(sc->sc_xfer[UMODEM_BULK_RD]);
414 mtx_unlock(&sc->sc_mtx);
416 error = ucom_attach(&sc->sc_super_ucom, &sc->sc_ucom, 1, sc,
417 &umodem_callback, &sc->sc_mtx);
421 ucom_set_pnpinfo_usb(&sc->sc_super_ucom, dev);
431 umodem_find_data_iface(struct usb_attach_arg *uaa,
432 uint8_t iface_index, uint8_t *p_data_no, uint8_t *p_match_class)
434 struct usb_interface_descriptor *id;
435 struct usb_interface *iface;
437 iface = usbd_get_iface(uaa->device, iface_index);
439 /* check for end of interfaces */
443 id = usbd_get_interface_descriptor(iface);
445 /* check for non-matching interface class */
446 if (id->bInterfaceClass != UICLASS_CDC_DATA ||
447 id->bInterfaceSubClass != UISUBCLASS_DATA) {
448 /* if we got a class match then return */
455 DPRINTFN(11, "Match at index %u\n", iface_index);
457 *p_data_no = id->bInterfaceNumber;
461 umodem_start_read(struct ucom_softc *ucom)
463 struct umodem_softc *sc = ucom->sc_parent;
465 /* start interrupt endpoint, if any */
466 usbd_transfer_start(sc->sc_xfer[UMODEM_INTR_RD]);
468 /* start read endpoint */
469 usbd_transfer_start(sc->sc_xfer[UMODEM_BULK_RD]);
473 umodem_stop_read(struct ucom_softc *ucom)
475 struct umodem_softc *sc = ucom->sc_parent;
477 /* stop interrupt endpoint, if any */
478 usbd_transfer_stop(sc->sc_xfer[UMODEM_INTR_RD]);
480 /* stop read endpoint */
481 usbd_transfer_stop(sc->sc_xfer[UMODEM_BULK_RD]);
485 umodem_start_write(struct ucom_softc *ucom)
487 struct umodem_softc *sc = ucom->sc_parent;
489 usbd_transfer_start(sc->sc_xfer[UMODEM_BULK_WR]);
493 umodem_stop_write(struct ucom_softc *ucom)
495 struct umodem_softc *sc = ucom->sc_parent;
497 usbd_transfer_stop(sc->sc_xfer[UMODEM_BULK_WR]);
501 umodem_get_caps(struct usb_attach_arg *uaa, uint8_t *cm, uint8_t *acm)
503 struct usb_cdc_cm_descriptor *cmd;
504 struct usb_cdc_acm_descriptor *cad;
506 cmd = umodem_get_desc(uaa, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM);
507 if ((cmd == NULL) || (cmd->bLength < sizeof(*cmd))) {
508 DPRINTF("no CM desc (faking one)\n");
509 *cm = USB_CDC_CM_DOES_CM | USB_CDC_CM_OVER_DATA;
511 *cm = cmd->bmCapabilities;
513 cad = umodem_get_desc(uaa, UDESC_CS_INTERFACE, UDESCSUB_CDC_ACM);
514 if ((cad == NULL) || (cad->bLength < sizeof(*cad))) {
515 DPRINTF("no ACM desc\n");
518 *acm = cad->bmCapabilities;
522 umodem_cfg_get_status(struct ucom_softc *ucom, uint8_t *lsr, uint8_t *msr)
524 struct umodem_softc *sc = ucom->sc_parent;
533 umodem_pre_param(struct ucom_softc *ucom, struct termios *t)
535 return (0); /* we accept anything */
539 umodem_cfg_param(struct ucom_softc *ucom, struct termios *t)
541 struct umodem_softc *sc = ucom->sc_parent;
542 struct usb_cdc_line_state ls;
543 struct usb_device_request req;
545 DPRINTF("sc=%p\n", sc);
547 memset(&ls, 0, sizeof(ls));
549 USETDW(ls.dwDTERate, t->c_ospeed);
551 ls.bCharFormat = (t->c_cflag & CSTOPB) ?
552 UCDC_STOP_BIT_2 : UCDC_STOP_BIT_1;
554 ls.bParityType = (t->c_cflag & PARENB) ?
555 ((t->c_cflag & PARODD) ?
556 UCDC_PARITY_ODD : UCDC_PARITY_EVEN) : UCDC_PARITY_NONE;
558 switch (t->c_cflag & CSIZE) {
573 DPRINTF("rate=%d fmt=%d parity=%d bits=%d\n",
574 UGETDW(ls.dwDTERate), ls.bCharFormat,
575 ls.bParityType, ls.bDataBits);
577 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
578 req.bRequest = UCDC_SET_LINE_CODING;
579 USETW(req.wValue, 0);
580 req.wIndex[0] = sc->sc_ctrl_iface_no;
582 USETW(req.wLength, sizeof(ls));
584 ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
589 umodem_ioctl(struct ucom_softc *ucom, uint32_t cmd, caddr_t data,
590 int flag, struct thread *td)
592 struct umodem_softc *sc = ucom->sc_parent;
595 DPRINTF("cmd=0x%08x\n", cmd);
598 case USB_GET_CM_OVER_DATA:
599 *(int *)data = sc->sc_cm_over_data;
602 case USB_SET_CM_OVER_DATA:
603 if (*(int *)data != sc->sc_cm_over_data) {
609 DPRINTF("unknown\n");
618 umodem_cfg_set_dtr(struct ucom_softc *ucom, uint8_t onoff)
620 struct umodem_softc *sc = ucom->sc_parent;
621 struct usb_device_request req;
623 DPRINTF("onoff=%d\n", onoff);
626 sc->sc_line |= UCDC_LINE_DTR;
628 sc->sc_line &= ~UCDC_LINE_DTR;
630 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
631 req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
632 USETW(req.wValue, sc->sc_line);
633 req.wIndex[0] = sc->sc_ctrl_iface_no;
635 USETW(req.wLength, 0);
637 ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
638 &req, NULL, 0, 1000);
642 umodem_cfg_set_rts(struct ucom_softc *ucom, uint8_t onoff)
644 struct umodem_softc *sc = ucom->sc_parent;
645 struct usb_device_request req;
647 DPRINTF("onoff=%d\n", onoff);
650 sc->sc_line |= UCDC_LINE_RTS;
652 sc->sc_line &= ~UCDC_LINE_RTS;
654 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
655 req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
656 USETW(req.wValue, sc->sc_line);
657 req.wIndex[0] = sc->sc_ctrl_iface_no;
659 USETW(req.wLength, 0);
661 ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
662 &req, NULL, 0, 1000);
666 umodem_cfg_set_break(struct ucom_softc *ucom, uint8_t onoff)
668 struct umodem_softc *sc = ucom->sc_parent;
669 struct usb_device_request req;
672 DPRINTF("onoff=%d\n", onoff);
674 if (sc->sc_acm_cap & USB_CDC_ACM_HAS_BREAK) {
676 temp = onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF;
678 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
679 req.bRequest = UCDC_SEND_BREAK;
680 USETW(req.wValue, temp);
681 req.wIndex[0] = sc->sc_ctrl_iface_no;
683 USETW(req.wLength, 0);
685 ucom_cfg_do_request(sc->sc_udev, &sc->sc_ucom,
686 &req, NULL, 0, 1000);
691 umodem_intr_callback(struct usb_xfer *xfer, usb_error_t error)
693 struct usb_cdc_notification pkt;
694 struct umodem_softc *sc = usbd_xfer_softc(xfer);
695 struct usb_page_cache *pc;
699 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
701 switch (USB_GET_STATE(xfer)) {
702 case USB_ST_TRANSFERRED:
705 DPRINTF("received short packet, "
706 "%d bytes\n", actlen);
709 if (actlen > (int)sizeof(pkt)) {
710 DPRINTF("truncating message\n");
711 actlen = sizeof(pkt);
713 pc = usbd_xfer_get_frame(xfer, 0);
714 usbd_copy_out(pc, 0, &pkt, actlen);
718 wLen = UGETW(pkt.wLength);
722 if (pkt.bmRequestType != UCDC_NOTIFICATION) {
723 DPRINTF("unknown message type, "
724 "0x%02x, on notify pipe!\n",
728 switch (pkt.bNotification) {
729 case UCDC_N_SERIAL_STATE:
731 * Set the serial state in ucom driver based on
732 * the bits from the notify message
735 DPRINTF("invalid notification "
736 "length, %d bytes!\n", actlen);
739 DPRINTF("notify bytes = %02x%02x\n",
743 /* Currently, lsr is always zero. */
747 if (pkt.data[0] & UCDC_N_SERIAL_RI) {
748 sc->sc_msr |= SER_RI;
750 if (pkt.data[0] & UCDC_N_SERIAL_DSR) {
751 sc->sc_msr |= SER_DSR;
753 if (pkt.data[0] & UCDC_N_SERIAL_DCD) {
754 sc->sc_msr |= SER_DCD;
756 ucom_status_change(&sc->sc_ucom);
760 DPRINTF("unknown notify message: 0x%02x\n",
767 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
768 usbd_transfer_submit(xfer);
772 if (error != USB_ERR_CANCELLED) {
773 /* try to clear stall first */
774 usbd_xfer_set_stall(xfer);
783 umodem_write_callback(struct usb_xfer *xfer, usb_error_t error)
785 struct umodem_softc *sc = usbd_xfer_softc(xfer);
786 struct usb_page_cache *pc;
789 switch (USB_GET_STATE(xfer)) {
791 case USB_ST_TRANSFERRED:
793 pc = usbd_xfer_get_frame(xfer, 0);
794 if (ucom_get_data(&sc->sc_ucom, pc, 0,
795 UMODEM_BUF_SIZE, &actlen)) {
797 usbd_xfer_set_frame_len(xfer, 0, actlen);
798 usbd_transfer_submit(xfer);
803 if (error != USB_ERR_CANCELLED) {
804 /* try to clear stall first */
805 usbd_xfer_set_stall(xfer);
813 umodem_read_callback(struct usb_xfer *xfer, usb_error_t error)
815 struct umodem_softc *sc = usbd_xfer_softc(xfer);
816 struct usb_page_cache *pc;
819 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
821 switch (USB_GET_STATE(xfer)) {
822 case USB_ST_TRANSFERRED:
824 DPRINTF("actlen=%d\n", actlen);
826 pc = usbd_xfer_get_frame(xfer, 0);
827 ucom_put_data(&sc->sc_ucom, pc, 0, actlen);
831 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
832 usbd_transfer_submit(xfer);
836 if (error != USB_ERR_CANCELLED) {
837 /* try to clear stall first */
838 usbd_xfer_set_stall(xfer);
846 umodem_get_desc(struct usb_attach_arg *uaa, uint8_t type, uint8_t subtype)
848 return (usbd_find_descriptor(uaa->device, NULL, uaa->info.bIfaceIndex,
849 type, 0xFF, subtype, 0xFF));
853 umodem_set_comm_feature(struct usb_device *udev, uint8_t iface_no,
854 uint16_t feature, uint16_t state)
856 struct usb_device_request req;
857 struct usb_cdc_abstract_state ast;
859 DPRINTF("feature=%d state=%d\n",
862 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
863 req.bRequest = UCDC_SET_COMM_FEATURE;
864 USETW(req.wValue, feature);
865 req.wIndex[0] = iface_no;
867 USETW(req.wLength, UCDC_ABSTRACT_STATE_LENGTH);
868 USETW(ast.wState, state);
870 return (usbd_do_request(udev, NULL, &req, &ast));
874 umodem_detach(device_t dev)
876 struct umodem_softc *sc = device_get_softc(dev);
878 DPRINTF("sc=%p\n", sc);
880 ucom_detach(&sc->sc_super_ucom, &sc->sc_ucom);
881 usbd_transfer_unsetup(sc->sc_xfer, UMODEM_N_TRANSFER);
883 device_claim_softc(dev);
885 umodem_free_softc(sc);
890 UCOM_UNLOAD_DRAIN(umodem);
893 umodem_free_softc(struct umodem_softc *sc)
895 if (ucom_unref(&sc->sc_super_ucom)) {
896 mtx_destroy(&sc->sc_mtx);
897 device_free_softc(sc);
902 umodem_free(struct ucom_softc *ucom)
904 umodem_free_softc(ucom->sc_parent);
908 umodem_poll(struct ucom_softc *ucom)
910 struct umodem_softc *sc = ucom->sc_parent;
911 usbd_transfer_poll(sc->sc_xfer, UMODEM_N_TRANSFER);