Index: head/share/man/man4/usb_template.4 =================================================================== --- head/share/man/man4/usb_template.4 (revision 328193) +++ head/share/man/man4/usb_template.4 (revision 328194) @@ -1,98 +1,121 @@ .\" $FreeBSD$ .\" .\" Copyright (c) 2008 Hans Petter Selasky. 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. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. .\" .Dd June 8, 2016 .Dt USB_TEMPLATE 4 .Os . .Sh NAME . . .Nm usb_template . .Nd "USB device side templates" . . .Sh SYNOPSIS To compile this module into the kernel, place the following line in your kernel configuration file: .Bd -ragged -offset indent .Cd "device usb_template" .Ed .Pp To load the module at boot time, place the following line in .Xr loader.conf 5 : .Bd -literal -offset indent usb_template_load="YES" .Ed . .Sh DESCRIPTION The .Nm module implements various USB templates that are needed when programming an USB device side driver. . A USB template consists of an USB device descriptor, one or more USB configuration descriptors, one or more USB interface descriptors, one or more USB endpoint descriptors, USB strings and additional USB descriptors. . USB templates are selected using the .Va hw.usb.template -sysctl and tunable. -. -The -.Va hw.usb.template -value can be changed at any time, but will not +sysctl and tunable, +or by using the +.Xr usbconfig 8 +.Cm set_template +subcommand. +The sysctl values can be changed at any time, but will not have any effect until the USB device has been re-enumerated. . Available templates are: .Bl -column -offset 3n "Value" .It Em Value Ta Em Description .It Dv 0 Ta USB Mass Storage .It Dv 1 Ta CDC Ethernet .It Dv 2 Ta Media Transfer Protocol (MTP) .It Dv 3 Ta USB serial port .It Dv 4 Ta USB audio .It Dv 5 Ta USB keyboard .It Dv 6 Ta USB mouse .It Dv 7 Ta USB phone .It Dv 8 Ta CDC Ethernet and serial port .It Dv 9 Ta USB MIDI .El . +.Sh SYSCTL VARIABLES +The following variables are available as both +.Xr sysctl 8 +variables and +.Xr loader 8 +tunables: +.Bl -tag -width indent +.It Va hw.usb.template +Currently selected template. +.It Va hw.usb.templates.N +Configuration for template number +.Va N . +.It Va hw.usb.templates.N.vendor_id +16-bit vendor identifier (VID), usually assigned by USB-IF. +.It Va hw.usb.templates.N.product_id +16-bit product identifier (PID). +.It Va hw.usb.templates.N.manufacturer +String containing human-readable manufacturer name. +.It Va hw.usb.templates.N.product +String containing human-readable product name. +.El .Sh SEE ALSO .Xr cfumass 4 , .Xr usb 4 , -.Xr usfs 4 +.Xr usfs 4 , +.Xr usbconfig 8 .Sh STANDARDS The .Nm module complies to the USB 1.0, 2.0 and 3.0 standard. .Sh HISTORY The .Nm module was written by .An Hans Petter Selasky Aq Mt hselasky@FreeBSD.org . Index: head/sys/dev/usb/template/usb_template.c =================================================================== --- head/sys/dev/usb/template/usb_template.c (revision 328193) +++ head/sys/dev/usb/template/usb_template.c (revision 328194) @@ -1,1399 +1,1447 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2007 Hans Petter Selasky. 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains sub-routines to build up USB descriptors from * USB templates. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "usbdevs.h" #include #include #include #include #include #include +#include #define USB_DEBUG_VAR usb_debug #include #include #include #include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ +SYSCTL_NODE(_hw_usb, OID_AUTO, templates, CTLFLAG_RW, 0, + "USB device side templates"); + MODULE_DEPEND(usb_template, usb, 1, 1, 1); MODULE_VERSION(usb_template, 1); /* function prototypes */ static void usb_make_raw_desc(struct usb_temp_setup *, const uint8_t *); static void usb_make_endpoint_desc(struct usb_temp_setup *, const struct usb_temp_endpoint_desc *); static void usb_make_interface_desc(struct usb_temp_setup *, const struct usb_temp_interface_desc *); static void usb_make_config_desc(struct usb_temp_setup *, const struct usb_temp_config_desc *); static void usb_make_device_desc(struct usb_temp_setup *, const struct usb_temp_device_desc *); static uint8_t usb_hw_ep_match(const struct usb_hw_ep_profile *, uint8_t, uint8_t); static uint8_t usb_hw_ep_find_match(struct usb_hw_ep_scratch *, struct usb_hw_ep_scratch_sub *, uint8_t); static uint8_t usb_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t, uint8_t); static usb_error_t usb_hw_ep_resolve(struct usb_device *, struct usb_descriptor *); static const struct usb_temp_device_desc *usb_temp_get_tdd(struct usb_device *); static void *usb_temp_get_device_desc(struct usb_device *); static void *usb_temp_get_qualifier_desc(struct usb_device *); static void *usb_temp_get_config_desc(struct usb_device *, uint16_t *, uint8_t); static const void *usb_temp_get_string_desc(struct usb_device *, uint16_t, uint8_t); static const void *usb_temp_get_vendor_desc(struct usb_device *, const struct usb_device_request *, uint16_t *plen); static const void *usb_temp_get_hub_desc(struct usb_device *); static usb_error_t usb_temp_get_desc(struct usb_device *, struct usb_device_request *, const void **, uint16_t *); static usb_error_t usb_temp_setup_by_index(struct usb_device *, uint16_t index); static void usb_temp_init(void *); + +/*------------------------------------------------------------------------* + * usb_decode_str_desc + * + * Helper function to decode string descriptors into a C string. + *------------------------------------------------------------------------*/ +void +usb_decode_str_desc(struct usb_string_descriptor *sd, char *buf, size_t buflen) +{ + size_t i; + + for (i = 0; i < buflen - 1 && i < sd->bLength / 2; i++) + buf[i] = UGETW(sd->bString[i]); + + buf[i] = '\0'; +} + +/*------------------------------------------------------------------------* + * usb_temp_sysctl + * + * Callback for SYSCTL_PROC(9), to set and retrieve template string + * descriptors. + *------------------------------------------------------------------------*/ +int +usb_temp_sysctl(SYSCTL_HANDLER_ARGS) +{ + char buf[128]; + struct usb_string_descriptor *sd = arg1; + size_t len, sdlen = arg2; + int error; + + usb_decode_str_desc(sd, buf, sizeof(buf)); + + error = sysctl_handle_string(oidp, buf, sizeof(buf), req); + if (error != 0 || req->newptr == NULL) + return (error); + + len = usb_make_str_desc(sd, sdlen, buf); + if (len == 0) + return (EINVAL); + + return (0); +} + /*------------------------------------------------------------------------* * usb_make_raw_desc * * This function will insert a raw USB descriptor into the generated * USB configuration. *------------------------------------------------------------------------*/ static void usb_make_raw_desc(struct usb_temp_setup *temp, const uint8_t *raw) { void *dst; uint8_t len; /* * The first byte of any USB descriptor gives the length. */ if (raw) { len = raw[0]; if (temp->buf) { dst = USB_ADD_BYTES(temp->buf, temp->size); memcpy(dst, raw, len); /* check if we have got a CDC union descriptor */ if ((raw[0] == sizeof(struct usb_cdc_union_descriptor)) && (raw[1] == UDESC_CS_INTERFACE) && (raw[2] == UDESCSUB_CDC_UNION)) { struct usb_cdc_union_descriptor *ud = (void *)dst; /* update the interface numbers */ ud->bMasterInterface += temp->bInterfaceNumber; ud->bSlaveInterface[0] += temp->bInterfaceNumber; } /* check if we have got an interface association descriptor */ if ((raw[0] == sizeof(struct usb_interface_assoc_descriptor)) && (raw[1] == UDESC_IFACE_ASSOC)) { struct usb_interface_assoc_descriptor *iad = (void *)dst; /* update the interface number */ iad->bFirstInterface += temp->bInterfaceNumber; } /* check if we have got a call management descriptor */ if ((raw[0] == sizeof(struct usb_cdc_cm_descriptor)) && (raw[1] == UDESC_CS_INTERFACE) && (raw[2] == UDESCSUB_CDC_CM)) { struct usb_cdc_cm_descriptor *ccd = (void *)dst; /* update the interface number */ ccd->bDataInterface += temp->bInterfaceNumber; } } temp->size += len; } } /*------------------------------------------------------------------------* * usb_make_endpoint_desc * * This function will generate an USB endpoint descriptor from the * given USB template endpoint descriptor, which will be inserted into * the USB configuration. *------------------------------------------------------------------------*/ static void usb_make_endpoint_desc(struct usb_temp_setup *temp, const struct usb_temp_endpoint_desc *ted) { struct usb_endpoint_descriptor *ed; const void **rd; uint16_t old_size; uint16_t mps; uint8_t ea; /* Endpoint Address */ uint8_t et; /* Endpiont Type */ /* Reserve memory */ old_size = temp->size; ea = (ted->bEndpointAddress & (UE_ADDR | UE_DIR_IN | UE_DIR_OUT)); et = (ted->bmAttributes & UE_XFERTYPE); if (et == UE_ISOCHRONOUS) { /* account for extra byte fields */ temp->size += sizeof(*ed) + 2; } else { temp->size += sizeof(*ed); } /* Scan all Raw Descriptors first */ rd = ted->ppRawDesc; if (rd) { while (*rd) { usb_make_raw_desc(temp, *rd); rd++; } } if (ted->pPacketSize == NULL) { /* not initialized */ temp->err = USB_ERR_INVAL; return; } mps = ted->pPacketSize->mps[temp->usb_speed]; if (mps == 0) { /* not initialized */ temp->err = USB_ERR_INVAL; return; } else if (mps == UE_ZERO_MPS) { /* escape for Zero Max Packet Size */ mps = 0; } /* * Fill out the real USB endpoint descriptor * in case there is a buffer present: */ if (temp->buf) { ed = USB_ADD_BYTES(temp->buf, old_size); if (et == UE_ISOCHRONOUS) ed->bLength = sizeof(*ed) + 2; else ed->bLength = sizeof(*ed); ed->bDescriptorType = UDESC_ENDPOINT; ed->bEndpointAddress = ea; ed->bmAttributes = ted->bmAttributes; USETW(ed->wMaxPacketSize, mps); /* setup bInterval parameter */ if (ted->pIntervals && ted->pIntervals->bInterval[temp->usb_speed]) { ed->bInterval = ted->pIntervals->bInterval[temp->usb_speed]; } else { switch (et) { case UE_BULK: case UE_CONTROL: ed->bInterval = 0; /* not used */ break; case UE_INTERRUPT: switch (temp->usb_speed) { case USB_SPEED_LOW: case USB_SPEED_FULL: ed->bInterval = 1; /* 1 ms */ break; default: ed->bInterval = 4; /* 1 ms */ break; } break; default: /* UE_ISOCHRONOUS */ switch (temp->usb_speed) { case USB_SPEED_LOW: case USB_SPEED_FULL: ed->bInterval = 1; /* 1 ms */ break; default: ed->bInterval = 1; /* 125 us */ break; } break; } } } temp->bNumEndpoints++; } /*------------------------------------------------------------------------* * usb_make_interface_desc * * This function will generate an USB interface descriptor from the * given USB template interface descriptor, which will be inserted * into the USB configuration. *------------------------------------------------------------------------*/ static void usb_make_interface_desc(struct usb_temp_setup *temp, const struct usb_temp_interface_desc *tid) { struct usb_interface_descriptor *id; const struct usb_temp_endpoint_desc **ted; const void **rd; uint16_t old_size; /* Reserve memory */ old_size = temp->size; temp->size += sizeof(*id); /* Update interface and alternate interface numbers */ if (tid->isAltInterface == 0) { temp->bAlternateSetting = 0; temp->bInterfaceNumber++; } else { temp->bAlternateSetting++; } /* Scan all Raw Descriptors first */ rd = tid->ppRawDesc; if (rd) { while (*rd) { usb_make_raw_desc(temp, *rd); rd++; } } /* Reset some counters */ temp->bNumEndpoints = 0; /* Scan all Endpoint Descriptors second */ ted = tid->ppEndpoints; if (ted) { while (*ted) { usb_make_endpoint_desc(temp, *ted); ted++; } } /* * Fill out the real USB interface descriptor * in case there is a buffer present: */ if (temp->buf) { id = USB_ADD_BYTES(temp->buf, old_size); id->bLength = sizeof(*id); id->bDescriptorType = UDESC_INTERFACE; id->bInterfaceNumber = temp->bInterfaceNumber; id->bAlternateSetting = temp->bAlternateSetting; id->bNumEndpoints = temp->bNumEndpoints; id->bInterfaceClass = tid->bInterfaceClass; id->bInterfaceSubClass = tid->bInterfaceSubClass; id->bInterfaceProtocol = tid->bInterfaceProtocol; id->iInterface = tid->iInterface; } } /*------------------------------------------------------------------------* * usb_make_config_desc * * This function will generate an USB config descriptor from the given * USB template config descriptor, which will be inserted into the USB * configuration. *------------------------------------------------------------------------*/ static void usb_make_config_desc(struct usb_temp_setup *temp, const struct usb_temp_config_desc *tcd) { struct usb_config_descriptor *cd; const struct usb_temp_interface_desc **tid; uint16_t old_size; /* Reserve memory */ old_size = temp->size; temp->size += sizeof(*cd); /* Reset some counters */ temp->bInterfaceNumber = 0xFF; temp->bAlternateSetting = 0; /* Scan all the USB interfaces */ tid = tcd->ppIfaceDesc; if (tid) { while (*tid) { usb_make_interface_desc(temp, *tid); tid++; } } /* * Fill out the real USB config descriptor * in case there is a buffer present: */ if (temp->buf) { cd = USB_ADD_BYTES(temp->buf, old_size); /* compute total size */ old_size = temp->size - old_size; cd->bLength = sizeof(*cd); cd->bDescriptorType = UDESC_CONFIG; USETW(cd->wTotalLength, old_size); cd->bNumInterface = temp->bInterfaceNumber + 1; cd->bConfigurationValue = temp->bConfigurationValue; cd->iConfiguration = tcd->iConfiguration; cd->bmAttributes = tcd->bmAttributes; cd->bMaxPower = tcd->bMaxPower; cd->bmAttributes |= (UC_REMOTE_WAKEUP | UC_BUS_POWERED); if (temp->self_powered) { cd->bmAttributes |= UC_SELF_POWERED; } else { cd->bmAttributes &= ~UC_SELF_POWERED; } } } /*------------------------------------------------------------------------* * usb_make_device_desc * * This function will generate an USB device descriptor from the * given USB template device descriptor. *------------------------------------------------------------------------*/ static void usb_make_device_desc(struct usb_temp_setup *temp, const struct usb_temp_device_desc *tdd) { struct usb_temp_data *utd; const struct usb_temp_config_desc **tcd; uint16_t old_size; /* Reserve memory */ old_size = temp->size; temp->size += sizeof(*utd); /* Scan all the USB configs */ temp->bConfigurationValue = 1; tcd = tdd->ppConfigDesc; if (tcd) { while (*tcd) { usb_make_config_desc(temp, *tcd); temp->bConfigurationValue++; tcd++; } } /* * Fill out the real USB device descriptor * in case there is a buffer present: */ if (temp->buf) { utd = USB_ADD_BYTES(temp->buf, old_size); /* Store a pointer to our template device descriptor */ utd->tdd = tdd; /* Fill out USB device descriptor */ utd->udd.bLength = sizeof(utd->udd); utd->udd.bDescriptorType = UDESC_DEVICE; utd->udd.bDeviceClass = tdd->bDeviceClass; utd->udd.bDeviceSubClass = tdd->bDeviceSubClass; utd->udd.bDeviceProtocol = tdd->bDeviceProtocol; USETW(utd->udd.idVendor, tdd->idVendor); USETW(utd->udd.idProduct, tdd->idProduct); USETW(utd->udd.bcdDevice, tdd->bcdDevice); utd->udd.iManufacturer = tdd->iManufacturer; utd->udd.iProduct = tdd->iProduct; utd->udd.iSerialNumber = tdd->iSerialNumber; utd->udd.bNumConfigurations = temp->bConfigurationValue - 1; /* * Fill out the USB device qualifier. Pretend that we * don't support any other speeds by setting * "bNumConfigurations" equal to zero. That saves us * generating an extra set of configuration * descriptors. */ utd->udq.bLength = sizeof(utd->udq); utd->udq.bDescriptorType = UDESC_DEVICE_QUALIFIER; utd->udq.bDeviceClass = tdd->bDeviceClass; utd->udq.bDeviceSubClass = tdd->bDeviceSubClass; utd->udq.bDeviceProtocol = tdd->bDeviceProtocol; utd->udq.bNumConfigurations = 0; USETW(utd->udq.bcdUSB, 0x0200); utd->udq.bMaxPacketSize0 = 0; switch (temp->usb_speed) { case USB_SPEED_LOW: USETW(utd->udd.bcdUSB, 0x0110); utd->udd.bMaxPacketSize = 8; break; case USB_SPEED_FULL: USETW(utd->udd.bcdUSB, 0x0110); utd->udd.bMaxPacketSize = 32; break; case USB_SPEED_HIGH: USETW(utd->udd.bcdUSB, 0x0200); utd->udd.bMaxPacketSize = 64; break; case USB_SPEED_VARIABLE: USETW(utd->udd.bcdUSB, 0x0250); utd->udd.bMaxPacketSize = 255; /* 512 bytes */ break; case USB_SPEED_SUPER: USETW(utd->udd.bcdUSB, 0x0300); utd->udd.bMaxPacketSize = 9; /* 2**9 = 512 bytes */ break; default: temp->err = USB_ERR_INVAL; break; } } } /*------------------------------------------------------------------------* * usb_hw_ep_match * * Return values: * 0: The endpoint profile does not match the criteria * Else: The endpoint profile matches the criteria *------------------------------------------------------------------------*/ static uint8_t usb_hw_ep_match(const struct usb_hw_ep_profile *pf, uint8_t ep_type, uint8_t ep_dir_in) { if (ep_type == UE_CONTROL) { /* special */ return (pf->support_control); } if ((pf->support_in && ep_dir_in) || (pf->support_out && !ep_dir_in)) { if ((pf->support_interrupt && (ep_type == UE_INTERRUPT)) || (pf->support_isochronous && (ep_type == UE_ISOCHRONOUS)) || (pf->support_bulk && (ep_type == UE_BULK))) { return (1); } } return (0); } /*------------------------------------------------------------------------* * usb_hw_ep_find_match * * This function is used to find the best matching endpoint profile * for and endpoint belonging to an USB descriptor. * * Return values: * 0: Success. Got a match. * Else: Failure. No match. *------------------------------------------------------------------------*/ static uint8_t usb_hw_ep_find_match(struct usb_hw_ep_scratch *ues, struct usb_hw_ep_scratch_sub *ep, uint8_t is_simplex) { const struct usb_hw_ep_profile *pf; uint16_t distance; uint16_t temp; uint16_t max_frame_size; uint8_t n; uint8_t best_n; uint8_t dir_in; uint8_t dir_out; distance = 0xFFFF; best_n = 0; if ((!ep->needs_in) && (!ep->needs_out)) { return (0); /* we are done */ } if (ep->needs_ep_type == UE_CONTROL) { dir_in = 1; dir_out = 1; } else { if (ep->needs_in) { dir_in = 1; dir_out = 0; } else { dir_in = 0; dir_out = 1; } } for (n = 1; n != (USB_EP_MAX / 2); n++) { /* get HW endpoint profile */ (ues->methods->get_hw_ep_profile) (ues->udev, &pf, n); if (pf == NULL) { /* end of profiles */ break; } /* check if IN-endpoint is reserved */ if (dir_in || pf->is_simplex) { if (ues->bmInAlloc[n / 8] & (1 << (n % 8))) { /* mismatch */ continue; } } /* check if OUT-endpoint is reserved */ if (dir_out || pf->is_simplex) { if (ues->bmOutAlloc[n / 8] & (1 << (n % 8))) { /* mismatch */ continue; } } /* check simplex */ if (pf->is_simplex == is_simplex) { /* mismatch */ continue; } /* check if HW endpoint matches */ if (!usb_hw_ep_match(pf, ep->needs_ep_type, dir_in)) { /* mismatch */ continue; } /* get maximum frame size */ if (dir_in) max_frame_size = pf->max_in_frame_size; else max_frame_size = pf->max_out_frame_size; /* check if we have a matching profile */ if (max_frame_size >= ep->max_frame_size) { temp = (max_frame_size - ep->max_frame_size); if (distance > temp) { distance = temp; best_n = n; ep->pf = pf; } } } /* see if we got a match */ if (best_n != 0) { /* get the correct profile */ pf = ep->pf; /* reserve IN-endpoint */ if (dir_in) { ues->bmInAlloc[best_n / 8] |= (1 << (best_n % 8)); ep->hw_endpoint_in = best_n | UE_DIR_IN; ep->needs_in = 0; } /* reserve OUT-endpoint */ if (dir_out) { ues->bmOutAlloc[best_n / 8] |= (1 << (best_n % 8)); ep->hw_endpoint_out = best_n | UE_DIR_OUT; ep->needs_out = 0; } return (0); /* got a match */ } return (1); /* failure */ } /*------------------------------------------------------------------------* * usb_hw_ep_get_needs * * This function will figure out the type and number of endpoints * which are needed for an USB configuration. * * Return values: * 0: Success. * Else: Failure. *------------------------------------------------------------------------*/ static uint8_t usb_hw_ep_get_needs(struct usb_hw_ep_scratch *ues, uint8_t ep_type, uint8_t is_complete) { const struct usb_hw_ep_profile *pf; struct usb_hw_ep_scratch_sub *ep_iface; struct usb_hw_ep_scratch_sub *ep_curr; struct usb_hw_ep_scratch_sub *ep_max; struct usb_hw_ep_scratch_sub *ep_end; struct usb_descriptor *desc; struct usb_interface_descriptor *id; struct usb_endpoint_descriptor *ed; enum usb_dev_speed speed; uint16_t wMaxPacketSize; uint16_t temp; uint8_t ep_no; ep_iface = ues->ep_max; ep_curr = ues->ep_max; ep_end = ues->ep + USB_EP_MAX; ep_max = ues->ep_max; desc = NULL; speed = usbd_get_speed(ues->udev); repeat: while ((desc = usb_desc_foreach(ues->cd, desc))) { if ((desc->bDescriptorType == UDESC_INTERFACE) && (desc->bLength >= sizeof(*id))) { id = (void *)desc; if (id->bAlternateSetting == 0) { /* going forward */ ep_iface = ep_max; } else { /* reset */ ep_curr = ep_iface; } } if ((desc->bDescriptorType == UDESC_ENDPOINT) && (desc->bLength >= sizeof(*ed))) { ed = (void *)desc; goto handle_endpoint_desc; } } ues->ep_max = ep_max; return (0); handle_endpoint_desc: temp = (ed->bmAttributes & UE_XFERTYPE); if (temp == ep_type) { if (ep_curr == ep_end) { /* too many endpoints */ return (1); /* failure */ } wMaxPacketSize = UGETW(ed->wMaxPacketSize); if ((wMaxPacketSize & 0xF800) && (speed == USB_SPEED_HIGH)) { /* handle packet multiplier */ temp = (wMaxPacketSize >> 11) & 3; wMaxPacketSize &= 0x7FF; if (temp == 1) { wMaxPacketSize *= 2; } else { wMaxPacketSize *= 3; } } /* * Check if we have a fixed endpoint number, else the * endpoint number is allocated dynamically: */ ep_no = (ed->bEndpointAddress & UE_ADDR); if (ep_no != 0) { /* get HW endpoint profile */ (ues->methods->get_hw_ep_profile) (ues->udev, &pf, ep_no); if (pf == NULL) { /* HW profile does not exist - failure */ DPRINTFN(0, "Endpoint profile %u " "does not exist\n", ep_no); return (1); } /* reserve fixed endpoint number */ if (ep_type == UE_CONTROL) { ues->bmInAlloc[ep_no / 8] |= (1 << (ep_no % 8)); ues->bmOutAlloc[ep_no / 8] |= (1 << (ep_no % 8)); if ((pf->max_in_frame_size < wMaxPacketSize) || (pf->max_out_frame_size < wMaxPacketSize)) { DPRINTFN(0, "Endpoint profile %u " "has too small buffer\n", ep_no); return (1); } } else if (ed->bEndpointAddress & UE_DIR_IN) { ues->bmInAlloc[ep_no / 8] |= (1 << (ep_no % 8)); if (pf->max_in_frame_size < wMaxPacketSize) { DPRINTFN(0, "Endpoint profile %u " "has too small buffer\n", ep_no); return (1); } } else { ues->bmOutAlloc[ep_no / 8] |= (1 << (ep_no % 8)); if (pf->max_out_frame_size < wMaxPacketSize) { DPRINTFN(0, "Endpoint profile %u " "has too small buffer\n", ep_no); return (1); } } } else if (is_complete) { /* check if we have enough buffer space */ if (wMaxPacketSize > ep_curr->max_frame_size) { return (1); /* failure */ } if (ed->bEndpointAddress & UE_DIR_IN) { ed->bEndpointAddress = ep_curr->hw_endpoint_in; } else { ed->bEndpointAddress = ep_curr->hw_endpoint_out; } } else { /* compute the maximum frame size */ if (ep_curr->max_frame_size < wMaxPacketSize) { ep_curr->max_frame_size = wMaxPacketSize; } if (temp == UE_CONTROL) { ep_curr->needs_in = 1; ep_curr->needs_out = 1; } else { if (ed->bEndpointAddress & UE_DIR_IN) { ep_curr->needs_in = 1; } else { ep_curr->needs_out = 1; } } ep_curr->needs_ep_type = ep_type; } ep_curr++; if (ep_max < ep_curr) { ep_max = ep_curr; } } goto repeat; } /*------------------------------------------------------------------------* * usb_hw_ep_resolve * * This function will try to resolve endpoint requirements by the * given endpoint profiles that the USB hardware reports. * * Return values: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ static usb_error_t usb_hw_ep_resolve(struct usb_device *udev, struct usb_descriptor *desc) { struct usb_hw_ep_scratch *ues; struct usb_hw_ep_scratch_sub *ep; const struct usb_hw_ep_profile *pf; const struct usb_bus_methods *methods; struct usb_device_descriptor *dd; uint16_t mps; if (desc == NULL) return (USB_ERR_INVAL); /* get bus methods */ methods = udev->bus->methods; if (methods->get_hw_ep_profile == NULL) return (USB_ERR_INVAL); if (desc->bDescriptorType == UDESC_DEVICE) { if (desc->bLength < sizeof(*dd)) return (USB_ERR_INVAL); dd = (void *)desc; /* get HW control endpoint 0 profile */ (methods->get_hw_ep_profile) (udev, &pf, 0); if (pf == NULL) { return (USB_ERR_INVAL); } if (!usb_hw_ep_match(pf, UE_CONTROL, 0)) { DPRINTFN(0, "Endpoint 0 does not " "support control\n"); return (USB_ERR_INVAL); } mps = dd->bMaxPacketSize; if (udev->speed == USB_SPEED_FULL) { /* * We can optionally choose another packet size ! */ while (1) { /* check if "mps" is ok */ if (pf->max_in_frame_size >= mps) { break; } /* reduce maximum packet size */ mps /= 2; /* check if "mps" is too small */ if (mps < 8) { return (USB_ERR_INVAL); } } dd->bMaxPacketSize = mps; } else { /* We only have one choice */ if (mps == 255) { mps = 512; } /* Check if we support the specified wMaxPacketSize */ if (pf->max_in_frame_size < mps) { return (USB_ERR_INVAL); } } return (0); /* success */ } if (desc->bDescriptorType != UDESC_CONFIG) return (USB_ERR_INVAL); if (desc->bLength < sizeof(*(ues->cd))) return (USB_ERR_INVAL); ues = udev->scratch.hw_ep_scratch; memset(ues, 0, sizeof(*ues)); ues->ep_max = ues->ep; ues->cd = (void *)desc; ues->methods = methods; ues->udev = udev; /* Get all the endpoints we need */ if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) || usb_hw_ep_get_needs(ues, UE_INTERRUPT, 0) || usb_hw_ep_get_needs(ues, UE_CONTROL, 0) || usb_hw_ep_get_needs(ues, UE_BULK, 0)) { DPRINTFN(0, "Could not get needs\n"); return (USB_ERR_INVAL); } for (ep = ues->ep; ep != ues->ep_max; ep++) { while (ep->needs_in || ep->needs_out) { /* * First try to use a simplex endpoint. * Then try to use a duplex endpoint. */ if (usb_hw_ep_find_match(ues, ep, 1) && usb_hw_ep_find_match(ues, ep, 0)) { DPRINTFN(0, "Could not find match\n"); return (USB_ERR_INVAL); } } } ues->ep_max = ues->ep; /* Update all endpoint addresses */ if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) || usb_hw_ep_get_needs(ues, UE_INTERRUPT, 1) || usb_hw_ep_get_needs(ues, UE_CONTROL, 1) || usb_hw_ep_get_needs(ues, UE_BULK, 1)) { DPRINTFN(0, "Could not update endpoint address\n"); return (USB_ERR_INVAL); } return (0); /* success */ } /*------------------------------------------------------------------------* * usb_temp_get_tdd * * Returns: * NULL: No USB template device descriptor found. * Else: Pointer to the USB template device descriptor. *------------------------------------------------------------------------*/ static const struct usb_temp_device_desc * usb_temp_get_tdd(struct usb_device *udev) { if (udev->usb_template_ptr == NULL) { return (NULL); } return (udev->usb_template_ptr->tdd); } /*------------------------------------------------------------------------* * usb_temp_get_device_desc * * Returns: * NULL: No USB device descriptor found. * Else: Pointer to USB device descriptor. *------------------------------------------------------------------------*/ static void * usb_temp_get_device_desc(struct usb_device *udev) { struct usb_device_descriptor *dd; if (udev->usb_template_ptr == NULL) { return (NULL); } dd = &udev->usb_template_ptr->udd; if (dd->bDescriptorType != UDESC_DEVICE) { /* sanity check failed */ return (NULL); } return (dd); } /*------------------------------------------------------------------------* * usb_temp_get_qualifier_desc * * Returns: * NULL: No USB device_qualifier descriptor found. * Else: Pointer to USB device_qualifier descriptor. *------------------------------------------------------------------------*/ static void * usb_temp_get_qualifier_desc(struct usb_device *udev) { struct usb_device_qualifier *dq; if (udev->usb_template_ptr == NULL) { return (NULL); } dq = &udev->usb_template_ptr->udq; if (dq->bDescriptorType != UDESC_DEVICE_QUALIFIER) { /* sanity check failed */ return (NULL); } return (dq); } /*------------------------------------------------------------------------* * usb_temp_get_config_desc * * Returns: * NULL: No USB config descriptor found. * Else: Pointer to USB config descriptor having index "index". *------------------------------------------------------------------------*/ static void * usb_temp_get_config_desc(struct usb_device *udev, uint16_t *pLength, uint8_t index) { struct usb_device_descriptor *dd; struct usb_config_descriptor *cd; uint16_t temp; if (udev->usb_template_ptr == NULL) { return (NULL); } dd = &udev->usb_template_ptr->udd; cd = (void *)(udev->usb_template_ptr + 1); if (index >= dd->bNumConfigurations) { /* out of range */ return (NULL); } while (index--) { if (cd->bDescriptorType != UDESC_CONFIG) { /* sanity check failed */ return (NULL); } temp = UGETW(cd->wTotalLength); cd = USB_ADD_BYTES(cd, temp); } if (pLength) { *pLength = UGETW(cd->wTotalLength); } return (cd); } /*------------------------------------------------------------------------* * usb_temp_get_vendor_desc * * Returns: * NULL: No vendor descriptor found. * Else: Pointer to a vendor descriptor. *------------------------------------------------------------------------*/ static const void * usb_temp_get_vendor_desc(struct usb_device *udev, const struct usb_device_request *req, uint16_t *plen) { const struct usb_temp_device_desc *tdd; tdd = usb_temp_get_tdd(udev); if (tdd == NULL) { return (NULL); } if (tdd->getVendorDesc == NULL) { return (NULL); } return ((tdd->getVendorDesc) (req, plen)); } /*------------------------------------------------------------------------* * usb_temp_get_string_desc * * Returns: * NULL: No string descriptor found. * Else: Pointer to a string descriptor. *------------------------------------------------------------------------*/ static const void * usb_temp_get_string_desc(struct usb_device *udev, uint16_t lang_id, uint8_t string_index) { const struct usb_temp_device_desc *tdd; tdd = usb_temp_get_tdd(udev); if (tdd == NULL) { return (NULL); } if (tdd->getStringDesc == NULL) { return (NULL); } return ((tdd->getStringDesc) (lang_id, string_index)); } /*------------------------------------------------------------------------* * usb_temp_get_hub_desc * * Returns: * NULL: No USB HUB descriptor found. * Else: Pointer to a USB HUB descriptor. *------------------------------------------------------------------------*/ static const void * usb_temp_get_hub_desc(struct usb_device *udev) { return (NULL); /* needs to be implemented */ } /*------------------------------------------------------------------------* * usb_temp_get_desc * * This function is a demultiplexer for local USB device side control * endpoint requests. *------------------------------------------------------------------------*/ static usb_error_t usb_temp_get_desc(struct usb_device *udev, struct usb_device_request *req, const void **pPtr, uint16_t *pLength) { const uint8_t *buf; uint16_t len; buf = NULL; len = 0; switch (req->bmRequestType) { case UT_READ_DEVICE: switch (req->bRequest) { case UR_GET_DESCRIPTOR: goto tr_handle_get_descriptor; default: goto tr_stalled; } case UT_READ_CLASS_DEVICE: switch (req->bRequest) { case UR_GET_DESCRIPTOR: goto tr_handle_get_class_descriptor; default: goto tr_stalled; } default: goto tr_stalled; } tr_handle_get_descriptor: switch (req->wValue[1]) { case UDESC_DEVICE: if (req->wValue[0]) { goto tr_stalled; } buf = usb_temp_get_device_desc(udev); goto tr_valid; case UDESC_DEVICE_QUALIFIER: if (udev->speed != USB_SPEED_HIGH) { goto tr_stalled; } if (req->wValue[0]) { goto tr_stalled; } buf = usb_temp_get_qualifier_desc(udev); goto tr_valid; case UDESC_OTHER_SPEED_CONFIGURATION: if (udev->speed != USB_SPEED_HIGH) { goto tr_stalled; } case UDESC_CONFIG: buf = usb_temp_get_config_desc(udev, &len, req->wValue[0]); goto tr_valid; case UDESC_STRING: buf = usb_temp_get_string_desc(udev, UGETW(req->wIndex), req->wValue[0]); goto tr_valid; default: goto tr_stalled; } tr_handle_get_class_descriptor: if (req->wValue[0]) { goto tr_stalled; } buf = usb_temp_get_hub_desc(udev); goto tr_valid; tr_valid: if (buf == NULL) goto tr_stalled; if (len == 0) len = buf[0]; *pPtr = buf; *pLength = len; return (0); /* success */ tr_stalled: /* try to get a vendor specific descriptor */ len = 0; buf = usb_temp_get_vendor_desc(udev, req, &len); if (buf != NULL) goto tr_valid; *pPtr = NULL; *pLength = 0; return (0); /* we ignore failures */ } /*------------------------------------------------------------------------* * usb_temp_setup * * This function generates USB descriptors according to the given USB * template device descriptor. It will also try to figure out the best * matching endpoint addresses using the hardware endpoint profiles. * * Returns: * 0: Success * Else: Failure *------------------------------------------------------------------------*/ usb_error_t usb_temp_setup(struct usb_device *udev, const struct usb_temp_device_desc *tdd) { struct usb_temp_setup *uts; void *buf; usb_error_t error; uint8_t n; uint8_t do_unlock; /* be NULL safe */ if (tdd == NULL) return (0); /* Protect scratch area */ do_unlock = usbd_ctrl_lock(udev); uts = udev->scratch.temp_setup; memset(uts, 0, sizeof(*uts)); uts->usb_speed = udev->speed; uts->self_powered = udev->flags.self_powered; /* first pass */ usb_make_device_desc(uts, tdd); if (uts->err) { /* some error happened */ goto done; } /* sanity check */ if (uts->size == 0) { uts->err = USB_ERR_INVAL; goto done; } /* allocate zeroed memory */ uts->buf = usbd_alloc_config_desc(udev, uts->size); /* * Allow malloc() to return NULL regardless of M_WAITOK flag. * This helps when porting the software to non-FreeBSD * systems. */ if (uts->buf == NULL) { /* could not allocate memory */ uts->err = USB_ERR_NOMEM; goto done; } /* second pass */ uts->size = 0; usb_make_device_desc(uts, tdd); /* * Store a pointer to our descriptors: */ udev->usb_template_ptr = uts->buf; if (uts->err) { /* some error happened during second pass */ goto done; } /* * Resolve all endpoint addresses ! */ buf = usb_temp_get_device_desc(udev); uts->err = usb_hw_ep_resolve(udev, buf); if (uts->err) { DPRINTFN(0, "Could not resolve endpoints for " "Device Descriptor, error = %s\n", usbd_errstr(uts->err)); goto done; } for (n = 0;; n++) { buf = usb_temp_get_config_desc(udev, NULL, n); if (buf == NULL) { break; } uts->err = usb_hw_ep_resolve(udev, buf); if (uts->err) { DPRINTFN(0, "Could not resolve endpoints for " "Config Descriptor %u, error = %s\n", n, usbd_errstr(uts->err)); goto done; } } done: error = uts->err; if (error) usb_temp_unsetup(udev); if (do_unlock) usbd_ctrl_unlock(udev); return (error); } /*------------------------------------------------------------------------* * usb_temp_unsetup * * This function frees any memory associated with the currently * setup template, if any. *------------------------------------------------------------------------*/ void usb_temp_unsetup(struct usb_device *udev) { usbd_free_config_desc(udev, udev->usb_template_ptr); udev->usb_template_ptr = NULL; } static usb_error_t usb_temp_setup_by_index(struct usb_device *udev, uint16_t index) { usb_error_t err; switch (index) { case USB_TEMP_MSC: err = usb_temp_setup(udev, &usb_template_msc); break; case USB_TEMP_CDCE: err = usb_temp_setup(udev, &usb_template_cdce); break; case USB_TEMP_MTP: err = usb_temp_setup(udev, &usb_template_mtp); break; case USB_TEMP_MODEM: err = usb_temp_setup(udev, &usb_template_modem); break; case USB_TEMP_AUDIO: err = usb_temp_setup(udev, &usb_template_audio); break; case USB_TEMP_KBD: err = usb_temp_setup(udev, &usb_template_kbd); break; case USB_TEMP_MOUSE: err = usb_temp_setup(udev, &usb_template_mouse); break; case USB_TEMP_PHONE: err = usb_temp_setup(udev, &usb_template_phone); break; case USB_TEMP_SERIALNET: err = usb_temp_setup(udev, &usb_template_serialnet); break; case USB_TEMP_MIDI: err = usb_temp_setup(udev, &usb_template_midi); break; default: return (USB_ERR_INVAL); } return (err); } static void usb_temp_init(void *arg) { /* register our functions */ usb_temp_get_desc_p = &usb_temp_get_desc; usb_temp_setup_by_index_p = &usb_temp_setup_by_index; usb_temp_unsetup_p = &usb_temp_unsetup; } SYSINIT(usb_temp_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_temp_init, NULL); SYSUNINIT(usb_temp_unload, SI_SUB_LOCK, SI_ORDER_ANY, usb_temp_unload, NULL); Index: head/sys/dev/usb/template/usb_template.h =================================================================== --- head/sys/dev/usb/template/usb_template.h (revision 328193) +++ head/sys/dev/usb/template/usb_template.h (revision 328194) @@ -1,118 +1,124 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2007 Hans Petter Selasky * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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 templates are used to build up real USB descriptors */ #ifndef _USB_TEMPLATE_H_ #define _USB_TEMPLATE_H_ #ifndef USB_TEMPLATE_VENDOR #define USB_TEMPLATE_VENDOR 0x0001 #endif typedef const void *(usb_temp_get_string_desc_t)(uint16_t lang_id, uint8_t string_index); typedef const void *(usb_temp_get_vendor_desc_t)(const struct usb_device_request *req, uint16_t *plen); struct usb_temp_packet_size { uint16_t mps[USB_SPEED_MAX]; }; struct usb_temp_interval { uint8_t bInterval[USB_SPEED_MAX]; }; struct usb_temp_endpoint_desc { const void **ppRawDesc; const struct usb_temp_packet_size *pPacketSize; const struct usb_temp_interval *pIntervals; /* * If (bEndpointAddress & UE_ADDR) is non-zero the endpoint number * is pre-selected for this endpoint descriptor. Else an endpoint * number is automatically chosen. */ uint8_t bEndpointAddress; /* UE_DIR_IN or UE_DIR_OUT */ uint8_t bmAttributes; }; struct usb_temp_interface_desc { const void **ppRawDesc; const struct usb_temp_endpoint_desc **ppEndpoints; uint8_t bInterfaceClass; uint8_t bInterfaceSubClass; uint8_t bInterfaceProtocol; uint8_t iInterface; uint8_t isAltInterface; }; struct usb_temp_config_desc { const struct usb_temp_interface_desc **ppIfaceDesc; uint8_t bmAttributes; uint8_t bMaxPower; uint8_t iConfiguration; }; struct usb_temp_device_desc { usb_temp_get_string_desc_t *getStringDesc; usb_temp_get_vendor_desc_t *getVendorDesc; const struct usb_temp_config_desc **ppConfigDesc; uint16_t idVendor; uint16_t idProduct; uint16_t bcdDevice; uint8_t bDeviceClass; uint8_t bDeviceSubClass; uint8_t bDeviceProtocol; uint8_t iManufacturer; uint8_t iProduct; uint8_t iSerialNumber; }; struct usb_temp_data { const struct usb_temp_device_desc *tdd; struct usb_device_descriptor udd; /* device descriptor */ struct usb_device_qualifier udq; /* device qualifier */ }; /* prototypes */ -extern const struct usb_temp_device_desc usb_template_audio; -extern const struct usb_temp_device_desc usb_template_cdce; -extern const struct usb_temp_device_desc usb_template_kbd; -extern const struct usb_temp_device_desc usb_template_modem; -extern const struct usb_temp_device_desc usb_template_mouse; -extern const struct usb_temp_device_desc usb_template_msc; -extern const struct usb_temp_device_desc usb_template_mtp; -extern const struct usb_temp_device_desc usb_template_phone; -extern const struct usb_temp_device_desc usb_template_serialnet; -extern const struct usb_temp_device_desc usb_template_midi; +extern struct usb_temp_device_desc usb_template_audio; +extern struct usb_temp_device_desc usb_template_cdce; +extern struct usb_temp_device_desc usb_template_kbd; +extern struct usb_temp_device_desc usb_template_modem; +extern struct usb_temp_device_desc usb_template_mouse; +extern struct usb_temp_device_desc usb_template_msc; +extern struct usb_temp_device_desc usb_template_mtp; +extern struct usb_temp_device_desc usb_template_phone; +extern struct usb_temp_device_desc usb_template_serialnet; +extern struct usb_temp_device_desc usb_template_midi; + +void usb_decode_str_desc(struct usb_string_descriptor *sd, + char *buf, size_t buflen); usb_error_t usb_temp_setup(struct usb_device *, const struct usb_temp_device_desc *); -void usb_temp_unsetup(struct usb_device *); +void usb_temp_unsetup(struct usb_device *); +int usb_temp_sysctl(SYSCTL_HANDLER_ARGS); + +SYSCTL_DECL(_hw_usb_templates); #endif /* _USB_TEMPLATE_H_ */ Index: head/sys/dev/usb/template/usb_template_audio.c =================================================================== --- head/sys/dev/usb/template/usb_template_audio.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_audio.c (revision 328194) @@ -1,401 +1,456 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2010 Hans Petter Selasky. All rights reserved. + * Copyright (c) 2010 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation + * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB template for an USB Audio Device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - INDEX_AUDIO_LANG, - INDEX_AUDIO_MIXER, - INDEX_AUDIO_RECORD, - INDEX_AUDIO_PLAYBACK, - INDEX_AUDIO_PRODUCT, - INDEX_AUDIO_MAX, + AUDIO_LANG_INDEX, + AUDIO_MIXER_INDEX, + AUDIO_RECORD_INDEX, + AUDIO_PLAYBACK_INDEX, + AUDIO_PRODUCT_INDEX, + AUDIO_MAX_INDEX, }; -#define STRING_AUDIO_PRODUCT \ - "A\0u\0d\0i\0o\0 \0T\0e\0s\0t\0 \0D\0e\0v\0i\0c\0e" +#define AUDIO_DEFAULT_PRODUCT "Audio Test Device" +#define AUDIO_DEFAULT_MIXER "Mixer interface" +#define AUDIO_DEFAULT_RECORD "Record interface" +#define AUDIO_DEFAULT_PLAYBACK "Playback interface" -#define STRING_AUDIO_MIXER \ - "M\0i\0x\0e\0r\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct usb_string_descriptor audio_mixer; +static struct usb_string_descriptor audio_record; +static struct usb_string_descriptor audio_playback; +static struct usb_string_descriptor audio_product; -#define STRING_AUDIO_RECORD \ - "R\0e\0c\0o\0r\0d\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct sysctl_ctx_list audio_ctx_list; -#define STRING_AUDIO_PLAYBACK \ - "P\0l\0a\0y\0b\0a\0c\0k\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" - - -/* make the real string descriptors */ - -USB_MAKE_STRING_DESC(STRING_AUDIO_MIXER, string_audio_mixer); -USB_MAKE_STRING_DESC(STRING_AUDIO_RECORD, string_audio_record); -USB_MAKE_STRING_DESC(STRING_AUDIO_PLAYBACK, string_audio_playback); -USB_MAKE_STRING_DESC(STRING_AUDIO_PRODUCT, string_audio_product); - /* prototypes */ /* * Audio Mixer description structures * * Some of the audio descriptors were dumped * from a Creative Labs USB audio device. */ static const uint8_t audio_raw_desc_0[] = { 0x0a, 0x24, 0x01, 0x00, 0x01, 0xa9, 0x00, 0x02, 0x01, 0x02 }; static const uint8_t audio_raw_desc_1[] = { 0x0c, 0x24, 0x02, 0x01, 0x01, 0x01, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00 }; static const uint8_t audio_raw_desc_2[] = { 0x0c, 0x24, 0x02, 0x02, 0x01, 0x02, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00 }; static const uint8_t audio_raw_desc_3[] = { 0x0c, 0x24, 0x02, 0x03, 0x03, 0x06, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00 }; static const uint8_t audio_raw_desc_4[] = { 0x0c, 0x24, 0x02, 0x04, 0x05, 0x06, 0x00, 0x02, 0x03, 0x00, 0x00, 0x00 }; static const uint8_t audio_raw_desc_5[] = { 0x09, 0x24, 0x03, 0x05, 0x05, 0x06, 0x00, 0x01, 0x00 }; static const uint8_t audio_raw_desc_6[] = { 0x09, 0x24, 0x03, 0x06, 0x01, 0x03, 0x00, 0x09, 0x00 }; static const uint8_t audio_raw_desc_7[] = { 0x09, 0x24, 0x03, 0x07, 0x01, 0x01, 0x00, 0x08, 0x00 }; static const uint8_t audio_raw_desc_8[] = { 0x09, 0x24, 0x05, 0x08, 0x03, 0x0a, 0x0b, 0x0c, 0x00 }; static const uint8_t audio_raw_desc_9[] = { 0x0a, 0x24, 0x06, 0x09, 0x0f, 0x01, 0x01, 0x02, 0x02, 0x00 }; static const uint8_t audio_raw_desc_10[] = { 0x0a, 0x24, 0x06, 0x0a, 0x02, 0x01, 0x43, 0x00, 0x00, 0x00 }; static const uint8_t audio_raw_desc_11[] = { 0x0a, 0x24, 0x06, 0x0b, 0x03, 0x01, 0x01, 0x02, 0x02, 0x00 }; static const uint8_t audio_raw_desc_12[] = { 0x0a, 0x24, 0x06, 0x0c, 0x04, 0x01, 0x01, 0x00, 0x00, 0x00 }; static const uint8_t audio_raw_desc_13[] = { 0x0a, 0x24, 0x06, 0x0d, 0x02, 0x01, 0x03, 0x00, 0x00, 0x00 }; static const uint8_t audio_raw_desc_14[] = { 0x0a, 0x24, 0x06, 0x0e, 0x03, 0x01, 0x01, 0x02, 0x02, 0x00 }; static const uint8_t audio_raw_desc_15[] = { 0x0f, 0x24, 0x04, 0x0f, 0x03, 0x01, 0x0d, 0x0e, 0x02, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00 }; static const void *audio_raw_iface_0_desc[] = { audio_raw_desc_0, audio_raw_desc_1, audio_raw_desc_2, audio_raw_desc_3, audio_raw_desc_4, audio_raw_desc_5, audio_raw_desc_6, audio_raw_desc_7, audio_raw_desc_8, audio_raw_desc_9, audio_raw_desc_10, audio_raw_desc_11, audio_raw_desc_12, audio_raw_desc_13, audio_raw_desc_14, audio_raw_desc_15, NULL, }; static const struct usb_temp_interface_desc audio_iface_0 = { .ppEndpoints = NULL, /* no endpoints */ .ppRawDesc = audio_raw_iface_0_desc, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOCONTROL, .bInterfaceProtocol = 0, - .iInterface = INDEX_AUDIO_MIXER, + .iInterface = AUDIO_MIXER_INDEX, }; static const uint8_t audio_raw_desc_20[] = { 0x07, 0x24, 0x01, 0x01, 0x03, 0x01, 0x00 }; static const uint8_t audio_raw_desc_21[] = { 0x0b, 0x24, 0x02, 0x01, 0x02, 0x02, 0x10, 0x01, /* 48kHz */ 0x80, 0xbb, 0x00 }; static const uint8_t audio_raw_desc_22[] = { 0x07, 0x25, 0x01, 0x00, 0x01, 0x04, 0x00 }; static const void *audio_raw_iface_1_desc[] = { audio_raw_desc_20, audio_raw_desc_21, NULL, }; static const void *audio_raw_ep_1_desc[] = { audio_raw_desc_22, NULL, }; static const struct usb_temp_packet_size audio_isoc_mps = { .mps[USB_SPEED_FULL] = 0xC8, .mps[USB_SPEED_HIGH] = 0xC8, }; static const struct usb_temp_interval audio_isoc_interval = { .bInterval[USB_SPEED_FULL] = 1, /* 1:1 */ .bInterval[USB_SPEED_HIGH] = 4, /* 1:8 */ }; static const struct usb_temp_endpoint_desc audio_isoc_out_ep = { .ppRawDesc = audio_raw_ep_1_desc, .pPacketSize = &audio_isoc_mps, .pIntervals = &audio_isoc_interval, .bEndpointAddress = UE_DIR_OUT, .bmAttributes = UE_ISOCHRONOUS | UE_ISO_ADAPT, }; static const struct usb_temp_endpoint_desc *audio_iface_1_ep[] = { &audio_isoc_out_ep, NULL, }; static const struct usb_temp_interface_desc audio_iface_1_alt_0 = { .ppEndpoints = NULL, /* no endpoints */ .ppRawDesc = NULL, /* no raw descriptors */ .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_AUDIO_PLAYBACK, + .iInterface = AUDIO_PLAYBACK_INDEX, }; static const struct usb_temp_interface_desc audio_iface_1_alt_1 = { .ppEndpoints = audio_iface_1_ep, .ppRawDesc = audio_raw_iface_1_desc, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_AUDIO_PLAYBACK, + .iInterface = AUDIO_PLAYBACK_INDEX, .isAltInterface = 1, /* this is an alternate setting */ }; static const uint8_t audio_raw_desc_30[] = { 0x07, 0x24, 0x01, 0x07, 0x01, 0x01, 0x00 }; static const uint8_t audio_raw_desc_31[] = { 0x0b, 0x24, 0x02, 0x01, 0x02, 0x02, 0x10, 0x01, /* 48kHz */ 0x80, 0xbb, 0x00 }; static const uint8_t audio_raw_desc_32[] = { 0x07, 0x25, 0x01, 0x01, 0x00, 0x00, 0x00 }; static const void *audio_raw_iface_2_desc[] = { audio_raw_desc_30, audio_raw_desc_31, NULL, }; static const void *audio_raw_ep_2_desc[] = { audio_raw_desc_32, NULL, }; static const struct usb_temp_endpoint_desc audio_isoc_in_ep = { .ppRawDesc = audio_raw_ep_2_desc, .pPacketSize = &audio_isoc_mps, .pIntervals = &audio_isoc_interval, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_ISOCHRONOUS | UE_ISO_ADAPT, }; static const struct usb_temp_endpoint_desc *audio_iface_2_ep[] = { &audio_isoc_in_ep, NULL, }; static const struct usb_temp_interface_desc audio_iface_2_alt_0 = { .ppEndpoints = NULL, /* no endpoints */ .ppRawDesc = NULL, /* no raw descriptors */ .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_AUDIO_RECORD, + .iInterface = AUDIO_RECORD_INDEX, }; static const struct usb_temp_interface_desc audio_iface_2_alt_1 = { .ppEndpoints = audio_iface_2_ep, .ppRawDesc = audio_raw_iface_2_desc, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_AUDIO_RECORD, + .iInterface = AUDIO_RECORD_INDEX, .isAltInterface = 1, /* this is an alternate setting */ }; static const struct usb_temp_interface_desc *audio_interfaces[] = { &audio_iface_0, &audio_iface_1_alt_0, &audio_iface_1_alt_1, &audio_iface_2_alt_0, &audio_iface_2_alt_1, NULL, }; static const struct usb_temp_config_desc audio_config_desc = { .ppIfaceDesc = audio_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = INDEX_AUDIO_PRODUCT, + .iConfiguration = AUDIO_PRODUCT_INDEX, }; static const struct usb_temp_config_desc *audio_configs[] = { &audio_config_desc, NULL, }; static usb_temp_get_string_desc_t audio_get_string_desc; -const struct usb_temp_device_desc usb_template_audio = { +struct usb_temp_device_desc usb_template_audio = { .getStringDesc = &audio_get_string_desc, .ppConfigDesc = audio_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x000A, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_COMM, .bDeviceSubClass = 0, .bDeviceProtocol = 0, - .iManufacturer = 0, - .iProduct = INDEX_AUDIO_PRODUCT, - .iSerialNumber = 0, + .iProduct = AUDIO_PRODUCT_INDEX, }; /*------------------------------------------------------------------------* * audio_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * audio_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[INDEX_AUDIO_MAX] = { - [INDEX_AUDIO_LANG] = &usb_string_lang_en, - [INDEX_AUDIO_MIXER] = &string_audio_mixer, - [INDEX_AUDIO_RECORD] = &string_audio_record, - [INDEX_AUDIO_PLAYBACK] = &string_audio_playback, - [INDEX_AUDIO_PRODUCT] = &string_audio_product, + static const void *ptr[AUDIO_MAX_INDEX] = { + [AUDIO_LANG_INDEX] = &usb_string_lang_en, + [AUDIO_MIXER_INDEX] = &audio_mixer, + [AUDIO_RECORD_INDEX] = &audio_record, + [AUDIO_PLAYBACK_INDEX] = &audio_playback, + [AUDIO_PRODUCT_INDEX] = &audio_product, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < INDEX_AUDIO_MAX) { + if (string_index < AUDIO_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +audio_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&audio_mixer, sizeof(audio_mixer), + AUDIO_DEFAULT_MIXER); + usb_make_str_desc(&audio_record, sizeof(audio_record), + AUDIO_DEFAULT_RECORD); + usb_make_str_desc(&audio_playback, sizeof(audio_playback), + AUDIO_DEFAULT_PLAYBACK); + usb_make_str_desc(&audio_product, sizeof(audio_product), + AUDIO_DEFAULT_PRODUCT); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_AUDIO); + sysctl_ctx_init(&audio_ctx_list); + + parent = SYSCTL_ADD_NODE(&audio_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Audio Interface device side template"); + SYSCTL_ADD_U16(&audio_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, &usb_template_audio.idVendor, + 1, "Vendor identifier"); + SYSCTL_ADD_U16(&audio_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, &usb_template_audio.idProduct, + 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&audio_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "mixer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &audio_mixer, sizeof(audio_mixer), usb_temp_sysctl, + "A", "Mixer interface string"); + SYSCTL_ADD_PROC(&audio_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "record", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &audio_record, sizeof(audio_record), usb_temp_sysctl, + "A", "Record interface string"); + SYSCTL_ADD_PROC(&audio_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "playback", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &audio_playback, sizeof(audio_playback), usb_temp_sysctl, + "A", "Playback interface string"); +#endif + SYSCTL_ADD_PROC(&audio_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &audio_product, sizeof(audio_product), usb_temp_sysctl, + "A", "Product string"); +} + +static void +audio_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&audio_ctx_list); +} + +SYSINIT(audio_init, SI_SUB_LOCK, SI_ORDER_FIRST, audio_init, NULL); +SYSUNINIT(audio_init, SI_SUB_LOCK, SI_ORDER_FIRST, audio_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_cdce.c =================================================================== --- head/sys/dev/usb/template/usb_template_cdce.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_cdce.c (revision 328194) @@ -1,284 +1,351 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2007 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB templates for a CDC USB ethernet device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - STRING_LANG_INDEX, - STRING_MAC_INDEX, - STRING_ETH_CONTROL_INDEX, - STRING_ETH_DATA_INDEX, - STRING_ETH_CONFIG_INDEX, - STRING_ETH_VENDOR_INDEX, - STRING_ETH_PRODUCT_INDEX, - STRING_ETH_SERIAL_INDEX, - STRING_ETH_MAX, + ETH_LANG_INDEX, + ETH_MAC_INDEX, + ETH_CONTROL_INDEX, + ETH_DATA_INDEX, + ETH_CONFIGURATION_INDEX, + ETH_MANUFACTURER_INDEX, + ETH_PRODUCT_INDEX, + ETH_SERIAL_NUMBER_INDEX, + ETH_MAX_INDEX, }; -#define STRING_MAC \ - "2\0A\0002\0003\0004\0005\0006\0007\08\09\0A\0B" +#define ETH_DEFAULT_MAC "2A02030405060789AB" +#define ETH_DEFAULT_CONTROL "USB Ethernet Comm Interface" +#define ETH_DEFAULT_DATA "USB Ethernet Data Interface" +#define ETH_DEFAULT_CONFIG "Default Config" +#define ETH_DEFAULT_MANUFACTURER "FreeBSD foundation" +#define ETH_DEFAULT_PRODUCT "USB Ethernet Adapter" +#define ETH_DEFAULT_SERIAL_NUMBER "December 2007" -#define STRING_ETH_CONTROL \ - "U\0S\0B\0 \0E\0t\0h\0e\0r\0n\0e\0t\0 " \ - "\0C\0o\0m\0m\0 \0I\0n\0t\0e\0r\0f\0a\0c\0e" +static struct usb_string_descriptor eth_mac; +static struct usb_string_descriptor eth_control; +static struct usb_string_descriptor eth_data; +static struct usb_string_descriptor eth_configuration; +static struct usb_string_descriptor eth_manufacturer; +static struct usb_string_descriptor eth_product; +static struct usb_string_descriptor eth_serial_number; -#define STRING_ETH_DATA \ - "U\0S\0B\0 \0E\0t\0h\0e\0r\0n\0e\0t\0 \0D\0a\0t\0a\0 " \ - "\0I\0n\0t\0e\0r\0f\0a\0c\0e" +static struct sysctl_ctx_list eth_ctx_list; -#define STRING_ETH_CONFIG \ - "D\0e\0f\0a\0u\0l\0t\0 \0c\0o\0n\0f\0i\0g" - -#define STRING_ETH_VENDOR \ - "F\0r\0e\0e\0B\0S\0D\0 \0f\0o\0u\0n\0d\0a\0t\0i\0o\0n" - -#define STRING_ETH_PRODUCT \ - "U\0S\0B\0 \0E\0t\0h\0e\0r\0n\0e\0t\0 \0A\0d\0a\0p\0t\0e\0r" - -#define STRING_ETH_SERIAL \ - "D\0e\0c\0e\0m\0b\0e\0r\0 \0002\0000\0000\0007" - -/* make the real string descriptors */ - -USB_MAKE_STRING_DESC(STRING_MAC, string_mac); -USB_MAKE_STRING_DESC(STRING_ETH_CONTROL, string_eth_control); -USB_MAKE_STRING_DESC(STRING_ETH_DATA, string_eth_data); -USB_MAKE_STRING_DESC(STRING_ETH_CONFIG, string_eth_config); -USB_MAKE_STRING_DESC(STRING_ETH_VENDOR, string_eth_vendor); -USB_MAKE_STRING_DESC(STRING_ETH_PRODUCT, string_eth_product); -USB_MAKE_STRING_DESC(STRING_ETH_SERIAL, string_eth_serial); - /* prototypes */ static usb_temp_get_string_desc_t eth_get_string_desc; static const struct usb_cdc_union_descriptor eth_union_desc = { .bLength = sizeof(eth_union_desc), .bDescriptorType = UDESC_CS_INTERFACE, .bDescriptorSubtype = UDESCSUB_CDC_UNION, .bMasterInterface = 0, /* this is automatically updated */ .bSlaveInterface[0] = 1, /* this is automatically updated */ }; static const struct usb_cdc_header_descriptor eth_header_desc = { .bLength = sizeof(eth_header_desc), .bDescriptorType = UDESC_CS_INTERFACE, .bDescriptorSubtype = UDESCSUB_CDC_HEADER, .bcdCDC[0] = 0x10, .bcdCDC[1] = 0x01, }; static const struct usb_cdc_ethernet_descriptor eth_enf_desc = { .bLength = sizeof(eth_enf_desc), .bDescriptorType = UDESC_CS_INTERFACE, .bDescriptorSubtype = UDESCSUB_CDC_ENF, - .iMacAddress = STRING_MAC_INDEX, + .iMacAddress = ETH_MAC_INDEX, .bmEthernetStatistics = {0, 0, 0, 0}, .wMaxSegmentSize = {0xEA, 0x05},/* 1514 bytes */ .wNumberMCFilters = {0, 0}, .bNumberPowerFilters = 0, }; static const void *eth_control_if_desc[] = { ð_union_desc, ð_header_desc, ð_enf_desc, NULL, }; static const struct usb_temp_packet_size bulk_mps = { .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 512, }; static const struct usb_temp_packet_size intr_mps = { .mps[USB_SPEED_FULL] = 8, .mps[USB_SPEED_HIGH] = 8, }; static const struct usb_temp_endpoint_desc bulk_in_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_IN_EP_0 .bEndpointAddress = USB_HIP_IN_EP_0, #else .bEndpointAddress = UE_DIR_IN, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc bulk_out_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_OUT_EP_0 .bEndpointAddress = USB_HIP_OUT_EP_0, #else .bEndpointAddress = UE_DIR_OUT, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc intr_in_ep = { .pPacketSize = &intr_mps, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc *eth_intr_endpoints[] = { &intr_in_ep, NULL, }; static const struct usb_temp_interface_desc eth_control_interface = { .ppEndpoints = eth_intr_endpoints, .ppRawDesc = eth_control_if_desc, .bInterfaceClass = UICLASS_CDC, .bInterfaceSubClass = UISUBCLASS_ETHERNET_NETWORKING_CONTROL_MODEL, .bInterfaceProtocol = 0, - .iInterface = STRING_ETH_CONTROL_INDEX, + .iInterface = ETH_CONTROL_INDEX, }; static const struct usb_temp_endpoint_desc *eth_data_endpoints[] = { &bulk_in_ep, &bulk_out_ep, NULL, }; static const struct usb_temp_interface_desc eth_data_null_interface = { .ppEndpoints = NULL, /* no endpoints */ .bInterfaceClass = UICLASS_CDC_DATA, .bInterfaceSubClass = 0, .bInterfaceProtocol = 0, - .iInterface = STRING_ETH_DATA_INDEX, + .iInterface = ETH_DATA_INDEX, }; static const struct usb_temp_interface_desc eth_data_interface = { .ppEndpoints = eth_data_endpoints, .bInterfaceClass = UICLASS_CDC_DATA, .bInterfaceSubClass = UISUBCLASS_DATA, .bInterfaceProtocol = 0, - .iInterface = STRING_ETH_DATA_INDEX, + .iInterface = ETH_DATA_INDEX, .isAltInterface = 1, /* this is an alternate setting */ }; static const struct usb_temp_interface_desc *eth_interfaces[] = { ð_control_interface, ð_data_null_interface, ð_data_interface, NULL, }; static const struct usb_temp_config_desc eth_config_desc = { .ppIfaceDesc = eth_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = STRING_ETH_CONFIG_INDEX, + .iConfiguration = ETH_CONFIGURATION_INDEX, }; static const struct usb_temp_config_desc *eth_configs[] = { ð_config_desc, NULL, }; -const struct usb_temp_device_desc usb_template_cdce = { +struct usb_temp_device_desc usb_template_cdce = { .getStringDesc = ð_get_string_desc, .ppConfigDesc = eth_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x0001, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_COMM, .bDeviceSubClass = 0, .bDeviceProtocol = 0, - .iManufacturer = STRING_ETH_VENDOR_INDEX, - .iProduct = STRING_ETH_PRODUCT_INDEX, - .iSerialNumber = STRING_ETH_SERIAL_INDEX, + .iManufacturer = ETH_MANUFACTURER_INDEX, + .iProduct = ETH_PRODUCT_INDEX, + .iSerialNumber = ETH_SERIAL_NUMBER_INDEX, }; /*------------------------------------------------------------------------* * eth_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * eth_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[STRING_ETH_MAX] = { - [STRING_LANG_INDEX] = &usb_string_lang_en, - [STRING_MAC_INDEX] = &string_mac, - [STRING_ETH_CONTROL_INDEX] = &string_eth_control, - [STRING_ETH_DATA_INDEX] = &string_eth_data, - [STRING_ETH_CONFIG_INDEX] = &string_eth_config, - [STRING_ETH_VENDOR_INDEX] = &string_eth_vendor, - [STRING_ETH_PRODUCT_INDEX] = &string_eth_product, - [STRING_ETH_SERIAL_INDEX] = &string_eth_serial, + static const void *ptr[ETH_MAX_INDEX] = { + [ETH_LANG_INDEX] = &usb_string_lang_en, + [ETH_MAC_INDEX] = ð_mac, + [ETH_CONTROL_INDEX] = ð_control, + [ETH_DATA_INDEX] = ð_data, + [ETH_CONFIGURATION_INDEX] = ð_configuration, + [ETH_MANUFACTURER_INDEX] = ð_manufacturer, + [ETH_PRODUCT_INDEX] = ð_product, + [ETH_SERIAL_NUMBER_INDEX] = ð_serial_number, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < STRING_ETH_MAX) { + if (string_index < ETH_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +eth_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(ð_mac, sizeof(eth_mac), + ETH_DEFAULT_MAC); + usb_make_str_desc(ð_control, sizeof(eth_control), + ETH_DEFAULT_CONTROL); + usb_make_str_desc(ð_data, sizeof(eth_data), + ETH_DEFAULT_DATA); + usb_make_str_desc(ð_configuration, sizeof(eth_configuration), + ETH_DEFAULT_CONFIG); + usb_make_str_desc(ð_manufacturer, sizeof(eth_manufacturer), + ETH_DEFAULT_MANUFACTURER); + usb_make_str_desc(ð_product, sizeof(eth_product), + ETH_DEFAULT_PRODUCT); + usb_make_str_desc(ð_serial_number, sizeof(eth_serial_number), + ETH_DEFAULT_SERIAL_NUMBER); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_CDCE); + sysctl_ctx_init(ð_ctx_list); + + parent = SYSCTL_ADD_NODE(ð_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB CDC Ethernet device side template"); + SYSCTL_ADD_U16(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_cdce.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_cdce.idProduct, 1, "Product identifier"); + SYSCTL_ADD_PROC(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "mac", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + ð_mac, sizeof(eth_mac), usb_temp_sysctl, + "A", "MAC address string"); +#if 0 + SYSCTL_ADD_PROC(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "control", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + ð_control, sizeof(eth_control), usb_temp_sysctl, + "A", "Control interface string"); + SYSCTL_ADD_PROC(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "data", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + ð_data, sizeof(eth_data), usb_temp_sysctl, + "A", "Data interface string"); + SYSCTL_ADD_PROC(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "configuration", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + ð_configuration, sizeof(eth_configuration), usb_temp_sysctl, + "A", "Configuration string"); +#endif + SYSCTL_ADD_PROC(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "manufacturer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + ð_manufacturer, sizeof(eth_manufacturer), usb_temp_sysctl, + "A", "Manufacturer string"); + SYSCTL_ADD_PROC(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + ð_product, sizeof(eth_product), usb_temp_sysctl, + "A", "Product string"); + SYSCTL_ADD_PROC(ð_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "serial_number", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + ð_serial_number, sizeof(eth_serial_number), usb_temp_sysctl, + "A", "Serial number string"); +} + +static void +eth_uninit(void *arg __unused) +{ + + sysctl_ctx_free(ð_ctx_list); +} + +SYSINIT(eth_init, SI_SUB_LOCK, SI_ORDER_FIRST, eth_init, NULL); +SYSUNINIT(eth_init, SI_SUB_LOCK, SI_ORDER_FIRST, eth_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_kbd.c =================================================================== --- head/sys/dev/usb/template/usb_template_kbd.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_kbd.c (revision 328194) @@ -1,222 +1,272 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2010 Hans Petter Selasky. All rights reserved. + * Copyright (c) 2010 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation + * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB template for an USB Keyboard Device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - INDEX_LANG, - INDEX_KEYBOARD, - INDEX_PRODUCT, - INDEX_MAX, + KBD_LANG_INDEX, + KBD_INTERFACE_INDEX, + KBD_PRODUCT_INDEX, + KBD_MAX_INDEX, }; -#define STRING_PRODUCT \ - "K\0e\0y\0b\0o\0a\0r\0d\0 \0T\0e\0s\0t\0 \0D\0e\0v\0i\0c\0e" +#define KBD_DEFAULT_INTERFACE "Keyboard Interface" +#define KBD_DEFAULT_PRODUCT "Keyboard Test Device" -#define STRING_KEYBOARD \ - "K\0e\0y\0b\0o\0a\0r\0d\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct usb_string_descriptor kbd_interface; +static struct usb_string_descriptor kbd_product; -/* make the real string descriptors */ +static struct sysctl_ctx_list kbd_ctx_list; -USB_MAKE_STRING_DESC(STRING_KEYBOARD, string_keyboard); -USB_MAKE_STRING_DESC(STRING_PRODUCT, string_product); - /* prototypes */ static const struct usb_temp_packet_size keyboard_intr_mps = { .mps[USB_SPEED_LOW] = 16, .mps[USB_SPEED_FULL] = 16, .mps[USB_SPEED_HIGH] = 16, }; static const struct usb_temp_interval keyboard_intr_interval = { .bInterval[USB_SPEED_LOW] = 2, /* 2 ms */ .bInterval[USB_SPEED_FULL] = 2, /* 2 ms */ .bInterval[USB_SPEED_HIGH] = 5, /* 2 ms */ }; /* The following HID descriptor was dumped from a HP keyboard. */ static uint8_t keyboard_hid_descriptor[] = { 0x05, 0x01, 0x09, 0x06, 0xa1, 0x01, 0x05, 0x07, 0x19, 0xe0, 0x29, 0xe7, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x08, 0x81, 0x02, 0x95, 0x01, 0x75, 0x08, 0x81, 0x01, 0x95, 0x03, 0x75, 0x01, 0x05, 0x08, 0x19, 0x01, 0x29, 0x03, 0x91, 0x02, 0x95, 0x05, 0x75, 0x01, 0x91, 0x01, 0x95, 0x06, 0x75, 0x08, 0x15, 0x00, 0x26, 0xff, 0x00, 0x05, 0x07, 0x19, 0x00, 0x2a, 0xff, 0x00, 0x81, 0x00, 0xc0 }; static const struct usb_temp_endpoint_desc keyboard_ep_0 = { .ppRawDesc = NULL, /* no raw descriptors */ .pPacketSize = &keyboard_intr_mps, .pIntervals = &keyboard_intr_interval, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc *keyboard_endpoints[] = { &keyboard_ep_0, NULL, }; static const uint8_t keyboard_raw_desc[] = { 0x09, 0x21, 0x10, 0x01, 0x00, 0x01, 0x22, sizeof(keyboard_hid_descriptor), 0x00 }; static const void *keyboard_iface_0_desc[] = { keyboard_raw_desc, NULL, }; static const struct usb_temp_interface_desc keyboard_iface_0 = { .ppRawDesc = keyboard_iface_0_desc, .ppEndpoints = keyboard_endpoints, .bInterfaceClass = UICLASS_HID, .bInterfaceSubClass = UISUBCLASS_BOOT, .bInterfaceProtocol = UIPROTO_BOOT_KEYBOARD, - .iInterface = INDEX_KEYBOARD, + .iInterface = KBD_INTERFACE_INDEX, }; static const struct usb_temp_interface_desc *keyboard_interfaces[] = { &keyboard_iface_0, NULL, }; static const struct usb_temp_config_desc keyboard_config_desc = { .ppIfaceDesc = keyboard_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = INDEX_PRODUCT, + .iConfiguration = KBD_PRODUCT_INDEX, }; static const struct usb_temp_config_desc *keyboard_configs[] = { &keyboard_config_desc, NULL, }; static usb_temp_get_string_desc_t keyboard_get_string_desc; static usb_temp_get_vendor_desc_t keyboard_get_vendor_desc; -const struct usb_temp_device_desc usb_template_kbd = { +struct usb_temp_device_desc usb_template_kbd = { .getStringDesc = &keyboard_get_string_desc, .getVendorDesc = &keyboard_get_vendor_desc, .ppConfigDesc = keyboard_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x00CB, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_COMM, .bDeviceSubClass = 0, .bDeviceProtocol = 0, .iManufacturer = 0, - .iProduct = INDEX_PRODUCT, + .iProduct = KBD_PRODUCT_INDEX, .iSerialNumber = 0, }; /*------------------------------------------------------------------------* * keyboard_get_vendor_desc * * Return values: * NULL: Failure. No such vendor descriptor. * Else: Success. Pointer to vendor descriptor is returned. *------------------------------------------------------------------------*/ static const void * keyboard_get_vendor_desc(const struct usb_device_request *req, uint16_t *plen) { if ((req->bmRequestType == 0x81) && (req->bRequest == 0x06) && (req->wValue[0] == 0x00) && (req->wValue[1] == 0x22) && (req->wIndex[1] == 0) && (req->wIndex[0] == 0)) { *plen = sizeof(keyboard_hid_descriptor); return (keyboard_hid_descriptor); } return (NULL); } /*------------------------------------------------------------------------* * keyboard_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * keyboard_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[INDEX_MAX] = { - [INDEX_LANG] = &usb_string_lang_en, - [INDEX_KEYBOARD] = &string_keyboard, - [INDEX_PRODUCT] = &string_product, + static const void *ptr[KBD_MAX_INDEX] = { + [KBD_LANG_INDEX] = &usb_string_lang_en, + [KBD_INTERFACE_INDEX] = &kbd_interface, + [KBD_PRODUCT_INDEX] = &kbd_product, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < INDEX_MAX) { + if (string_index < KBD_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +kbd_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&kbd_interface, sizeof(kbd_interface), + KBD_DEFAULT_INTERFACE); + usb_make_str_desc(&kbd_product, sizeof(kbd_product), + KBD_DEFAULT_PRODUCT); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_KBD); + sysctl_ctx_init(&kbd_ctx_list); + + parent = SYSCTL_ADD_NODE(&kbd_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Keyboard device side template"); + SYSCTL_ADD_U16(&kbd_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_kbd.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&kbd_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_kbd.idProduct, 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&kbd_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "interface", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &kbd_interface, sizeof(kbd_interface), usb_temp_sysctl, + "A", "Interface string"); +#endif + SYSCTL_ADD_PROC(&kbd_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &kbd_product, sizeof(kbd_product), usb_temp_sysctl, + "A", "Product string"); +} + +static void +kbd_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&kbd_ctx_list); +} + +SYSINIT(kbd_init, SI_SUB_LOCK, SI_ORDER_FIRST, kbd_init, NULL); +SYSUNINIT(kbd_init, SI_SUB_LOCK, SI_ORDER_FIRST, kbd_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_midi.c =================================================================== --- head/sys/dev/usb/template/usb_template_midi.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_midi.c (revision 328194) @@ -1,240 +1,290 @@ /* $FreeBSD$ */ /*- - * Copyright (c) 2015 Hans Petter Selasky. All rights reserved. + * Copyright (c) 2015 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation + * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB template for an USB MIDI Device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - INDEX_MIDI_LANG, - INDEX_MIDI_IF, - INDEX_MIDI_PRODUCT, - INDEX_MIDI_MAX, + MIDI_LANG_INDEX, + MIDI_INTERFACE_INDEX, + MIDI_PRODUCT_INDEX, + MIDI_MAX_INDEX, }; -#define STRING_MIDI_PRODUCT \ - "M\0I\0D\0I\0 \0T\0e\0s\0t\0 \0D\0e\0v\0i\0c\0e" +#define MIDI_DEFAULT_INTERFACE "MIDI interface" +#define MIDI_DEFAULT_PRODUCT "MIDI Test Device" -#define STRING_MIDI_IF \ - "M\0I\0D\0I\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct usb_string_descriptor midi_interface; +static struct usb_string_descriptor midi_product; -/* make the real string descriptors */ +static struct sysctl_ctx_list midi_ctx_list; -USB_MAKE_STRING_DESC(STRING_MIDI_IF, string_midi_if); -USB_MAKE_STRING_DESC(STRING_MIDI_PRODUCT, string_midi_product); - /* prototypes */ static const uint8_t midi_desc_raw_0[9] = { 0x09, 0x24, 0x01, 0x00, 0x01, 0x09, 0x00, 0x01, 0x01 }; static const void *midi_descs_0[] = { &midi_desc_raw_0, NULL }; static const struct usb_temp_interface_desc midi_iface_0 = { .ppEndpoints = NULL, /* no endpoints */ .ppRawDesc = midi_descs_0, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOCONTROL, .bInterfaceProtocol = 0, - .iInterface = INDEX_MIDI_IF, + .iInterface = MIDI_INTERFACE_INDEX, }; static const struct usb_temp_packet_size midi_mps = { .mps[USB_SPEED_LOW] = 8, .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 512, }; static const uint8_t midi_desc_raw_7[5] = { 0x05, 0x25, 0x01, 0x01, 0x01 }; static const void *midi_descs_2[] = { &midi_desc_raw_7, NULL }; static const struct usb_temp_endpoint_desc midi_bulk_out_ep = { .ppRawDesc = midi_descs_2, .pPacketSize = &midi_mps, .bEndpointAddress = UE_DIR_OUT, .bmAttributes = UE_BULK, }; static const uint8_t midi_desc_raw_6[5] = { 0x05, 0x25, 0x01, 0x01, 0x03, }; static const void *midi_descs_3[] = { &midi_desc_raw_6, NULL }; static const struct usb_temp_endpoint_desc midi_bulk_in_ep = { .ppRawDesc = midi_descs_3, .pPacketSize = &midi_mps, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc *midi_iface_1_ep[] = { &midi_bulk_out_ep, &midi_bulk_in_ep, NULL, }; static const uint8_t midi_desc_raw_1[7] = { 0x07, 0x24, 0x01, 0x00, 0x01, /* wTotalLength: */ 0x41, 0x00 }; static const uint8_t midi_desc_raw_2[6] = { 0x06, 0x24, 0x02, 0x01, 0x01, 0x00 }; static const uint8_t midi_desc_raw_3[6] = { 0x06, 0x24, 0x02, 0x02, 0x02, 0x00 }; static const uint8_t midi_desc_raw_4[9] = { 0x09, 0x24, 0x03, 0x01, 0x03, 0x01, 0x02, 0x01, 0x00 }; static const uint8_t midi_desc_raw_5[9] = { 0x09, 0x24, 0x03, 0x02, 0x04, 0x01, 0x01, 0x01, 0x00 }; static const void *midi_descs_1[] = { &midi_desc_raw_1, &midi_desc_raw_2, &midi_desc_raw_3, &midi_desc_raw_4, &midi_desc_raw_5, NULL }; static const struct usb_temp_interface_desc midi_iface_1 = { .ppRawDesc = midi_descs_1, .ppEndpoints = midi_iface_1_ep, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_MIDISTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_MIDI_IF, + .iInterface = MIDI_INTERFACE_INDEX, }; static const struct usb_temp_interface_desc *midi_interfaces[] = { &midi_iface_0, &midi_iface_1, NULL, }; static const struct usb_temp_config_desc midi_config_desc = { .ppIfaceDesc = midi_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = INDEX_MIDI_PRODUCT, + .iConfiguration = MIDI_PRODUCT_INDEX, }; static const struct usb_temp_config_desc *midi_configs[] = { &midi_config_desc, NULL, }; static usb_temp_get_string_desc_t midi_get_string_desc; -const struct usb_temp_device_desc usb_template_midi = { +struct usb_temp_device_desc usb_template_midi = { .getStringDesc = &midi_get_string_desc, .ppConfigDesc = midi_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x00BB, .bcdDevice = 0x0100, .bDeviceClass = 0, .bDeviceSubClass = 0, .bDeviceProtocol = 0, .iManufacturer = 0, - .iProduct = INDEX_MIDI_PRODUCT, + .iProduct = MIDI_PRODUCT_INDEX, .iSerialNumber = 0, }; /*------------------------------------------------------------------------* * midi_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * midi_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[INDEX_MIDI_MAX] = { - [INDEX_MIDI_LANG] = &usb_string_lang_en, - [INDEX_MIDI_IF] = &string_midi_if, - [INDEX_MIDI_PRODUCT] = &string_midi_product, + static const void *ptr[MIDI_MAX_INDEX] = { + [MIDI_LANG_INDEX] = &usb_string_lang_en, + [MIDI_INTERFACE_INDEX] = &midi_interface, + [MIDI_PRODUCT_INDEX] = &midi_product, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < INDEX_MIDI_MAX) { + if (string_index < MIDI_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +midi_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&midi_interface, sizeof(midi_interface), + MIDI_DEFAULT_INTERFACE); + usb_make_str_desc(&midi_product, sizeof(midi_product), + MIDI_DEFAULT_PRODUCT); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_MIDI); + sysctl_ctx_init(&midi_ctx_list); + + parent = SYSCTL_ADD_NODE(&midi_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB MIDI device side template"); + SYSCTL_ADD_U16(&midi_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_midi.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&midi_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_midi.idProduct, 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&midi_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "interface", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &midi_interface, sizeof(midi_interface), usb_temp_sysctl, + "A", "Interface string"); +#endif + SYSCTL_ADD_PROC(&midi_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &midi_product, sizeof(midi_product), usb_temp_sysctl, + "A", "Product string"); +} + +static void +midi_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&midi_ctx_list); +} + +SYSINIT(midi_init, SI_SUB_LOCK, SI_ORDER_FIRST, midi_init, NULL); +SYSUNINIT(midi_init, SI_SUB_LOCK, SI_ORDER_FIRST, midi_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_modem.c =================================================================== --- head/sys/dev/usb/template/usb_template_modem.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_modem.c (revision 328194) @@ -1,250 +1,300 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2010 Hans Petter Selasky. All rights reserved. + * Copyright (c) 2010 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation + * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB template for an USB Modem Device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - INDEX_LANG, - INDEX_MODEM, - INDEX_PRODUCT, - INDEX_MAX, + MODEM_LANG_INDEX, + MODEM_INTERFACE_INDEX, + MODEM_PRODUCT_INDEX, + MODEM_MAX_INDEX, }; -#define STRING_PRODUCT \ - "M\0o\0d\0e\0m\0 \0T\0e\0s\0t\0 \0D\0e\0v\0i\0c\0e" +#define MODEM_DEFAULT_INTERFACE "Modem interface" +#define MODEM_DEFAULT_PRODUCT "Modem Test Device" -#define STRING_MODEM \ - "M\0o\0d\0e\0m\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct usb_string_descriptor modem_interface; +static struct usb_string_descriptor modem_product; -/* make the real string descriptors */ +static struct sysctl_ctx_list modem_ctx_list; -USB_MAKE_STRING_DESC(STRING_MODEM, string_modem); -USB_MAKE_STRING_DESC(STRING_PRODUCT, string_product); - #define MODEM_IFACE_0 0 #define MODEM_IFACE_1 1 /* prototypes */ static const struct usb_temp_packet_size modem_bulk_mps = { .mps[USB_SPEED_LOW] = 8, .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 512, }; static const struct usb_temp_packet_size modem_intr_mps = { .mps[USB_SPEED_LOW] = 8, .mps[USB_SPEED_FULL] = 8, .mps[USB_SPEED_HIGH] = 8, }; static const struct usb_temp_interval modem_intr_interval = { .bInterval[USB_SPEED_LOW] = 8, /* 8ms */ .bInterval[USB_SPEED_FULL] = 8, /* 8ms */ .bInterval[USB_SPEED_HIGH] = 7, /* 8ms */ }; static const struct usb_temp_endpoint_desc modem_ep_0 = { .pPacketSize = &modem_intr_mps, .pIntervals = &modem_intr_interval, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc modem_ep_1 = { .pPacketSize = &modem_bulk_mps, .bEndpointAddress = UE_DIR_OUT, .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc modem_ep_2 = { .pPacketSize = &modem_bulk_mps, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc *modem_iface_0_ep[] = { &modem_ep_0, NULL, }; static const struct usb_temp_endpoint_desc *modem_iface_1_ep[] = { &modem_ep_1, &modem_ep_2, NULL, }; static const uint8_t modem_raw_desc_0[] = { 0x05, 0x24, 0x00, 0x10, 0x01 }; static const uint8_t modem_raw_desc_1[] = { 0x05, 0x24, 0x06, MODEM_IFACE_0, MODEM_IFACE_1 }; static const uint8_t modem_raw_desc_2[] = { 0x05, 0x24, 0x01, 0x03, MODEM_IFACE_1 }; static const uint8_t modem_raw_desc_3[] = { 0x04, 0x24, 0x02, 0x07 }; static const void *modem_iface_0_desc[] = { &modem_raw_desc_0, &modem_raw_desc_1, &modem_raw_desc_2, &modem_raw_desc_3, NULL, }; static const struct usb_temp_interface_desc modem_iface_0 = { .ppRawDesc = modem_iface_0_desc, .ppEndpoints = modem_iface_0_ep, .bInterfaceClass = UICLASS_CDC, .bInterfaceSubClass = UISUBCLASS_ABSTRACT_CONTROL_MODEL, .bInterfaceProtocol = UIPROTO_CDC_AT, - .iInterface = INDEX_MODEM, + .iInterface = MODEM_INTERFACE_INDEX, }; static const struct usb_temp_interface_desc modem_iface_1 = { .ppEndpoints = modem_iface_1_ep, .bInterfaceClass = UICLASS_CDC_DATA, .bInterfaceSubClass = UISUBCLASS_DATA, .bInterfaceProtocol = UIPROTO_CDC_NONE, - .iInterface = INDEX_MODEM, + .iInterface = MODEM_INTERFACE_INDEX, }; static const struct usb_temp_interface_desc *modem_interfaces[] = { &modem_iface_0, &modem_iface_1, NULL, }; static const struct usb_temp_config_desc modem_config_desc = { .ppIfaceDesc = modem_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = INDEX_PRODUCT, + .iConfiguration = MODEM_PRODUCT_INDEX, }; static const struct usb_temp_config_desc *modem_configs[] = { &modem_config_desc, NULL, }; static usb_temp_get_string_desc_t modem_get_string_desc; static usb_temp_get_vendor_desc_t modem_get_vendor_desc; -const struct usb_temp_device_desc usb_template_modem = { +struct usb_temp_device_desc usb_template_modem = { .getStringDesc = &modem_get_string_desc, .getVendorDesc = &modem_get_vendor_desc, .ppConfigDesc = modem_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x000E, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_COMM, .bDeviceSubClass = 0, .bDeviceProtocol = 0, .iManufacturer = 0, - .iProduct = INDEX_PRODUCT, + .iProduct = MODEM_PRODUCT_INDEX, .iSerialNumber = 0, }; /*------------------------------------------------------------------------* * modem_get_vendor_desc * * Return values: * NULL: Failure. No such vendor descriptor. * Else: Success. Pointer to vendor descriptor is returned. *------------------------------------------------------------------------*/ static const void * modem_get_vendor_desc(const struct usb_device_request *req, uint16_t *plen) { return (NULL); } /*------------------------------------------------------------------------* * modem_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * modem_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[INDEX_MAX] = { - [INDEX_LANG] = &usb_string_lang_en, - [INDEX_MODEM] = &string_modem, - [INDEX_PRODUCT] = &string_product, + static const void *ptr[MODEM_MAX_INDEX] = { + [MODEM_LANG_INDEX] = &usb_string_lang_en, + [MODEM_INTERFACE_INDEX] = &modem_interface, + [MODEM_PRODUCT_INDEX] = &modem_product, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < INDEX_MAX) { + if (string_index < MODEM_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +modem_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&modem_interface, sizeof(modem_interface), + MODEM_DEFAULT_INTERFACE); + usb_make_str_desc(&modem_product, sizeof(modem_product), + MODEM_DEFAULT_PRODUCT); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_MODEM); + sysctl_ctx_init(&modem_ctx_list); + + parent = SYSCTL_ADD_NODE(&modem_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Modem device side template"); + SYSCTL_ADD_U16(&modem_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_modem.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&modem_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_modem.idProduct, 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&modem_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "keyboard", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &modem_interface, sizeof(modem_interface), usb_temp_sysctl, + "A", "Interface string"); +#endif + SYSCTL_ADD_PROC(&modem_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &modem_product, sizeof(modem_product), usb_temp_sysctl, + "A", "Product string"); +} + +static void +modem_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&modem_ctx_list); +} + +SYSINIT(modem_init, SI_SUB_LOCK, SI_ORDER_FIRST, modem_init, NULL); +SYSUNINIT(modem_init, SI_SUB_LOCK, SI_ORDER_FIRST, modem_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_mouse.c =================================================================== --- head/sys/dev/usb/template/usb_template_mouse.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_mouse.c (revision 328194) @@ -1,220 +1,270 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * - * Copyright (c) 2010 Hans Petter Selasky. All rights reserved. + * Copyright (c) 2010 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation + * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB template for an USB Mouse Device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - INDEX_LANG, - INDEX_MOUSE, - INDEX_PRODUCT, - INDEX_MAX, + MOUSE_LANG_INDEX, + MOUSE_INTERFACE_INDEX, + MOUSE_PRODUCT_INDEX, + MOUSE_MAX_INDEX, }; -#define STRING_PRODUCT \ - "M\0o\0u\0s\0e\0 \0T\0e\0s\0t\0 \0D\0e\0v\0i\0c\0e" +#define MOUSE_DEFAULT_INTERFACE "Mouse interface" +#define MOUSE_DEFAULT_PRODUCT "Mouse Test Interface" -#define STRING_MOUSE \ - "M\0o\0u\0s\0e\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct usb_string_descriptor mouse_interface; +static struct usb_string_descriptor mouse_product; -/* make the real string descriptors */ +static struct sysctl_ctx_list mouse_ctx_list; -USB_MAKE_STRING_DESC(STRING_MOUSE, string_mouse); -USB_MAKE_STRING_DESC(STRING_PRODUCT, string_product); - /* prototypes */ /* The following HID descriptor was dumped from a HP mouse. */ static uint8_t mouse_hid_descriptor[] = { 0x05, 0x01, 0x09, 0x02, 0xa1, 0x01, 0x09, 0x01, 0xa1, 0x00, 0x05, 0x09, 0x19, 0x01, 0x29, 0x03, 0x15, 0x00, 0x25, 0x01, 0x95, 0x03, 0x75, 0x01, 0x81, 0x02, 0x95, 0x05, 0x81, 0x03, 0x05, 0x01, 0x09, 0x30, 0x09, 0x31, 0x09, 0x38, 0x15, 0x81, 0x25, 0x7f, 0x75, 0x08, 0x95, 0x03, 0x81, 0x06, 0xc0, 0xc0 }; static const struct usb_temp_packet_size mouse_intr_mps = { .mps[USB_SPEED_LOW] = 8, .mps[USB_SPEED_FULL] = 8, .mps[USB_SPEED_HIGH] = 8, }; static const struct usb_temp_interval mouse_intr_interval = { .bInterval[USB_SPEED_LOW] = 2, /* 2ms */ .bInterval[USB_SPEED_FULL] = 2, /* 2ms */ .bInterval[USB_SPEED_HIGH] = 5, /* 2ms */ }; static const struct usb_temp_endpoint_desc mouse_ep_0 = { .ppRawDesc = NULL, /* no raw descriptors */ .pPacketSize = &mouse_intr_mps, .pIntervals = &mouse_intr_interval, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc *mouse_endpoints[] = { &mouse_ep_0, NULL, }; static const uint8_t mouse_raw_desc[] = { 0x09, 0x21, 0x10, 0x01, 0x00, 0x01, 0x22, sizeof(mouse_hid_descriptor), 0x00 }; static const void *mouse_iface_0_desc[] = { mouse_raw_desc, NULL, }; static const struct usb_temp_interface_desc mouse_iface_0 = { .ppRawDesc = mouse_iface_0_desc, .ppEndpoints = mouse_endpoints, .bInterfaceClass = UICLASS_HID, .bInterfaceSubClass = UISUBCLASS_BOOT, .bInterfaceProtocol = UIPROTO_MOUSE, - .iInterface = INDEX_MOUSE, + .iInterface = MOUSE_INTERFACE_INDEX, }; static const struct usb_temp_interface_desc *mouse_interfaces[] = { &mouse_iface_0, NULL, }; static const struct usb_temp_config_desc mouse_config_desc = { .ppIfaceDesc = mouse_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = INDEX_PRODUCT, + .iConfiguration = MOUSE_INTERFACE_INDEX, }; static const struct usb_temp_config_desc *mouse_configs[] = { &mouse_config_desc, NULL, }; static usb_temp_get_string_desc_t mouse_get_string_desc; static usb_temp_get_vendor_desc_t mouse_get_vendor_desc; -const struct usb_temp_device_desc usb_template_mouse = { +struct usb_temp_device_desc usb_template_mouse = { .getStringDesc = &mouse_get_string_desc, .getVendorDesc = &mouse_get_vendor_desc, .ppConfigDesc = mouse_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x00AE, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_COMM, .bDeviceSubClass = 0, .bDeviceProtocol = 0, .iManufacturer = 0, - .iProduct = INDEX_PRODUCT, + .iProduct = MOUSE_PRODUCT_INDEX, .iSerialNumber = 0, }; /*------------------------------------------------------------------------* * mouse_get_vendor_desc * * Return values: * NULL: Failure. No such vendor descriptor. * Else: Success. Pointer to vendor descriptor is returned. *------------------------------------------------------------------------*/ static const void * mouse_get_vendor_desc(const struct usb_device_request *req, uint16_t *plen) { if ((req->bmRequestType == 0x81) && (req->bRequest == 0x06) && (req->wValue[0] == 0x00) && (req->wValue[1] == 0x22) && (req->wIndex[1] == 0) && (req->wIndex[0] == 0)) { *plen = sizeof(mouse_hid_descriptor); return (mouse_hid_descriptor); } return (NULL); } /*------------------------------------------------------------------------* * mouse_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * mouse_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[INDEX_MAX] = { - [INDEX_LANG] = &usb_string_lang_en, - [INDEX_MOUSE] = &string_mouse, - [INDEX_PRODUCT] = &string_product, + static const void *ptr[MOUSE_MAX_INDEX] = { + [MOUSE_LANG_INDEX] = &usb_string_lang_en, + [MOUSE_INTERFACE_INDEX] = &mouse_interface, + [MOUSE_PRODUCT_INDEX] = &mouse_product, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < INDEX_MAX) { + if (string_index < MOUSE_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +mouse_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&mouse_interface, sizeof(mouse_interface), + MOUSE_DEFAULT_INTERFACE); + usb_make_str_desc(&mouse_product, sizeof(mouse_product), + MOUSE_DEFAULT_PRODUCT); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_MOUSE); + sysctl_ctx_init(&mouse_ctx_list); + + parent = SYSCTL_ADD_NODE(&mouse_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Mouse device side template"); + SYSCTL_ADD_U16(&mouse_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_mouse.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&mouse_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_mouse.idProduct, 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&mouse_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "interface", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &mouse_interface, sizeof(mouse_interface), usb_temp_sysctl, + "A", "Interface string"); +#endif + SYSCTL_ADD_PROC(&mouse_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &mouse_product, sizeof(mouse_product), usb_temp_sysctl, + "A", "Product string"); +} + +static void +mouse_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&mouse_ctx_list); +} + +SYSINIT(mouse_init, SI_SUB_LOCK, SI_ORDER_FIRST, mouse_init, NULL); +SYSUNINIT(mouse_init, SI_SUB_LOCK, SI_ORDER_FIRST, mouse_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_msc.c =================================================================== --- head/sys/dev/usb/template/usb_template_msc.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_msc.c (revision 328194) @@ -1,200 +1,260 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2008 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB templates for an USB Mass Storage Device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - STRING_LANG_INDEX, - STRING_MSC_DATA_INDEX, - STRING_MSC_CONFIG_INDEX, - STRING_MSC_VENDOR_INDEX, - STRING_MSC_PRODUCT_INDEX, - STRING_MSC_SERIAL_INDEX, - STRING_MSC_MAX, + MSC_LANG_INDEX, + MSC_INTERFACE_INDEX, + MSC_CONFIGURATION_INDEX, + MSC_MANUFACTURER_INDEX, + MSC_PRODUCT_INDEX, + MSC_SERIAL_NUMBER_INDEX, + MSC_MAX_INDEX, }; -#define STRING_MSC_DATA \ - "U\0S\0B\0 \0M\0a\0s\0s\0 \0S\0t\0o\0r\0a\0g\0e\0 " \ - "\0I\0n\0t\0e\0r\0f\0a\0c\0e" +#define MSC_DEFAULT_INTERFACE "USB Mass Storage Interface" +#define MSC_DEFAULT_CONFIGURATION "Default Config" +#define MSC_DEFAULT_MANUFACTURER "FreeBSD foundation" +#define MSC_DEFAULT_PRODUCT "USB Memory Stick" +#define MSC_DEFAULT_SERIAL_NUMBER "March 2008" -#define STRING_MSC_CONFIG \ - "D\0e\0f\0a\0u\0l\0t\0 \0c\0o\0n\0f\0i\0g" +static struct usb_string_descriptor msc_interface; +static struct usb_string_descriptor msc_configuration; +static struct usb_string_descriptor msc_manufacturer; +static struct usb_string_descriptor msc_product; +static struct usb_string_descriptor msc_serial_number; -#define STRING_MSC_VENDOR \ - "F\0r\0e\0e\0B\0S\0D\0 \0f\0o\0u\0n\0d\0a\0t\0i\0o\0n" +static struct sysctl_ctx_list msc_ctx_list; -#define STRING_MSC_PRODUCT \ - "U\0S\0B\0 \0M\0e\0m\0o\0r\0y\0 \0S\0t\0i\0c\0k" - -#define STRING_MSC_SERIAL \ - "M\0a\0r\0c\0h\0 \0002\0000\0000\08" - -/* make the real string descriptors */ - -USB_MAKE_STRING_DESC(STRING_MSC_DATA, string_msc_data); -USB_MAKE_STRING_DESC(STRING_MSC_CONFIG, string_msc_config); -USB_MAKE_STRING_DESC(STRING_MSC_VENDOR, string_msc_vendor); -USB_MAKE_STRING_DESC(STRING_MSC_PRODUCT, string_msc_product); -USB_MAKE_STRING_DESC(STRING_MSC_SERIAL, string_msc_serial); - /* prototypes */ static usb_temp_get_string_desc_t msc_get_string_desc; static const struct usb_temp_packet_size bulk_mps = { .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 512, }; static const struct usb_temp_endpoint_desc bulk_in_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_IN_EP_0 .bEndpointAddress = USB_HIP_IN_EP_0, #else .bEndpointAddress = UE_DIR_IN, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc bulk_out_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_OUT_EP_0 .bEndpointAddress = USB_HIP_OUT_EP_0, #else .bEndpointAddress = UE_DIR_OUT, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc *msc_data_endpoints[] = { &bulk_in_ep, &bulk_out_ep, NULL, }; static const struct usb_temp_interface_desc msc_data_interface = { .ppEndpoints = msc_data_endpoints, .bInterfaceClass = UICLASS_MASS, .bInterfaceSubClass = UISUBCLASS_SCSI, .bInterfaceProtocol = UIPROTO_MASS_BBB, - .iInterface = STRING_MSC_DATA_INDEX, + .iInterface = MSC_INTERFACE_INDEX, }; static const struct usb_temp_interface_desc *msc_interfaces[] = { &msc_data_interface, NULL, }; static const struct usb_temp_config_desc msc_config_desc = { .ppIfaceDesc = msc_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = STRING_MSC_CONFIG_INDEX, + .iConfiguration = MSC_CONFIGURATION_INDEX, }; static const struct usb_temp_config_desc *msc_configs[] = { &msc_config_desc, NULL, }; -const struct usb_temp_device_desc usb_template_msc = { +struct usb_temp_device_desc usb_template_msc = { .getStringDesc = &msc_get_string_desc, .ppConfigDesc = msc_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x0012, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_COMM, .bDeviceSubClass = 0, .bDeviceProtocol = 0, - .iManufacturer = STRING_MSC_VENDOR_INDEX, - .iProduct = STRING_MSC_PRODUCT_INDEX, - .iSerialNumber = STRING_MSC_SERIAL_INDEX, + .iManufacturer = MSC_MANUFACTURER_INDEX, + .iProduct = MSC_PRODUCT_INDEX, + .iSerialNumber = MSC_SERIAL_NUMBER_INDEX, }; /*------------------------------------------------------------------------* * msc_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * msc_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[STRING_MSC_MAX] = { - [STRING_LANG_INDEX] = &usb_string_lang_en, - [STRING_MSC_DATA_INDEX] = &string_msc_data, - [STRING_MSC_CONFIG_INDEX] = &string_msc_config, - [STRING_MSC_VENDOR_INDEX] = &string_msc_vendor, - [STRING_MSC_PRODUCT_INDEX] = &string_msc_product, - [STRING_MSC_SERIAL_INDEX] = &string_msc_serial, + static const void *ptr[MSC_MAX_INDEX] = { + [MSC_LANG_INDEX] = &usb_string_lang_en, + [MSC_INTERFACE_INDEX] = &msc_interface, + [MSC_CONFIGURATION_INDEX] = &msc_configuration, + [MSC_MANUFACTURER_INDEX] = &msc_manufacturer, + [MSC_PRODUCT_INDEX] = &msc_product, + [MSC_SERIAL_NUMBER_INDEX] = &msc_serial_number, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < STRING_MSC_MAX) { + if (string_index < MSC_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +msc_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&msc_interface, sizeof(msc_interface), + MSC_DEFAULT_INTERFACE); + usb_make_str_desc(&msc_configuration, sizeof(msc_configuration), + MSC_DEFAULT_CONFIGURATION); + usb_make_str_desc(&msc_manufacturer, sizeof(msc_manufacturer), + MSC_DEFAULT_MANUFACTURER); + usb_make_str_desc(&msc_product, sizeof(msc_product), + MSC_DEFAULT_PRODUCT); + usb_make_str_desc(&msc_serial_number, sizeof(msc_serial_number), + MSC_DEFAULT_SERIAL_NUMBER); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_MSC); + sysctl_ctx_init(&msc_ctx_list); + + parent = SYSCTL_ADD_NODE(&msc_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Mass Storage device side template"); + SYSCTL_ADD_U16(&msc_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_msc.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&msc_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_msc.idProduct, 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&msc_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "interface", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &msc_interface, sizeof(msc_interface), usb_temp_sysctl, + "A", "Interface string"); + SYSCTL_ADD_PROC(&msc_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "configuration", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &msc_configuration, sizeof(msc_configuration), usb_temp_sysctl, + "A", "Configuration string"); +#endif + SYSCTL_ADD_PROC(&msc_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "manufacturer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &msc_manufacturer, sizeof(msc_manufacturer), usb_temp_sysctl, + "A", "Manufacturer string"); + SYSCTL_ADD_PROC(&msc_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &msc_product, sizeof(msc_product), usb_temp_sysctl, + "A", "Product string"); + SYSCTL_ADD_PROC(&msc_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "serial_number", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &msc_serial_number, sizeof(msc_serial_number), usb_temp_sysctl, + "A", "Serial number string"); +} + +static void +msc_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&msc_ctx_list); +} + +SYSINIT(msc_init, SI_SUB_LOCK, SI_ORDER_FIRST, msc_init, NULL); +SYSUNINIT(msc_init, SI_SUB_LOCK, SI_ORDER_FIRST, msc_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_mtp.c =================================================================== --- head/sys/dev/usb/template/usb_template_mtp.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_mtp.c (revision 328194) @@ -1,266 +1,327 @@ /* $FreeBSD$ */ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2008 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB templates for an USB Media Transfer * Protocol device. * * NOTE: It is common practice that MTP devices use some dummy * descriptor cludges to be automatically detected by the host * operating system. These descriptors are documented in the LibMTP * library at sourceforge.net. The alternative is to supply the host * operating system the VID and PID of your device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ #define MTP_BREQUEST 0x08 enum { - STRING_LANG_INDEX, - STRING_MTP_DATA_INDEX, - STRING_MTP_CONFIG_INDEX, - STRING_MTP_VENDOR_INDEX, - STRING_MTP_PRODUCT_INDEX, - STRING_MTP_SERIAL_INDEX, - STRING_MTP_MAX, + MTP_LANG_INDEX, + MTP_INTERFACE_INDEX, + MTP_CONFIGURATION_INDEX, + MTP_MANUFACTURER_INDEX, + MTP_PRODUCT_INDEX, + MTP_SERIAL_NUMBER_INDEX, + MTP_MAX_INDEX, }; -#define STRING_MTP_DATA \ - "U\0S\0B\0 \0M\0T\0P\0 \0I\0n\0t\0e\0r\0f\0a\0c\0e" +#define MTP_DEFAULT_INTERFACE "USB MTP Interface" +#define MTP_DEFAULT_CONFIGURATION "Default Config" +#define MTP_DEFAULT_MANUFACTURER "FreeBSD foundation" +#define MTP_DEFAULT_PRODUCT "USB MTP" +#define MTP_DEFAULT_SERIAL_NUMBER "June 2008" -#define STRING_MTP_CONFIG \ - "D\0e\0f\0a\0u\0l\0t\0 \0c\0o\0n\0f\0i\0g" +static struct usb_string_descriptor mtp_interface; +static struct usb_string_descriptor mtp_configuration; +static struct usb_string_descriptor mtp_manufacturer; +static struct usb_string_descriptor mtp_product; +static struct usb_string_descriptor mtp_serial_number; -#define STRING_MTP_VENDOR \ - "F\0r\0e\0e\0B\0S\0D\0 \0f\0o\0u\0n\0d\0a\0t\0i\0o\0n" +static struct sysctl_ctx_list mtp_ctx_list; -#define STRING_MTP_PRODUCT \ - "U\0S\0B\0 \0M\0T\0P" - -#define STRING_MTP_SERIAL \ - "J\0u\0n\0e\0 \0002\0000\0000\08" - -/* make the real string descriptors */ - -USB_MAKE_STRING_DESC(STRING_MTP_DATA, string_mtp_data); -USB_MAKE_STRING_DESC(STRING_MTP_CONFIG, string_mtp_config); -USB_MAKE_STRING_DESC(STRING_MTP_VENDOR, string_mtp_vendor); -USB_MAKE_STRING_DESC(STRING_MTP_PRODUCT, string_mtp_product); -USB_MAKE_STRING_DESC(STRING_MTP_SERIAL, string_mtp_serial); - /* prototypes */ static usb_temp_get_string_desc_t mtp_get_string_desc; static usb_temp_get_vendor_desc_t mtp_get_vendor_desc; static const struct usb_temp_packet_size bulk_mps = { .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 512, }; static const struct usb_temp_packet_size intr_mps = { .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 64, }; static const struct usb_temp_endpoint_desc bulk_out_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_OUT_EP_0 .bEndpointAddress = USB_HIP_OUT_EP_0, #else .bEndpointAddress = UE_DIR_OUT, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc intr_in_ep = { .pPacketSize = &intr_mps, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc bulk_in_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_IN_EP_0 .bEndpointAddress = USB_HIP_IN_EP_0, #else .bEndpointAddress = UE_DIR_IN, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc *mtp_data_endpoints[] = { &bulk_in_ep, &bulk_out_ep, &intr_in_ep, NULL, }; static const struct usb_temp_interface_desc mtp_data_interface = { .ppEndpoints = mtp_data_endpoints, .bInterfaceClass = UICLASS_IMAGE, .bInterfaceSubClass = UISUBCLASS_SIC, /* Still Image Class */ .bInterfaceProtocol = 1, /* PIMA 15740 */ - .iInterface = STRING_MTP_DATA_INDEX, + .iInterface = MTP_INTERFACE_INDEX, }; static const struct usb_temp_interface_desc *mtp_interfaces[] = { &mtp_data_interface, NULL, }; static const struct usb_temp_config_desc mtp_config_desc = { .ppIfaceDesc = mtp_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = STRING_MTP_CONFIG_INDEX, + .iConfiguration = MTP_CONFIGURATION_INDEX, }; static const struct usb_temp_config_desc *mtp_configs[] = { &mtp_config_desc, NULL, }; -const struct usb_temp_device_desc usb_template_mtp = { +struct usb_temp_device_desc usb_template_mtp = { .getStringDesc = &mtp_get_string_desc, .getVendorDesc = &mtp_get_vendor_desc, .ppConfigDesc = mtp_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x0011, .bcdDevice = 0x0100, .bDeviceClass = 0, .bDeviceSubClass = 0, .bDeviceProtocol = 0, - .iManufacturer = STRING_MTP_VENDOR_INDEX, - .iProduct = STRING_MTP_PRODUCT_INDEX, - .iSerialNumber = STRING_MTP_SERIAL_INDEX, + .iManufacturer = MTP_MANUFACTURER_INDEX, + .iProduct = MTP_PRODUCT_INDEX, + .iSerialNumber = MTP_SERIAL_NUMBER_INDEX, }; /*------------------------------------------------------------------------* * mtp_get_vendor_desc * * Return values: * NULL: Failure. No such vendor descriptor. * Else: Success. Pointer to vendor descriptor is returned. *------------------------------------------------------------------------*/ static const void * mtp_get_vendor_desc(const struct usb_device_request *req, uint16_t *plen) { static const uint8_t dummy_desc[0x28] = { 0x28, 0, 0, 0, 0, 1, 4, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0x4D, 0x54, 0x50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; if ((req->bmRequestType == UT_READ_VENDOR_DEVICE) && (req->bRequest == MTP_BREQUEST) && (req->wValue[0] == 0) && (req->wValue[1] == 0) && (req->wIndex[1] == 0) && ((req->wIndex[0] == 4) || (req->wIndex[0] == 5))) { /* * By returning this descriptor LibMTP will * automatically pickup our device. */ return (dummy_desc); } return (NULL); } /*------------------------------------------------------------------------* * mtp_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * mtp_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[STRING_MTP_MAX] = { - [STRING_LANG_INDEX] = &usb_string_lang_en, - [STRING_MTP_DATA_INDEX] = &string_mtp_data, - [STRING_MTP_CONFIG_INDEX] = &string_mtp_config, - [STRING_MTP_VENDOR_INDEX] = &string_mtp_vendor, - [STRING_MTP_PRODUCT_INDEX] = &string_mtp_product, - [STRING_MTP_SERIAL_INDEX] = &string_mtp_serial, + static const void *ptr[MTP_MAX_INDEX] = { + [MTP_LANG_INDEX] = &usb_string_lang_en, + [MTP_INTERFACE_INDEX] = &mtp_interface, + [MTP_CONFIGURATION_INDEX] = &mtp_configuration, + [MTP_MANUFACTURER_INDEX] = &mtp_manufacturer, + [MTP_PRODUCT_INDEX] = &mtp_product, + [MTP_SERIAL_NUMBER_INDEX] = &mtp_serial_number, }; static const uint8_t dummy_desc[0x12] = { 0x12, 0x03, 0x4D, 0x00, 0x53, 0x00, 0x46, 0x00, 0x54, 0x00, 0x31, 0x00, 0x30, 0x00, 0x30, 0x00, MTP_BREQUEST, 0x00, }; if (string_index == 0xEE) { /* * By returning this string LibMTP will automatically * pickup our device. */ return (dummy_desc); } if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < STRING_MTP_MAX) { + if (string_index < MTP_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +mtp_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&mtp_interface, sizeof(mtp_interface), + MTP_DEFAULT_INTERFACE); + usb_make_str_desc(&mtp_configuration, sizeof(mtp_configuration), + MTP_DEFAULT_CONFIGURATION); + usb_make_str_desc(&mtp_manufacturer, sizeof(mtp_manufacturer), + MTP_DEFAULT_MANUFACTURER); + usb_make_str_desc(&mtp_product, sizeof(mtp_product), + MTP_DEFAULT_PRODUCT); + usb_make_str_desc(&mtp_serial_number, sizeof(mtp_serial_number), + MTP_DEFAULT_SERIAL_NUMBER); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_MTP); + sysctl_ctx_init(&mtp_ctx_list); + + parent = SYSCTL_ADD_NODE(&mtp_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Media Transfer Protocol device side template"); + SYSCTL_ADD_U16(&mtp_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_mtp.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&mtp_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_mtp.idProduct, 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&mtp_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "interface", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &mtp_interface, sizeof(mtp_interface), usb_temp_sysctl, + "A", "Interface string"); + SYSCTL_ADD_PROC(&mtp_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "configuration", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &mtp_configuration, sizeof(mtp_configuration), usb_temp_sysctl, + "A", "Configuration string"); +#endif + SYSCTL_ADD_PROC(&mtp_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "manufacturer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &mtp_manufacturer, sizeof(mtp_manufacturer), usb_temp_sysctl, + "A", "Manufacturer string"); + SYSCTL_ADD_PROC(&mtp_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &mtp_product, sizeof(mtp_product), usb_temp_sysctl, + "A", "Product string"); + SYSCTL_ADD_PROC(&mtp_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "serial_number", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &mtp_serial_number, sizeof(mtp_serial_number), usb_temp_sysctl, + "A", "Serial number string"); +} + +static void +mtp_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&mtp_ctx_list); +} + +SYSINIT(mtp_init, SI_SUB_LOCK, SI_ORDER_FIRST, mtp_init, NULL); +SYSUNINIT(mtp_init, SI_SUB_LOCK, SI_ORDER_FIRST, mtp_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_phone.c =================================================================== --- head/sys/dev/usb/template/usb_template_phone.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_phone.c (revision 328194) @@ -1,419 +1,481 @@ /* $FreeBSD$ */ /*- - * Copyright (c) 2014 Hans Petter Selasky. All rights reserved. + * Copyright (c) 2014 Hans Petter Selasky + * Copyright (c) 2018 The FreeBSD Foundation + * All rights reserved. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB template for an USB phone device. */ #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ enum { - INDEX_PHONE_LANG, - INDEX_PHONE_MIXER, - INDEX_PHONE_RECORD, - INDEX_PHONE_PLAYBACK, - INDEX_PHONE_PRODUCT, - INDEX_PHONE_HID, - INDEX_PHONE_MAX, + PHONE_LANG_INDEX, + PHONE_MIXER_INDEX, + PHONE_RECORD_INDEX, + PHONE_PLAYBACK_INDEX, + PHONE_PRODUCT_INDEX, + PHONE_HID_INDEX, + PHONE_MAX_INDEX, }; -#define STRING_PHONE_PRODUCT \ - "U\0S\0B\0 \0P\0h\0o\0n\0e\0 \0D\0e\0v\0i\0c\0e" +#define PHONE_DEFAULT_MIXER "Mixer interface" +#define PHONE_DEFAULT_RECORD "Record interface" +#define PHONE_DEFAULT_PLAYBACK "Playback interface" +#define PHONE_DEFAULT_PRODUCT "USB Phone Device" +#define PHONE_DEFAULT_HID "HID interface" -#define STRING_PHONE_MIXER \ - "M\0i\0x\0e\0r\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct usb_string_descriptor phone_mixer; +static struct usb_string_descriptor phone_record; +static struct usb_string_descriptor phone_playback; +static struct usb_string_descriptor phone_product; +static struct usb_string_descriptor phone_hid; -#define STRING_PHONE_RECORD \ - "R\0e\0c\0o\0r\0d\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" +static struct sysctl_ctx_list phone_ctx_list; -#define STRING_PHONE_PLAYBACK \ - "P\0l\0a\0y\0b\0a\0c\0k\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" - -#define STRING_PHONE_HID \ - "H\0I\0D\0 \0i\0n\0t\0e\0r\0f\0a\0c\0e" - -/* make the real string descriptors */ - -USB_MAKE_STRING_DESC(STRING_PHONE_MIXER, string_phone_mixer); -USB_MAKE_STRING_DESC(STRING_PHONE_RECORD, string_phone_record); -USB_MAKE_STRING_DESC(STRING_PHONE_PLAYBACK, string_phone_playback); -USB_MAKE_STRING_DESC(STRING_PHONE_PRODUCT, string_phone_product); -USB_MAKE_STRING_DESC(STRING_PHONE_HID, string_phone_hid); - /* prototypes */ /* * Phone Mixer description structures * * Some of the phone descriptors were dumped from no longer in * production Yealink VOIP USB phone adapter: */ static uint8_t phone_hid_descriptor[] = { 0x05, 0x0b, 0x09, 0x01, 0xa1, 0x01, 0x05, 0x09, 0x19, 0x01, 0x29, 0x3f, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x80, 0x81, 0x00, 0x05, 0x08, 0x19, 0x01, 0x29, 0x10, 0x15, 0x00, 0x25, 0x01, 0x75, 0x01, 0x95, 0x80, 0x91, 0x00, 0xc0 }; static const uint8_t phone_raw_desc_0[] = { 0x0a, 0x24, 0x01, 0x00, 0x01, 0x4a, 0x00, 0x02, 0x01, 0x02 }; static const uint8_t phone_raw_desc_1[] = { 0x0c, 0x24, 0x02, 0x01, 0x01, 0x02, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 }; static const uint8_t phone_raw_desc_2[] = { 0x0c, 0x24, 0x02, 0x02, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00 }; static const uint8_t phone_raw_desc_3[] = { 0x09, 0x24, 0x03, 0x03, 0x01, 0x03, 0x00, 0x06, 0x00 }; static const uint8_t phone_raw_desc_4[] = { 0x09, 0x24, 0x03, 0x04, 0x01, 0x01, 0x00, 0x05, 0x00 }; static const uint8_t phone_raw_desc_5[] = { 0x0b, 0x24, 0x06, 0x05, 0x01, 0x02, 0x03, 0x00, 0x03, 0x00, 0x00 }; static const uint8_t phone_raw_desc_6[] = { 0x0b, 0x24, 0x06, 0x06, 0x02, 0x02, 0x03, 0x00, 0x03, 0x00, 0x00 }; static const void *phone_raw_iface_0_desc[] = { phone_raw_desc_0, phone_raw_desc_1, phone_raw_desc_2, phone_raw_desc_3, phone_raw_desc_4, phone_raw_desc_5, phone_raw_desc_6, NULL, }; static const struct usb_temp_interface_desc phone_iface_0 = { .ppEndpoints = NULL, /* no endpoints */ .ppRawDesc = phone_raw_iface_0_desc, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOCONTROL, .bInterfaceProtocol = 0, - .iInterface = INDEX_PHONE_MIXER, + .iInterface = PHONE_MIXER_INDEX, }; static const uint8_t phone_raw_desc_20[] = { 0x07, 0x24, 0x01, 0x04, 0x01, 0x01, 0x00 }; static const uint8_t phone_raw_desc_21[] = { 0x0b, 0x24, 0x02, 0x01, 0x01, 0x02, 0x10, 0x01, /* 8kHz */ 0x40, 0x1f, 0x00 }; static const uint8_t phone_raw_desc_22[] = { 0x07, 0x25, 0x01, 0x00, 0x00, 0x00, 0x00 }; static const void *phone_raw_iface_1_desc[] = { phone_raw_desc_20, phone_raw_desc_21, NULL, }; static const void *phone_raw_ep_1_desc[] = { phone_raw_desc_22, NULL, }; static const struct usb_temp_packet_size phone_isoc_mps = { .mps[USB_SPEED_FULL] = 0x10, .mps[USB_SPEED_HIGH] = 0x10, }; static const struct usb_temp_interval phone_isoc_interval = { .bInterval[USB_SPEED_FULL] = 1, /* 1:1 */ .bInterval[USB_SPEED_HIGH] = 4, /* 1:8 */ }; static const struct usb_temp_endpoint_desc phone_isoc_in_ep = { .ppRawDesc = phone_raw_ep_1_desc, .pPacketSize = &phone_isoc_mps, .pIntervals = &phone_isoc_interval, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_ISOCHRONOUS, }; static const struct usb_temp_endpoint_desc *phone_iface_1_ep[] = { &phone_isoc_in_ep, NULL, }; static const struct usb_temp_interface_desc phone_iface_1_alt_0 = { .ppEndpoints = NULL, /* no endpoints */ .ppRawDesc = NULL, /* no raw descriptors */ .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_PHONE_PLAYBACK, + .iInterface = PHONE_PLAYBACK_INDEX, }; static const struct usb_temp_interface_desc phone_iface_1_alt_1 = { .ppEndpoints = phone_iface_1_ep, .ppRawDesc = phone_raw_iface_1_desc, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_PHONE_PLAYBACK, + .iInterface = PHONE_PLAYBACK_INDEX, .isAltInterface = 1, /* this is an alternate setting */ }; static const uint8_t phone_raw_desc_30[] = { 0x07, 0x24, 0x01, 0x02, 0x01, 0x01, 0x00 }; static const uint8_t phone_raw_desc_31[] = { 0x0b, 0x24, 0x02, 0x01, 0x01, 0x02, 0x10, 0x01, /* 8kHz */ 0x40, 0x1f, 0x00 }; static const uint8_t phone_raw_desc_32[] = { 0x07, 0x25, 0x01, 0x00, 0x00, 0x00, 0x00 }; static const void *phone_raw_iface_2_desc[] = { phone_raw_desc_30, phone_raw_desc_31, NULL, }; static const void *phone_raw_ep_2_desc[] = { phone_raw_desc_32, NULL, }; static const struct usb_temp_endpoint_desc phone_isoc_out_ep = { .ppRawDesc = phone_raw_ep_2_desc, .pPacketSize = &phone_isoc_mps, .pIntervals = &phone_isoc_interval, .bEndpointAddress = UE_DIR_OUT, .bmAttributes = UE_ISOCHRONOUS, }; static const struct usb_temp_endpoint_desc *phone_iface_2_ep[] = { &phone_isoc_out_ep, NULL, }; static const struct usb_temp_interface_desc phone_iface_2_alt_0 = { .ppEndpoints = NULL, /* no endpoints */ .ppRawDesc = NULL, /* no raw descriptors */ .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_PHONE_RECORD, + .iInterface = PHONE_RECORD_INDEX, }; static const struct usb_temp_interface_desc phone_iface_2_alt_1 = { .ppEndpoints = phone_iface_2_ep, .ppRawDesc = phone_raw_iface_2_desc, .bInterfaceClass = UICLASS_AUDIO, .bInterfaceSubClass = UISUBCLASS_AUDIOSTREAM, .bInterfaceProtocol = 0, - .iInterface = INDEX_PHONE_RECORD, + .iInterface = PHONE_RECORD_INDEX, .isAltInterface = 1, /* this is an alternate setting */ }; static const uint8_t phone_hid_raw_desc_0[] = { 0x09, 0x21, 0x00, 0x01, 0x00, 0x01, 0x22, sizeof(phone_hid_descriptor), 0x00 }; static const void *phone_hid_desc_0[] = { phone_hid_raw_desc_0, NULL, }; static const struct usb_temp_packet_size phone_hid_mps = { .mps[USB_SPEED_FULL] = 0x10, .mps[USB_SPEED_HIGH] = 0x10, }; static const struct usb_temp_interval phone_hid_interval = { .bInterval[USB_SPEED_FULL] = 2, /* 2ms */ .bInterval[USB_SPEED_HIGH] = 2, /* 2ms */ }; static const struct usb_temp_endpoint_desc phone_hid_in_ep = { .pPacketSize = &phone_hid_mps, .pIntervals = &phone_hid_interval, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc *phone_iface_3_ep[] = { &phone_hid_in_ep, NULL, }; static const struct usb_temp_interface_desc phone_iface_3 = { .ppEndpoints = phone_iface_3_ep, .ppRawDesc = phone_hid_desc_0, .bInterfaceClass = UICLASS_HID, .bInterfaceSubClass = 0, .bInterfaceProtocol = 0, - .iInterface = INDEX_PHONE_HID, + .iInterface = PHONE_HID_INDEX, }; static const struct usb_temp_interface_desc *phone_interfaces[] = { &phone_iface_0, &phone_iface_1_alt_0, &phone_iface_1_alt_1, &phone_iface_2_alt_0, &phone_iface_2_alt_1, &phone_iface_3, NULL, }; static const struct usb_temp_config_desc phone_config_desc = { .ppIfaceDesc = phone_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = INDEX_PHONE_PRODUCT, + .iConfiguration = PHONE_PRODUCT_INDEX, }; static const struct usb_temp_config_desc *phone_configs[] = { &phone_config_desc, NULL, }; static usb_temp_get_string_desc_t phone_get_string_desc; static usb_temp_get_vendor_desc_t phone_get_vendor_desc; -const struct usb_temp_device_desc usb_template_phone = { +struct usb_temp_device_desc usb_template_phone = { .getStringDesc = &phone_get_string_desc, .getVendorDesc = &phone_get_vendor_desc, .ppConfigDesc = phone_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0xb001, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_IN_INTERFACE, .bDeviceSubClass = 0, .bDeviceProtocol = 0, .iManufacturer = 0, - .iProduct = INDEX_PHONE_PRODUCT, + .iProduct = PHONE_PRODUCT_INDEX, .iSerialNumber = 0, }; /*------------------------------------------------------------------------* * phone_get_vendor_desc * * Return values: * NULL: Failure. No such vendor descriptor. * Else: Success. Pointer to vendor descriptor is returned. *------------------------------------------------------------------------*/ static const void * phone_get_vendor_desc(const struct usb_device_request *req, uint16_t *plen) { if ((req->bmRequestType == 0x81) && (req->bRequest == 0x06) && (req->wValue[0] == 0x00) && (req->wValue[1] == 0x22) && (req->wIndex[1] == 0) && (req->wIndex[0] == 3 /* iface */)) { *plen = sizeof(phone_hid_descriptor); return (phone_hid_descriptor); } return (NULL); } /*------------------------------------------------------------------------* * phone_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * phone_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[INDEX_PHONE_MAX] = { - [INDEX_PHONE_LANG] = &usb_string_lang_en, - [INDEX_PHONE_MIXER] = &string_phone_mixer, - [INDEX_PHONE_RECORD] = &string_phone_record, - [INDEX_PHONE_PLAYBACK] = &string_phone_playback, - [INDEX_PHONE_PRODUCT] = &string_phone_product, - [INDEX_PHONE_HID] = &string_phone_hid, + static const void *ptr[PHONE_MAX_INDEX] = { + [PHONE_LANG_INDEX] = &usb_string_lang_en, + [PHONE_MIXER_INDEX] = &phone_mixer, + [PHONE_RECORD_INDEX] = &phone_record, + [PHONE_PLAYBACK_INDEX] = &phone_playback, + [PHONE_PRODUCT_INDEX] = &phone_product, + [PHONE_HID_INDEX] = &phone_hid, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < INDEX_PHONE_MAX) { + if (string_index < PHONE_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +phone_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&phone_mixer, sizeof(phone_mixer), + PHONE_DEFAULT_MIXER); + usb_make_str_desc(&phone_record, sizeof(phone_record), + PHONE_DEFAULT_RECORD); + usb_make_str_desc(&phone_playback, sizeof(phone_playback), + PHONE_DEFAULT_PLAYBACK); + usb_make_str_desc(&phone_product, sizeof(phone_product), + PHONE_DEFAULT_PRODUCT); + usb_make_str_desc(&phone_hid, sizeof(phone_hid), + PHONE_DEFAULT_HID); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_PHONE); + sysctl_ctx_init(&phone_ctx_list); + + parent = SYSCTL_ADD_NODE(&phone_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Phone device side template"); + SYSCTL_ADD_U16(&phone_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_cdce.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&phone_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_cdce.idProduct, 1, "Product identifier"); +#if 0 + SYSCTL_ADD_PROC(&phone_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "mixer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &phone_mixer, sizeof(phone_mixer), usb_temp_sysctl, + "A", "Mixer interface string"); + SYSCTL_ADD_PROC(&phone_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "record", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &phone_record, sizeof(phone_record), usb_temp_sysctl, + "A", "Record interface string"); + SYSCTL_ADD_PROC(&phone_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "playback", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &phone_playback, sizeof(phone_playback), usb_temp_sysctl, + "A", "Playback interface string"); +#endif + SYSCTL_ADD_PROC(&phone_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &phone_product, sizeof(phone_product), usb_temp_sysctl, + "A", "Product string"); + SYSCTL_ADD_PROC(&phone_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "hid", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &phone_hid, sizeof(phone_hid), usb_temp_sysctl, + "A", "HID interface string"); +} + +static void +phone_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&phone_ctx_list); +} + +SYSINIT(phone_init, SI_SUB_LOCK, SI_ORDER_FIRST, phone_init, NULL); +SYSUNINIT(phone_init, SI_SUB_LOCK, SI_ORDER_FIRST, phone_uninit, NULL); Index: head/sys/dev/usb/template/usb_template_serialnet.c =================================================================== --- head/sys/dev/usb/template/usb_template_serialnet.c (revision 328193) +++ head/sys/dev/usb/template/usb_template_serialnet.c (revision 328194) @@ -1,387 +1,458 @@ /*- * Copyright (c) 2015 Ruslan Bukin + * Copyright (c) 2018 The FreeBSD Foundation * All rights reserved. * * This software was developed by SRI International and the University of * Cambridge Computer Laboratory under DARPA/AFRL contract (FA8750-10-C-0237) * ("CTSRD"), as part of the DARPA CRASH research programme. * + * Portions of this software were developed by Edward Tomasz Napierala + * under sponsorship from the FreeBSD Foundation. + * * 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. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 THE AUTHOR OR 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. */ /* * This file contains the USB template for USB Networking and Serial */ #include __FBSDID("$FreeBSD$"); #ifdef USB_GLOBAL_INCLUDE_FILE #include USB_GLOBAL_INCLUDE_FILE #else #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include +#include +#include #include #endif /* USB_GLOBAL_INCLUDE_FILE */ #define MODEM_IFACE_0 0 #define MODEM_IFACE_1 1 enum { - STRING_LANG_INDEX, - STRING_MODEM_INDEX, - STRING_ETH_MAC_INDEX, - STRING_ETH_CONTROL_INDEX, - STRING_ETH_DATA_INDEX, - STRING_ETH_CONFIG_INDEX, - STRING_CONFIG_INDEX, - STRING_VENDOR_INDEX, - STRING_PRODUCT_INDEX, - STRING_SERIAL_INDEX, - STRING_MAX, + SERIALNET_LANG_INDEX, + SERIALNET_MODEM_INDEX, + SERIALNET_ETH_MAC_INDEX, + SERIALNET_ETH_CONTROL_INDEX, + SERIALNET_ETH_DATA_INDEX, + SERIALNET_ETH_CONFIG_INDEX, + SERIALNET_CONFIGURATION_INDEX, + SERIALNET_MANUFACTURER_INDEX, + SERIALNET_PRODUCT_INDEX, + SERIALNET_SERIAL_NUMBER_INDEX, + SERIALNET_MAX_INDEX, }; -#define STRING_MODEM \ - "U\0S\0B\0 \0M\0o\0d\0e\0m\0 \0I\0n\0t\0e\0r\0f\0a\0c\0e" +#define SERIALNET_DEFAULT_MODEM "USB Modem Interface" +#define SERIALNET_DEFAULT_ETH_MAC "2A02030405060789AB" +#define SERIALNET_DEFAULT_ETH_CONTROL "USB Ethernet Comm Interface" +#define SERIALNET_DEFAULT_ETH_DATA "USB Ethernet Data Interface" +#define SERIALNET_DEFAULT_CONFIGURATION "Default configuration" +#define SERIALNET_DEFAULT_MANUFACTURER "The FreeBSD Project" +#define SERIALNET_DEFAULT_PRODUCT "SERIALNET" +#define SERIALNET_DEFAULT_SERIAL_NUMBER "January 2015" -#define STRING_ETH_MAC \ - "2\0A\0002\0003\0004\0005\0006\0007\08\09\0A\0B" +static struct usb_string_descriptor serialnet_modem; +static struct usb_string_descriptor serialnet_eth_mac; +static struct usb_string_descriptor serialnet_eth_control; +static struct usb_string_descriptor serialnet_eth_data; +static struct usb_string_descriptor serialnet_configuration; +static struct usb_string_descriptor serialnet_manufacturer; +static struct usb_string_descriptor serialnet_product; +static struct usb_string_descriptor serialnet_serial_number; -#define STRING_ETH_CONTROL \ - "U\0S\0B\0 \0E\0t\0h\0e\0r\0n\0e\0t\0 " \ - "\0C\0o\0m\0m\0 \0I\0n\0t\0e\0r\0f\0a\0c\0e" +static struct sysctl_ctx_list serialnet_ctx_list; -#define STRING_ETH_DATA \ - "U\0S\0B\0 \0E\0t\0h\0e\0r\0n\0e\0t\0 \0D\0a\0t\0a\0 " \ - "\0I\0n\0t\0e\0r\0f\0a\0c\0e" - -#define STRING_CONFIG \ - "D\0e\0f\0a\0u\0l\0t\0 \0c\0o\0n\0f\0i\0g\0u\0r\0a\0t\0i\0o\0n" - -#define STRING_VENDOR \ - "T\0h\0e\0 \0F\0r\0e\0e\0B\0S\0D\0 \0P\0r\0o\0j\0e\0c\0t" - -#define STRING_PRODUCT \ - "S\0E\0R\0I\0A\0L\0N\0E\0T" - -#define STRING_SERIAL \ - "J\0a\0n\0u\0a\0r\0y\0 \0002\0000\0001\0005" - -/* make the real string descriptors */ - -USB_MAKE_STRING_DESC(STRING_MODEM, string_modem); -USB_MAKE_STRING_DESC(STRING_ETH_MAC, string_eth_mac); -USB_MAKE_STRING_DESC(STRING_ETH_CONTROL, string_eth_control); -USB_MAKE_STRING_DESC(STRING_ETH_DATA, string_eth_data); -USB_MAKE_STRING_DESC(STRING_CONFIG, string_serialnet_config); -USB_MAKE_STRING_DESC(STRING_VENDOR, string_serialnet_vendor); -USB_MAKE_STRING_DESC(STRING_PRODUCT, string_serialnet_product); -USB_MAKE_STRING_DESC(STRING_SERIAL, string_serialnet_serial); - /* prototypes */ static usb_temp_get_string_desc_t serialnet_get_string_desc; static const struct usb_cdc_union_descriptor eth_union_desc = { .bLength = sizeof(eth_union_desc), .bDescriptorType = UDESC_CS_INTERFACE, .bDescriptorSubtype = UDESCSUB_CDC_UNION, .bMasterInterface = 0, /* this is automatically updated */ .bSlaveInterface[0] = 1, /* this is automatically updated */ }; static const struct usb_cdc_header_descriptor eth_header_desc = { .bLength = sizeof(eth_header_desc), .bDescriptorType = UDESC_CS_INTERFACE, .bDescriptorSubtype = UDESCSUB_CDC_HEADER, .bcdCDC[0] = 0x10, .bcdCDC[1] = 0x01, }; static const struct usb_cdc_ethernet_descriptor eth_enf_desc = { .bLength = sizeof(eth_enf_desc), .bDescriptorType = UDESC_CS_INTERFACE, .bDescriptorSubtype = UDESCSUB_CDC_ENF, - .iMacAddress = STRING_ETH_MAC_INDEX, + .iMacAddress = SERIALNET_ETH_MAC_INDEX, .bmEthernetStatistics = {0, 0, 0, 0}, .wMaxSegmentSize = {0xEA, 0x05},/* 1514 bytes */ .wNumberMCFilters = {0, 0}, .bNumberPowerFilters = 0, }; static const void *eth_control_if_desc[] = { ð_union_desc, ð_header_desc, ð_enf_desc, NULL, }; static const struct usb_temp_packet_size bulk_mps = { .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 512, }; static const struct usb_temp_packet_size intr_mps = { .mps[USB_SPEED_FULL] = 8, .mps[USB_SPEED_HIGH] = 8, }; static const struct usb_temp_endpoint_desc bulk_in_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_IN_EP_0 .bEndpointAddress = USB_HIP_IN_EP_0, #else .bEndpointAddress = UE_DIR_IN, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc bulk_out_ep = { .pPacketSize = &bulk_mps, #ifdef USB_HIP_OUT_EP_0 .bEndpointAddress = USB_HIP_OUT_EP_0, #else .bEndpointAddress = UE_DIR_OUT, #endif .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc intr_in_ep = { .pPacketSize = &intr_mps, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc *eth_intr_endpoints[] = { &intr_in_ep, NULL, }; static const struct usb_temp_interface_desc eth_control_interface = { .ppEndpoints = eth_intr_endpoints, .ppRawDesc = eth_control_if_desc, .bInterfaceClass = UICLASS_CDC, .bInterfaceSubClass = UISUBCLASS_ETHERNET_NETWORKING_CONTROL_MODEL, .bInterfaceProtocol = UIPROTO_CDC_NONE, - .iInterface = STRING_ETH_CONTROL_INDEX, + .iInterface = SERIALNET_ETH_CONTROL_INDEX, }; static const struct usb_temp_endpoint_desc *eth_data_endpoints[] = { &bulk_in_ep, &bulk_out_ep, NULL, }; static const struct usb_temp_interface_desc eth_data_null_interface = { .ppEndpoints = NULL, /* no endpoints */ .bInterfaceClass = UICLASS_CDC_DATA, .bInterfaceSubClass = UISUBCLASS_DATA, .bInterfaceProtocol = 0, - .iInterface = STRING_ETH_DATA_INDEX, + .iInterface = SERIALNET_ETH_DATA_INDEX, }; static const struct usb_temp_interface_desc eth_data_interface = { .ppEndpoints = eth_data_endpoints, .bInterfaceClass = UICLASS_CDC_DATA, .bInterfaceSubClass = UISUBCLASS_DATA, .bInterfaceProtocol = 0, - .iInterface = STRING_ETH_DATA_INDEX, + .iInterface = SERIALNET_ETH_DATA_INDEX, .isAltInterface = 1, /* this is an alternate setting */ }; static const struct usb_temp_packet_size modem_bulk_mps = { .mps[USB_SPEED_LOW] = 8, .mps[USB_SPEED_FULL] = 64, .mps[USB_SPEED_HIGH] = 512, }; static const struct usb_temp_packet_size modem_intr_mps = { .mps[USB_SPEED_LOW] = 8, .mps[USB_SPEED_FULL] = 8, .mps[USB_SPEED_HIGH] = 8, }; static const struct usb_temp_interval modem_intr_interval = { .bInterval[USB_SPEED_LOW] = 8, /* 8ms */ .bInterval[USB_SPEED_FULL] = 8, /* 8ms */ .bInterval[USB_SPEED_HIGH] = 7, /* 8ms */ }; static const struct usb_temp_endpoint_desc modem_ep_0 = { .pPacketSize = &modem_intr_mps, .pIntervals = &modem_intr_interval, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_INTERRUPT, }; static const struct usb_temp_endpoint_desc modem_ep_1 = { .pPacketSize = &modem_bulk_mps, .bEndpointAddress = UE_DIR_OUT, .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc modem_ep_2 = { .pPacketSize = &modem_bulk_mps, .bEndpointAddress = UE_DIR_IN, .bmAttributes = UE_BULK, }; static const struct usb_temp_endpoint_desc *modem_iface_0_ep[] = { &modem_ep_0, NULL, }; static const struct usb_temp_endpoint_desc *modem_iface_1_ep[] = { &modem_ep_1, &modem_ep_2, NULL, }; static const uint8_t modem_raw_desc_0[] = { 0x05, 0x24, 0x00, 0x10, 0x01 }; static const uint8_t modem_raw_desc_1[] = { 0x05, 0x24, 0x06, MODEM_IFACE_0, MODEM_IFACE_1 }; static const uint8_t modem_raw_desc_2[] = { 0x05, 0x24, 0x01, 0x03, MODEM_IFACE_1 }; static const uint8_t modem_raw_desc_3[] = { 0x04, 0x24, 0x02, 0x07 }; static const void *modem_iface_0_desc[] = { &modem_raw_desc_0, &modem_raw_desc_1, &modem_raw_desc_2, &modem_raw_desc_3, NULL, }; static const struct usb_temp_interface_desc modem_iface_0 = { .ppRawDesc = modem_iface_0_desc, .ppEndpoints = modem_iface_0_ep, .bInterfaceClass = UICLASS_CDC, .bInterfaceSubClass = UISUBCLASS_ABSTRACT_CONTROL_MODEL, .bInterfaceProtocol = UIPROTO_CDC_AT, - .iInterface = STRING_MODEM_INDEX, + .iInterface = SERIALNET_MODEM_INDEX, }; static const struct usb_temp_interface_desc modem_iface_1 = { .ppEndpoints = modem_iface_1_ep, .bInterfaceClass = UICLASS_CDC_DATA, .bInterfaceSubClass = UISUBCLASS_DATA, .bInterfaceProtocol = 0, - .iInterface = STRING_MODEM_INDEX, + .iInterface = SERIALNET_MODEM_INDEX, }; static const struct usb_temp_interface_desc *serialnet_interfaces[] = { &modem_iface_0, &modem_iface_1, ð_control_interface, ð_data_null_interface, ð_data_interface, NULL, }; static const struct usb_temp_config_desc serialnet_config_desc = { .ppIfaceDesc = serialnet_interfaces, .bmAttributes = UC_BUS_POWERED, .bMaxPower = 25, /* 50 mA */ - .iConfiguration = STRING_CONFIG_INDEX, + .iConfiguration = SERIALNET_CONFIGURATION_INDEX, }; static const struct usb_temp_config_desc *serialnet_configs[] = { &serialnet_config_desc, NULL, }; -const struct usb_temp_device_desc usb_template_serialnet = { +struct usb_temp_device_desc usb_template_serialnet = { .getStringDesc = &serialnet_get_string_desc, .ppConfigDesc = serialnet_configs, .idVendor = USB_TEMPLATE_VENDOR, .idProduct = 0x0001, .bcdDevice = 0x0100, .bDeviceClass = UDCLASS_COMM, .bDeviceSubClass = 0, .bDeviceProtocol = 0, - .iManufacturer = STRING_VENDOR_INDEX, - .iProduct = STRING_PRODUCT_INDEX, - .iSerialNumber = STRING_SERIAL_INDEX, + .iManufacturer = SERIALNET_MANUFACTURER_INDEX, + .iProduct = SERIALNET_PRODUCT_INDEX, + .iSerialNumber = SERIALNET_SERIAL_NUMBER_INDEX, }; /*------------------------------------------------------------------------* * serialnet_get_string_desc * * Return values: * NULL: Failure. No such string. * Else: Success. Pointer to string descriptor is returned. *------------------------------------------------------------------------*/ static const void * serialnet_get_string_desc(uint16_t lang_id, uint8_t string_index) { - static const void *ptr[STRING_MAX] = { - [STRING_LANG_INDEX] = &usb_string_lang_en, - [STRING_MODEM_INDEX] = &string_modem, - [STRING_ETH_MAC_INDEX] = &string_eth_mac, - [STRING_ETH_CONTROL_INDEX] = &string_eth_control, - [STRING_ETH_DATA_INDEX] = &string_eth_data, - [STRING_CONFIG_INDEX] = &string_serialnet_config, - [STRING_VENDOR_INDEX] = &string_serialnet_vendor, - [STRING_PRODUCT_INDEX] = &string_serialnet_product, - [STRING_SERIAL_INDEX] = &string_serialnet_serial, + static const void *ptr[SERIALNET_MAX_INDEX] = { + [SERIALNET_LANG_INDEX] = &usb_string_lang_en, + [SERIALNET_MODEM_INDEX] = &serialnet_modem, + [SERIALNET_ETH_MAC_INDEX] = &serialnet_eth_mac, + [SERIALNET_ETH_CONTROL_INDEX] = &serialnet_eth_control, + [SERIALNET_ETH_DATA_INDEX] = &serialnet_eth_data, + [SERIALNET_CONFIGURATION_INDEX] = &serialnet_configuration, + [SERIALNET_MANUFACTURER_INDEX] = &serialnet_manufacturer, + [SERIALNET_PRODUCT_INDEX] = &serialnet_product, + [SERIALNET_SERIAL_NUMBER_INDEX] = &serialnet_serial_number, }; if (string_index == 0) { return (&usb_string_lang_en); } if (lang_id != 0x0409) { return (NULL); } - if (string_index < STRING_MAX) { + if (string_index < SERIALNET_MAX_INDEX) { return (ptr[string_index]); } return (NULL); } + +static void +serialnet_init(void *arg __unused) +{ + struct sysctl_oid *parent; + char parent_name[3]; + + usb_make_str_desc(&serialnet_modem, sizeof(serialnet_modem), + SERIALNET_DEFAULT_MODEM); + usb_make_str_desc(&serialnet_eth_mac, sizeof(serialnet_eth_mac), + SERIALNET_DEFAULT_ETH_MAC); + usb_make_str_desc(&serialnet_eth_control, sizeof(serialnet_eth_control), + SERIALNET_DEFAULT_ETH_CONTROL); + usb_make_str_desc(&serialnet_eth_data, sizeof(serialnet_eth_data), + SERIALNET_DEFAULT_ETH_DATA); + usb_make_str_desc(&serialnet_configuration, sizeof(serialnet_configuration), + SERIALNET_DEFAULT_CONFIGURATION); + usb_make_str_desc(&serialnet_manufacturer, sizeof(serialnet_manufacturer), + SERIALNET_DEFAULT_MANUFACTURER); + usb_make_str_desc(&serialnet_product, sizeof(serialnet_product), + SERIALNET_DEFAULT_PRODUCT); + usb_make_str_desc(&serialnet_serial_number, sizeof(serialnet_serial_number), + SERIALNET_DEFAULT_SERIAL_NUMBER); + + snprintf(parent_name, sizeof(parent_name), "%d", USB_TEMP_SERIALNET); + sysctl_ctx_init(&serialnet_ctx_list); + + parent = SYSCTL_ADD_NODE(&serialnet_ctx_list, + SYSCTL_STATIC_CHILDREN(_hw_usb_templates), OID_AUTO, + parent_name, CTLFLAG_RW, + 0, "USB Mass Storage device side template"); + SYSCTL_ADD_U16(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "vendor_id", CTLFLAG_RWTUN, + &usb_template_serialnet.idVendor, 1, "Vendor identifier"); + SYSCTL_ADD_U16(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product_id", CTLFLAG_RWTUN, + &usb_template_serialnet.idProduct, 1, "Product identifier"); + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "eth_mac", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_eth_mac, sizeof(serialnet_eth_mac), usb_temp_sysctl, + "A", "Ethernet MAC address string"); +#if 0 + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "modem", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_modem, sizeof(serialnet_modem), usb_temp_sysctl, + "A", "Modem interface string"); + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "eth_control", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_eth_control, sizeof(serialnet_eth_data), usb_temp_sysctl, + "A", "Ethernet control interface string"); + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "eth_data", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_eth_data, sizeof(serialnet_eth_data), usb_temp_sysctl, + "A", "Ethernet data interface string"); + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "configuration", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_configuration, sizeof(serialnet_configuration), usb_temp_sysctl, + "A", "Configuration string"); +#endif + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "manufacturer", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_manufacturer, sizeof(serialnet_manufacturer), usb_temp_sysctl, + "A", "Manufacturer string"); + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "product", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_product, sizeof(serialnet_product), usb_temp_sysctl, + "A", "Product string"); + SYSCTL_ADD_PROC(&serialnet_ctx_list, SYSCTL_CHILDREN(parent), OID_AUTO, + "serial_number", CTLTYPE_STRING | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, + &serialnet_serial_number, sizeof(serialnet_serial_number), usb_temp_sysctl, + "A", "Serial number string"); +} + +static void +serialnet_uninit(void *arg __unused) +{ + + sysctl_ctx_free(&serialnet_ctx_list); +} + +SYSINIT(serialnet_init, SI_SUB_LOCK, SI_ORDER_FIRST, serialnet_init, NULL); +SYSUNINIT(serialnet_init, SI_SUB_LOCK, SI_ORDER_FIRST, serialnet_uninit, NULL);