forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
603 lines
14 KiB
603 lines
14 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* aspeed-vhub -- Driver for Aspeed SoC "vHub" USB gadget |
|
* |
|
* dev.c - Individual device/gadget management (ie, a port = a gadget) |
|
* |
|
* Copyright 2017 IBM Corporation |
|
* |
|
* This program is free software; you can redistribute it and/or modify |
|
* it under the terms of the GNU General Public License as published by |
|
* the Free Software Foundation; either version 2 of the License, or |
|
* (at your option) any later version. |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/delay.h> |
|
#include <linux/ioport.h> |
|
#include <linux/slab.h> |
|
#include <linux/errno.h> |
|
#include <linux/list.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/proc_fs.h> |
|
#include <linux/prefetch.h> |
|
#include <linux/clk.h> |
|
#include <linux/usb/gadget.h> |
|
#include <linux/of.h> |
|
#include <linux/of_gpio.h> |
|
#include <linux/regmap.h> |
|
#include <linux/dma-mapping.h> |
|
#include <linux/usb.h> |
|
#include <linux/usb/hcd.h> |
|
|
|
#include "vhub.h" |
|
|
|
void ast_vhub_dev_irq(struct ast_vhub_dev *d) |
|
{ |
|
u32 istat = readl(d->regs + AST_VHUB_DEV_ISR); |
|
|
|
writel(istat, d->regs + AST_VHUB_DEV_ISR); |
|
|
|
if (istat & VHUV_DEV_IRQ_EP0_IN_ACK_STALL) |
|
ast_vhub_ep0_handle_ack(&d->ep0, true); |
|
if (istat & VHUV_DEV_IRQ_EP0_OUT_ACK_STALL) |
|
ast_vhub_ep0_handle_ack(&d->ep0, false); |
|
if (istat & VHUV_DEV_IRQ_EP0_SETUP) |
|
ast_vhub_ep0_handle_setup(&d->ep0); |
|
} |
|
|
|
static void ast_vhub_dev_enable(struct ast_vhub_dev *d) |
|
{ |
|
u32 reg, hmsk, i; |
|
|
|
if (d->enabled) |
|
return; |
|
|
|
/* Cleanup EP0 state */ |
|
ast_vhub_reset_ep0(d); |
|
|
|
/* Enable device and its EP0 interrupts */ |
|
reg = VHUB_DEV_EN_ENABLE_PORT | |
|
VHUB_DEV_EN_EP0_IN_ACK_IRQEN | |
|
VHUB_DEV_EN_EP0_OUT_ACK_IRQEN | |
|
VHUB_DEV_EN_EP0_SETUP_IRQEN; |
|
if (d->gadget.speed == USB_SPEED_HIGH) |
|
reg |= VHUB_DEV_EN_SPEED_SEL_HIGH; |
|
writel(reg, d->regs + AST_VHUB_DEV_EN_CTRL); |
|
|
|
/* Enable device interrupt in the hub as well */ |
|
hmsk = VHUB_IRQ_DEVICE1 << d->index; |
|
reg = readl(d->vhub->regs + AST_VHUB_IER); |
|
reg |= hmsk; |
|
writel(reg, d->vhub->regs + AST_VHUB_IER); |
|
|
|
/* Set EP0 DMA buffer address */ |
|
writel(d->ep0.buf_dma, d->regs + AST_VHUB_DEV_EP0_DATA); |
|
|
|
/* Clear stall on all EPs */ |
|
for (i = 0; i < d->max_epns; i++) { |
|
struct ast_vhub_ep *ep = d->epns[i]; |
|
|
|
if (ep && (ep->epn.stalled || ep->epn.wedged)) { |
|
ep->epn.stalled = false; |
|
ep->epn.wedged = false; |
|
ast_vhub_update_epn_stall(ep); |
|
} |
|
} |
|
|
|
/* Additional cleanups */ |
|
d->wakeup_en = false; |
|
d->enabled = true; |
|
} |
|
|
|
static void ast_vhub_dev_disable(struct ast_vhub_dev *d) |
|
{ |
|
u32 reg, hmsk; |
|
|
|
if (!d->enabled) |
|
return; |
|
|
|
/* Disable device interrupt in the hub */ |
|
hmsk = VHUB_IRQ_DEVICE1 << d->index; |
|
reg = readl(d->vhub->regs + AST_VHUB_IER); |
|
reg &= ~hmsk; |
|
writel(reg, d->vhub->regs + AST_VHUB_IER); |
|
|
|
/* Then disable device */ |
|
writel(0, d->regs + AST_VHUB_DEV_EN_CTRL); |
|
d->gadget.speed = USB_SPEED_UNKNOWN; |
|
d->enabled = false; |
|
} |
|
|
|
static int ast_vhub_dev_feature(struct ast_vhub_dev *d, |
|
u16 wIndex, u16 wValue, |
|
bool is_set) |
|
{ |
|
DDBG(d, "%s_FEATURE(dev val=%02x)\n", |
|
is_set ? "SET" : "CLEAR", wValue); |
|
|
|
if (wValue != USB_DEVICE_REMOTE_WAKEUP) |
|
return std_req_driver; |
|
|
|
d->wakeup_en = is_set; |
|
|
|
return std_req_complete; |
|
} |
|
|
|
static int ast_vhub_ep_feature(struct ast_vhub_dev *d, |
|
u16 wIndex, u16 wValue, bool is_set) |
|
{ |
|
struct ast_vhub_ep *ep; |
|
int ep_num; |
|
|
|
ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK; |
|
DDBG(d, "%s_FEATURE(ep%d val=%02x)\n", |
|
is_set ? "SET" : "CLEAR", ep_num, wValue); |
|
if (ep_num == 0) |
|
return std_req_complete; |
|
if (ep_num >= d->max_epns || !d->epns[ep_num - 1]) |
|
return std_req_stall; |
|
if (wValue != USB_ENDPOINT_HALT) |
|
return std_req_driver; |
|
|
|
ep = d->epns[ep_num - 1]; |
|
if (WARN_ON(!ep)) |
|
return std_req_stall; |
|
|
|
if (!ep->epn.enabled || !ep->ep.desc || ep->epn.is_iso || |
|
ep->epn.is_in != !!(wIndex & USB_DIR_IN)) |
|
return std_req_stall; |
|
|
|
DDBG(d, "%s stall on EP %d\n", |
|
is_set ? "setting" : "clearing", ep_num); |
|
ep->epn.stalled = is_set; |
|
ast_vhub_update_epn_stall(ep); |
|
|
|
return std_req_complete; |
|
} |
|
|
|
static int ast_vhub_dev_status(struct ast_vhub_dev *d, |
|
u16 wIndex, u16 wValue) |
|
{ |
|
u8 st0; |
|
|
|
DDBG(d, "GET_STATUS(dev)\n"); |
|
|
|
st0 = d->gadget.is_selfpowered << USB_DEVICE_SELF_POWERED; |
|
if (d->wakeup_en) |
|
st0 |= 1 << USB_DEVICE_REMOTE_WAKEUP; |
|
|
|
return ast_vhub_simple_reply(&d->ep0, st0, 0); |
|
} |
|
|
|
static int ast_vhub_ep_status(struct ast_vhub_dev *d, |
|
u16 wIndex, u16 wValue) |
|
{ |
|
int ep_num = wIndex & USB_ENDPOINT_NUMBER_MASK; |
|
struct ast_vhub_ep *ep; |
|
u8 st0 = 0; |
|
|
|
DDBG(d, "GET_STATUS(ep%d)\n", ep_num); |
|
|
|
if (ep_num >= d->max_epns) |
|
return std_req_stall; |
|
if (ep_num != 0) { |
|
ep = d->epns[ep_num - 1]; |
|
if (!ep) |
|
return std_req_stall; |
|
if (!ep->epn.enabled || !ep->ep.desc || ep->epn.is_iso || |
|
ep->epn.is_in != !!(wIndex & USB_DIR_IN)) |
|
return std_req_stall; |
|
if (ep->epn.stalled) |
|
st0 |= 1 << USB_ENDPOINT_HALT; |
|
} |
|
|
|
return ast_vhub_simple_reply(&d->ep0, st0, 0); |
|
} |
|
|
|
static void ast_vhub_dev_set_address(struct ast_vhub_dev *d, u8 addr) |
|
{ |
|
u32 reg; |
|
|
|
DDBG(d, "SET_ADDRESS: Got address %x\n", addr); |
|
|
|
reg = readl(d->regs + AST_VHUB_DEV_EN_CTRL); |
|
reg &= ~VHUB_DEV_EN_ADDR_MASK; |
|
reg |= VHUB_DEV_EN_SET_ADDR(addr); |
|
writel(reg, d->regs + AST_VHUB_DEV_EN_CTRL); |
|
} |
|
|
|
int ast_vhub_std_dev_request(struct ast_vhub_ep *ep, |
|
struct usb_ctrlrequest *crq) |
|
{ |
|
struct ast_vhub_dev *d = ep->dev; |
|
u16 wValue, wIndex; |
|
|
|
/* No driver, we shouldn't be enabled ... */ |
|
if (!d->driver || !d->enabled) { |
|
EPDBG(ep, |
|
"Device is wrong state driver=%p enabled=%d\n", |
|
d->driver, d->enabled); |
|
return std_req_stall; |
|
} |
|
|
|
/* |
|
* Note: we used to reject/stall requests while suspended, |
|
* we don't do that anymore as we seem to have cases of |
|
* mass storage getting very upset. |
|
*/ |
|
|
|
/* First packet, grab speed */ |
|
if (d->gadget.speed == USB_SPEED_UNKNOWN) { |
|
d->gadget.speed = ep->vhub->speed; |
|
if (d->gadget.speed > d->driver->max_speed) |
|
d->gadget.speed = d->driver->max_speed; |
|
DDBG(d, "fist packet, captured speed %d\n", |
|
d->gadget.speed); |
|
} |
|
|
|
wValue = le16_to_cpu(crq->wValue); |
|
wIndex = le16_to_cpu(crq->wIndex); |
|
|
|
switch ((crq->bRequestType << 8) | crq->bRequest) { |
|
/* SET_ADDRESS */ |
|
case DeviceOutRequest | USB_REQ_SET_ADDRESS: |
|
ast_vhub_dev_set_address(d, wValue); |
|
return std_req_complete; |
|
|
|
/* GET_STATUS */ |
|
case DeviceRequest | USB_REQ_GET_STATUS: |
|
return ast_vhub_dev_status(d, wIndex, wValue); |
|
case InterfaceRequest | USB_REQ_GET_STATUS: |
|
return ast_vhub_simple_reply(ep, 0, 0); |
|
case EndpointRequest | USB_REQ_GET_STATUS: |
|
return ast_vhub_ep_status(d, wIndex, wValue); |
|
|
|
/* SET/CLEAR_FEATURE */ |
|
case DeviceOutRequest | USB_REQ_SET_FEATURE: |
|
return ast_vhub_dev_feature(d, wIndex, wValue, true); |
|
case DeviceOutRequest | USB_REQ_CLEAR_FEATURE: |
|
return ast_vhub_dev_feature(d, wIndex, wValue, false); |
|
case EndpointOutRequest | USB_REQ_SET_FEATURE: |
|
return ast_vhub_ep_feature(d, wIndex, wValue, true); |
|
case EndpointOutRequest | USB_REQ_CLEAR_FEATURE: |
|
return ast_vhub_ep_feature(d, wIndex, wValue, false); |
|
} |
|
return std_req_driver; |
|
} |
|
|
|
static int ast_vhub_udc_wakeup(struct usb_gadget* gadget) |
|
{ |
|
struct ast_vhub_dev *d = to_ast_dev(gadget); |
|
unsigned long flags; |
|
int rc = -EINVAL; |
|
|
|
spin_lock_irqsave(&d->vhub->lock, flags); |
|
if (!d->wakeup_en) |
|
goto err; |
|
|
|
DDBG(d, "Device initiated wakeup\n"); |
|
|
|
/* Wakeup the host */ |
|
ast_vhub_hub_wake_all(d->vhub); |
|
rc = 0; |
|
err: |
|
spin_unlock_irqrestore(&d->vhub->lock, flags); |
|
return rc; |
|
} |
|
|
|
static int ast_vhub_udc_get_frame(struct usb_gadget* gadget) |
|
{ |
|
struct ast_vhub_dev *d = to_ast_dev(gadget); |
|
|
|
return (readl(d->vhub->regs + AST_VHUB_USBSTS) >> 16) & 0x7ff; |
|
} |
|
|
|
static void ast_vhub_dev_nuke(struct ast_vhub_dev *d) |
|
{ |
|
unsigned int i; |
|
|
|
for (i = 0; i < d->max_epns; i++) { |
|
if (!d->epns[i]) |
|
continue; |
|
ast_vhub_nuke(d->epns[i], -ESHUTDOWN); |
|
} |
|
} |
|
|
|
static int ast_vhub_udc_pullup(struct usb_gadget* gadget, int on) |
|
{ |
|
struct ast_vhub_dev *d = to_ast_dev(gadget); |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&d->vhub->lock, flags); |
|
|
|
DDBG(d, "pullup(%d)\n", on); |
|
|
|
/* Mark disconnected in the hub */ |
|
ast_vhub_device_connect(d->vhub, d->index, on); |
|
|
|
/* |
|
* If enabled, nuke all requests if any (there shouldn't be) |
|
* and disable the port. This will clear the address too. |
|
*/ |
|
if (d->enabled) { |
|
ast_vhub_dev_nuke(d); |
|
ast_vhub_dev_disable(d); |
|
} |
|
|
|
spin_unlock_irqrestore(&d->vhub->lock, flags); |
|
|
|
return 0; |
|
} |
|
|
|
static int ast_vhub_udc_start(struct usb_gadget *gadget, |
|
struct usb_gadget_driver *driver) |
|
{ |
|
struct ast_vhub_dev *d = to_ast_dev(gadget); |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&d->vhub->lock, flags); |
|
|
|
DDBG(d, "start\n"); |
|
|
|
/* We don't do much more until the hub enables us */ |
|
d->driver = driver; |
|
d->gadget.is_selfpowered = 1; |
|
|
|
spin_unlock_irqrestore(&d->vhub->lock, flags); |
|
|
|
return 0; |
|
} |
|
|
|
static struct usb_ep *ast_vhub_udc_match_ep(struct usb_gadget *gadget, |
|
struct usb_endpoint_descriptor *desc, |
|
struct usb_ss_ep_comp_descriptor *ss) |
|
{ |
|
struct ast_vhub_dev *d = to_ast_dev(gadget); |
|
struct ast_vhub_ep *ep; |
|
struct usb_ep *u_ep; |
|
unsigned int max, addr, i; |
|
|
|
DDBG(d, "Match EP type %d\n", usb_endpoint_type(desc)); |
|
|
|
/* |
|
* First we need to look for an existing unclaimed EP as another |
|
* configuration may have already associated a bunch of EPs with |
|
* this gadget. This duplicates the code in usb_ep_autoconfig_ss() |
|
* unfortunately. |
|
*/ |
|
list_for_each_entry(u_ep, &gadget->ep_list, ep_list) { |
|
if (usb_gadget_ep_match_desc(gadget, u_ep, desc, ss)) { |
|
DDBG(d, " -> using existing EP%d\n", |
|
to_ast_ep(u_ep)->d_idx); |
|
return u_ep; |
|
} |
|
} |
|
|
|
/* |
|
* We didn't find one, we need to grab one from the pool. |
|
* |
|
* First let's do some sanity checking |
|
*/ |
|
switch(usb_endpoint_type(desc)) { |
|
case USB_ENDPOINT_XFER_CONTROL: |
|
/* Only EP0 can be a control endpoint */ |
|
return NULL; |
|
case USB_ENDPOINT_XFER_ISOC: |
|
/* ISO: limit 1023 bytes full speed, 1024 high/super speed */ |
|
if (gadget_is_dualspeed(gadget)) |
|
max = 1024; |
|
else |
|
max = 1023; |
|
break; |
|
case USB_ENDPOINT_XFER_BULK: |
|
if (gadget_is_dualspeed(gadget)) |
|
max = 512; |
|
else |
|
max = 64; |
|
break; |
|
case USB_ENDPOINT_XFER_INT: |
|
if (gadget_is_dualspeed(gadget)) |
|
max = 1024; |
|
else |
|
max = 64; |
|
break; |
|
} |
|
if (usb_endpoint_maxp(desc) > max) |
|
return NULL; |
|
|
|
/* |
|
* Find a free EP address for that device. We can't |
|
* let the generic code assign these as it would |
|
* create overlapping numbers for IN and OUT which |
|
* we don't support, so also create a suitable name |
|
* that will allow the generic code to use our |
|
* assigned address. |
|
*/ |
|
for (i = 0; i < d->max_epns; i++) |
|
if (d->epns[i] == NULL) |
|
break; |
|
if (i >= d->max_epns) |
|
return NULL; |
|
addr = i + 1; |
|
|
|
/* |
|
* Now grab an EP from the shared pool and associate |
|
* it with our device |
|
*/ |
|
ep = ast_vhub_alloc_epn(d, addr); |
|
if (!ep) |
|
return NULL; |
|
DDBG(d, "Allocated epn#%d for port EP%d\n", |
|
ep->epn.g_idx, addr); |
|
|
|
return &ep->ep; |
|
} |
|
|
|
static int ast_vhub_udc_stop(struct usb_gadget *gadget) |
|
{ |
|
struct ast_vhub_dev *d = to_ast_dev(gadget); |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&d->vhub->lock, flags); |
|
|
|
DDBG(d, "stop\n"); |
|
|
|
d->driver = NULL; |
|
d->gadget.speed = USB_SPEED_UNKNOWN; |
|
|
|
ast_vhub_dev_nuke(d); |
|
|
|
if (d->enabled) |
|
ast_vhub_dev_disable(d); |
|
|
|
spin_unlock_irqrestore(&d->vhub->lock, flags); |
|
|
|
return 0; |
|
} |
|
|
|
static const struct usb_gadget_ops ast_vhub_udc_ops = { |
|
.get_frame = ast_vhub_udc_get_frame, |
|
.wakeup = ast_vhub_udc_wakeup, |
|
.pullup = ast_vhub_udc_pullup, |
|
.udc_start = ast_vhub_udc_start, |
|
.udc_stop = ast_vhub_udc_stop, |
|
.match_ep = ast_vhub_udc_match_ep, |
|
}; |
|
|
|
void ast_vhub_dev_suspend(struct ast_vhub_dev *d) |
|
{ |
|
if (d->driver && d->driver->suspend) { |
|
spin_unlock(&d->vhub->lock); |
|
d->driver->suspend(&d->gadget); |
|
spin_lock(&d->vhub->lock); |
|
} |
|
} |
|
|
|
void ast_vhub_dev_resume(struct ast_vhub_dev *d) |
|
{ |
|
if (d->driver && d->driver->resume) { |
|
spin_unlock(&d->vhub->lock); |
|
d->driver->resume(&d->gadget); |
|
spin_lock(&d->vhub->lock); |
|
} |
|
} |
|
|
|
void ast_vhub_dev_reset(struct ast_vhub_dev *d) |
|
{ |
|
/* No driver, just disable the device and return */ |
|
if (!d->driver) { |
|
ast_vhub_dev_disable(d); |
|
return; |
|
} |
|
|
|
/* If the port isn't enabled, just enable it */ |
|
if (!d->enabled) { |
|
DDBG(d, "Reset of disabled device, enabling...\n"); |
|
ast_vhub_dev_enable(d); |
|
} else { |
|
DDBG(d, "Reset of enabled device, resetting...\n"); |
|
spin_unlock(&d->vhub->lock); |
|
usb_gadget_udc_reset(&d->gadget, d->driver); |
|
spin_lock(&d->vhub->lock); |
|
|
|
/* |
|
* Disable and maybe re-enable HW, this will clear the address |
|
* and speed setting. |
|
*/ |
|
ast_vhub_dev_disable(d); |
|
ast_vhub_dev_enable(d); |
|
} |
|
} |
|
|
|
void ast_vhub_del_dev(struct ast_vhub_dev *d) |
|
{ |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&d->vhub->lock, flags); |
|
if (!d->registered) { |
|
spin_unlock_irqrestore(&d->vhub->lock, flags); |
|
return; |
|
} |
|
d->registered = false; |
|
spin_unlock_irqrestore(&d->vhub->lock, flags); |
|
|
|
usb_del_gadget_udc(&d->gadget); |
|
device_unregister(d->port_dev); |
|
kfree(d->epns); |
|
} |
|
|
|
static void ast_vhub_dev_release(struct device *dev) |
|
{ |
|
kfree(dev); |
|
} |
|
|
|
int ast_vhub_init_dev(struct ast_vhub *vhub, unsigned int idx) |
|
{ |
|
struct ast_vhub_dev *d = &vhub->ports[idx].dev; |
|
struct device *parent = &vhub->pdev->dev; |
|
int rc; |
|
|
|
d->vhub = vhub; |
|
d->index = idx; |
|
d->name = devm_kasprintf(parent, GFP_KERNEL, "port%d", idx+1); |
|
d->regs = vhub->regs + 0x100 + 0x10 * idx; |
|
|
|
ast_vhub_init_ep0(vhub, &d->ep0, d); |
|
|
|
/* |
|
* A USB device can have up to 30 endpoints besides control |
|
* endpoint 0. |
|
*/ |
|
d->max_epns = min_t(u32, vhub->max_epns, 30); |
|
d->epns = kcalloc(d->max_epns, sizeof(*d->epns), GFP_KERNEL); |
|
if (!d->epns) |
|
return -ENOMEM; |
|
|
|
/* |
|
* The UDC core really needs us to have separate and uniquely |
|
* named "parent" devices for each port so we create a sub device |
|
* here for that purpose |
|
*/ |
|
d->port_dev = kzalloc(sizeof(struct device), GFP_KERNEL); |
|
if (!d->port_dev) { |
|
rc = -ENOMEM; |
|
goto fail_alloc; |
|
} |
|
device_initialize(d->port_dev); |
|
d->port_dev->release = ast_vhub_dev_release; |
|
d->port_dev->parent = parent; |
|
dev_set_name(d->port_dev, "%s:p%d", dev_name(parent), idx + 1); |
|
rc = device_add(d->port_dev); |
|
if (rc) |
|
goto fail_add; |
|
|
|
/* Populate gadget */ |
|
INIT_LIST_HEAD(&d->gadget.ep_list); |
|
d->gadget.ops = &ast_vhub_udc_ops; |
|
d->gadget.ep0 = &d->ep0.ep; |
|
d->gadget.name = KBUILD_MODNAME; |
|
if (vhub->force_usb1) |
|
d->gadget.max_speed = USB_SPEED_FULL; |
|
else |
|
d->gadget.max_speed = USB_SPEED_HIGH; |
|
d->gadget.speed = USB_SPEED_UNKNOWN; |
|
d->gadget.dev.of_node = vhub->pdev->dev.of_node; |
|
|
|
rc = usb_add_gadget_udc(d->port_dev, &d->gadget); |
|
if (rc != 0) |
|
goto fail_udc; |
|
d->registered = true; |
|
|
|
return 0; |
|
fail_udc: |
|
device_del(d->port_dev); |
|
fail_add: |
|
put_device(d->port_dev); |
|
fail_alloc: |
|
kfree(d->epns); |
|
|
|
return rc; |
|
}
|
|
|