Date: Tue, 1 Jul 2008 17:38:46 GMT From: Hans Petter Selasky <hselasky@FreeBSD.org> To: Perforce Change Reviews <perforce@FreeBSD.org> Subject: PERFORCE change 144435 for review Message-ID: <200807011738.m61HckWA051141@repoman.freebsd.org>
next in thread | raw e-mail | index | archive | help
http://perforce.freebsd.org/chv.cgi?CH=144435 Change 144435 by hselasky@hselasky_laptop001 on 2008/07/01 17:38:36 New USB template modules is finished. Affected files ... .. //depot/projects/usb/src/sys/dev/usb2/template/usb2_template.c#2 edit .. //depot/projects/usb/src/sys/dev/usb2/template/usb2_template.h#2 edit .. //depot/projects/usb/src/sys/dev/usb2/template/usb2_template_cdce.c#2 edit .. //depot/projects/usb/src/sys/dev/usb2/template/usb2_template_msc.c#2 edit .. //depot/projects/usb/src/sys/dev/usb2/template/usb2_template_mtp.c#2 edit .. //depot/projects/usb/src/sys/modules/usb2/template/Makefile#2 edit Differences ... ==== //depot/projects/usb/src/sys/dev/usb2/template/usb2_template.c#2 (text+ko) ==== @@ -1,9 +1,5 @@ -#include <sys/cdefs.h> -__FBSDID("$FreeBSD: src/sys/dev/usb/usb_template.c $"); - /*- - * Copyright (c) 2007 Hans Petter Selasky <hselasky@freebsd.org> - * All rights reserved. + * 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 @@ -32,28 +28,62 @@ * USB templates. */ -#include <sys/param.h> -#include <sys/systm.h> -#include <sys/kernel.h> -#include <sys/endian.h> -#include <sys/queue.h> -#include <sys/lock.h> -#include <sys/malloc.h> +#include <dev/usb2/include/usb2_standard.h> +#include <dev/usb2/include/usb2_cdc.h> +#include <dev/usb2/include/usb2_mfunc.h> +#include <dev/usb2/include/usb2_revision.h> +#include <dev/usb2/include/usb2_defs.h> +#include <dev/usb2/include/usb2_error.h> + +#define USB_DEBUG_VAR usb2_debug + +#include <dev/usb2/core/usb2_core.h> +#include <dev/usb2/core/usb2_busdma.h> +#include <dev/usb2/core/usb2_process.h> +#include <dev/usb2/core/usb2_debug.h> +#include <dev/usb2/core/usb2_parse.h> +#include <dev/usb2/core/usb2_device.h> +#include <dev/usb2/core/usb2_dynamic.h> + +#include <dev/usb2/controller/usb2_controller.h> +#include <dev/usb2/controller/usb2_bus.h> + +#include <dev/usb2/template/usb2_template.h> + +MODULE_DEPEND(usb2_template, usb2_core, 1, 1, 1); +MODULE_VERSION(usb2_template, 1); + +/* function prototypes */ -#include <dev/usb/usb_port.h> -#include <dev/usb/usb.h> -#include <dev/usb/usb_subr.h> -#include <dev/usb/usb_template.h> -#include <dev/usb/usb_cdc.h> +static void usb2_make_raw_desc(struct usb2_temp_setup *temp, const uint8_t *raw); +static void usb2_make_endpoint_desc(struct usb2_temp_setup *temp, const struct usb2_temp_endpoint_desc *ted); +static void usb2_make_interface_desc(struct usb2_temp_setup *temp, const struct usb2_temp_interface_desc *tid); +static void usb2_make_config_desc(struct usb2_temp_setup *temp, const struct usb2_temp_config_desc *tcd); +static void usb2_make_device_desc(struct usb2_temp_setup *temp, const struct usb2_temp_device_desc *tdd); +static uint8_t usb2_hw_ep_match(const struct usb2_hw_ep_profile *pf, uint8_t ep_type, uint8_t ep_dir_in); +static uint8_t usb2_hw_ep_find_match(struct usb2_hw_ep_scratch *ues, struct usb2_hw_ep_scratch_sub *ep, uint8_t is_simplex); +static uint8_t usb2_hw_ep_get_needs(struct usb2_hw_ep_scratch *ues, uint8_t ep_type, uint8_t is_complete); +static usb2_error_t usb2_hw_ep_resolve(struct usb2_device *udev, struct usb2_descriptor *desc); +static const struct usb2_temp_device_desc *usb2_temp_get_tdd(struct usb2_device *udev); +static void *usb2_temp_get_device_desc(struct usb2_device *udev); +static void *usb2_temp_get_qualifier_desc(struct usb2_device *udev); +static void *usb2_temp_get_config_desc(struct usb2_device *udev, uint16_t *pLength, uint8_t index); +static const void *usb2_temp_get_string_desc(struct usb2_device *udev, uint16_t lang_id, uint8_t string_index); +static const void *usb2_temp_get_hub_desc(struct usb2_device *udev); +static void usb2_temp_get_desc(struct usb2_device *udev, struct usb2_device_request *req, const void **pPtr, uint16_t *pLength); +static usb2_error_t usb2_temp_setup(struct usb2_device *udev, const struct usb2_temp_device_desc *tdd); +static void usb2_temp_unsetup(struct usb2_device *udev); +static usb2_error_t usb2_temp_setup_by_index(struct usb2_device *udev, uint16_t index); +static void usb2_temp_init(void *arg); /*------------------------------------------------------------------------* - * usbd_make_raw_desc + * usb2_make_raw_desc * * This function will insert a raw USB descriptor into the generated * USB configuration. *------------------------------------------------------------------------*/ static void -usbd_make_raw_desc(struct usbd_temp_setup *temp, +usb2_make_raw_desc(struct usb2_temp_setup *temp, const uint8_t *raw) { void *dst; @@ -65,15 +95,15 @@ if (raw) { len = raw[0]; if (temp->buf) { - dst = USBD_ADD_BYTES(temp->buf, temp->size); + dst = USB_ADD_BYTES(temp->buf, temp->size); bcopy(raw, dst, len); /* check if we have got a CDC union descriptor */ - if ((raw[0] >= sizeof(usb_cdc_union_descriptor_t)) && + if ((raw[0] >= sizeof(struct usb2_cdc_union_descriptor)) && (raw[1] == UDESC_CS_INTERFACE) && (raw[2] == UDESCSUB_CDC_UNION)) { - usb_cdc_union_descriptor_t *ud = (void *)dst; + struct usb2_cdc_union_descriptor *ud = (void *)dst; /* update the interface numbers */ @@ -89,17 +119,17 @@ } /*------------------------------------------------------------------------* - * usbd_make_endpoint_desc + * usb2_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 -usbd_make_endpoint_desc(struct usbd_temp_setup *temp, - const struct usb_temp_endpoint_desc *ted) +usb2_make_endpoint_desc(struct usb2_temp_setup *temp, + const struct usb2_temp_endpoint_desc *ted) { - usb_endpoint_descriptor_t *ed; + struct usb2_endpoint_descriptor *ed; const void **rd; uint16_t old_size; uint16_t mps; @@ -115,19 +145,19 @@ rd = ted->ppRawDesc; if (rd) { while (*rd) { - usbd_make_raw_desc(temp, *rd); + usb2_make_raw_desc(temp, *rd); rd++; } } if (ted->pPacketSize == NULL) { /* not initialized */ - temp->err = USBD_ERR_INVAL; + temp->err = USB_ERR_INVAL; return; } - mps = ted->pPacketSize->mps[temp->usb_speed]; + mps = ted->pPacketSize->mps[temp->usb2_speed]; if (mps == 0) { /* not initialized */ - temp->err = USBD_ERR_INVAL; + temp->err = USB_ERR_INVAL; return; } else if (mps == UE_ZERO_MPS) { /* escape for Zero Max Packet Size */ @@ -141,7 +171,7 @@ * in case there is a buffer present: */ if (temp->buf) { - ed = USBD_ADD_BYTES(temp->buf, old_size); + ed = USB_ADD_BYTES(temp->buf, old_size); ed->bLength = sizeof(*ed); ed->bDescriptorType = UDESC_ENDPOINT; ed->bEndpointAddress = ea; @@ -151,9 +181,9 @@ /* setup bInterval parameter */ if (ted->pIntervals && - ted->pIntervals->bInterval[temp->usb_speed]) { + ted->pIntervals->bInterval[temp->usb2_speed]) { ed->bInterval = - ted->pIntervals->bInterval[temp->usb_speed]; + ted->pIntervals->bInterval[temp->usb2_speed]; } else { switch (et) { case UE_BULK: @@ -161,7 +191,7 @@ ed->bInterval = 0; /* not used */ break; case UE_INTERRUPT: - switch (temp->usb_speed) { + switch (temp->usb2_speed) { case USB_SPEED_LOW: case USB_SPEED_FULL: ed->bInterval = 1; /* 1 ms */ @@ -172,7 +202,7 @@ } break; default: /* UE_ISOCHRONOUS */ - switch (temp->usb_speed) { + switch (temp->usb2_speed) { case USB_SPEED_LOW: case USB_SPEED_FULL: ed->bInterval = 1; /* 1 ms */ @@ -190,18 +220,18 @@ } /*------------------------------------------------------------------------* - * usbd_make_interface_desc + * usb2_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 -usbd_make_interface_desc(struct usbd_temp_setup *temp, - const struct usb_temp_interface_desc *tid) +usb2_make_interface_desc(struct usb2_temp_setup *temp, + const struct usb2_temp_interface_desc *tid) { - usb_interface_descriptor_t *id; - const struct usb_temp_endpoint_desc **ted; + struct usb2_interface_descriptor *id; + const struct usb2_temp_endpoint_desc **ted; const void **rd; uint16_t old_size; @@ -225,7 +255,7 @@ if (rd) { while (*rd) { - usbd_make_raw_desc(temp, *rd); + usb2_make_raw_desc(temp, *rd); rd++; } } @@ -238,7 +268,7 @@ ted = tid->ppEndpoints; if (ted) { while (*ted) { - usbd_make_endpoint_desc(temp, *ted); + usb2_make_endpoint_desc(temp, *ted); ted++; } } @@ -247,7 +277,7 @@ * in case there is a buffer present: */ if (temp->buf) { - id = USBD_ADD_BYTES(temp->buf, old_size); + id = USB_ADD_BYTES(temp->buf, old_size); id->bLength = sizeof(*id); id->bDescriptorType = UDESC_INTERFACE; id->bInterfaceNumber = temp->bInterfaceNumber; @@ -262,18 +292,18 @@ } /*------------------------------------------------------------------------* - * usbd_make_config_desc + * usb2_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 -usbd_make_config_desc(struct usbd_temp_setup *temp, - const struct usb_temp_config_desc *tcd) +usb2_make_config_desc(struct usb2_temp_setup *temp, + const struct usb2_temp_config_desc *tcd) { - usb_config_descriptor_t *cd; - const struct usb_temp_interface_desc **tid; + struct usb2_config_descriptor *cd; + const struct usb2_temp_interface_desc **tid; uint16_t old_size; /* Reserve memory */ @@ -291,7 +321,7 @@ tid = tcd->ppIfaceDesc; if (tid) { while (*tid) { - usbd_make_interface_desc(temp, *tid); + usb2_make_interface_desc(temp, *tid); tid++; } } @@ -300,7 +330,7 @@ * in case there is a buffer present: */ if (temp->buf) { - cd = USBD_ADD_BYTES(temp->buf, old_size); + cd = USB_ADD_BYTES(temp->buf, old_size); /* compute total size */ old_size = temp->size - old_size; @@ -325,17 +355,17 @@ } /*------------------------------------------------------------------------* - * usbd_make_device_desc + * usb2_make_device_desc * * This function will generate an USB device descriptor from the * given USB template device descriptor. *------------------------------------------------------------------------*/ static void -usbd_make_device_desc(struct usbd_temp_setup *temp, - const struct usb_temp_device_desc *tdd) +usb2_make_device_desc(struct usb2_temp_setup *temp, + const struct usb2_temp_device_desc *tdd) { - struct usb_temp_data *utd; - const struct usb_temp_config_desc **tcd; + struct usb2_temp_data *utd; + const struct usb2_temp_config_desc **tcd; uint16_t old_size; /* Reserve memory */ @@ -349,7 +379,7 @@ tcd = tdd->ppConfigDesc; if (tcd) { while (*tcd) { - usbd_make_config_desc(temp, *tcd); + usb2_make_config_desc(temp, *tcd); temp->bConfigurationValue++; tcd++; } @@ -360,7 +390,7 @@ */ if (temp->buf) { - utd = USBD_ADD_BYTES(temp->buf, old_size); + utd = USB_ADD_BYTES(temp->buf, old_size); /* Store a pointer to our template device descriptor */ utd->tdd = tdd; @@ -395,7 +425,7 @@ USETW(utd->udq.bcdUSB, 0x0200); utd->udq.bMaxPacketSize0 = 0; - switch (temp->usb_speed) { + switch (temp->usb2_speed) { case USB_SPEED_LOW: USETW(utd->udd.bcdUSB, 0x0110); utd->udd.bMaxPacketSize = 8; @@ -413,7 +443,7 @@ utd->udd.bMaxPacketSize = 255; /* 512 bytes */ break; default: - temp->err = USBD_ERR_INVAL; + temp->err = USB_ERR_INVAL; break; } } @@ -421,14 +451,14 @@ } /*------------------------------------------------------------------------* - * usbd_hw_ep_match + * usb2_hw_ep_match * * Return values: * 0: The endpoint profile does not match the criterias * Else: The endpoint profile matches the criterias *------------------------------------------------------------------------*/ static uint8_t -usbd_hw_ep_match(const struct usbd_hw_ep_profile *pf, +usb2_hw_ep_match(const struct usb2_hw_ep_profile *pf, uint8_t ep_type, uint8_t ep_dir_in) { if (ep_type == UE_CONTROL) { @@ -447,7 +477,7 @@ } /*------------------------------------------------------------------------* - * usbd_hw_ep_find_match + * usb2_hw_ep_find_match * * This function is used to find the best matching endpoint profile * for and endpoint belonging to an USB descriptor. @@ -457,10 +487,10 @@ * Else: Failure. No match. *------------------------------------------------------------------------*/ static uint8_t -usbd_hw_ep_find_match(struct usbd_hw_ep_scratch *ues, - struct usbd_sw_ep_scratch *ep, uint8_t is_simplex) +usb2_hw_ep_find_match(struct usb2_hw_ep_scratch *ues, + struct usb2_hw_ep_scratch_sub *ep, uint8_t is_simplex) { - const struct usbd_hw_ep_profile *pf; + const struct usb2_hw_ep_profile *pf; uint16_t distance; uint16_t temp; uint8_t n; @@ -486,7 +516,7 @@ } } - for (n = 1; n != (USB_MAX_ENDPOINTS / 2); n++) { + for (n = 1; n != (USB_EP_MAX / 2); n++) { /* check if IN-endpoint is reserved */ if (dir_in) { @@ -514,7 +544,7 @@ continue; } /* check if HW endpoint matches */ - if (!usbd_hw_ep_match(pf, ep->needs_ep_type, dir_in)) { + if (!usb2_hw_ep_match(pf, ep->needs_ep_type, dir_in)) { /* mismatch */ continue; } @@ -568,7 +598,7 @@ } /*------------------------------------------------------------------------* - * usbd_hw_ep_get_needs + * usb2_hw_ep_get_needs * * This function will figure out the type and number of endpoints * which are needed for an USB configuration. @@ -578,16 +608,16 @@ * Else: Failure. *------------------------------------------------------------------------*/ static uint8_t -usbd_hw_ep_get_needs(struct usbd_hw_ep_scratch *ues, +usb2_hw_ep_get_needs(struct usb2_hw_ep_scratch *ues, uint8_t ep_type, uint8_t is_complete) { - struct usbd_sw_ep_scratch *ep_iface; - struct usbd_sw_ep_scratch *ep_curr; - struct usbd_sw_ep_scratch *ep_max; - struct usbd_sw_ep_scratch *ep_end; - usb_descriptor_t *desc; - usb_interface_descriptor_t *id; - usb_endpoint_descriptor_t *ed; + struct usb2_hw_ep_scratch_sub *ep_iface; + struct usb2_hw_ep_scratch_sub *ep_curr; + struct usb2_hw_ep_scratch_sub *ep_max; + struct usb2_hw_ep_scratch_sub *ep_end; + struct usb2_descriptor *desc; + struct usb2_interface_descriptor *id; + struct usb2_endpoint_descriptor *ed; uint16_t wMaxPacketSize; uint16_t temp; uint8_t allow_override; @@ -595,14 +625,14 @@ ep_iface = ues->ep_max; ep_curr = ues->ep_max; - ep_end = ues->ep + USB_MAX_ENDPOINTS; + ep_end = ues->ep + USB_EP_MAX; ep_max = ues->ep_max; desc = NULL; - speed = ues->udev->speed; + speed = usb2_get_speed(ues->udev); repeat: - while ((desc = usbd_desc_foreach(ues->cd, desc))) { + while ((desc = usb2_desc_foreach(ues->cd, desc))) { if ((desc->bDescriptorType == UDESC_INTERFACE) && (desc->bLength >= sizeof(*id))) { @@ -726,7 +756,7 @@ } /*------------------------------------------------------------------------* - * usbd_hw_ep_resolve + * usb2_hw_ep_resolve * * This function will try to resolve endpoint requirements by the * given endpoint profiles that the USB hardware reports. @@ -735,42 +765,42 @@ * 0: Success * Else: Failure *------------------------------------------------------------------------*/ -static usbd_status_t -usbd_hw_ep_resolve(struct usbd_device *udev, - usb_descriptor_t *desc) +static usb2_error_t +usb2_hw_ep_resolve(struct usb2_device *udev, + struct usb2_descriptor *desc) { - struct usbd_hw_ep_scratch *ues; - struct usbd_sw_ep_scratch *ep; - const struct usbd_hw_ep_profile *pf; - struct usbd_bus_methods *methods; - usb_device_descriptor_t *dd; + struct usb2_hw_ep_scratch *ues; + struct usb2_hw_ep_scratch_sub *ep; + const struct usb2_hw_ep_profile *pf; + struct usb2_bus_methods *methods; + struct usb2_device_descriptor *dd; uint16_t mps; if (desc == NULL) { - return (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } /* get bus methods */ methods = udev->bus->methods; if (methods->get_hw_ep_profile == NULL) { - return (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } if (desc->bDescriptorType == UDESC_DEVICE) { if (desc->bLength < sizeof(*dd)) { - return (USBD_ERR_INVAL); + 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 (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } - if (!usbd_hw_ep_match(pf, UE_CONTROL, 0)) { - PRINTFN(-1, ("Endpoint 0 does not " - "support control\n")); - return (USBD_ERR_INVAL); + if (!usb2_hw_ep_match(pf, UE_CONTROL, 0)) { + DPRINTF(-1, "Endpoint 0 does not " + "support control\n"); + return (USB_ERR_INVAL); } mps = dd->bMaxPacketSize; @@ -788,7 +818,7 @@ /* check if "mps" is too small */ if (mps < 8) { - return (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } } @@ -801,18 +831,18 @@ } /* Check if we support the specified wMaxPacketSize */ if (pf->max_frame_size < mps) { - return (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } } return (0); /* success */ } if (desc->bDescriptorType != UDESC_CONFIG) { - return (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } if (desc->bLength < sizeof(*(ues->cd))) { - return (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } - ues = udev->scratch[0].hw_ep_scratch; + ues = udev->bus->scratch[0].hw_ep_scratch; bzero(ues, sizeof(*ues)); @@ -823,12 +853,12 @@ /* Get all the endpoints we need */ - if (usbd_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) || - usbd_hw_ep_get_needs(ues, UE_INTERRUPT, 0) || - usbd_hw_ep_get_needs(ues, UE_CONTROL, 0) || - usbd_hw_ep_get_needs(ues, UE_BULK, 0)) { - PRINTFN(-1, ("Could not get needs\n")); - return (USBD_ERR_INVAL); + if (usb2_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) || + usb2_hw_ep_get_needs(ues, UE_INTERRUPT, 0) || + usb2_hw_ep_get_needs(ues, UE_CONTROL, 0) || + usb2_hw_ep_get_needs(ues, UE_BULK, 0)) { + DPRINTF(-1, "Could not get needs\n"); + return (USB_ERR_INVAL); } for (ep = ues->ep; ep != ues->ep_max; ep++) { @@ -838,10 +868,10 @@ * First try to use a simplex endpoint. * Then try to use a duplex endpoint. */ - if (usbd_hw_ep_find_match(ues, ep, 1) && - usbd_hw_ep_find_match(ues, ep, 0)) { - PRINTFN(-1, ("Could not find match\n")); - return (USBD_ERR_INVAL); + if (usb2_hw_ep_find_match(ues, ep, 1) && + usb2_hw_ep_find_match(ues, ep, 0)) { + DPRINTF(-1, "Could not find match\n"); + return (USB_ERR_INVAL); } } } @@ -850,48 +880,48 @@ /* Update all endpoint addresses */ - if (usbd_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) || - usbd_hw_ep_get_needs(ues, UE_INTERRUPT, 1) || - usbd_hw_ep_get_needs(ues, UE_CONTROL, 1) || - usbd_hw_ep_get_needs(ues, UE_BULK, 1)) { - PRINTFN(-1, ("Could not update endpoint address\n")); - return (USBD_ERR_INVAL); + if (usb2_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) || + usb2_hw_ep_get_needs(ues, UE_INTERRUPT, 1) || + usb2_hw_ep_get_needs(ues, UE_CONTROL, 1) || + usb2_hw_ep_get_needs(ues, UE_BULK, 1)) { + DPRINTF(-1, "Could not update endpoint address\n"); + return (USB_ERR_INVAL); } return (0); /* success */ } /*------------------------------------------------------------------------* - * usbd_temp_get_tdd + * usb2_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 * -usbd_temp_get_tdd(struct usbd_device *udev) +static const struct usb2_temp_device_desc * +usb2_temp_get_tdd(struct usb2_device *udev) { - if (udev->usb_template_ptr == NULL) { + if (udev->usb2_template_ptr == NULL) { return (NULL); } - return (udev->usb_template_ptr->tdd); + return (udev->usb2_template_ptr->tdd); } /*------------------------------------------------------------------------* - * usbd_temp_get_device_desc + * usb2_temp_get_device_desc * * Returns: * NULL: No USB device descriptor found. * Else: Pointer to USB device descriptor. *------------------------------------------------------------------------*/ static void * -usbd_temp_get_device_desc(struct usbd_device *udev) +usb2_temp_get_device_desc(struct usb2_device *udev) { - usb_device_descriptor_t *dd; + struct usb2_device_descriptor *dd; - if (udev->usb_template_ptr == NULL) { + if (udev->usb2_template_ptr == NULL) { return (NULL); } - dd = &(udev->usb_template_ptr->udd); + dd = &(udev->usb2_template_ptr->udd); if (dd->bDescriptorType != UDESC_DEVICE) { /* sanity check failed */ return (NULL); @@ -900,21 +930,21 @@ } /*------------------------------------------------------------------------* - * usbd_temp_get_qualifier_desc + * usb2_temp_get_qualifier_desc * * Returns: * NULL: No USB device_qualifier descriptor found. * Else: Pointer to USB device_qualifier descriptor. *------------------------------------------------------------------------*/ static void * -usbd_temp_get_qualifier_desc(struct usbd_device *udev) +usb2_temp_get_qualifier_desc(struct usb2_device *udev) { - usb_device_qualifier_t *dq; + struct usb2_device_qualifier *dq; - if (udev->usb_template_ptr == NULL) { + if (udev->usb2_template_ptr == NULL) { return (NULL); } - dq = &(udev->usb_template_ptr->udq); + dq = &(udev->usb2_template_ptr->udq); if (dq->bDescriptorType != UDESC_DEVICE_QUALIFIER) { /* sanity check failed */ return (NULL); @@ -923,25 +953,25 @@ } /*------------------------------------------------------------------------* - * usbd_temp_get_config_desc + * usb2_temp_get_config_desc * * Returns: * NULL: No USB config descriptor found. * Else: Pointer to USB config descriptor having index "index". *------------------------------------------------------------------------*/ static void * -usbd_temp_get_config_desc(struct usbd_device *udev, +usb2_temp_get_config_desc(struct usb2_device *udev, uint16_t *pLength, uint8_t index) { - usb_device_descriptor_t *dd; - usb_config_descriptor_t *cd; + struct usb2_device_descriptor *dd; + struct usb2_config_descriptor *cd; uint16_t temp; - if (udev->usb_template_ptr == NULL) { + if (udev->usb2_template_ptr == NULL) { return (NULL); } - dd = &(udev->usb_template_ptr->udd); - cd = (void *)(udev->usb_template_ptr + 1); + dd = &(udev->usb2_template_ptr->udd); + cd = (void *)(udev->usb2_template_ptr + 1); if (index >= dd->bNumConfigurations) { /* out of range */ @@ -953,7 +983,7 @@ return (NULL); } temp = UGETW(cd->wTotalLength); - cd = USBD_ADD_BYTES(cd, temp); + cd = USB_ADD_BYTES(cd, temp); } if (pLength) { @@ -963,19 +993,19 @@ } /*------------------------------------------------------------------------* - * usbd_temp_get_string_desc + * usb2_temp_get_string_desc * * Returns: * NULL: No string descriptor found. * Else: Pointer to a string descriptor. *------------------------------------------------------------------------*/ static const void * -usbd_temp_get_string_desc(struct usbd_device *udev, +usb2_temp_get_string_desc(struct usb2_device *udev, uint16_t lang_id, uint8_t string_index) { - const struct usb_temp_device_desc *tdd; + const struct usb2_temp_device_desc *tdd; - tdd = usbd_temp_get_tdd(udev); + tdd = usb2_temp_get_tdd(udev); if (tdd == NULL) { return (NULL); } @@ -986,26 +1016,26 @@ } /*------------------------------------------------------------------------* - * usbd_temp_get_hub_desc + * usb2_temp_get_hub_desc * * Returns: * NULL: No USB HUB descriptor found. * Else: Pointer to a USB HUB descriptor. *------------------------------------------------------------------------*/ static const void * -usbd_temp_get_hub_desc(struct usbd_device *udev) +usb2_temp_get_hub_desc(struct usb2_device *udev) { return (NULL); /* needs to be implemented */ } /*------------------------------------------------------------------------* - * usbd_temp_get_desc + * usb2_temp_get_desc * * This function is a demultiplexer for local USB device side control * endpoint requests. *------------------------------------------------------------------------*/ -void -usbd_temp_get_desc(struct usbd_device *udev, usb_device_request_t *req, +static void +usb2_temp_get_desc(struct usb2_device *udev, struct usb2_device_request *req, const void **pPtr, uint16_t *pLength) { const uint8_t *buf; @@ -1041,7 +1071,7 @@ if (req->wValue[0]) { goto tr_stalled; } - buf = usbd_temp_get_device_desc(udev); + buf = usb2_temp_get_device_desc(udev); goto tr_valid; case UDESC_DEVICE_QUALIFIER: if (udev->speed != USB_SPEED_HIGH) { @@ -1050,18 +1080,18 @@ if (req->wValue[0]) { goto tr_stalled; } - buf = usbd_temp_get_qualifier_desc(udev); + buf = usb2_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 = usbd_temp_get_config_desc(udev, + buf = usb2_temp_get_config_desc(udev, &len, req->wValue[0]); goto tr_valid; case UDESC_STRING: - buf = usbd_temp_get_string_desc(udev, + buf = usb2_temp_get_string_desc(udev, UGETW(req->wIndex), req->wValue[0]); goto tr_valid; default: @@ -1073,7 +1103,7 @@ if (req->wValue[0]) { goto tr_stalled; } - buf = usbd_temp_get_hub_desc(udev); + buf = usb2_temp_get_hub_desc(udev); goto tr_valid; tr_valid: @@ -1094,7 +1124,7 @@ } /*------------------------------------------------------------------------* - * usbd_temp_setup + * usb2_temp_setup * * This function generates USB descriptors according to the given USB * template device descriptor. It will also try to figure out the best @@ -1104,11 +1134,11 @@ * 0: Success * Else: Failure *------------------------------------------------------------------------*/ -usbd_status_t -usbd_temp_setup(struct usbd_device *udev, - const struct usb_temp_device_desc *tdd) +static usb2_error_t +usb2_temp_setup(struct usb2_device *udev, + const struct usb2_temp_device_desc *tdd) { - struct usbd_temp_setup *uts; + struct usb2_temp_setup *uts; void *buf; uint8_t n; @@ -1116,16 +1146,16 @@ /* be NULL safe */ return (0); } - uts = udev->scratch[0].temp_setup; + uts = udev->bus->scratch[0].temp_setup; bzero(uts, sizeof(*uts)); - uts->usb_speed = udev->speed; + uts->usb2_speed = udev->speed; uts->self_powered = udev->flags.self_powered; /* first pass */ - usbd_make_device_desc(uts, tdd); + usb2_make_device_desc(uts, tdd); if (uts->err) { /* some error happened */ @@ -1133,24 +1163,24 @@ } /* sanity check */ if (uts->size == 0) { - return (USBD_ERR_INVAL); + return (USB_ERR_INVAL); } /* allocate zeroed memory */ uts->buf = malloc(uts->size, M_USB, M_WAITOK | M_ZERO); if (uts->buf == NULL) { /* could not allocate memory */ - return (USBD_ERR_NOMEM); + return (USB_ERR_NOMEM); } /* second pass */ uts->size = 0; - usbd_make_device_desc(uts, tdd); + usb2_make_device_desc(uts, tdd); /* * Store a pointer to our descriptors: */ - udev->usb_template_ptr = uts->buf; + udev->usb2_template_ptr = uts->buf; if (uts->err) { /* some error happened during second pass */ @@ -1159,49 +1189,84 @@ /* * Resolve all endpoint addresses ! */ - buf = usbd_temp_get_device_desc(udev); - uts->err = usbd_hw_ep_resolve(udev, buf); + buf = usb2_temp_get_device_desc(udev); + uts->err = usb2_hw_ep_resolve(udev, buf); if (uts->err) { - PRINTFN(-1, ("Could not resolve endpoints for " + DPRINTF(-1, "Could not resolve endpoints for " "Device Descriptor, error = %s\n", - usbd_errstr(uts->err))); + usb2_errstr(uts->err)); goto error; } for (n = 0;; n++) { - buf = usbd_temp_get_config_desc(udev, NULL, n); + buf = usb2_temp_get_config_desc(udev, NULL, n); if (buf == NULL) { break; } - uts->err = usbd_hw_ep_resolve(udev, buf); + uts->err = usb2_hw_ep_resolve(udev, buf); if (uts->err) { - PRINTFN(-1, ("Could not resolve endpoints for " + DPRINTF(-1, "Could not resolve endpoints for " "Config Descriptor %u, error = %s\n", n, - usbd_errstr(uts->err))); + usb2_errstr(uts->err)); goto error; } } return (uts->err); error: - usbd_temp_unsetup(udev); + usb2_temp_unsetup(udev); return (uts->err); } /*------------------------------------------------------------------------* - * usbd_temp_unsetup + * usb2_temp_unsetup * * This function frees any memory associated with the currently * setup template, if any. *------------------------------------------------------------------------*/ -void -usbd_temp_unsetup(struct usbd_device *udev) +static void +usb2_temp_unsetup(struct usb2_device *udev) { - if (udev->usb_template_ptr) { + if (udev->usb2_template_ptr) { + + free(udev->usb2_template_ptr, M_USB); + + udev->usb2_template_ptr = NULL; + } + return; +} - free(udev->usb_template_ptr, M_USB); +static usb2_error_t +usb2_temp_setup_by_index(struct usb2_device *udev, uint16_t index) +{ + usb2_error_t err; - udev->usb_template_ptr = NULL; + switch (index) { + case 0: + err = usb2_temp_setup(udev, &usb2_template_msc); + break; + case 1: + err = usb2_temp_setup(udev, &usb2_template_cdce); + break; + case 2: + err = usb2_temp_setup(udev, &usb2_template_mtp); + break; + default: + return (USB_ERR_INVAL); } + + return (err); +} + +static void +usb2_temp_init(void *arg) >>> TRUNCATED FOR MAIL (1000 lines) <<<
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?200807011738.m61HckWA051141>