/* $NetBSD: if_ncm.c,v 1.3 2026/01/26 01:27:46 riastradh Exp $ */ /* * Copyright (c) 1997, 1998, 1999, 2000-2003 Bill Paul * Copyright (c) 2003 Craig Boston * Copyright (c) 2004 Daniel Hartmeier * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by Bill Paul. * 4. Neither the name of the author nor the names of any co-contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY Bill Paul AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL Bill Paul, THE VOICES IN HIS HEAD OR * THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * USB Network Control Model (NCM) * https://www.usb.org/sites/default/files/NCM10_012011.zip */ #include __KERNEL_RCSID(0, "$NetBSD: if_ncm.c,v 1.3 2026/01/26 01:27:46 riastradh Exp $"); #include #include #include #include #include #include struct ncm_softc { struct usbnet ncm_un; uint32_t sc_tx_seq; }; static int ncm_match(device_t, cfdata_t, void *); static void ncm_attach(device_t, device_t, void *); CFATTACH_DECL_NEW(ncm, sizeof(struct ncm_softc), ncm_match, ncm_attach, usbnet_detach, usbnet_activate); static void ncm_uno_rx_loop(struct usbnet *, struct usbnet_chain *, uint32_t); static unsigned ncm_uno_tx_prepare(struct usbnet *, struct mbuf *, struct usbnet_chain *); static const struct usbnet_ops ncm_ops = { .uno_tx_prepare = ncm_uno_tx_prepare, .uno_rx_loop = ncm_uno_rx_loop, }; static int ncm_match(device_t parent, cfdata_t match, void *aux) { struct usbif_attach_arg *uiaa = aux; if (uiaa->uiaa_class == UICLASS_CDC && uiaa->uiaa_subclass == UISUBCLASS_NETWORK_CONTROL_MODEL) return UMATCH_IFACECLASS_GENERIC; return UMATCH_NONE; } static void ncm_attach(device_t parent, device_t self, void *aux) { struct ncm_softc *sc = device_private(self); struct usbnet * const un = &sc->ncm_un; struct usbif_attach_arg *uiaa = aux; char *devinfop; struct usbd_device *dev = uiaa->uiaa_device; usb_interface_descriptor_t *id; usb_endpoint_descriptor_t *ed; const usb_cdc_union_descriptor_t *ud; usb_config_descriptor_t *cd; int data_ifcno; int i, j, numalts; const usb_cdc_ethernet_descriptor_t *ue; char eaddr_str[USB_MAX_ENCODED_STRING_LEN]; usb_device_request_t req; struct ncm_ntb_parameters np; aprint_naive("\n"); aprint_normal("\n"); devinfop = usbd_devinfo_alloc(dev, 0); aprint_normal_dev(self, "%s\n", devinfop); usbd_devinfo_free(devinfop); un->un_dev = self; un->un_udev = dev; un->un_sc = sc; un->un_ops = &ncm_ops; un->un_rx_xfer_flags = USBD_SHORT_XFER_OK; un->un_tx_xfer_flags = USBD_FORCE_SHORT_XFER; ud = (const usb_cdc_union_descriptor_t *)usb_find_desc_if(un->un_udev, UDESC_CS_INTERFACE, UDESCSUB_CDC_UNION, usbd_get_interface_descriptor(uiaa->uiaa_iface)); if (ud == NULL) { aprint_error_dev(self, "no union descriptor\n"); return; } data_ifcno = ud->bSlaveInterface[0]; for (i = 0; i < uiaa->uiaa_nifaces; i++) { if (uiaa->uiaa_ifaces[i] != NULL) { id = usbd_get_interface_descriptor( uiaa->uiaa_ifaces[i]); if (id != NULL && id->bInterfaceNumber == data_ifcno) { un->un_iface = uiaa->uiaa_ifaces[i]; uiaa->uiaa_ifaces[i] = NULL; } } } if (un->un_iface == NULL) { aprint_error_dev(self, "no data interface\n"); return; } /* * * The Data Class interface of a networking device shall have a minimum * of two interface settings. The first setting (the default interface * setting) includes no endpoints and therefore no networking traffic is * exchanged whenever the default interface setting is selected. One or * more additional interface settings are used for normal operation, and * therefore each includes a pair of endpoints (one IN, and one OUT) to * exchange network traffic. Select an alternate interface setting to * initialize the network aspects of the device and to enable the * exchange of network traffic. * * * Some devices, most notably cable modems, include interface settings * that have no IN or OUT endpoint, therefore loop through the list of all * available interface settings looking for one with both IN and OUT * endpoints. */ id = usbd_get_interface_descriptor(un->un_iface); cd = usbd_get_config_descriptor(un->un_udev); numalts = usbd_get_no_alts(cd, id->bInterfaceNumber); for (j = 0; j < numalts; j++) { if (usbd_set_interface(un->un_iface, j)) { aprint_error_dev(un->un_dev, "setting alternate interface failed\n"); return; } /* Find endpoints. */ id = usbd_get_interface_descriptor(un->un_iface); un->un_ed[USBNET_ENDPT_RX] = un->un_ed[USBNET_ENDPT_TX] = 0; for (i = 0; i < id->bNumEndpoints; i++) { ed = usbd_interface2endpoint_descriptor(un->un_iface, i); if (!ed) { aprint_error_dev(self, "could not read endpoint descriptor\n"); return; } if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { un->un_ed[USBNET_ENDPT_RX] = ed->bEndpointAddress; } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT && UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) { un->un_ed[USBNET_ENDPT_TX] = ed->bEndpointAddress; } else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN && UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) { /* XXX: CDC spec defines an interrupt pipe, but it is not * needed for simple host-to-host applications. */ } else { aprint_error_dev(self, "unexpected endpoint\n"); } } /* If we found something, try and use it... */ if (un->un_ed[USBNET_ENDPT_RX] != 0 && un->un_ed[USBNET_ENDPT_TX] != 0) break; } if (un->un_ed[USBNET_ENDPT_RX] == 0) { aprint_error_dev(self, "could not find data bulk in\n"); return; } if (un->un_ed[USBNET_ENDPT_TX] == 0) { aprint_error_dev(self, "could not find data bulk out\n"); return; } ue = (const usb_cdc_ethernet_descriptor_t *)usb_find_desc_if(dev, UDESC_CS_INTERFACE, UDESCSUB_CDC_ENF, usbd_get_interface_descriptor(uiaa->uiaa_iface)); if (!ue || usbd_get_string(dev, ue->iMacAddress, eaddr_str) || ether_aton_r(un->un_eaddr, sizeof(un->un_eaddr), eaddr_str)) { aprint_normal_dev(self, "faking address\n"); un->un_eaddr[0] = 0x2a; uint32_t ticks = getticks(); memcpy(&un->un_eaddr[1], &ticks, sizeof(ticks)); un->un_eaddr[5] = (uint8_t)(device_unit(un->un_dev)); } /* Query NTB transfers sizes */ req.bmRequestType = UT_READ_CLASS_INTERFACE; req.bRequest = NCM_GET_NTB_PARAMETERS; USETW(req.wValue, 0); USETW(req.wIndex, uiaa->uiaa_ifaceno); USETW(req.wLength, sizeof(np)); if (usbd_do_request(un->un_udev, &req, &np) != USBD_NORMAL_COMPLETION || UGETW(np.wLength) != sizeof(np)) { aprint_error_dev(un->un_dev, "NCM_GET_NTB_PARAMETERS failed\n"); return; } un->un_rx_list_cnt = 1; un->un_tx_list_cnt = 1; un->un_rx_bufsz = UGETDW(np.dwNtbInMaxSize); un->un_tx_bufsz = UGETDW(np.dwNtbOutMaxSize); if (un->un_tx_bufsz < NCM_MIN_TX_BUFSZ) { aprint_error_dev(un->un_dev, "dwNtbOutMaxSize %u too small\n", un->un_tx_bufsz); return; } usbnet_attach(un); usbnet_attach_ifp(un, IFF_SIMPLEX | IFF_BROADCAST | IFF_MULTICAST, 0, NULL); /* XXX There is no link state, pretend we are always on */ if_link_state_change(usbnet_ifp(un), LINK_STATE_UP); } static void ncm_uno_rx_loop(struct usbnet *un, struct usbnet_chain *c, uint32_t total_len) { struct ifnet *ifp = usbnet_ifp(un); uint8_t *buf = c->unc_buf; struct ncm_header16 *hdr; struct ncm_dptab16 *ptr; unsigned i; if (total_len < sizeof(*hdr) + sizeof(*ptr)) { aprint_error_dev(un->un_dev, "got a too small usb message\n"); if_statinc(ifp, if_ierrors); return; } hdr = (struct ncm_header16 *)buf; if (UGETDW(hdr->dwSignature) != NCM_HDR16_SIG) { aprint_error_dev(un->un_dev, "got a non NCM_HDR16_SIG header %08x\n", UGETDW(hdr->dwSignature)); return; } const unsigned ndp_index = UGETW(hdr->wNdpIndex); if (ndp_index < sizeof(*hdr) || ndp_index > total_len - sizeof(*ptr)) { aprint_error_dev(un->un_dev, "ndp start offset %d " "bigger than data sizeof(*hdr) %zu sizeof(*ptr) %zu " "total_len %u\n", ndp_index, sizeof(*hdr), sizeof(*ptr), total_len); if_statinc(ifp, if_ierrors); return; } ptr = (struct ncm_dptab16 *)(buf + ndp_index); if (UGETDW(ptr->dwSignature) != NCM_PTR16_SIG_NO_CRC) { aprint_error_dev(un->un_dev, "ncm dptab16 signature %08x is " "weird\n", UGETDW(ptr->dwSignature)); if_statinc(ifp, if_ierrors); return; } if ((unsigned)UGETW(ptr->wLength) > total_len - ndp_index) { aprint_error_dev(un->un_dev, "dptab16 wlength %u goes off end " "ndp_index %u total_len %u\n", UGETW(ptr->wLength), ndp_index, total_len); if_statinc(ifp, if_ierrors); return; } const unsigned max_datagrams = (UGETW(ptr->wLength) - offsetof(struct ncm_dptab16, datagram))/sizeof(ptr->datagram[0]); for (i = 0; i < max_datagrams; i++) { uint16_t data_start = UGETW(ptr->datagram[i].wDatagramIndex); uint16_t data_len = UGETW(ptr->datagram[i].wDatagramLength); if (data_start == 0 || data_len == 0) break; if (data_len > total_len || data_start > total_len - data_len) { aprint_error_dev(un->un_dev, "datagram points out of buffer\n"); if_statinc(ifp, if_ierrors); return; } usbnet_enqueue(un, buf + data_start, data_len, 0, 0, 0); } } static unsigned ncm_uno_tx_prepare(struct usbnet *un, struct mbuf *m, struct usbnet_chain *c) { struct ncm_softc *sc = un->un_sc; struct ncm_dptab16 *ptr; struct ncm_header16 *hdr; unsigned hdr_len, len; hdr_len = sizeof(*hdr) + sizeof(*ptr); len = m->m_pkthdr.len; KASSERT(hdr_len <= un->un_tx_bufsz); if (len > un->un_tx_bufsz - hdr_len) return 0; hdr = (struct ncm_header16 *)c->unc_buf; ptr = (struct ncm_dptab16 *)(hdr + 1); memset(hdr, 0, sizeof(*hdr)); memset(ptr, 0, sizeof(*ptr)); USETDW(hdr->dwSignature, NCM_HDR16_SIG); USETW(hdr->wHeaderLength, sizeof(*hdr)); USETW(hdr->wSequence, sc->sc_tx_seq); sc->sc_tx_seq++; USETW(hdr->wBlockLength, hdr_len + len); USETW(hdr->wNdpIndex, sizeof(*hdr)); USETDW(ptr->dwSignature, NCM_PTR16_SIG_NO_CRC); USETW(ptr->wLength, sizeof(*ptr)); USETW(ptr->wNextNdpIndex, 0); USETW(ptr->datagram[0].wDatagramIndex, hdr_len); USETW(ptr->datagram[0].wDatagramLength, len); USETW(ptr->datagram[1].wDatagramIndex, 0); USETW(ptr->datagram[1].wDatagramLength, 0); m_copydata(m, 0, len, c->unc_buf + hdr_len); return len + hdr_len; } #ifdef _MODULE #include "ioconf.c" #endif USBNET_MODULE(ncm)