static void free_wrapper(struct gadget_wrapper *d)
{
if (d->driver) {
/* should have been done already by driver model core */
DWC_WARN("driver is still registered\n");
usb_gadget_unregister_driver(d->driver);
}
//device_unregister(&d->gadget.dev);
dwc_free(d);
}
/**
* This function frees a request object.
*
* @param ep The endpoint associated with the request
* @param req The request being freed
*/
static void dwc_otg_pcd_free_request(struct usb_ep *ep, struct usb_request *req)
{
DWC_DEBUGPL(DBG_PCDV, "%s(%p,%p)\n", __func__, ep, req);
if (0 == ep || 0 == req) {
DWC_WARN("%s() %s\n", __func__,
"Invalid ep or req argument!\n");
return;
}
dwc_free(req);
}
/* Computes the modular exponentiation (num^exp % mod). num, exp, and mod are
* big endian numbers of size len, in bytes. Each len value must be a multiple
* of 4. */
int dwc_dh_modpow(void *mem_ctx, void *num, uint32_t num_len,
void *exp, uint32_t exp_len,
void *mod, uint32_t mod_len,
void *out)
{
/* modpow() takes little endian numbers. AM uses big-endian. This
* function swaps bytes of numbers before passing onto modpow. */
int retval = 0;
uint32_t *result;
uint32_t *bignum_num = dwc_alloc(mem_ctx, num_len + 4);
uint32_t *bignum_exp = dwc_alloc(mem_ctx, exp_len + 4);
uint32_t *bignum_mod = dwc_alloc(mem_ctx, mod_len + 4);
dh_swap_bytes(num, &bignum_num[1], num_len);
bignum_num[0] = num_len / 4;
dh_swap_bytes(exp, &bignum_exp[1], exp_len);
bignum_exp[0] = exp_len / 4;
dh_swap_bytes(mod, &bignum_mod[1], mod_len);
bignum_mod[0] = mod_len / 4;
result = dwc_modpow(mem_ctx, bignum_num, bignum_exp, bignum_mod);
if (!result) {
retval = -1;
goto dh_modpow_nomem;
}
dh_swap_bytes(&result[1], out, result[0] * 4);
dwc_free(mem_ctx, result);
dh_modpow_nomem:
dwc_free(mem_ctx, bignum_num);
dwc_free(mem_ctx, bignum_exp);
dwc_free(mem_ctx, bignum_mod);
return retval;
}
static struct gadget_wrapper *alloc_wrapper(
struct dwc_otg_device *_dev
)
{
static char pcd_name[] = "dwc_otg";
//dwc_otg_device_t *otg_dev = platform_get_drvdata(_dev);
dwc_otg_device_t *otg_dev = _dev;
struct gadget_wrapper *d;
int retval;
d = dwc_alloc(sizeof(*d));
if (d == NULL) {
return NULL;
}
memset(d, 0, sizeof(*d));
d->gadget.name = pcd_name;
d->pcd = otg_dev->pcd;
//sword
/*
strcpy(d->gadget.dev.bus_id, "gadget");
*/
#if 0
dev_set_name(&d->gadget.dev, "gadget");
d->gadget.dev.parent = &_dev->dev;
d->gadget.dev.release = dwc_otg_pcd_gadget_release;
#endif
d->gadget.ops = &dwc_otg_pcd_ops;
d->gadget.is_dualspeed = dwc_otg_pcd_is_dualspeed(otg_dev->pcd);
d->gadget.is_otg = dwc_otg_pcd_is_otg(otg_dev->pcd);
d->driver = 0;
/* Register the gadget device */
#if 0
retval = device_register(&d->gadget.dev);
if (retval != 0) {
DWC_ERROR("device_register failed\n");
dwc_free(d);
return NULL;
}
#endif
return d;
}
static struct gadget_wrapper *alloc_wrapper(
struct platform_device *_dev
)
{
static char pcd_name[] = "dwc_otg";
dwc_otg_device_t *otg_dev = platform_get_drvdata(_dev);
struct gadget_wrapper *d;
int retval;
d = dwc_alloc(sizeof(*d));
if (d == NULL) {
return NULL;
}
memset(d, 0, sizeof(*d));
d->gadget.name = pcd_name;
d->pcd = otg_dev->pcd;
//sword
/*
strcpy(d->gadget.dev.bus_id, "gadget");
*/
dev_set_name(&d->gadget.dev, "gadget");
d->gadget.dev.parent = &_dev->dev;
d->gadget.dev.release = dwc_otg_pcd_gadget_release;
d->gadget.ops = &dwc_otg_pcd_ops;
d->gadget.max_speed = USB_SPEED_HIGH;
d->gadget.is_otg = dwc_otg_pcd_is_otg(otg_dev->pcd);
if (d->pcd->core_if->dma_enable &&
d->pcd->core_if->dma_desc_enable)
d->gadget.sg_supported = 1;
d->driver = 0;
/* Register the gadget device */
#if 0
retval = device_register(&d->gadget.dev);
if (retval != 0) {
DWC_ERROR("device_register failed\n");
dwc_free(d);
return NULL;
}
#endif
return d;
}
/**
* Sets the final status of an URB and returns it to the device driver. Any
* required cleanup of the URB is performed.
*/
static int _complete(dwc_otg_hcd_t * hcd, void *urb_handle,
dwc_otg_hcd_urb_t * dwc_otg_urb, uint32_t status)
{
struct urb *urb = (struct urb *)urb_handle;
#ifdef DEBUG
if (CHK_DEBUG_LEVEL(DBG_HCDV | DBG_HCD_URB)) {
DWC_PRINTF("%s: urb %p, device %d, ep %d %s, status=%d\n",
__func__, urb, usb_pipedevice(urb->pipe),
usb_pipeendpoint(urb->pipe),
usb_pipein(urb->pipe) ? "IN" : "OUT", status);
if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
int i;
for (i = 0; i < urb->number_of_packets; i++) {
DWC_PRINTF(" ISO Desc %d status: %d\n",
i, urb->iso_frame_desc[i].status);
}
}
}
#endif
urb->actual_length = dwc_otg_hcd_urb_get_actual_length(dwc_otg_urb);
/* Convert status value. */
switch (status) {
case -DWC_E_PROTOCOL:
status = -EPROTO;
break;
case -DWC_E_IN_PROGRESS:
status = -EINPROGRESS;
break;
case -DWC_E_PIPE:
status = -EPIPE;
break;
case -DWC_E_IO:
status = -EIO;
break;
case -DWC_E_TIMEOUT:
status = -ETIMEDOUT;
break;
default:
if (status) {
/* alan.K
* DWC_OTG IP don't know this status, so assumed to be a DWC_E_PROTOCOL.
*/
DWC_WARN("Unknown urb status %d, but assumed to be an EPROTO\n", status);
status = -EPROTO;
}
}
if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
int i;
urb->error_count = dwc_otg_hcd_urb_get_error_count(dwc_otg_urb);
for (i = 0; i < urb->number_of_packets; ++i) {
urb->iso_frame_desc[i].actual_length =
dwc_otg_hcd_urb_get_iso_desc_actual_length
(dwc_otg_urb, i);
urb->iso_frame_desc[i].status =
dwc_otg_hcd_urb_get_iso_desc_actual_length
(dwc_otg_urb, i);
}
}
urb->status = status;
urb->hcpriv = NULL;
if (!status) {
if ((urb->transfer_flags & URB_SHORT_NOT_OK) &&
(urb->actual_length < urb->transfer_buffer_length)) {
urb->status = -EREMOTEIO;
}
}
if ((usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) ||
(usb_pipetype(urb->pipe) == PIPE_INTERRUPT)) {
struct usb_host_endpoint *ep = dwc_urb_to_endpoint(urb);
if (ep) {
free_bus_bandwidth(dwc_otg_hcd_to_hcd(hcd),
dwc_otg_hcd_get_ep_bandwidth(hcd, ep->hcpriv),
urb);
}
}
dwc_free(dwc_otg_urb);
usb_hcd_giveback_urb(dwc_otg_hcd_to_hcd(hcd), urb, status);
return 0;
}
