Home | History | Annotate | Line # | Download | only in usb
umodem.c revision 1.28 
      1 /*	$NetBSD: umodem.c,v 1.28 2000/04/27 15:26:49 augustss Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
      5  * All rights reserved.
      6  *
      7  * This code is derived from software contributed to The NetBSD Foundation
      8  * by Lennart Augustsson (lennart (at) augustsson.net) at
      9  * Carlstedt Research & Technology.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions and the following disclaimer.
     16  * 2. Redistributions in binary form must reproduce the above copyright
     17  *    notice, this list of conditions and the following disclaimer in the
     18  *    documentation and/or other materials provided with the distribution.
     19  * 3. All advertising materials mentioning features or use of this software
     20  *    must display the following acknowledgement:
     21  *        This product includes software developed by the NetBSD
     22  *        Foundation, Inc. and its contributors.
     23  * 4. Neither the name of The NetBSD Foundation nor the names of its
     24  *    contributors may be used to endorse or promote products derived
     25  *    from this software without specific prior written permission.
     26  *
     27  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     28  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     29  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     30  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     31  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     32  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     33  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     34  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     35  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     36  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     37  * POSSIBILITY OF SUCH DAMAGE.
     38  */
     39 
     40 /*
     41  * Comm Class spec: http://www.usb.org/developers/data/usbcdc11.pdf
     42  */
     43 
     44 /*
     45  * TODO:
     46  * - Add error recovery in various places; the big problem is what
     47  *   to do in a callback if there is an error.
     48  * - Implement a Call Device for modems without multiplexed commands.
     49  *
     50  */
     51 
     52 #include <sys/param.h>
     53 #include <sys/systm.h>
     54 #include <sys/kernel.h>
     55 #include <sys/ioctl.h>
     56 #include <sys/conf.h>
     57 #include <sys/tty.h>
     58 #include <sys/file.h>
     59 #include <sys/select.h>
     60 #include <sys/proc.h>
     61 #include <sys/vnode.h>
     62 #include <sys/device.h>
     63 #include <sys/poll.h>
     64 
     65 #include <dev/usb/usb.h>
     66 #include <dev/usb/usbcdc.h>
     67 
     68 #include <dev/usb/usbdi.h>
     69 #include <dev/usb/usbdi_util.h>
     70 #include <dev/usb/usbdevs.h>
     71 #include <dev/usb/usb_quirks.h>
     72 
     73 #include <dev/usb/usbdevs.h>
     74 #include <dev/usb/ucomvar.h>
     75 
     76 #ifdef UMODEM_DEBUG
     77 #define DPRINTFN(n, x)	if (umodemdebug > (n)) logprintf x
     78 int	umodemdebug = 0;
     79 #else
     80 #define DPRINTFN(n, x)
     81 #endif
     82 #define DPRINTF(x) DPRINTFN(0, x)
     83 
     84 /*
     85  * These are the maximum number of bytes transferred per frame.
     86  * If some really high speed devices should use this driver they
     87  * may need to be increased, but this is good enough for normal modems.
     88  */
     89 #define UMODEMIBUFSIZE 64
     90 #define UMODEMOBUFSIZE 256
     91 
     92 struct umodem_softc {
     93 	USBBASEDEVICE		sc_dev;		/* base device */
     94 
     95 	usbd_device_handle	sc_udev;	/* USB device */
     96 
     97 	int			sc_ctl_iface_no;
     98 	usbd_interface_handle	sc_ctl_iface;	/* control interface */
     99 	int			sc_data_iface_no;
    100 	usbd_interface_handle	sc_data_iface;	/* data interface */
    101 
    102 	int			sc_cm_cap;	/* CM capabilities */
    103 	int			sc_acm_cap;	/* ACM capabilities */
    104 
    105 	int			sc_cm_over_data;
    106 
    107 	usb_cdc_line_state_t	sc_line_state;	/* current line state */
    108 	u_char			sc_dtr;		/* current DTR state */
    109 	u_char			sc_rts;		/* current RTS state */
    110 
    111 	device_ptr_t		sc_subdev;	/* ucom device */
    112 
    113 	u_char			sc_opening;	/* lock during open */
    114 	u_char			sc_dying;	/* disconnecting */
    115 };
    116 
    117 Static void	*umodem_get_desc
    118 		__P((usbd_device_handle dev, int type, int subtype));
    119 Static usbd_status umodem_set_comm_feature
    120 		__P((struct umodem_softc *sc, int feature, int state));
    121 Static usbd_status umodem_set_line_coding
    122 		__P((struct umodem_softc *sc, usb_cdc_line_state_t *state));
    123 
    124 Static void	umodem_get_caps	__P((usbd_device_handle, int *, int *));
    125 
    126 Static void	umodem_get_status
    127 		__P((void *, int portno, u_char *lsr, u_char *msr));
    128 Static void	umodem_set	__P((void *, int, int, int));
    129 Static void	umodem_dtr	__P((struct umodem_softc *, int));
    130 Static void	umodem_rts	__P((struct umodem_softc *, int));
    131 Static void	umodem_break	__P((struct umodem_softc *, int));
    132 Static void	umodem_set_line_state __P((struct umodem_softc *));
    133 Static int	umodem_param	__P((void *, int, struct termios *));
    134 Static int	umodem_ioctl	__P((void *, int, u_long, caddr_t, int,
    135 				     struct proc *));
    136 
    137 Static struct ucom_methods umodem_methods = {
    138 	umodem_get_status,
    139 	umodem_set,
    140 	umodem_param,
    141 	umodem_ioctl,
    142 	NULL,
    143 	NULL,
    144 	NULL,
    145 	NULL,
    146 };
    147 
    148 USB_DECLARE_DRIVER(umodem);
    149 
    150 USB_MATCH(umodem)
    151 {
    152 	USB_MATCH_START(umodem, uaa);
    153 	usb_interface_descriptor_t *id;
    154 	int cm, acm;
    155 
    156 	if (uaa->iface == NULL)
    157 		return (UMATCH_NONE);
    158 
    159 	id = usbd_get_interface_descriptor(uaa->iface);
    160 	if (id == NULL ||
    161 	    id->bInterfaceClass != UICLASS_CDC ||
    162 	    id->bInterfaceSubClass != UISUBCLASS_ABSTRACT_CONTROL_MODEL ||
    163 	    id->bInterfaceProtocol != UIPROTO_CDC_AT)
    164 		return (UMATCH_NONE);
    165 
    166 	umodem_get_caps(uaa->device, &cm, &acm);
    167 	if (!(cm & USB_CDC_CM_DOES_CM) ||
    168 	    !(cm & USB_CDC_CM_OVER_DATA) ||
    169 	    !(acm & USB_CDC_ACM_HAS_LINE))
    170 		return (UMATCH_NONE);
    171 
    172 	return (UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO);
    173 }
    174 
    175 USB_ATTACH(umodem)
    176 {
    177 	USB_ATTACH_START(umodem, sc, uaa);
    178 	usbd_device_handle dev = uaa->device;
    179 	usb_interface_descriptor_t *id;
    180 	usb_endpoint_descriptor_t *ed;
    181 	usb_cdc_cm_descriptor_t *cmd;
    182 	char devinfo[1024];
    183 	usbd_status err;
    184 	int data_ifcno;
    185 	int i;
    186 	struct ucom_attach_args uca;
    187 
    188 	usbd_devinfo(uaa->device, 0, devinfo);
    189 	USB_ATTACH_SETUP;
    190 
    191 	sc->sc_udev = dev;
    192 	sc->sc_ctl_iface = uaa->iface;
    193 
    194 	id = usbd_get_interface_descriptor(sc->sc_ctl_iface);
    195 	printf("%s: %s, iclass %d/%d\n", USBDEVNAME(sc->sc_dev),
    196 	       devinfo, id->bInterfaceClass, id->bInterfaceSubClass);
    197 	sc->sc_ctl_iface_no = id->bInterfaceNumber;
    198 
    199 	umodem_get_caps(dev, &sc->sc_cm_cap, &sc->sc_acm_cap);
    200 
    201 	/* Get the data interface no. */
    202 	cmd = umodem_get_desc(dev, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM);
    203 	if (cmd == NULL) {
    204 		printf("%s: no CM descriptor\n", USBDEVNAME(sc->sc_dev));
    205 		goto bad;
    206 	}
    207 	sc->sc_data_iface_no = data_ifcno = cmd->bDataInterface;
    208 
    209 	printf("%s: data interface %d, has %sCM over data, has %sbreak\n",
    210 	       USBDEVNAME(sc->sc_dev), data_ifcno,
    211 	       sc->sc_cm_cap & USB_CDC_CM_OVER_DATA ? "" : "no ",
    212 	       sc->sc_acm_cap & USB_CDC_ACM_HAS_BREAK ? "" : "no ");
    213 
    214 
    215 	/* Get the data interface too. */
    216 	for (i = 0; i < uaa->nifaces; i++) {
    217 		if (uaa->ifaces[i] != NULL) {
    218 			id = usbd_get_interface_descriptor(uaa->ifaces[i]);
    219 			if (id != NULL && id->bInterfaceNumber == data_ifcno) {
    220 				sc->sc_data_iface = uaa->ifaces[i];
    221 				uaa->ifaces[i] = NULL;
    222 			}
    223 		}
    224 	}
    225 	if (sc->sc_data_iface == NULL) {
    226 		printf("%s: no data interface\n", USBDEVNAME(sc->sc_dev));
    227 		goto bad;
    228 	}
    229 
    230 	/*
    231 	 * Find the bulk endpoints.
    232 	 * Iterate over all endpoints in the data interface and take note.
    233 	 */
    234 	uca.bulkin = uca.bulkout = -1;
    235 
    236 	id = usbd_get_interface_descriptor(sc->sc_data_iface);
    237 	for (i = 0; i < id->bNumEndpoints; i++) {
    238 		ed = usbd_interface2endpoint_descriptor(sc->sc_data_iface, i);
    239 		if (ed == NULL) {
    240 			printf("%s: no endpoint descriptor for %d\n",
    241 				USBDEVNAME(sc->sc_dev), i);
    242 			goto bad;
    243 		}
    244 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
    245 		    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
    246                         uca.bulkin = ed->bEndpointAddress;
    247                 } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
    248 			   (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
    249                         uca.bulkout = ed->bEndpointAddress;
    250                 }
    251         }
    252 
    253 	if (uca.bulkin == -1) {
    254 		printf("%s: Could not find data bulk in\n",
    255 		       USBDEVNAME(sc->sc_dev));
    256 		goto bad;
    257 	}
    258 	if (uca.bulkout == -1) {
    259 		printf("%s: Could not find data bulk out\n",
    260 			USBDEVNAME(sc->sc_dev));
    261 		goto bad;
    262 	}
    263 
    264 	if (sc->sc_cm_cap & USB_CDC_CM_OVER_DATA) {
    265 		err = umodem_set_comm_feature(sc, UCDC_ABSTRACT_STATE,
    266 					      UCDC_DATA_MULTIPLEXED);
    267 		if (err) {
    268 			printf("%s: could not set data multiplex mode\n",
    269 			       USBDEVNAME(sc->sc_dev));
    270 			goto bad;
    271 		}
    272 		sc->sc_cm_over_data = 1;
    273 	}
    274 
    275 	sc->sc_dtr = -1;
    276 
    277 	uca.portno = UCOM_UNK_PORTNO;
    278 	/* bulkin, bulkout set above */
    279 	uca.ibufsize = UMODEMIBUFSIZE;
    280 	uca.obufsize = UMODEMOBUFSIZE;
    281 	uca.ibufsizepad = UMODEMIBUFSIZE;
    282 	uca.obufsizepad = UMODEMOBUFSIZE;
    283 	uca.device = sc->sc_udev;
    284 	uca.iface = sc->sc_data_iface;
    285 	uca.methods = &umodem_methods;
    286 	uca.arg = sc;
    287 
    288 	DPRINTF(("umodem_attach: sc=%p\n", sc));
    289 	sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
    290 
    291 	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
    292 			   USBDEV(sc->sc_dev));
    293 
    294 	USB_ATTACH_SUCCESS_RETURN;
    295 
    296  bad:
    297 	sc->sc_dying = 1;
    298 	USB_ATTACH_ERROR_RETURN;
    299 }
    300 
    301 void
    302 umodem_get_caps(dev, cm, acm)
    303 	usbd_device_handle dev;
    304 	int *cm, *acm;
    305 {
    306 	usb_cdc_cm_descriptor_t *cmd;
    307 	usb_cdc_acm_descriptor_t *cad;
    308 
    309 	*cm = *acm = 0;
    310 
    311 	cmd = umodem_get_desc(dev, UDESC_CS_INTERFACE, UDESCSUB_CDC_CM);
    312 	if (cmd == NULL) {
    313 		DPRINTF(("umodem_get_desc: no CM desc\n"));
    314 		return;
    315 	}
    316 	*cm = cmd->bmCapabilities;
    317 
    318 	cad = umodem_get_desc(dev, UDESC_CS_INTERFACE, UDESCSUB_CDC_ACM);
    319 	if (cad == NULL) {
    320 		DPRINTF(("umodem_get_desc: no ACM desc\n"));
    321 		return;
    322 	}
    323 	*acm = cad->bmCapabilities;
    324 }
    325 
    326 void
    327 umodem_get_status(addr, portno, lsr, msr)
    328 	void *addr;
    329 	int portno;
    330 	u_char *lsr, *msr;
    331 {
    332 	DPRINTF(("umodem_get_status:\n"));
    333 
    334 	if (lsr != NULL)
    335 		*lsr = 0;	/* XXX */
    336 	if (msr != NULL)
    337 		*msr = 0;	/* XXX */
    338 }
    339 
    340 int
    341 umodem_param(addr, portno, t)
    342 	void *addr;
    343 	int portno;
    344 	struct termios *t;
    345 {
    346 	struct umodem_softc *sc = addr;
    347 	usbd_status err;
    348 	usb_cdc_line_state_t ls;
    349 
    350 	DPRINTF(("umodem_param: sc=%p\n", sc));
    351 
    352 	USETDW(ls.dwDTERate, t->c_ospeed);
    353 	if (ISSET(t->c_cflag, CSTOPB))
    354 		ls.bCharFormat = UCDC_STOP_BIT_2;
    355 	else
    356 		ls.bCharFormat = UCDC_STOP_BIT_1;
    357 	if (ISSET(t->c_cflag, PARENB)) {
    358 		if (ISSET(t->c_cflag, PARODD))
    359 			ls.bParityType = UCDC_PARITY_ODD;
    360 		else
    361 			ls.bParityType = UCDC_PARITY_EVEN;
    362 	} else
    363 		ls.bParityType = UCDC_PARITY_NONE;
    364 	switch (ISSET(t->c_cflag, CSIZE)) {
    365 	case CS5:
    366 		ls.bDataBits = 5;
    367 		break;
    368 	case CS6:
    369 		ls.bDataBits = 6;
    370 		break;
    371 	case CS7:
    372 		ls.bDataBits = 7;
    373 		break;
    374 	case CS8:
    375 		ls.bDataBits = 8;
    376 		break;
    377 	}
    378 
    379 	err = umodem_set_line_coding(sc, &ls);
    380 	if (err) {
    381 		DPRINTF(("umodem_param: err=%s\n", usbd_errstr(err)));
    382 		return (1);
    383 	}
    384 	return (0);
    385 }
    386 
    387 int
    388 umodem_ioctl(addr, portno, cmd, data, flag, p)
    389 	void *addr;
    390 	int portno;
    391 	u_long cmd;
    392 	caddr_t data;
    393 	int flag;
    394 	struct proc *p;
    395 {
    396 	struct umodem_softc *sc = addr;
    397 	int error = 0;
    398 
    399 	if (sc->sc_dying)
    400 		return (EIO);
    401 
    402 	DPRINTF(("umodemioctl: cmd=0x%08lx\n", cmd));
    403 
    404 	switch (cmd) {
    405 	case USB_GET_CM_OVER_DATA:
    406 		*(int *)data = sc->sc_cm_over_data;
    407 		break;
    408 
    409 	case USB_SET_CM_OVER_DATA:
    410 		if (*(int *)data != sc->sc_cm_over_data) {
    411 			/* XXX change it */
    412 		}
    413 		break;
    414 
    415 	default:
    416 		DPRINTF(("umodemioctl: unknown\n"));
    417 		error = ENOTTY;
    418 		break;
    419 	}
    420 
    421 	return (error);
    422 }
    423 
    424 void
    425 umodem_dtr(sc, onoff)
    426 	struct umodem_softc *sc;
    427 	int onoff;
    428 {
    429 	DPRINTF(("umodem_modem: onoff=%d\n", onoff));
    430 
    431 	if (sc->sc_dtr == onoff)
    432 		return;
    433 	sc->sc_dtr = onoff;
    434 
    435 	umodem_set_line_state(sc);
    436 }
    437 
    438 void
    439 umodem_rts(sc, onoff)
    440 	struct umodem_softc *sc;
    441 	int onoff;
    442 {
    443 	DPRINTF(("umodem_modem: onoff=%d\n", onoff));
    444 
    445 	if (sc->sc_rts == onoff)
    446 		return;
    447 	sc->sc_rts = onoff;
    448 
    449 	umodem_set_line_state(sc);
    450 }
    451 
    452 void
    453 umodem_set_line_state(sc)
    454 	struct umodem_softc *sc;
    455 {
    456 	usb_device_request_t req;
    457 	int ls;
    458 
    459 	ls = (sc->sc_dtr ? UCDC_LINE_DTR : 0) |
    460 	     (sc->sc_rts ? UCDC_LINE_RTS : 0);
    461 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
    462 	req.bRequest = UCDC_SET_CONTROL_LINE_STATE;
    463 	USETW(req.wValue, ls);
    464 	USETW(req.wIndex, sc->sc_ctl_iface_no);
    465 	USETW(req.wLength, 0);
    466 
    467 	(void)usbd_do_request(sc->sc_udev, &req, 0);
    468 
    469 }
    470 
    471 void
    472 umodem_break(sc, onoff)
    473 	struct umodem_softc *sc;
    474 	int onoff;
    475 {
    476 	usb_device_request_t req;
    477 
    478 	DPRINTF(("umodem_break: onoff=%d\n", onoff));
    479 
    480 	if (!(sc->sc_acm_cap & USB_CDC_ACM_HAS_BREAK))
    481 		return;
    482 
    483 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
    484 	req.bRequest = UCDC_SEND_BREAK;
    485 	USETW(req.wValue, onoff ? UCDC_BREAK_ON : UCDC_BREAK_OFF);
    486 	USETW(req.wIndex, sc->sc_ctl_iface_no);
    487 	USETW(req.wLength, 0);
    488 
    489 	(void)usbd_do_request(sc->sc_udev, &req, 0);
    490 }
    491 
    492 void
    493 umodem_set(addr, portno, reg, onoff)
    494 	void *addr;
    495 	int portno;
    496 	int reg;
    497 	int onoff;
    498 {
    499 	struct umodem_softc *sc = addr;
    500 
    501 	switch (reg) {
    502 	case UCOM_SET_DTR:
    503 		umodem_dtr(sc, onoff);
    504 		break;
    505 	case UCOM_SET_RTS:
    506 		umodem_rts(sc, onoff);
    507 		break;
    508 	case UCOM_SET_BREAK:
    509 		umodem_break(sc, onoff);
    510 		break;
    511 	default:
    512 		break;
    513 	}
    514 }
    515 
    516 usbd_status
    517 umodem_set_line_coding(sc, state)
    518 	struct umodem_softc *sc;
    519 	usb_cdc_line_state_t *state;
    520 {
    521 	usb_device_request_t req;
    522 	usbd_status err;
    523 
    524 	DPRINTF(("umodem_set_line_coding: rate=%d fmt=%d parity=%d bits=%d\n",
    525 		 UGETDW(state->dwDTERate), state->bCharFormat,
    526 		 state->bParityType, state->bDataBits));
    527 
    528 	if (memcmp(state, &sc->sc_line_state, UCDC_LINE_STATE_LENGTH) == 0) {
    529 		DPRINTF(("umodem_set_line_coding: already set\n"));
    530 		return (USBD_NORMAL_COMPLETION);
    531 	}
    532 
    533 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
    534 	req.bRequest = UCDC_SET_LINE_CODING;
    535 	USETW(req.wValue, 0);
    536 	USETW(req.wIndex, sc->sc_ctl_iface_no);
    537 	USETW(req.wLength, UCDC_LINE_STATE_LENGTH);
    538 
    539 	err = usbd_do_request(sc->sc_udev, &req, state);
    540 	if (err) {
    541 		DPRINTF(("umodem_set_line_coding: failed, err=%s\n",
    542 			 usbd_errstr(err)));
    543 		return (err);
    544 	}
    545 
    546 	sc->sc_line_state = *state;
    547 
    548 	return (USBD_NORMAL_COMPLETION);
    549 }
    550 
    551 void *
    552 umodem_get_desc(dev, type, subtype)
    553 	usbd_device_handle dev;
    554 	int type;
    555 	int subtype;
    556 {
    557 	usb_descriptor_t *desc;
    558 	usb_config_descriptor_t *cd = usbd_get_config_descriptor(dev);
    559         uByte *p = (uByte *)cd;
    560         uByte *end = p + UGETW(cd->wTotalLength);
    561 
    562 	while (p < end) {
    563 		desc = (usb_descriptor_t *)p;
    564 		if (desc->bDescriptorType == type &&
    565 		    desc->bDescriptorSubtype == subtype)
    566 			return (desc);
    567 		p += desc->bLength;
    568 	}
    569 
    570 	return (0);
    571 }
    572 
    573 usbd_status
    574 umodem_set_comm_feature(sc, feature, state)
    575 	struct umodem_softc *sc;
    576 	int feature;
    577 	int state;
    578 {
    579 	usb_device_request_t req;
    580 	usbd_status err;
    581 	usb_cdc_abstract_state_t ast;
    582 
    583 	DPRINTF(("umodem_set_comm_feature: feature=%d state=%d\n", feature,
    584 		 state));
    585 
    586 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
    587 	req.bRequest = UCDC_SET_COMM_FEATURE;
    588 	USETW(req.wValue, feature);
    589 	USETW(req.wIndex, sc->sc_ctl_iface_no);
    590 	USETW(req.wLength, UCDC_ABSTRACT_STATE_LENGTH);
    591 	USETW(ast.wState, state);
    592 
    593 	err = usbd_do_request(sc->sc_udev, &req, &ast);
    594 	if (err) {
    595 		DPRINTF(("umodem_set_comm_feature: feature=%d, err=%s\n",
    596 			 feature, usbd_errstr(err)));
    597 		return (err);
    598 	}
    599 
    600 	return (USBD_NORMAL_COMPLETION);
    601 }
    602 
    603 int
    604 umodem_activate(self, act)
    605 	device_ptr_t self;
    606 	enum devact act;
    607 {
    608 	struct umodem_softc *sc = (struct umodem_softc *)self;
    609 	int rv = 0;
    610 
    611 	switch (act) {
    612 	case DVACT_ACTIVATE:
    613 		return (EOPNOTSUPP);
    614 		break;
    615 
    616 	case DVACT_DEACTIVATE:
    617 		sc->sc_dying = 1;
    618 		if (sc->sc_subdev)
    619 			rv = config_deactivate(sc->sc_subdev);
    620 		break;
    621 	}
    622 	return (rv);
    623 }
    624 
    625 USB_DETACH(umodem)
    626 {
    627 	USB_DETACH_START(umodem, sc);
    628 	int rv = 0;
    629 
    630 	DPRINTF(("umodem_detach: sc=%p flags=%d\n", sc, flags));
    631 
    632 	sc->sc_dying = 1;
    633 
    634 	if (sc->sc_subdev != NULL)
    635 		rv = config_detach(sc->sc_subdev, flags);
    636 
    637 	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
    638 			   USBDEV(sc->sc_dev));
    639 
    640 	return (rv);
    641 }
    642