2017-11-03 04:28:30 -06:00
|
|
|
// SPDX-License-Identifier: GPL-2.0
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2011-04-21 02:06:43 -06:00
|
|
|
* Copyright (c) 2011 Samsung Electronics Co., Ltd.
|
|
|
|
* http://www.samsung.com
|
2009-06-02 07:58:06 -06:00
|
|
|
*
|
|
|
|
* Copyright 2008 Openmoko, Inc.
|
|
|
|
* Copyright 2008 Simtec Electronics
|
|
|
|
* Ben Dooks <ben@simtec.co.uk>
|
|
|
|
* http://armlinux.simtec.co.uk/
|
|
|
|
*
|
|
|
|
* S3C USB2.0 High-speed / OtG driver
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/platform_device.h>
|
|
|
|
#include <linux/dma-mapping.h>
|
2014-11-21 07:14:48 -07:00
|
|
|
#include <linux/mutex.h>
|
2009-06-02 07:58:06 -06:00
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/io.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2013-06-25 09:38:23 -06:00
|
|
|
#include <linux/of_platform.h>
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
#include <linux/usb/ch9.h>
|
|
|
|
#include <linux/usb/gadget.h>
|
2012-11-14 03:27:16 -07:00
|
|
|
#include <linux/usb/phy.h>
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-04-14 15:13:35 -06:00
|
|
|
#include "core.h"
|
2014-11-11 10:13:33 -07:00
|
|
|
#include "hw.h"
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* conversion functions */
|
2015-08-06 17:11:54 -06:00
|
|
|
static inline struct dwc2_hsotg_req *our_req(struct usb_request *req)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
return container_of(req, struct dwc2_hsotg_req, req);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static inline struct dwc2_hsotg_ep *our_ep(struct usb_ep *ep)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
return container_of(ep, struct dwc2_hsotg_ep, ep);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2014-11-11 10:13:33 -07:00
|
|
|
static inline struct dwc2_hsotg *to_hsotg(struct usb_gadget *gadget)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2014-11-11 10:13:33 -07:00
|
|
|
return container_of(gadget, struct dwc2_hsotg, gadget);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2018-01-19 03:42:08 -07:00
|
|
|
static inline void dwc2_set_bit(void __iomem *ptr, u32 val)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(dwc2_readl(ptr) | val, ptr);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2018-01-19 03:42:08 -07:00
|
|
|
static inline void dwc2_clear_bit(void __iomem *ptr, u32 val)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(dwc2_readl(ptr) & ~val, ptr);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static inline struct dwc2_hsotg_ep *index_to_ep(struct dwc2_hsotg *hsotg,
|
2015-01-09 05:38:50 -07:00
|
|
|
u32 ep_index, u32 dir_in)
|
|
|
|
{
|
|
|
|
if (dir_in)
|
|
|
|
return hsotg->eps_in[ep_index];
|
|
|
|
else
|
|
|
|
return hsotg->eps_out[ep_index];
|
|
|
|
}
|
|
|
|
|
2014-12-23 09:39:45 -07:00
|
|
|
/* forward declaration of functions */
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_dump(struct dwc2_hsotg *hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/**
|
|
|
|
* using_dma - return the DMA status of the driver.
|
|
|
|
* @hsotg: The driver state.
|
|
|
|
*
|
|
|
|
* Return true if we're using DMA.
|
|
|
|
*
|
|
|
|
* Currently, we have the DMA support code worked into everywhere
|
|
|
|
* that needs it, but the AMBA DMA implementation in the hardware can
|
|
|
|
* only DMA from 32bit aligned addresses. This means that gadgets such
|
|
|
|
* as the CDC Ethernet cannot work as they often pass packets which are
|
|
|
|
* not 32bit aligned.
|
|
|
|
*
|
|
|
|
* Unfortunately the choice to use DMA or not is global to the controller
|
|
|
|
* and seems to be only settable when the controller is being put through
|
|
|
|
* a core reset. This means we either need to fix the gadgets to take
|
|
|
|
* account of DMA alignment, or add bounce buffers (yuerk).
|
|
|
|
*
|
2015-01-09 05:38:48 -07:00
|
|
|
* g_using_dma is set depending on dts flag.
|
2009-06-02 07:58:06 -06:00
|
|
|
*/
|
2014-11-11 10:13:33 -07:00
|
|
|
static inline bool using_dma(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2016-11-03 18:56:05 -06:00
|
|
|
return hsotg->params.g_dma;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2016-11-09 20:27:48 -07:00
|
|
|
/*
|
|
|
|
* using_desc_dma - return the descriptor DMA status of the driver.
|
|
|
|
* @hsotg: The driver state.
|
|
|
|
*
|
|
|
|
* Return true if we're using descriptor DMA.
|
|
|
|
*/
|
|
|
|
static inline bool using_desc_dma(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
return hsotg->params.g_dma_desc;
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:05 -06:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_incr_frame_num - Increments the targeted frame number.
|
|
|
|
* @hs_ep: The endpoint
|
|
|
|
* @increment: The value to increment by
|
|
|
|
*
|
|
|
|
* This function will also check if the frame number overruns DSTS_SOFFN_LIMIT.
|
|
|
|
* If an overrun occurs it will wrap the value and set the frame_overrun flag.
|
|
|
|
*/
|
|
|
|
static inline void dwc2_gadget_incr_frame_num(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
hs_ep->target_frame += hs_ep->interval;
|
|
|
|
if (hs_ep->target_frame > DSTS_SOFFN_LIMIT) {
|
2018-01-23 08:45:31 -07:00
|
|
|
hs_ep->frame_overrun = true;
|
2016-05-25 19:07:05 -06:00
|
|
|
hs_ep->target_frame &= DSTS_SOFFN_LIMIT;
|
|
|
|
} else {
|
2018-01-23 08:45:31 -07:00
|
|
|
hs_ep->frame_overrun = false;
|
2016-05-25 19:07:05 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_en_gsint - enable one or more of the general interrupt
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
* @ints: A bitmask of the interrupts to enable
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_en_gsint(struct dwc2_hsotg *hsotg, u32 ints)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 gsintmsk = dwc2_readl(hsotg->regs + GINTMSK);
|
2009-06-02 07:58:06 -06:00
|
|
|
u32 new_gsintmsk;
|
|
|
|
|
|
|
|
new_gsintmsk = gsintmsk | ints;
|
|
|
|
|
|
|
|
if (new_gsintmsk != gsintmsk) {
|
|
|
|
dev_dbg(hsotg->dev, "gsintmsk now 0x%08x\n", new_gsintmsk);
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(new_gsintmsk, hsotg->regs + GINTMSK);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_disable_gsint - disable one or more of the general interrupt
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
* @ints: A bitmask of the interrupts to enable
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_disable_gsint(struct dwc2_hsotg *hsotg, u32 ints)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 gsintmsk = dwc2_readl(hsotg->regs + GINTMSK);
|
2009-06-02 07:58:06 -06:00
|
|
|
u32 new_gsintmsk;
|
|
|
|
|
|
|
|
new_gsintmsk = gsintmsk & ~ints;
|
|
|
|
|
|
|
|
if (new_gsintmsk != gsintmsk)
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(new_gsintmsk, hsotg->regs + GINTMSK);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ctrl_epint - enable/disable an endpoint irq
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
* @ep: The endpoint index
|
|
|
|
* @dir_in: True if direction is in.
|
|
|
|
* @en: The enable value, true to enable
|
|
|
|
*
|
|
|
|
* Set or clear the mask for an individual endpoint's interrupt
|
|
|
|
* request.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_ctrl_epint(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
unsigned int ep, unsigned int dir_in,
|
2009-06-02 07:58:06 -06:00
|
|
|
unsigned int en)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
u32 bit = 1 << ep;
|
|
|
|
u32 daint;
|
|
|
|
|
|
|
|
if (!dir_in)
|
|
|
|
bit <<= 16;
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
2015-08-20 12:41:07 -06:00
|
|
|
daint = dwc2_readl(hsotg->regs + DAINTMSK);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (en)
|
|
|
|
daint |= bit;
|
|
|
|
else
|
|
|
|
daint &= ~bit;
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(daint, hsotg->regs + DAINTMSK);
|
2009-06-02 07:58:06 -06:00
|
|
|
local_irq_restore(flags);
|
|
|
|
}
|
|
|
|
|
2017-01-23 16:01:23 -07:00
|
|
|
/**
|
|
|
|
* dwc2_hsotg_tx_fifo_count - return count of TX FIFOs in device mode
|
|
|
|
*/
|
|
|
|
int dwc2_hsotg_tx_fifo_count(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
if (hsotg->hw_params.en_multiple_tx_fifo)
|
|
|
|
/* In dedicated FIFO mode we need count of IN EPs */
|
2017-11-30 01:16:37 -07:00
|
|
|
return hsotg->hw_params.num_dev_in_eps;
|
2017-01-23 16:01:23 -07:00
|
|
|
else
|
|
|
|
/* In shared FIFO mode we need count of Periodic IN EPs */
|
|
|
|
return hsotg->hw_params.num_dev_perio_in_ep;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_hsotg_tx_fifo_total_depth - return total FIFO depth available for
|
|
|
|
* device mode TX FIFOs
|
|
|
|
*/
|
|
|
|
int dwc2_hsotg_tx_fifo_total_depth(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
int addr;
|
|
|
|
int tx_addr_max;
|
|
|
|
u32 np_tx_fifo_size;
|
|
|
|
|
|
|
|
np_tx_fifo_size = min_t(u32, hsotg->hw_params.dev_nperio_tx_fifo_size,
|
|
|
|
hsotg->params.g_np_tx_fifo_size);
|
|
|
|
|
|
|
|
/* Get Endpoint Info Control block size in DWORDs. */
|
2017-11-30 01:16:37 -07:00
|
|
|
tx_addr_max = hsotg->hw_params.total_fifo_size;
|
2017-01-23 16:01:23 -07:00
|
|
|
|
|
|
|
addr = hsotg->params.g_rx_fifo_size + np_tx_fifo_size;
|
|
|
|
if (tx_addr_max <= addr)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return tx_addr_max - addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_hsotg_tx_fifo_average_depth - returns average depth of device mode
|
|
|
|
* TX FIFOs
|
|
|
|
*/
|
|
|
|
int dwc2_hsotg_tx_fifo_average_depth(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
int tx_fifo_count;
|
|
|
|
int tx_fifo_depth;
|
|
|
|
|
|
|
|
tx_fifo_depth = dwc2_hsotg_tx_fifo_total_depth(hsotg);
|
|
|
|
|
|
|
|
tx_fifo_count = dwc2_hsotg_tx_fifo_count(hsotg);
|
|
|
|
|
|
|
|
if (!tx_fifo_count)
|
|
|
|
return tx_fifo_depth;
|
|
|
|
else
|
|
|
|
return tx_fifo_depth / tx_fifo_count;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_init_fifo - initialise non-periodic FIFOs
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device instance.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_init_fifo(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2016-10-17 18:36:23 -06:00
|
|
|
unsigned int ep;
|
2010-05-24 22:36:50 -06:00
|
|
|
unsigned int addr;
|
2010-05-24 22:36:52 -06:00
|
|
|
int timeout;
|
2018-01-19 03:39:31 -07:00
|
|
|
|
2010-05-24 22:36:50 -06:00
|
|
|
u32 val;
|
2016-11-03 18:56:05 -06:00
|
|
|
u32 *txfsz = hsotg->params.g_tx_fifo_size;
|
2010-05-24 22:36:50 -06:00
|
|
|
|
2015-01-09 05:39:06 -07:00
|
|
|
/* Reset fifo map if not correctly cleared during previous session */
|
|
|
|
WARN_ON(hsotg->fifo_map);
|
|
|
|
hsotg->fifo_map = 0;
|
|
|
|
|
2015-01-09 05:38:52 -07:00
|
|
|
/* set RX/NPTX FIFO sizes */
|
2016-11-03 18:56:05 -06:00
|
|
|
dwc2_writel(hsotg->params.g_rx_fifo_size, hsotg->regs + GRXFSIZ);
|
|
|
|
dwc2_writel((hsotg->params.g_rx_fifo_size << FIFOSIZE_STARTADDR_SHIFT) |
|
|
|
|
(hsotg->params.g_np_tx_fifo_size << FIFOSIZE_DEPTH_SHIFT),
|
|
|
|
hsotg->regs + GNPTXFSIZ);
|
2010-05-24 22:36:50 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* arange all the rest of the TX FIFOs, as some versions of this
|
2010-05-24 22:36:50 -06:00
|
|
|
* block have overlapping default addresses. This also ensures
|
|
|
|
* that if the settings have been changed, then they are set to
|
2012-05-04 06:17:11 -06:00
|
|
|
* known values.
|
|
|
|
*/
|
2010-05-24 22:36:50 -06:00
|
|
|
|
|
|
|
/* start at the end of the GNPTXFSIZ, rounded up */
|
2016-11-03 18:56:05 -06:00
|
|
|
addr = hsotg->params.g_rx_fifo_size + hsotg->params.g_np_tx_fifo_size;
|
2010-05-24 22:36:50 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
2015-01-09 05:38:52 -07:00
|
|
|
* Configure fifos sizes from provided configuration and assign
|
2014-09-09 02:44:56 -06:00
|
|
|
* them to endpoints dynamically according to maxpacket size value of
|
|
|
|
* given endpoint.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2016-10-17 18:36:23 -06:00
|
|
|
for (ep = 1; ep < MAX_EPS_CHANNELS; ep++) {
|
2016-11-03 18:56:05 -06:00
|
|
|
if (!txfsz[ep])
|
2016-10-17 18:36:25 -06:00
|
|
|
continue;
|
|
|
|
val = addr;
|
2016-11-03 18:56:05 -06:00
|
|
|
val |= txfsz[ep] << FIFOSIZE_DEPTH_SHIFT;
|
|
|
|
WARN_ONCE(addr + txfsz[ep] > hsotg->fifo_mem,
|
2016-10-17 18:36:25 -06:00
|
|
|
"insufficient fifo memory");
|
2016-11-03 18:56:05 -06:00
|
|
|
addr += txfsz[ep];
|
2010-05-24 22:36:50 -06:00
|
|
|
|
2016-10-17 18:36:23 -06:00
|
|
|
dwc2_writel(val, hsotg->regs + DPTXFSIZN(ep));
|
2016-11-03 18:56:05 -06:00
|
|
|
val = dwc2_readl(hsotg->regs + DPTXFSIZN(ep));
|
2010-05-24 22:36:50 -06:00
|
|
|
}
|
2010-05-24 22:36:52 -06:00
|
|
|
|
2017-01-18 19:34:19 -07:00
|
|
|
dwc2_writel(hsotg->hw_params.total_fifo_size |
|
|
|
|
addr << GDFIFOCFG_EPINFOBASE_SHIFT,
|
|
|
|
hsotg->regs + GDFIFOCFG);
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* according to p428 of the design guide, we need to ensure that
|
|
|
|
* all fifos are flushed before continuing
|
|
|
|
*/
|
2010-05-24 22:36:52 -06:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(GRSTCTL_TXFNUM(0x10) | GRSTCTL_TXFFLSH |
|
2014-04-14 15:13:34 -06:00
|
|
|
GRSTCTL_RXFFLSH, hsotg->regs + GRSTCTL);
|
2010-05-24 22:36:52 -06:00
|
|
|
|
|
|
|
/* wait until the fifos are both flushed */
|
|
|
|
timeout = 100;
|
|
|
|
while (1) {
|
2015-08-20 12:41:07 -06:00
|
|
|
val = dwc2_readl(hsotg->regs + GRSTCTL);
|
2010-05-24 22:36:52 -06:00
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if ((val & (GRSTCTL_TXFFLSH | GRSTCTL_RXFFLSH)) == 0)
|
2010-05-24 22:36:52 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
if (--timeout == 0) {
|
|
|
|
dev_err(hsotg->dev,
|
|
|
|
"%s: timeout flushing fifos (GRSTCTL=%08x)\n",
|
|
|
|
__func__, val);
|
2015-01-09 05:39:01 -07:00
|
|
|
break;
|
2010-05-24 22:36:52 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
udelay(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "FIFOs reset, timeout at %d\n", timeout);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @ep: USB endpoint to allocate request for.
|
|
|
|
* @flags: Allocation flags
|
|
|
|
*
|
|
|
|
* Allocate a new USB request structure appropriate for the specified endpoint
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static struct usb_request *dwc2_hsotg_ep_alloc_request(struct usb_ep *ep,
|
2017-01-17 21:30:27 -07:00
|
|
|
gfp_t flags)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *req;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2017-01-17 21:32:41 -07:00
|
|
|
req = kzalloc(sizeof(*req), flags);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (!req)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&req->queue);
|
|
|
|
|
|
|
|
return &req->req;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* is_ep_periodic - return true if the endpoint is in periodic mode.
|
|
|
|
* @hs_ep: The endpoint to query.
|
|
|
|
*
|
|
|
|
* Returns true if the endpoint is in periodic mode, meaning it is being
|
|
|
|
* used for an Interrupt or ISO transfer.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static inline int is_ep_periodic(struct dwc2_hsotg_ep *hs_ep)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
|
|
|
return hs_ep->periodic;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_unmap_dma - unmap the DMA memory being used for the request
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
* @hs_ep: The endpoint for the request
|
|
|
|
* @hs_req: The request being processed.
|
|
|
|
*
|
2015-08-06 17:11:54 -06:00
|
|
|
* This is the reverse of dwc2_hsotg_map_dma(), called for the completion
|
2009-06-02 07:58:06 -06:00
|
|
|
* of a request to ensure the buffer is ready for access by the caller.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_unmap_dma(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
|
|
|
struct usb_request *req = &hs_req->req;
|
2017-01-17 21:30:27 -07:00
|
|
|
|
2013-05-11 06:14:00 -06:00
|
|
|
usb_gadget_unmap_request(&hsotg->gadget, req, hs_ep->dir_in);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2016-11-09 20:27:56 -07:00
|
|
|
/*
|
|
|
|
* dwc2_gadget_alloc_ctrl_desc_chains - allocate DMA descriptor chains
|
|
|
|
* for Control endpoint
|
|
|
|
* @hsotg: The device state.
|
|
|
|
*
|
|
|
|
* This function will allocate 4 descriptor chains for EP 0: 2 for
|
|
|
|
* Setup stage, per one for IN and OUT data/status transactions.
|
|
|
|
*/
|
|
|
|
static int dwc2_gadget_alloc_ctrl_desc_chains(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
hsotg->setup_desc[0] =
|
|
|
|
dmam_alloc_coherent(hsotg->dev,
|
|
|
|
sizeof(struct dwc2_dma_desc),
|
|
|
|
&hsotg->setup_desc_dma[0],
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hsotg->setup_desc[0])
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
hsotg->setup_desc[1] =
|
|
|
|
dmam_alloc_coherent(hsotg->dev,
|
|
|
|
sizeof(struct dwc2_dma_desc),
|
|
|
|
&hsotg->setup_desc_dma[1],
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hsotg->setup_desc[1])
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
hsotg->ctrl_in_desc =
|
|
|
|
dmam_alloc_coherent(hsotg->dev,
|
|
|
|
sizeof(struct dwc2_dma_desc),
|
|
|
|
&hsotg->ctrl_in_desc_dma,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hsotg->ctrl_in_desc)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
hsotg->ctrl_out_desc =
|
|
|
|
dmam_alloc_coherent(hsotg->dev,
|
|
|
|
sizeof(struct dwc2_dma_desc),
|
|
|
|
&hsotg->ctrl_out_desc_dma,
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hsotg->ctrl_out_desc)
|
|
|
|
goto fail;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
fail:
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_write_fifo - write packet Data to the TxFIFO
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The controller state.
|
|
|
|
* @hs_ep: The endpoint we're going to write for.
|
|
|
|
* @hs_req: The request to write data for.
|
|
|
|
*
|
|
|
|
* This is called when the TxFIFO has some space in it to hold a new
|
|
|
|
* transmission and we have something to give it. The actual setup of
|
|
|
|
* the data size is done elsewhere, so all we have to do is to actually
|
|
|
|
* write the data.
|
|
|
|
*
|
|
|
|
* The return value is zero if there is more space (or nothing was done)
|
|
|
|
* otherwise -ENOSPC is returned if the FIFO space was used up.
|
|
|
|
*
|
|
|
|
* This routine is only needed for PIO
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_write_fifo(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
|
|
|
bool periodic = is_ep_periodic(hs_ep);
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 gnptxsts = dwc2_readl(hsotg->regs + GNPTXSTS);
|
2009-06-02 07:58:06 -06:00
|
|
|
int buf_pos = hs_req->req.actual;
|
|
|
|
int to_write = hs_ep->size_loaded;
|
|
|
|
void *data;
|
|
|
|
int can_write;
|
|
|
|
int pkt_round;
|
2013-10-09 01:00:02 -06:00
|
|
|
int max_transfer;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
to_write -= (buf_pos - hs_ep->last_load);
|
|
|
|
|
|
|
|
/* if there's nothing to write, get out early */
|
|
|
|
if (to_write == 0)
|
|
|
|
return 0;
|
|
|
|
|
2010-07-19 02:40:44 -06:00
|
|
|
if (periodic && !hsotg->dedicated_fifos) {
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 epsize = dwc2_readl(hsotg->regs + DIEPTSIZ(hs_ep->index));
|
2009-06-02 07:58:06 -06:00
|
|
|
int size_left;
|
|
|
|
int size_done;
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* work out how much data was loaded so we can calculate
|
|
|
|
* how much data is left in the fifo.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* if shared fifo, we cannot write anything until the
|
2010-07-19 02:40:42 -06:00
|
|
|
* previous data has been completely sent.
|
|
|
|
*/
|
|
|
|
if (hs_ep->fifo_load != 0) {
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
|
2010-07-19 02:40:42 -06:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: left=%d, load=%d, fifo=%d, size %d\n",
|
|
|
|
__func__, size_left,
|
|
|
|
hs_ep->size_loaded, hs_ep->fifo_load, hs_ep->fifo_size);
|
|
|
|
|
|
|
|
/* how much of the data has moved */
|
|
|
|
size_done = hs_ep->size_loaded - size_left;
|
|
|
|
|
|
|
|
/* how much data is left in the fifo */
|
|
|
|
can_write = hs_ep->fifo_load - size_done;
|
|
|
|
dev_dbg(hsotg->dev, "%s: => can_write1=%d\n",
|
|
|
|
__func__, can_write);
|
|
|
|
|
|
|
|
can_write = hs_ep->fifo_size - can_write;
|
|
|
|
dev_dbg(hsotg->dev, "%s: => can_write2=%d\n",
|
|
|
|
__func__, can_write);
|
|
|
|
|
|
|
|
if (can_write <= 0) {
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_en_gsint(hsotg, GINTSTS_PTXFEMP);
|
2009-06-02 07:58:06 -06:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
2010-07-19 02:40:44 -06:00
|
|
|
} else if (hsotg->dedicated_fifos && hs_ep->index != 0) {
|
2016-08-29 14:38:50 -06:00
|
|
|
can_write = dwc2_readl(hsotg->regs +
|
|
|
|
DTXFSTS(hs_ep->fifo_index));
|
2010-07-19 02:40:44 -06:00
|
|
|
|
|
|
|
can_write &= 0xffff;
|
|
|
|
can_write *= 4;
|
2009-06-02 07:58:06 -06:00
|
|
|
} else {
|
2014-04-14 15:13:34 -06:00
|
|
|
if (GNPTXSTS_NP_TXQ_SPC_AVAIL_GET(gnptxsts) == 0) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev,
|
|
|
|
"%s: no queue slots available (0x%08x)\n",
|
|
|
|
__func__, gnptxsts);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_en_gsint(hsotg, GINTSTS_NPTXFEMP);
|
2009-06-02 07:58:06 -06:00
|
|
|
return -ENOSPC;
|
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
can_write = GNPTXSTS_NP_TXF_SPC_AVAIL_GET(gnptxsts);
|
2010-07-19 02:40:41 -06:00
|
|
|
can_write *= 4; /* fifo size is in 32bit quantities. */
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2013-10-09 01:00:02 -06:00
|
|
|
max_transfer = hs_ep->ep.maxpacket * hs_ep->mc;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: GNPTXSTS=%08x, can=%d, to=%d, max_transfer %d\n",
|
2017-01-17 21:30:27 -07:00
|
|
|
__func__, gnptxsts, can_write, to_write, max_transfer);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* limit to 512 bytes of data, it seems at least on the non-periodic
|
2009-06-02 07:58:06 -06:00
|
|
|
* FIFO, requests of >512 cause the endpoint to get stuck with a
|
|
|
|
* fragment of the end of the transfer in it.
|
|
|
|
*/
|
2013-09-24 03:24:28 -06:00
|
|
|
if (can_write > 512 && !periodic)
|
2009-06-02 07:58:06 -06:00
|
|
|
can_write = 512;
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* limit the write to one max-packet size worth of data, but allow
|
2010-07-19 02:40:45 -06:00
|
|
|
* the transfer to return that it did not run out of fifo space
|
2012-05-04 06:17:11 -06:00
|
|
|
* doing it.
|
|
|
|
*/
|
2013-10-09 01:00:02 -06:00
|
|
|
if (to_write > max_transfer) {
|
|
|
|
to_write = max_transfer;
|
2010-07-19 02:40:45 -06:00
|
|
|
|
2013-09-19 03:50:18 -06:00
|
|
|
/* it's needed only when we do not use dedicated fifos */
|
|
|
|
if (!hsotg->dedicated_fifos)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_en_gsint(hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
periodic ? GINTSTS_PTXFEMP :
|
2014-04-14 15:13:34 -06:00
|
|
|
GINTSTS_NPTXFEMP);
|
2010-07-19 02:40:45 -06:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/* see if we can write data */
|
|
|
|
|
|
|
|
if (to_write > can_write) {
|
|
|
|
to_write = can_write;
|
2013-10-09 01:00:02 -06:00
|
|
|
pkt_round = to_write % max_transfer;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* Round the write down to an
|
2009-06-02 07:58:06 -06:00
|
|
|
* exact number of packets.
|
|
|
|
*
|
|
|
|
* Note, we do not currently check to see if we can ever
|
|
|
|
* write a full packet or not to the FIFO.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (pkt_round)
|
|
|
|
to_write -= pkt_round;
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* enable correct FIFO interrupt to alert us when there
|
|
|
|
* is more room left.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2013-09-19 03:50:18 -06:00
|
|
|
/* it's needed only when we do not use dedicated fifos */
|
|
|
|
if (!hsotg->dedicated_fifos)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_en_gsint(hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
periodic ? GINTSTS_PTXFEMP :
|
2014-04-14 15:13:34 -06:00
|
|
|
GINTSTS_NPTXFEMP);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "write %d/%d, can_write %d, done %d\n",
|
2017-01-17 21:30:27 -07:00
|
|
|
to_write, hs_req->req.length, can_write, buf_pos);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (to_write <= 0)
|
|
|
|
return -ENOSPC;
|
|
|
|
|
|
|
|
hs_req->req.actual = buf_pos + to_write;
|
|
|
|
hs_ep->total_data += to_write;
|
|
|
|
|
|
|
|
if (periodic)
|
|
|
|
hs_ep->fifo_load += to_write;
|
|
|
|
|
|
|
|
to_write = DIV_ROUND_UP(to_write, 4);
|
|
|
|
data = hs_req->req.buf + buf_pos;
|
|
|
|
|
2014-02-03 08:29:09 -07:00
|
|
|
iowrite32_rep(hsotg->regs + EPFIFO(hs_ep->index), data, to_write);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
return (to_write >= can_write) ? -ENOSPC : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* get_ep_limit - get the maximum data legnth for this endpoint
|
|
|
|
* @hs_ep: The endpoint
|
|
|
|
*
|
|
|
|
* Return the maximum data that can be queued in one go on a given endpoint
|
|
|
|
* so that transfers that are too long can be split.
|
|
|
|
*/
|
2017-01-17 21:30:27 -07:00
|
|
|
static unsigned int get_ep_limit(struct dwc2_hsotg_ep *hs_ep)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
|
|
|
int index = hs_ep->index;
|
2017-01-17 21:30:27 -07:00
|
|
|
unsigned int maxsize;
|
|
|
|
unsigned int maxpkt;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (index != 0) {
|
2014-04-14 15:13:34 -06:00
|
|
|
maxsize = DXEPTSIZ_XFERSIZE_LIMIT + 1;
|
|
|
|
maxpkt = DXEPTSIZ_PKTCNT_LIMIT + 1;
|
2009-06-02 07:58:06 -06:00
|
|
|
} else {
|
2017-01-17 21:30:27 -07:00
|
|
|
maxsize = 64 + 64;
|
2011-05-13 06:26:15 -06:00
|
|
|
if (hs_ep->dir_in)
|
2014-04-14 15:13:34 -06:00
|
|
|
maxpkt = DIEPTSIZ0_PKTCNT_LIMIT + 1;
|
2011-05-13 06:26:15 -06:00
|
|
|
else
|
2009-06-02 07:58:06 -06:00
|
|
|
maxpkt = 2;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we made the constant loading easier above by using +1 */
|
|
|
|
maxpkt--;
|
|
|
|
maxsize--;
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* constrain by packet count if maxpkts*pktsize is greater
|
|
|
|
* than the length register size.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if ((maxpkt * hs_ep->ep.maxpacket) < maxsize)
|
|
|
|
maxsize = maxpkt * hs_ep->ep.maxpacket;
|
|
|
|
|
|
|
|
return maxsize;
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
/**
|
2017-01-17 21:31:13 -07:00
|
|
|
* dwc2_hsotg_read_frameno - read current frame number
|
|
|
|
* @hsotg: The device instance
|
|
|
|
*
|
|
|
|
* Return the current frame number
|
|
|
|
*/
|
2016-05-25 19:07:17 -06:00
|
|
|
static u32 dwc2_hsotg_read_frameno(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
u32 dsts;
|
|
|
|
|
|
|
|
dsts = dwc2_readl(hsotg->regs + DSTS);
|
|
|
|
dsts &= DSTS_SOFFN_MASK;
|
|
|
|
dsts >>= DSTS_SOFFN_SHIFT;
|
|
|
|
|
|
|
|
return dsts;
|
|
|
|
}
|
|
|
|
|
2016-11-09 20:28:01 -07:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_get_chain_limit - get the maximum data payload value of the
|
|
|
|
* DMA descriptor chain prepared for specific endpoint
|
|
|
|
* @hs_ep: The endpoint
|
|
|
|
*
|
|
|
|
* Return the maximum data that can be queued in one go on a given endpoint
|
|
|
|
* depending on its descriptor chain capacity so that transfers that
|
|
|
|
* are too long can be split.
|
|
|
|
*/
|
|
|
|
static unsigned int dwc2_gadget_get_chain_limit(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
int is_isoc = hs_ep->isochronous;
|
|
|
|
unsigned int maxsize;
|
|
|
|
|
|
|
|
if (is_isoc)
|
|
|
|
maxsize = hs_ep->dir_in ? DEV_DMA_ISOC_TX_NBYTES_LIMIT :
|
|
|
|
DEV_DMA_ISOC_RX_NBYTES_LIMIT;
|
|
|
|
else
|
|
|
|
maxsize = DEV_DMA_NBYTES_LIMIT;
|
|
|
|
|
|
|
|
/* Above size of one descriptor was chosen, multiple it */
|
|
|
|
maxsize *= MAX_DMA_DESC_NUM_GENERIC;
|
|
|
|
|
|
|
|
return maxsize;
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:24 -07:00
|
|
|
/*
|
|
|
|
* dwc2_gadget_get_desc_params - get DMA descriptor parameters.
|
|
|
|
* @hs_ep: The endpoint
|
|
|
|
* @mask: RX/TX bytes mask to be defined
|
|
|
|
*
|
|
|
|
* Returns maximum data payload for one descriptor after analyzing endpoint
|
|
|
|
* characteristics.
|
|
|
|
* DMA descriptor transfer bytes limit depends on EP type:
|
|
|
|
* Control out - MPS,
|
|
|
|
* Isochronous - descriptor rx/tx bytes bitfield limit,
|
|
|
|
* Control In/Bulk/Interrupt - multiple of mps. This will allow to not
|
|
|
|
* have concatenations from various descriptors within one packet.
|
|
|
|
*
|
|
|
|
* Selects corresponding mask for RX/TX bytes as well.
|
|
|
|
*/
|
|
|
|
static u32 dwc2_gadget_get_desc_params(struct dwc2_hsotg_ep *hs_ep, u32 *mask)
|
|
|
|
{
|
|
|
|
u32 mps = hs_ep->ep.maxpacket;
|
|
|
|
int dir_in = hs_ep->dir_in;
|
|
|
|
u32 desc_size = 0;
|
|
|
|
|
|
|
|
if (!hs_ep->index && !dir_in) {
|
|
|
|
desc_size = mps;
|
|
|
|
*mask = DEV_DMA_NBYTES_MASK;
|
|
|
|
} else if (hs_ep->isochronous) {
|
|
|
|
if (dir_in) {
|
|
|
|
desc_size = DEV_DMA_ISOC_TX_NBYTES_LIMIT;
|
|
|
|
*mask = DEV_DMA_ISOC_TX_NBYTES_MASK;
|
|
|
|
} else {
|
|
|
|
desc_size = DEV_DMA_ISOC_RX_NBYTES_LIMIT;
|
|
|
|
*mask = DEV_DMA_ISOC_RX_NBYTES_MASK;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
desc_size = DEV_DMA_NBYTES_LIMIT;
|
|
|
|
*mask = DEV_DMA_NBYTES_MASK;
|
|
|
|
|
|
|
|
/* Round down desc_size to be mps multiple */
|
|
|
|
desc_size -= desc_size % mps;
|
|
|
|
}
|
|
|
|
|
|
|
|
return desc_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dwc2_gadget_config_nonisoc_xfer_ddma - prepare non ISOC DMA desc chain.
|
|
|
|
* @hs_ep: The endpoint
|
|
|
|
* @dma_buff: DMA address to use
|
|
|
|
* @len: Length of the transfer
|
|
|
|
*
|
|
|
|
* This function will iterate over descriptor chain and fill its entries
|
|
|
|
* with corresponding information based on transfer data.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_config_nonisoc_xfer_ddma(struct dwc2_hsotg_ep *hs_ep,
|
|
|
|
dma_addr_t dma_buff,
|
|
|
|
unsigned int len)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
int dir_in = hs_ep->dir_in;
|
|
|
|
struct dwc2_dma_desc *desc = hs_ep->desc_list;
|
|
|
|
u32 mps = hs_ep->ep.maxpacket;
|
|
|
|
u32 maxsize = 0;
|
|
|
|
u32 offset = 0;
|
|
|
|
u32 mask = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
maxsize = dwc2_gadget_get_desc_params(hs_ep, &mask);
|
|
|
|
|
|
|
|
hs_ep->desc_count = (len / maxsize) +
|
|
|
|
((len % maxsize) ? 1 : 0);
|
|
|
|
if (len == 0)
|
|
|
|
hs_ep->desc_count = 1;
|
|
|
|
|
|
|
|
for (i = 0; i < hs_ep->desc_count; ++i) {
|
|
|
|
desc->status = 0;
|
|
|
|
desc->status |= (DEV_DMA_BUFF_STS_HBUSY
|
|
|
|
<< DEV_DMA_BUFF_STS_SHIFT);
|
|
|
|
|
|
|
|
if (len > maxsize) {
|
|
|
|
if (!hs_ep->index && !dir_in)
|
|
|
|
desc->status |= (DEV_DMA_L | DEV_DMA_IOC);
|
|
|
|
|
|
|
|
desc->status |= (maxsize <<
|
|
|
|
DEV_DMA_NBYTES_SHIFT & mask);
|
|
|
|
desc->buf = dma_buff + offset;
|
|
|
|
|
|
|
|
len -= maxsize;
|
|
|
|
offset += maxsize;
|
|
|
|
} else {
|
|
|
|
desc->status |= (DEV_DMA_L | DEV_DMA_IOC);
|
|
|
|
|
|
|
|
if (dir_in)
|
|
|
|
desc->status |= (len % mps) ? DEV_DMA_SHORT :
|
|
|
|
((hs_ep->send_zlp) ? DEV_DMA_SHORT : 0);
|
|
|
|
if (len > maxsize)
|
|
|
|
dev_err(hsotg->dev, "wrong len %d\n", len);
|
|
|
|
|
|
|
|
desc->status |=
|
|
|
|
len << DEV_DMA_NBYTES_SHIFT & mask;
|
|
|
|
desc->buf = dma_buff + offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
desc->status &= ~DEV_DMA_BUFF_STS_MASK;
|
|
|
|
desc->status |= (DEV_DMA_BUFF_STS_HREADY
|
|
|
|
<< DEV_DMA_BUFF_STS_SHIFT);
|
|
|
|
desc++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
/*
|
|
|
|
* dwc2_gadget_fill_isoc_desc - fills next isochronous descriptor in chain.
|
|
|
|
* @hs_ep: The isochronous endpoint.
|
|
|
|
* @dma_buff: usb requests dma buffer.
|
|
|
|
* @len: usb request transfer length.
|
|
|
|
*
|
|
|
|
* Finds out index of first free entry either in the bottom or up half of
|
|
|
|
* descriptor chain depend on which is under SW control and not processed
|
|
|
|
* by HW. Then fills that descriptor with the data of the arrived usb request,
|
|
|
|
* frame info, sets Last and IOC bits increments next_desc. If filled
|
|
|
|
* descriptor is not the first one, removes L bit from the previous descriptor
|
|
|
|
* status.
|
|
|
|
*/
|
|
|
|
static int dwc2_gadget_fill_isoc_desc(struct dwc2_hsotg_ep *hs_ep,
|
|
|
|
dma_addr_t dma_buff, unsigned int len)
|
|
|
|
{
|
|
|
|
struct dwc2_dma_desc *desc;
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
u32 index;
|
|
|
|
u32 maxsize = 0;
|
|
|
|
u32 mask = 0;
|
|
|
|
|
|
|
|
maxsize = dwc2_gadget_get_desc_params(hs_ep, &mask);
|
|
|
|
if (len > maxsize) {
|
|
|
|
dev_err(hsotg->dev, "wrong len %d\n", len);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If SW has already filled half of chain, then return and wait for
|
|
|
|
* the other chain to be processed by HW.
|
|
|
|
*/
|
|
|
|
if (hs_ep->next_desc == MAX_DMA_DESC_NUM_GENERIC / 2)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
/* Increment frame number by interval for IN */
|
|
|
|
if (hs_ep->dir_in)
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
|
|
|
|
|
|
|
index = (MAX_DMA_DESC_NUM_GENERIC / 2) * hs_ep->isoc_chain_num +
|
|
|
|
hs_ep->next_desc;
|
|
|
|
|
|
|
|
/* Sanity check of calculated index */
|
|
|
|
if ((hs_ep->isoc_chain_num && index > MAX_DMA_DESC_NUM_GENERIC) ||
|
|
|
|
(!hs_ep->isoc_chain_num && index > MAX_DMA_DESC_NUM_GENERIC / 2)) {
|
|
|
|
dev_err(hsotg->dev, "wrong index %d for iso chain\n", index);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
desc = &hs_ep->desc_list[index];
|
|
|
|
|
|
|
|
/* Clear L bit of previous desc if more than one entries in the chain */
|
|
|
|
if (hs_ep->next_desc)
|
|
|
|
hs_ep->desc_list[index - 1].status &= ~DEV_DMA_L;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: Filling ep %d, dir %s isoc desc # %d\n",
|
|
|
|
__func__, hs_ep->index, hs_ep->dir_in ? "in" : "out", index);
|
|
|
|
|
|
|
|
desc->status = 0;
|
|
|
|
desc->status |= (DEV_DMA_BUFF_STS_HBUSY << DEV_DMA_BUFF_STS_SHIFT);
|
|
|
|
|
|
|
|
desc->buf = dma_buff;
|
|
|
|
desc->status |= (DEV_DMA_L | DEV_DMA_IOC |
|
|
|
|
((len << DEV_DMA_NBYTES_SHIFT) & mask));
|
|
|
|
|
|
|
|
if (hs_ep->dir_in) {
|
|
|
|
desc->status |= ((hs_ep->mc << DEV_DMA_ISOC_PID_SHIFT) &
|
|
|
|
DEV_DMA_ISOC_PID_MASK) |
|
|
|
|
((len % hs_ep->ep.maxpacket) ?
|
|
|
|
DEV_DMA_SHORT : 0) |
|
|
|
|
((hs_ep->target_frame <<
|
|
|
|
DEV_DMA_ISOC_FRNUM_SHIFT) &
|
|
|
|
DEV_DMA_ISOC_FRNUM_MASK);
|
|
|
|
}
|
|
|
|
|
|
|
|
desc->status &= ~DEV_DMA_BUFF_STS_MASK;
|
|
|
|
desc->status |= (DEV_DMA_BUFF_STS_HREADY << DEV_DMA_BUFF_STS_SHIFT);
|
|
|
|
|
|
|
|
/* Update index of last configured entry in the chain */
|
|
|
|
hs_ep->next_desc++;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dwc2_gadget_start_isoc_ddma - start isochronous transfer in DDMA
|
|
|
|
* @hs_ep: The isochronous endpoint.
|
|
|
|
*
|
|
|
|
* Prepare first descriptor chain for isochronous endpoints. Afterwards
|
|
|
|
* write DMA address to HW and enable the endpoint.
|
|
|
|
*
|
|
|
|
* Switch between descriptor chains via isoc_chain_num to give SW opportunity
|
|
|
|
* to prepare second descriptor chain while first one is being processed by HW.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_start_isoc_ddma(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
struct dwc2_hsotg_req *hs_req, *treq;
|
|
|
|
int index = hs_ep->index;
|
|
|
|
int ret;
|
|
|
|
u32 dma_reg;
|
|
|
|
u32 depctl;
|
|
|
|
u32 ctrl;
|
|
|
|
|
|
|
|
if (list_empty(&hs_ep->queue)) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: No requests in queue\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
list_for_each_entry_safe(hs_req, treq, &hs_ep->queue, queue) {
|
|
|
|
ret = dwc2_gadget_fill_isoc_desc(hs_ep, hs_req->req.dma,
|
|
|
|
hs_req->req.length);
|
|
|
|
if (ret) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: desc chain full\n", __func__);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
depctl = hs_ep->dir_in ? DIEPCTL(index) : DOEPCTL(index);
|
|
|
|
dma_reg = hs_ep->dir_in ? DIEPDMA(index) : DOEPDMA(index);
|
|
|
|
|
|
|
|
/* write descriptor chain address to control register */
|
|
|
|
dwc2_writel(hs_ep->desc_list_dma, hsotg->regs + dma_reg);
|
|
|
|
|
|
|
|
ctrl = dwc2_readl(hsotg->regs + depctl);
|
|
|
|
ctrl |= DXEPCTL_EPENA | DXEPCTL_CNAK;
|
|
|
|
dwc2_writel(ctrl, hsotg->regs + depctl);
|
|
|
|
|
|
|
|
/* Switch ISOC descriptor chain number being processed by SW*/
|
|
|
|
hs_ep->isoc_chain_num = (hs_ep->isoc_chain_num ^ 1) & 0x1;
|
|
|
|
hs_ep->next_desc = 0;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_start_req - start a USB request from an endpoint's queue
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The controller state.
|
|
|
|
* @hs_ep: The endpoint to process a request for
|
|
|
|
* @hs_req: The request to start.
|
|
|
|
* @continuing: True if we are doing more for the current request.
|
|
|
|
*
|
|
|
|
* Start the given request running by setting the endpoint registers
|
|
|
|
* appropriately, and writing any data to the FIFOs.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_start_req(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req,
|
2009-06-02 07:58:06 -06:00
|
|
|
bool continuing)
|
|
|
|
{
|
|
|
|
struct usb_request *ureq = &hs_req->req;
|
|
|
|
int index = hs_ep->index;
|
|
|
|
int dir_in = hs_ep->dir_in;
|
|
|
|
u32 epctrl_reg;
|
|
|
|
u32 epsize_reg;
|
|
|
|
u32 epsize;
|
|
|
|
u32 ctrl;
|
2017-01-17 21:30:27 -07:00
|
|
|
unsigned int length;
|
|
|
|
unsigned int packets;
|
|
|
|
unsigned int maxreq;
|
2016-11-14 20:16:26 -07:00
|
|
|
unsigned int dma_reg;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (index != 0) {
|
|
|
|
if (hs_ep->req && !continuing) {
|
|
|
|
dev_err(hsotg->dev, "%s: active request\n", __func__);
|
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
|
|
|
} else if (hs_ep->req != hs_req && continuing) {
|
|
|
|
dev_err(hsotg->dev,
|
|
|
|
"%s: continue different req\n", __func__);
|
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:26 -07:00
|
|
|
dma_reg = dir_in ? DIEPDMA(index) : DOEPDMA(index);
|
2012-05-04 06:17:14 -06:00
|
|
|
epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
|
|
|
|
epsize_reg = dir_in ? DIEPTSIZ(index) : DOEPTSIZ(index);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x, ep %d, dir %s\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
__func__, dwc2_readl(hsotg->regs + epctrl_reg), index,
|
2009-06-02 07:58:06 -06:00
|
|
|
hs_ep->dir_in ? "in" : "out");
|
|
|
|
|
2011-04-21 02:06:41 -06:00
|
|
|
/* If endpoint is stalled, we will restart request later */
|
2015-08-20 12:41:07 -06:00
|
|
|
ctrl = dwc2_readl(hsotg->regs + epctrl_reg);
|
2011-04-21 02:06:41 -06:00
|
|
|
|
2015-09-29 04:08:22 -06:00
|
|
|
if (index && ctrl & DXEPCTL_STALL) {
|
2011-04-21 02:06:41 -06:00
|
|
|
dev_warn(hsotg->dev, "%s: ep%d is stalled\n", __func__, index);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
length = ureq->length - ureq->actual;
|
2012-05-04 06:17:03 -06:00
|
|
|
dev_dbg(hsotg->dev, "ureq->length:%d ureq->actual:%d\n",
|
|
|
|
ureq->length, ureq->actual);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2016-11-09 20:28:01 -07:00
|
|
|
if (!using_desc_dma(hsotg))
|
|
|
|
maxreq = get_ep_limit(hs_ep);
|
|
|
|
else
|
|
|
|
maxreq = dwc2_gadget_get_chain_limit(hs_ep);
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (length > maxreq) {
|
|
|
|
int round = maxreq % hs_ep->ep.maxpacket;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: length %d, max-req %d, r %d\n",
|
|
|
|
__func__, length, maxreq, round);
|
|
|
|
|
|
|
|
/* round down to multiple of packets */
|
|
|
|
if (round)
|
|
|
|
maxreq -= round;
|
|
|
|
|
|
|
|
length = maxreq;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (length)
|
|
|
|
packets = DIV_ROUND_UP(length, hs_ep->ep.maxpacket);
|
|
|
|
else
|
|
|
|
packets = 1; /* send one packet if length is zero. */
|
|
|
|
|
2013-10-09 01:00:02 -06:00
|
|
|
if (hs_ep->isochronous && length > (hs_ep->mc * hs_ep->ep.maxpacket)) {
|
|
|
|
dev_err(hsotg->dev, "req length > maxpacket*mc\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (dir_in && index != 0)
|
2013-10-09 01:00:02 -06:00
|
|
|
if (hs_ep->isochronous)
|
2014-04-14 15:13:34 -06:00
|
|
|
epsize = DXEPTSIZ_MC(packets);
|
2013-10-09 01:00:02 -06:00
|
|
|
else
|
2014-04-14 15:13:34 -06:00
|
|
|
epsize = DXEPTSIZ_MC(1);
|
2009-06-02 07:58:06 -06:00
|
|
|
else
|
|
|
|
epsize = 0;
|
|
|
|
|
2015-01-09 05:38:59 -07:00
|
|
|
/*
|
|
|
|
* zero length packet should be programmed on its own and should not
|
|
|
|
* be counted in DIEPTSIZ.PktCnt with other packets.
|
|
|
|
*/
|
|
|
|
if (dir_in && ureq->zero && !continuing) {
|
|
|
|
/* Test if zlp is actually required. */
|
|
|
|
if ((ureq->length >= hs_ep->ep.maxpacket) &&
|
2017-01-17 21:30:27 -07:00
|
|
|
!(ureq->length % hs_ep->ep.maxpacket))
|
2015-01-09 05:39:03 -07:00
|
|
|
hs_ep->send_zlp = 1;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
epsize |= DXEPTSIZ_PKTCNT(packets);
|
|
|
|
epsize |= DXEPTSIZ_XFERSIZE(length);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: %d@%d/%d, 0x%08x => 0x%08x\n",
|
|
|
|
__func__, packets, length, ureq->length, epsize, epsize_reg);
|
|
|
|
|
|
|
|
/* store the request as the current one we're doing */
|
|
|
|
hs_ep->req = hs_req;
|
|
|
|
|
2016-11-14 20:16:26 -07:00
|
|
|
if (using_desc_dma(hsotg)) {
|
|
|
|
u32 offset = 0;
|
|
|
|
u32 mps = hs_ep->ep.maxpacket;
|
|
|
|
|
|
|
|
/* Adjust length: EP0 - MPS, other OUT EPs - multiple of MPS */
|
|
|
|
if (!dir_in) {
|
|
|
|
if (!index)
|
|
|
|
length = mps;
|
|
|
|
else if (length % mps)
|
|
|
|
length += (mps - (length % mps));
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
2016-11-14 20:16:26 -07:00
|
|
|
* If more data to send, adjust DMA for EP0 out data stage.
|
|
|
|
* ureq->dma stays unchanged, hence increment it by already
|
|
|
|
* passed passed data count before starting new transaction.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2016-11-14 20:16:26 -07:00
|
|
|
if (!index && hsotg->ep0_state == DWC2_EP0_DATA_OUT &&
|
|
|
|
continuing)
|
|
|
|
offset = ureq->actual;
|
|
|
|
|
|
|
|
/* Fill DDMA chain entries */
|
|
|
|
dwc2_gadget_config_nonisoc_xfer_ddma(hs_ep, ureq->dma + offset,
|
|
|
|
length);
|
|
|
|
|
|
|
|
/* write descriptor chain address to control register */
|
|
|
|
dwc2_writel(hs_ep->desc_list_dma, hsotg->regs + dma_reg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2016-11-14 20:16:26 -07:00
|
|
|
dev_dbg(hsotg->dev, "%s: %08x pad => 0x%08x\n",
|
|
|
|
__func__, (u32)hs_ep->desc_list_dma, dma_reg);
|
|
|
|
} else {
|
|
|
|
/* write size / packets */
|
|
|
|
dwc2_writel(epsize, hsotg->regs + epsize_reg);
|
|
|
|
|
2016-11-16 16:33:55 -07:00
|
|
|
if (using_dma(hsotg) && !continuing && (length != 0)) {
|
2016-11-14 20:16:26 -07:00
|
|
|
/*
|
|
|
|
* write DMA address to control register, buffer
|
|
|
|
* already synced by dwc2_hsotg_ep_queue().
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2016-11-14 20:16:26 -07:00
|
|
|
dwc2_writel(ureq->dma, hsotg->regs + dma_reg);
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: %pad => 0x%08x\n",
|
|
|
|
__func__, &ureq->dma, dma_reg);
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (hs_ep->isochronous && hs_ep->interval == 1) {
|
|
|
|
hs_ep->target_frame = dwc2_hsotg_read_frameno(hsotg);
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
|
|
|
|
|
|
|
if (hs_ep->target_frame & 0x1)
|
|
|
|
ctrl |= DXEPCTL_SETODDFR;
|
|
|
|
else
|
|
|
|
ctrl |= DXEPCTL_SETEVENFR;
|
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
ctrl |= DXEPCTL_EPENA; /* ensure ep enabled */
|
2012-05-04 06:17:03 -06:00
|
|
|
|
2015-01-09 05:38:58 -07:00
|
|
|
dev_dbg(hsotg->dev, "ep0 state:%d\n", hsotg->ep0_state);
|
2012-05-04 06:17:03 -06:00
|
|
|
|
|
|
|
/* For Setup request do not clear NAK */
|
2015-01-09 05:38:58 -07:00
|
|
|
if (!(index == 0 && hsotg->ep0_state == DWC2_EP0_SETUP))
|
2014-04-14 15:13:34 -06:00
|
|
|
ctrl |= DXEPCTL_CNAK; /* clear NAK set by core */
|
2012-05-04 06:17:03 -06:00
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(ctrl, hsotg->regs + epctrl_reg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* set these, it seems that DMA support increments past the end
|
2009-06-02 07:58:06 -06:00
|
|
|
* of the packet buffer so we need to calculate the length from
|
2012-05-04 06:17:11 -06:00
|
|
|
* this information.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
hs_ep->size_loaded = length;
|
|
|
|
hs_ep->last_load = ureq->actual;
|
|
|
|
|
|
|
|
if (dir_in && !using_dma(hsotg)) {
|
|
|
|
/* set these anyway, we may need them for non-periodic in */
|
|
|
|
hs_ep->fifo_load = 0;
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_write_fifo(hsotg, hs_ep, hs_req);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* Note, trying to clear the NAK here causes problems with transmit
|
|
|
|
* on the S3C6400 ending up with the TXFIFO becoming full.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* check ep is enabled */
|
2015-08-20 12:41:07 -06:00
|
|
|
if (!(dwc2_readl(hsotg->regs + epctrl_reg) & DXEPCTL_EPENA))
|
2015-01-09 05:39:00 -07:00
|
|
|
dev_dbg(hsotg->dev,
|
2017-01-17 21:30:27 -07:00
|
|
|
"ep%d: failed to become enabled (DXEPCTL=0x%08x)?\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
index, dwc2_readl(hsotg->regs + epctrl_reg));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: DXEPCTL=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
__func__, dwc2_readl(hsotg->regs + epctrl_reg));
|
2013-09-19 03:50:19 -06:00
|
|
|
|
|
|
|
/* enable ep interrupts */
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 1);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_map_dma - map the DMA memory being used for the request
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
* @hs_ep: The endpoint the request is on.
|
|
|
|
* @req: The request being processed.
|
|
|
|
*
|
|
|
|
* We've been asked to queue a request, so ensure that the memory buffer
|
|
|
|
* is correctly setup for DMA. If we've been passed an extant DMA address
|
|
|
|
* then ensure the buffer has been synced to memory. If our buffer has no
|
|
|
|
* DMA memory, then we map the memory and mark our request to allow us to
|
|
|
|
* cleanup on completion.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_map_dma(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
2009-06-02 07:58:06 -06:00
|
|
|
struct usb_request *req)
|
|
|
|
{
|
2013-01-28 05:48:36 -07:00
|
|
|
int ret;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2013-01-28 05:48:36 -07:00
|
|
|
ret = usb_gadget_map_request(&hsotg->gadget, req, hs_ep->dir_in);
|
|
|
|
if (ret)
|
|
|
|
goto dma_error;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dma_error:
|
|
|
|
dev_err(hsotg->dev, "%s: failed to map buffer %p, %d bytes\n",
|
|
|
|
__func__, req->buf, req->length);
|
|
|
|
|
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_handle_unaligned_buf_start(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:31:58 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
|
|
|
struct dwc2_hsotg_req *hs_req)
|
2015-01-30 01:09:31 -07:00
|
|
|
{
|
|
|
|
void *req_buf = hs_req->req.buf;
|
|
|
|
|
|
|
|
/* If dma is not being used or buffer is aligned */
|
|
|
|
if (!using_dma(hsotg) || !((long)req_buf & 3))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
WARN_ON(hs_req->saved_req_buf);
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: %s: buf=%p length=%d\n", __func__,
|
2017-01-17 21:30:27 -07:00
|
|
|
hs_ep->ep.name, req_buf, hs_req->req.length);
|
2015-01-30 01:09:31 -07:00
|
|
|
|
|
|
|
hs_req->req.buf = kmalloc(hs_req->req.length, GFP_ATOMIC);
|
|
|
|
if (!hs_req->req.buf) {
|
|
|
|
hs_req->req.buf = req_buf;
|
|
|
|
dev_err(hsotg->dev,
|
|
|
|
"%s: unable to allocate memory for bounce buffer\n",
|
|
|
|
__func__);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Save actual buffer */
|
|
|
|
hs_req->saved_req_buf = req_buf;
|
|
|
|
|
|
|
|
if (hs_ep->dir_in)
|
|
|
|
memcpy(hs_req->req.buf, req_buf, hs_req->req.length);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-01-17 21:31:58 -07:00
|
|
|
static void
|
|
|
|
dwc2_hsotg_handle_unaligned_buf_complete(struct dwc2_hsotg *hsotg,
|
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
|
|
|
struct dwc2_hsotg_req *hs_req)
|
2015-01-30 01:09:31 -07:00
|
|
|
{
|
|
|
|
/* If dma is not being used or buffer was aligned */
|
|
|
|
if (!using_dma(hsotg) || !hs_req->saved_req_buf)
|
|
|
|
return;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: %s: status=%d actual-length=%d\n", __func__,
|
|
|
|
hs_ep->ep.name, hs_req->req.status, hs_req->req.actual);
|
|
|
|
|
|
|
|
/* Copy data from bounce buffer on successful out transfer */
|
|
|
|
if (!hs_ep->dir_in && !hs_req->req.status)
|
|
|
|
memcpy(hs_req->saved_req_buf, hs_req->req.buf,
|
2017-01-17 21:30:27 -07:00
|
|
|
hs_req->req.actual);
|
2015-01-30 01:09:31 -07:00
|
|
|
|
|
|
|
/* Free bounce buffer */
|
|
|
|
kfree(hs_req->req.buf);
|
|
|
|
|
|
|
|
hs_req->req.buf = hs_req->saved_req_buf;
|
|
|
|
hs_req->saved_req_buf = NULL;
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_target_frame_elapsed - Checks target frame
|
|
|
|
* @hs_ep: The driver endpoint to check
|
|
|
|
*
|
|
|
|
* Returns 1 if targeted frame elapsed. If returned 1 then we need to drop
|
|
|
|
* corresponding transfer.
|
|
|
|
*/
|
|
|
|
static bool dwc2_gadget_target_frame_elapsed(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
u32 target_frame = hs_ep->target_frame;
|
|
|
|
u32 current_frame = dwc2_hsotg_read_frameno(hsotg);
|
|
|
|
bool frame_overrun = hs_ep->frame_overrun;
|
|
|
|
|
|
|
|
if (!frame_overrun && current_frame >= target_frame)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (frame_overrun && current_frame >= target_frame &&
|
|
|
|
((current_frame - target_frame) < DSTS_SOFFN_LIMIT / 2))
|
|
|
|
return true;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:24 -07:00
|
|
|
/*
|
|
|
|
* dwc2_gadget_set_ep0_desc_chain - Set EP's desc chain pointers
|
|
|
|
* @hsotg: The driver state
|
|
|
|
* @hs_ep: the ep descriptor chain is for
|
|
|
|
*
|
|
|
|
* Called to update EP0 structure's pointers depend on stage of
|
|
|
|
* control transfer.
|
|
|
|
*/
|
|
|
|
static int dwc2_gadget_set_ep0_desc_chain(struct dwc2_hsotg *hsotg,
|
|
|
|
struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
switch (hsotg->ep0_state) {
|
|
|
|
case DWC2_EP0_SETUP:
|
|
|
|
case DWC2_EP0_STATUS_OUT:
|
|
|
|
hs_ep->desc_list = hsotg->setup_desc[0];
|
|
|
|
hs_ep->desc_list_dma = hsotg->setup_desc_dma[0];
|
|
|
|
break;
|
|
|
|
case DWC2_EP0_DATA_IN:
|
|
|
|
case DWC2_EP0_STATUS_IN:
|
|
|
|
hs_ep->desc_list = hsotg->ctrl_in_desc;
|
|
|
|
hs_ep->desc_list_dma = hsotg->ctrl_in_desc_dma;
|
|
|
|
break;
|
|
|
|
case DWC2_EP0_DATA_OUT:
|
|
|
|
hs_ep->desc_list = hsotg->ctrl_out_desc;
|
|
|
|
hs_ep->desc_list_dma = hsotg->ctrl_out_desc_dma;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(hsotg->dev, "invalid EP 0 state in queue %d\n",
|
|
|
|
hsotg->ep0_state);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_ep_queue(struct usb_ep *ep, struct usb_request *req,
|
2017-01-17 21:30:27 -07:00
|
|
|
gfp_t gfp_flags)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req = our_req(req);
|
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hs = hs_ep->parent;
|
2009-06-02 07:58:06 -06:00
|
|
|
bool first;
|
2015-01-30 01:09:31 -07:00
|
|
|
int ret;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hs->dev, "%s: req %p: %d@%p, noi=%d, zero=%d, snok=%d\n",
|
|
|
|
ep->name, req, req->length, req->buf, req->no_interrupt,
|
|
|
|
req->zero, req->short_not_ok);
|
|
|
|
|
2015-04-29 14:09:08 -06:00
|
|
|
/* Prevent new request submission when controller is suspended */
|
2018-01-24 06:44:25 -07:00
|
|
|
if (hs->lx_state != DWC2_L0) {
|
|
|
|
dev_dbg(hs->dev, "%s: submit request only in active state\n",
|
2017-01-17 21:30:27 -07:00
|
|
|
__func__);
|
2015-04-29 14:09:08 -06:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/* initialise status of the request */
|
|
|
|
INIT_LIST_HEAD(&hs_req->queue);
|
|
|
|
req->actual = 0;
|
|
|
|
req->status = -EINPROGRESS;
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_handle_unaligned_buf_start(hs, hs_ep, hs_req);
|
2015-01-30 01:09:31 -07:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/* if we're using DMA, sync the buffers as necessary */
|
|
|
|
if (using_dma(hs)) {
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_map_dma(hs, hs_ep, req);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2016-11-14 20:16:24 -07:00
|
|
|
/* If using descriptor DMA configure EP0 descriptor chain pointers */
|
|
|
|
if (using_desc_dma(hs) && !hs_ep->index) {
|
|
|
|
ret = dwc2_gadget_set_ep0_desc_chain(hs, hs_ep);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
first = list_empty(&hs_ep->queue);
|
|
|
|
list_add_tail(&hs_req->queue, &hs_ep->queue);
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
/*
|
|
|
|
* Handle DDMA isochronous transfers separately - just add new entry
|
|
|
|
* to the half of descriptor chain that is not processed by HW.
|
|
|
|
* Transfer will be started once SW gets either one of NAK or
|
|
|
|
* OutTknEpDis interrupts.
|
|
|
|
*/
|
|
|
|
if (using_desc_dma(hs) && hs_ep->isochronous &&
|
|
|
|
hs_ep->target_frame != TARGET_FRAME_INITIAL) {
|
|
|
|
ret = dwc2_gadget_fill_isoc_desc(hs_ep, hs_req->req.dma,
|
|
|
|
hs_req->req.length);
|
|
|
|
if (ret)
|
|
|
|
dev_dbg(hs->dev, "%s: ISO desc chain full\n", __func__);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (first) {
|
|
|
|
if (!hs_ep->isochronous) {
|
|
|
|
dwc2_hsotg_start_req(hs, hs_ep, hs_req, false);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (dwc2_gadget_target_frame_elapsed(hs_ep))
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (hs_ep->target_frame != TARGET_FRAME_INITIAL)
|
|
|
|
dwc2_hsotg_start_req(hs, hs_ep, hs_req, false);
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_ep_queue_lock(struct usb_ep *ep, struct usb_request *req,
|
2017-01-17 21:30:27 -07:00
|
|
|
gfp_t gfp_flags)
|
2012-06-14 02:02:26 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hs = hs_ep->parent;
|
2012-06-14 02:02:26 -06:00
|
|
|
unsigned long flags = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hs->lock, flags);
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_ep_queue(ep, req, gfp_flags);
|
2012-06-14 02:02:26 -06:00
|
|
|
spin_unlock_irqrestore(&hs->lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_ep_free_request(struct usb_ep *ep,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct usb_request *req)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req = our_req(req);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
kfree(hs_req);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_complete_oursetup - setup completion callback
|
2009-06-02 07:58:06 -06:00
|
|
|
* @ep: The endpoint the request was on.
|
|
|
|
* @req: The request completed.
|
|
|
|
*
|
|
|
|
* Called on completion of any requests the driver itself
|
|
|
|
* submitted that need cleaning up.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_complete_oursetup(struct usb_ep *ep,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct usb_request *req)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: ep %p, req %p\n", __func__, ep, req);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ep_free_request(ep, req);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* ep_from_windex - convert control wIndex value to endpoint
|
|
|
|
* @hsotg: The driver state.
|
|
|
|
* @windex: The control request wIndex field (in host order).
|
|
|
|
*
|
|
|
|
* Convert the given wIndex into a pointer to an driver endpoint
|
|
|
|
* structure, or return NULL if it is not a valid endpoint.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static struct dwc2_hsotg_ep *ep_from_windex(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
u32 windex)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep;
|
2009-06-02 07:58:06 -06:00
|
|
|
int dir = (windex & USB_DIR_IN) ? 1 : 0;
|
|
|
|
int idx = windex & 0x7F;
|
|
|
|
|
|
|
|
if (windex >= 0x100)
|
|
|
|
return NULL;
|
|
|
|
|
2012-05-04 06:17:09 -06:00
|
|
|
if (idx > hsotg->num_of_eps)
|
2009-06-02 07:58:06 -06:00
|
|
|
return NULL;
|
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
ep = index_to_ep(hsotg, idx, dir);
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (idx && ep->dir_in != dir)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
return ep;
|
|
|
|
}
|
|
|
|
|
2015-01-30 01:09:28 -07:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_set_test_mode - Enable usb Test Modes
|
2015-01-30 01:09:28 -07:00
|
|
|
* @hsotg: The driver state.
|
|
|
|
* @testmode: requested usb test mode
|
|
|
|
* Enable usb Test Mode requested by the Host.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
int dwc2_hsotg_set_test_mode(struct dwc2_hsotg *hsotg, int testmode)
|
2015-01-30 01:09:28 -07:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
int dctl = dwc2_readl(hsotg->regs + DCTL);
|
2015-01-30 01:09:28 -07:00
|
|
|
|
|
|
|
dctl &= ~DCTL_TSTCTL_MASK;
|
|
|
|
switch (testmode) {
|
|
|
|
case TEST_J:
|
|
|
|
case TEST_K:
|
|
|
|
case TEST_SE0_NAK:
|
|
|
|
case TEST_PACKET:
|
|
|
|
case TEST_FORCE_EN:
|
|
|
|
dctl |= testmode << DCTL_TSTCTL_SHIFT;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(dctl, hsotg->regs + DCTL);
|
2015-01-30 01:09:28 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_send_reply - send reply to control request
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
* @ep: Endpoint 0
|
|
|
|
* @buff: Buffer for request
|
|
|
|
* @length: Length of reply.
|
|
|
|
*
|
|
|
|
* Create a request and queue it on the given endpoint. This is useful as
|
|
|
|
* an internal method of sending replies to certain control requests, etc.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_send_reply(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *ep,
|
2009-06-02 07:58:06 -06:00
|
|
|
void *buff,
|
|
|
|
int length)
|
|
|
|
{
|
|
|
|
struct usb_request *req;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: buff %p, len %d\n", __func__, buff, length);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
req = dwc2_hsotg_ep_alloc_request(&ep->ep, GFP_ATOMIC);
|
2009-06-02 07:58:06 -06:00
|
|
|
hsotg->ep0_reply = req;
|
|
|
|
if (!req) {
|
|
|
|
dev_warn(hsotg->dev, "%s: cannot alloc req\n", __func__);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
req->buf = hsotg->ep0_buff;
|
|
|
|
req->length = length;
|
2015-01-09 05:38:59 -07:00
|
|
|
/*
|
|
|
|
* zero flag is for sending zlp in DATA IN stage. It has no impact on
|
|
|
|
* STATUS stage.
|
|
|
|
*/
|
|
|
|
req->zero = 0;
|
2015-08-06 17:11:54 -06:00
|
|
|
req->complete = dwc2_hsotg_complete_oursetup;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (length)
|
|
|
|
memcpy(req->buf, buff, length);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_ep_queue(&ep->ep, req, GFP_ATOMIC);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (ret) {
|
|
|
|
dev_warn(hsotg->dev, "%s: cannot queue req\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_process_req_status - process request GET_STATUS
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
* @ctrl: USB control request
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_process_req_status(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct usb_ctrlrequest *ctrl)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
|
|
|
|
struct dwc2_hsotg_ep *ep;
|
2009-06-02 07:58:06 -06:00
|
|
|
__le16 reply;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: USB_REQ_GET_STATUS\n", __func__);
|
|
|
|
|
|
|
|
if (!ep0->dir_in) {
|
|
|
|
dev_warn(hsotg->dev, "%s: direction out?\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (ctrl->bRequestType & USB_RECIP_MASK) {
|
|
|
|
case USB_RECIP_DEVICE:
|
2017-01-17 21:31:13 -07:00
|
|
|
/*
|
|
|
|
* bit 0 => self powered
|
|
|
|
* bit 1 => remote wakeup
|
|
|
|
*/
|
|
|
|
reply = cpu_to_le16(0);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_RECIP_INTERFACE:
|
|
|
|
/* currently, the data result should be zero */
|
|
|
|
reply = cpu_to_le16(0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_RECIP_ENDPOINT:
|
|
|
|
ep = ep_from_windex(hsotg, le16_to_cpu(ctrl->wIndex));
|
|
|
|
if (!ep)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
reply = cpu_to_le16(ep->halted ? 1 : 0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (le16_to_cpu(ctrl->wLength) != 2)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_send_reply(hsotg, ep0, &reply, 2);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev, "%s: failed to send reply\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2016-05-23 23:41:57 -06:00
|
|
|
static int dwc2_hsotg_ep_sethalt(struct usb_ep *ep, int value, bool now);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2011-04-21 02:06:41 -06:00
|
|
|
/**
|
|
|
|
* get_ep_head - return the first request on the endpoint
|
|
|
|
* @hs_ep: The controller endpoint to get
|
|
|
|
*
|
|
|
|
* Get the first request on the endpoint.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static struct dwc2_hsotg_req *get_ep_head(struct dwc2_hsotg_ep *hs_ep)
|
2011-04-21 02:06:41 -06:00
|
|
|
{
|
2016-09-18 10:03:13 -06:00
|
|
|
return list_first_entry_or_null(&hs_ep->queue, struct dwc2_hsotg_req,
|
|
|
|
queue);
|
2011-04-21 02:06:41 -06:00
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:12 -06:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_start_next_request - Starts next request from ep queue
|
|
|
|
* @hs_ep: Endpoint structure
|
|
|
|
*
|
|
|
|
* If queue is empty and EP is ISOC-OUT - unmasks OUTTKNEPDIS which is masked
|
|
|
|
* in its handler. Hence we need to unmask it here to be able to do
|
|
|
|
* resynchronization.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_start_next_request(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
u32 mask;
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
int dir_in = hs_ep->dir_in;
|
|
|
|
struct dwc2_hsotg_req *hs_req;
|
|
|
|
u32 epmsk_reg = dir_in ? DIEPMSK : DOEPMSK;
|
|
|
|
|
|
|
|
if (!list_empty(&hs_ep->queue)) {
|
|
|
|
hs_req = get_ep_head(hs_ep);
|
|
|
|
dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, false);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!hs_ep->isochronous)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (dir_in) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: No more ISOC-IN requests\n",
|
|
|
|
__func__);
|
|
|
|
} else {
|
|
|
|
dev_dbg(hsotg->dev, "%s: No more ISOC-OUT requests\n",
|
|
|
|
__func__);
|
|
|
|
mask = dwc2_readl(hsotg->regs + epmsk_reg);
|
|
|
|
mask |= DOEPMSK_OUTTKNEPDISMSK;
|
|
|
|
dwc2_writel(mask, hsotg->regs + epmsk_reg);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_process_req_feature - process request {SET,CLEAR}_FEATURE
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
* @ctrl: USB control request
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_process_req_feature(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct usb_ctrlrequest *ctrl)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
|
|
|
|
struct dwc2_hsotg_req *hs_req;
|
2009-06-02 07:58:06 -06:00
|
|
|
bool set = (ctrl->bRequest == USB_REQ_SET_FEATURE);
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep;
|
2011-04-21 02:06:40 -06:00
|
|
|
int ret;
|
2013-09-19 03:50:22 -06:00
|
|
|
bool halted;
|
2015-01-30 01:09:28 -07:00
|
|
|
u32 recip;
|
|
|
|
u32 wValue;
|
|
|
|
u32 wIndex;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: %s_FEATURE\n",
|
|
|
|
__func__, set ? "SET" : "CLEAR");
|
|
|
|
|
2015-01-30 01:09:28 -07:00
|
|
|
wValue = le16_to_cpu(ctrl->wValue);
|
|
|
|
wIndex = le16_to_cpu(ctrl->wIndex);
|
|
|
|
recip = ctrl->bRequestType & USB_RECIP_MASK;
|
|
|
|
|
|
|
|
switch (recip) {
|
|
|
|
case USB_RECIP_DEVICE:
|
|
|
|
switch (wValue) {
|
2018-02-16 03:08:53 -07:00
|
|
|
case USB_DEVICE_REMOTE_WAKEUP:
|
|
|
|
hsotg->remote_wakeup_allowed = 1;
|
|
|
|
break;
|
|
|
|
|
2015-01-30 01:09:28 -07:00
|
|
|
case USB_DEVICE_TEST_MODE:
|
|
|
|
if ((wIndex & 0xff) != 0)
|
|
|
|
return -EINVAL;
|
|
|
|
if (!set)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
hsotg->test_mode = wIndex >> 8;
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
|
2015-01-30 01:09:28 -07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev,
|
|
|
|
"%s: failed to send reply\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_RECIP_ENDPOINT:
|
|
|
|
ep = ep_from_windex(hsotg, wIndex);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (!ep) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: no endpoint for 0x%04x\n",
|
2015-01-30 01:09:28 -07:00
|
|
|
__func__, wIndex);
|
2009-06-02 07:58:06 -06:00
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2015-01-30 01:09:28 -07:00
|
|
|
switch (wValue) {
|
2009-06-02 07:58:06 -06:00
|
|
|
case USB_ENDPOINT_HALT:
|
2013-09-19 03:50:22 -06:00
|
|
|
halted = ep->halted;
|
|
|
|
|
2016-05-23 23:41:57 -06:00
|
|
|
dwc2_hsotg_ep_sethalt(&ep->ep, set, true);
|
2011-04-21 02:06:40 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
|
2011-04-21 02:06:40 -06:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev,
|
|
|
|
"%s: failed to send reply\n", __func__);
|
|
|
|
return ret;
|
|
|
|
}
|
2011-04-21 02:06:41 -06:00
|
|
|
|
2013-09-19 03:50:22 -06:00
|
|
|
/*
|
|
|
|
* we have to complete all requests for ep if it was
|
|
|
|
* halted, and the halt was cleared by CLEAR_FEATURE
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (!set && halted) {
|
2011-04-21 02:06:41 -06:00
|
|
|
/*
|
|
|
|
* If we have request in progress,
|
|
|
|
* then complete it
|
|
|
|
*/
|
|
|
|
if (ep->req) {
|
|
|
|
hs_req = ep->req;
|
|
|
|
ep->req = NULL;
|
|
|
|
list_del_init(&hs_req->queue);
|
2015-01-30 01:09:27 -07:00
|
|
|
if (hs_req->req.complete) {
|
|
|
|
spin_unlock(&hsotg->lock);
|
|
|
|
usb_gadget_giveback_request(
|
|
|
|
&ep->ep, &hs_req->req);
|
|
|
|
spin_lock(&hsotg->lock);
|
|
|
|
}
|
2011-04-21 02:06:41 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If we have pending request, then start it */
|
2017-01-17 21:31:43 -07:00
|
|
|
if (!ep->req)
|
2016-05-25 19:07:12 -06:00
|
|
|
dwc2_gadget_start_next_request(ep);
|
2011-04-21 02:06:41 -06:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2015-01-30 01:09:28 -07:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg);
|
2013-09-19 03:50:17 -06:00
|
|
|
|
2014-01-14 00:36:00 -07:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_stall_ep0 - stall ep0
|
2014-01-14 00:36:00 -07:00
|
|
|
* @hsotg: The device state
|
|
|
|
*
|
|
|
|
* Set stall for ep0 as response for setup request.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_stall_ep0(struct dwc2_hsotg *hsotg)
|
2014-06-03 07:14:56 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
|
2014-01-14 00:36:00 -07:00
|
|
|
u32 reg;
|
|
|
|
u32 ctrl;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "ep0 stall (dir=%d)\n", ep0->dir_in);
|
|
|
|
reg = (ep0->dir_in) ? DIEPCTL0 : DOEPCTL0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* DxEPCTL_Stall will be cleared by EP once it has
|
|
|
|
* taken effect, so no need to clear later.
|
|
|
|
*/
|
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
ctrl = dwc2_readl(hsotg->regs + reg);
|
2014-04-14 15:13:34 -06:00
|
|
|
ctrl |= DXEPCTL_STALL;
|
|
|
|
ctrl |= DXEPCTL_CNAK;
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(ctrl, hsotg->regs + reg);
|
2014-01-14 00:36:00 -07:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev,
|
2014-04-14 15:13:34 -06:00
|
|
|
"written DXEPCTL=0x%08x to %08x (DXEPCTL=0x%08x)\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
ctrl, reg, dwc2_readl(hsotg->regs + reg));
|
2014-01-14 00:36:00 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* complete won't be called, so we enqueue
|
|
|
|
* setup request here
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_enqueue_setup(hsotg);
|
2014-01-14 00:36:00 -07:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_process_control - process a control request
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
* @ctrl: The control request received
|
|
|
|
*
|
|
|
|
* The controller has received the SETUP phase of a control request, and
|
|
|
|
* needs to work out what to do next (and whether to pass it on to the
|
|
|
|
* gadget driver).
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_process_control(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct usb_ctrlrequest *ctrl)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep0 = hsotg->eps_out[0];
|
2009-06-02 07:58:06 -06:00
|
|
|
int ret = 0;
|
|
|
|
u32 dcfg;
|
|
|
|
|
2015-09-29 04:08:23 -06:00
|
|
|
dev_dbg(hsotg->dev,
|
|
|
|
"ctrl Type=%02x, Req=%02x, V=%04x, I=%04x, L=%04x\n",
|
|
|
|
ctrl->bRequestType, ctrl->bRequest, ctrl->wValue,
|
|
|
|
ctrl->wIndex, ctrl->wLength);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-01-09 05:38:58 -07:00
|
|
|
if (ctrl->wLength == 0) {
|
|
|
|
ep0->dir_in = 1;
|
|
|
|
hsotg->ep0_state = DWC2_EP0_STATUS_IN;
|
|
|
|
} else if (ctrl->bRequestType & USB_DIR_IN) {
|
2009-06-02 07:58:06 -06:00
|
|
|
ep0->dir_in = 1;
|
2015-01-09 05:38:58 -07:00
|
|
|
hsotg->ep0_state = DWC2_EP0_DATA_IN;
|
|
|
|
} else {
|
|
|
|
ep0->dir_in = 0;
|
|
|
|
hsotg->ep0_state = DWC2_EP0_DATA_OUT;
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if ((ctrl->bRequestType & USB_TYPE_MASK) == USB_TYPE_STANDARD) {
|
|
|
|
switch (ctrl->bRequest) {
|
|
|
|
case USB_REQ_SET_ADDRESS:
|
2015-01-09 05:39:10 -07:00
|
|
|
hsotg->connected = 1;
|
2015-08-20 12:41:07 -06:00
|
|
|
dcfg = dwc2_readl(hsotg->regs + DCFG);
|
2014-04-14 15:13:34 -06:00
|
|
|
dcfg &= ~DCFG_DEVADDR_MASK;
|
2014-04-25 15:18:13 -06:00
|
|
|
dcfg |= (le16_to_cpu(ctrl->wValue) <<
|
|
|
|
DCFG_DEVADDR_SHIFT) & DCFG_DEVADDR_MASK;
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(dcfg, hsotg->regs + DCFG);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_info(hsotg->dev, "new address %d\n", ctrl->wValue);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_send_reply(hsotg, ep0, NULL, 0);
|
2009-06-02 07:58:06 -06:00
|
|
|
return;
|
|
|
|
|
|
|
|
case USB_REQ_GET_STATUS:
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_process_req_status(hsotg, ctrl);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_REQ_CLEAR_FEATURE:
|
|
|
|
case USB_REQ_SET_FEATURE:
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_process_req_feature(hsotg, ctrl);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* as a fallback, try delivering it to the driver to deal with */
|
|
|
|
|
|
|
|
if (ret == 0 && hsotg->driver) {
|
2013-11-21 05:49:17 -07:00
|
|
|
spin_unlock(&hsotg->lock);
|
2009-06-02 07:58:06 -06:00
|
|
|
ret = hsotg->driver->setup(&hsotg->gadget, ctrl);
|
2013-11-21 05:49:17 -07:00
|
|
|
spin_lock(&hsotg->lock);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (ret < 0)
|
|
|
|
dev_dbg(hsotg->dev, "driver->setup() ret %d\n", ret);
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* the request is either unhandlable, or is not formatted correctly
|
2009-06-02 07:58:06 -06:00
|
|
|
* so respond with a STALL for the status stage to indicate failure.
|
|
|
|
*/
|
|
|
|
|
2014-01-14 00:36:00 -07:00
|
|
|
if (ret < 0)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_stall_ep0(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_complete_setup - completion of a setup transfer
|
2009-06-02 07:58:06 -06:00
|
|
|
* @ep: The endpoint the request was on.
|
|
|
|
* @req: The request completed.
|
|
|
|
*
|
|
|
|
* Called on completion of any requests the driver itself submitted for
|
|
|
|
* EP0 setup packets
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_complete_setup(struct usb_ep *ep,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct usb_request *req)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (req->status < 0) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: failed %d\n", __func__, req->status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-21 05:49:17 -07:00
|
|
|
spin_lock(&hsotg->lock);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (req->actual == 0)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_enqueue_setup(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
else
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_process_control(hsotg, req->buf);
|
2013-11-21 05:49:17 -07:00
|
|
|
spin_unlock(&hsotg->lock);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_enqueue_setup - start a request for EP0 packets
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
*
|
|
|
|
* Enqueue a request on EP0 if necessary to received any SETUP packets
|
|
|
|
* received from the host.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_enqueue_setup(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
|
|
|
struct usb_request *req = hsotg->ctrl_req;
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req = our_req(req);
|
2009-06-02 07:58:06 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: queueing setup request\n", __func__);
|
|
|
|
|
|
|
|
req->zero = 0;
|
|
|
|
req->length = 8;
|
|
|
|
req->buf = hsotg->ctrl_buff;
|
2015-08-06 17:11:54 -06:00
|
|
|
req->complete = dwc2_hsotg_complete_setup;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (!list_empty(&hs_req->queue)) {
|
|
|
|
dev_dbg(hsotg->dev, "%s already queued???\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
hsotg->eps_out[0]->dir_in = 0;
|
2015-01-09 05:39:03 -07:00
|
|
|
hsotg->eps_out[0]->send_zlp = 0;
|
2015-01-09 05:38:58 -07:00
|
|
|
hsotg->ep0_state = DWC2_EP0_SETUP;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_ep_queue(&hsotg->eps_out[0]->ep, req, GFP_ATOMIC);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(hsotg->dev, "%s: failed queue (%d)\n", __func__, ret);
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* Don't think there's much we can do other than watch the
|
|
|
|
* driver fail.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_program_zlp(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep)
|
2015-01-09 05:38:58 -07:00
|
|
|
{
|
|
|
|
u32 ctrl;
|
|
|
|
u8 index = hs_ep->index;
|
|
|
|
u32 epctl_reg = hs_ep->dir_in ? DIEPCTL(index) : DOEPCTL(index);
|
|
|
|
u32 epsiz_reg = hs_ep->dir_in ? DIEPTSIZ(index) : DOEPTSIZ(index);
|
|
|
|
|
2015-01-30 01:09:34 -07:00
|
|
|
if (hs_ep->dir_in)
|
|
|
|
dev_dbg(hsotg->dev, "Sending zero-length packet on ep%d\n",
|
2016-11-14 20:16:24 -07:00
|
|
|
index);
|
2015-01-30 01:09:34 -07:00
|
|
|
else
|
|
|
|
dev_dbg(hsotg->dev, "Receiving zero-length packet on ep%d\n",
|
2016-11-14 20:16:24 -07:00
|
|
|
index);
|
|
|
|
if (using_desc_dma(hsotg)) {
|
|
|
|
/* Not specific buffer needed for ep0 ZLP */
|
|
|
|
dma_addr_t dma = hs_ep->desc_list_dma;
|
2015-01-09 05:38:58 -07:00
|
|
|
|
2018-01-16 05:03:32 -07:00
|
|
|
if (!index)
|
|
|
|
dwc2_gadget_set_ep0_desc_chain(hsotg, hs_ep);
|
|
|
|
|
2016-11-14 20:16:24 -07:00
|
|
|
dwc2_gadget_config_nonisoc_xfer_ddma(hs_ep, dma, 0);
|
|
|
|
} else {
|
|
|
|
dwc2_writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
|
|
|
|
DXEPTSIZ_XFERSIZE(0), hsotg->regs +
|
|
|
|
epsiz_reg);
|
|
|
|
}
|
2015-01-09 05:38:58 -07:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
ctrl = dwc2_readl(hsotg->regs + epctl_reg);
|
2015-01-09 05:38:58 -07:00
|
|
|
ctrl |= DXEPCTL_CNAK; /* clear NAK set by core */
|
|
|
|
ctrl |= DXEPCTL_EPENA; /* ensure ep enabled */
|
|
|
|
ctrl |= DXEPCTL_USBACTEP;
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(ctrl, hsotg->regs + epctl_reg);
|
2015-01-09 05:38:58 -07:00
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_complete_request - complete a request given to us
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
* @hs_ep: The endpoint the request was on.
|
|
|
|
* @hs_req: The request to complete.
|
|
|
|
* @result: The result code (0 => Ok, otherwise errno)
|
|
|
|
*
|
|
|
|
* The given request has finished, so call the necessary completion
|
|
|
|
* if it has one and then look to see if we can start a new request
|
|
|
|
* on the endpoint.
|
|
|
|
*
|
|
|
|
* Note, expects the ep to already be locked as appropriate.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_complete_request(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req,
|
2009-06-02 07:58:06 -06:00
|
|
|
int result)
|
|
|
|
{
|
|
|
|
if (!hs_req) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: nothing to complete?\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "complete: ep %p %s, req %p, %d => %p\n",
|
|
|
|
hs_ep, hs_ep->ep.name, hs_req, result, hs_req->req.complete);
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* only replace the status if we've not already set an error
|
|
|
|
* from a previous transaction
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (hs_req->req.status == -EINPROGRESS)
|
|
|
|
hs_req->req.status = result;
|
|
|
|
|
2015-09-29 04:25:01 -06:00
|
|
|
if (using_dma(hsotg))
|
|
|
|
dwc2_hsotg_unmap_dma(hsotg, hs_ep, hs_req);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_handle_unaligned_buf_complete(hsotg, hs_ep, hs_req);
|
2015-01-30 01:09:31 -07:00
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
hs_ep->req = NULL;
|
|
|
|
list_del_init(&hs_req->queue);
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* call the complete request with the locks off, just in case the
|
|
|
|
* request tries to queue more work for this endpoint.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (hs_req->req.complete) {
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_unlock(&hsotg->lock);
|
2014-09-24 14:43:19 -06:00
|
|
|
usb_gadget_giveback_request(&hs_ep->ep, &hs_req->req);
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_lock(&hsotg->lock);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
/* In DDMA don't need to proceed to starting of next ISOC request */
|
|
|
|
if (using_desc_dma(hsotg) && hs_ep->isochronous)
|
|
|
|
return;
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* Look to see if there is anything else to do. Note, the completion
|
2009-06-02 07:58:06 -06:00
|
|
|
* of the previous request may have caused a new request to be started
|
2012-05-04 06:17:11 -06:00
|
|
|
* so be careful when doing this.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2017-01-17 21:31:43 -07:00
|
|
|
if (!hs_ep->req && result >= 0)
|
2016-05-25 19:07:12 -06:00
|
|
|
dwc2_gadget_start_next_request(hs_ep);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
/*
|
|
|
|
* dwc2_gadget_complete_isoc_request_ddma - complete an isoc request in DDMA
|
|
|
|
* @hs_ep: The endpoint the request was on.
|
|
|
|
*
|
|
|
|
* Get first request from the ep queue, determine descriptor on which complete
|
|
|
|
* happened. SW based on isoc_chain_num discovers which half of the descriptor
|
|
|
|
* chain is currently in use by HW, adjusts dma_address and calculates index
|
|
|
|
* of completed descriptor based on the value of DEPDMA register. Update actual
|
|
|
|
* length of request, giveback to gadget.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_complete_isoc_request_ddma(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
struct dwc2_hsotg_req *hs_req;
|
|
|
|
struct usb_request *ureq;
|
|
|
|
int index;
|
|
|
|
dma_addr_t dma_addr;
|
|
|
|
u32 dma_reg;
|
|
|
|
u32 depdma;
|
|
|
|
u32 desc_sts;
|
|
|
|
u32 mask;
|
|
|
|
|
|
|
|
hs_req = get_ep_head(hs_ep);
|
|
|
|
if (!hs_req) {
|
|
|
|
dev_warn(hsotg->dev, "%s: ISOC EP queue empty\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
ureq = &hs_req->req;
|
|
|
|
|
|
|
|
dma_addr = hs_ep->desc_list_dma;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If lower half of descriptor chain is currently use by SW,
|
|
|
|
* that means higher half is being processed by HW, so shift
|
|
|
|
* DMA address to higher half of descriptor chain.
|
|
|
|
*/
|
|
|
|
if (!hs_ep->isoc_chain_num)
|
|
|
|
dma_addr += sizeof(struct dwc2_dma_desc) *
|
|
|
|
(MAX_DMA_DESC_NUM_GENERIC / 2);
|
|
|
|
|
|
|
|
dma_reg = hs_ep->dir_in ? DIEPDMA(hs_ep->index) : DOEPDMA(hs_ep->index);
|
|
|
|
depdma = dwc2_readl(hsotg->regs + dma_reg);
|
|
|
|
|
|
|
|
index = (depdma - dma_addr) / sizeof(struct dwc2_dma_desc) - 1;
|
|
|
|
desc_sts = hs_ep->desc_list[index].status;
|
|
|
|
|
|
|
|
mask = hs_ep->dir_in ? DEV_DMA_ISOC_TX_NBYTES_MASK :
|
|
|
|
DEV_DMA_ISOC_RX_NBYTES_MASK;
|
|
|
|
ureq->actual = ureq->length -
|
|
|
|
((desc_sts & mask) >> DEV_DMA_ISOC_NBYTES_SHIFT);
|
|
|
|
|
2016-11-14 20:16:46 -07:00
|
|
|
/* Adjust actual length for ISOC Out if length is not align of 4 */
|
|
|
|
if (!hs_ep->dir_in && ureq->length & 0x3)
|
|
|
|
ureq->actual += 4 - (ureq->length & 0x3);
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* dwc2_gadget_start_next_isoc_ddma - start next isoc request, if any.
|
|
|
|
* @hs_ep: The isochronous endpoint to be re-enabled.
|
|
|
|
*
|
|
|
|
* If ep has been disabled due to last descriptor servicing (IN endpoint) or
|
|
|
|
* BNA (OUT endpoint) check the status of other half of descriptor chain that
|
|
|
|
* was under SW control till HW was busy and restart the endpoint if needed.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_start_next_isoc_ddma(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
u32 depctl;
|
|
|
|
u32 dma_reg;
|
|
|
|
u32 ctrl;
|
|
|
|
u32 dma_addr = hs_ep->desc_list_dma;
|
|
|
|
unsigned char index = hs_ep->index;
|
|
|
|
|
|
|
|
dma_reg = hs_ep->dir_in ? DIEPDMA(index) : DOEPDMA(index);
|
|
|
|
depctl = hs_ep->dir_in ? DIEPCTL(index) : DOEPCTL(index);
|
|
|
|
|
|
|
|
ctrl = dwc2_readl(hsotg->regs + depctl);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EP was disabled if HW has processed last descriptor or BNA was set.
|
|
|
|
* So restart ep if SW has prepared new descriptor chain in ep_queue
|
|
|
|
* routine while HW was busy.
|
|
|
|
*/
|
|
|
|
if (!(ctrl & DXEPCTL_EPENA)) {
|
|
|
|
if (!hs_ep->next_desc) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: No more ISOC requests\n",
|
|
|
|
__func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
dma_addr += sizeof(struct dwc2_dma_desc) *
|
|
|
|
(MAX_DMA_DESC_NUM_GENERIC / 2) *
|
|
|
|
hs_ep->isoc_chain_num;
|
|
|
|
dwc2_writel(dma_addr, hsotg->regs + dma_reg);
|
|
|
|
|
|
|
|
ctrl |= DXEPCTL_EPENA | DXEPCTL_CNAK;
|
|
|
|
dwc2_writel(ctrl, hsotg->regs + depctl);
|
|
|
|
|
|
|
|
/* Switch ISOC descriptor chain number being processed by SW*/
|
|
|
|
hs_ep->isoc_chain_num = (hs_ep->isoc_chain_num ^ 1) & 0x1;
|
|
|
|
hs_ep->next_desc = 0;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: Restarted isochronous endpoint\n",
|
|
|
|
__func__);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_rx_data - receive data from the FIFO for an endpoint
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
* @ep_idx: The endpoint index for the data
|
|
|
|
* @size: The size of data in the fifo, in bytes
|
|
|
|
*
|
|
|
|
* The FIFO status shows there is data to read from the FIFO for a given
|
|
|
|
* endpoint, so sort out whether we need to read the data into a request
|
|
|
|
* that has been made for that endpoint.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_rx_data(struct dwc2_hsotg *hsotg, int ep_idx, int size)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = hsotg->eps_out[ep_idx];
|
|
|
|
struct dwc2_hsotg_req *hs_req = hs_ep->req;
|
2012-05-04 06:17:14 -06:00
|
|
|
void __iomem *fifo = hsotg->regs + EPFIFO(ep_idx);
|
2009-06-02 07:58:06 -06:00
|
|
|
int to_read;
|
|
|
|
int max_req;
|
|
|
|
int read_ptr;
|
|
|
|
|
|
|
|
if (!hs_req) {
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 epctl = dwc2_readl(hsotg->regs + DOEPCTL(ep_idx));
|
2009-06-02 07:58:06 -06:00
|
|
|
int ptr;
|
|
|
|
|
2014-12-16 03:51:44 -07:00
|
|
|
dev_dbg(hsotg->dev,
|
2017-01-17 21:30:27 -07:00
|
|
|
"%s: FIFO %d bytes on ep%d but no req (DXEPCTl=0x%08x)\n",
|
2009-06-02 07:58:06 -06:00
|
|
|
__func__, size, ep_idx, epctl);
|
|
|
|
|
|
|
|
/* dump the data from the FIFO, we've nothing we can do */
|
|
|
|
for (ptr = 0; ptr < size; ptr += 4)
|
2015-08-20 12:41:07 -06:00
|
|
|
(void)dwc2_readl(fifo);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
to_read = size;
|
|
|
|
read_ptr = hs_req->req.actual;
|
|
|
|
max_req = hs_req->req.length - read_ptr;
|
|
|
|
|
2010-07-19 02:40:49 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: read %d/%d, done %d/%d\n",
|
|
|
|
__func__, to_read, max_req, read_ptr, hs_req->req.length);
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (to_read > max_req) {
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* more data appeared than we where willing
|
2009-06-02 07:58:06 -06:00
|
|
|
* to deal with in this request.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* currently we don't deal this */
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
hs_ep->total_data += to_read;
|
|
|
|
hs_req->req.actual += to_read;
|
|
|
|
to_read = DIV_ROUND_UP(to_read, 4);
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* note, we might over-write the buffer end by 3 bytes depending on
|
|
|
|
* alignment of the data.
|
|
|
|
*/
|
2014-02-03 08:29:09 -07:00
|
|
|
ioread32_rep(fifo, hs_req->req.buf + read_ptr, to_read);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ep0_zlp - send/receive zero-length packet on control endpoint
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device instance
|
2015-01-09 05:38:58 -07:00
|
|
|
* @dir_in: If IN zlp
|
2009-06-02 07:58:06 -06:00
|
|
|
*
|
|
|
|
* Generate a zero-length IN packet request for terminating a SETUP
|
|
|
|
* transaction.
|
|
|
|
*
|
|
|
|
* Note, since we don't write any data to the TxFIFO, then it is
|
2011-03-30 19:57:33 -06:00
|
|
|
* currently believed that we do not need to wait for any space in
|
2009-06-02 07:58:06 -06:00
|
|
|
* the TxFIFO.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_ep0_zlp(struct dwc2_hsotg *hsotg, bool dir_in)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-01-09 05:38:50 -07:00
|
|
|
/* eps_out[0] is used in both directions */
|
2015-01-09 05:38:58 -07:00
|
|
|
hsotg->eps_out[0]->dir_in = dir_in;
|
|
|
|
hsotg->ep0_state = dir_in ? DWC2_EP0_STATUS_IN : DWC2_EP0_STATUS_OUT;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_program_zlp(hsotg, hsotg->eps_out[0]);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-09-10 19:13:43 -06:00
|
|
|
static void dwc2_hsotg_change_ep_iso_parity(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
u32 epctl_reg)
|
2015-09-10 19:13:43 -06:00
|
|
|
{
|
|
|
|
u32 ctrl;
|
|
|
|
|
|
|
|
ctrl = dwc2_readl(hsotg->regs + epctl_reg);
|
|
|
|
if (ctrl & DXEPCTL_EOFRNUM)
|
|
|
|
ctrl |= DXEPCTL_SETEVENFR;
|
|
|
|
else
|
|
|
|
ctrl |= DXEPCTL_SETODDFR;
|
|
|
|
dwc2_writel(ctrl, hsotg->regs + epctl_reg);
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:26 -07:00
|
|
|
/*
|
|
|
|
* dwc2_gadget_get_xfersize_ddma - get transferred bytes amount from desc
|
|
|
|
* @hs_ep - The endpoint on which transfer went
|
|
|
|
*
|
|
|
|
* Iterate over endpoints descriptor chain and get info on bytes remained
|
|
|
|
* in DMA descriptors after transfer has completed. Used for non isoc EPs.
|
|
|
|
*/
|
|
|
|
static unsigned int dwc2_gadget_get_xfersize_ddma(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
unsigned int bytes_rem = 0;
|
|
|
|
struct dwc2_dma_desc *desc = hs_ep->desc_list;
|
|
|
|
int i;
|
|
|
|
u32 status;
|
|
|
|
|
|
|
|
if (!desc)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
for (i = 0; i < hs_ep->desc_count; ++i) {
|
|
|
|
status = desc->status;
|
|
|
|
bytes_rem += status & DEV_DMA_NBYTES_MASK;
|
|
|
|
|
|
|
|
if (status & DEV_DMA_STS_MASK)
|
|
|
|
dev_err(hsotg->dev, "descriptor %d closed with %x\n",
|
|
|
|
i, status & DEV_DMA_STS_MASK);
|
|
|
|
}
|
|
|
|
|
|
|
|
return bytes_rem;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_handle_outdone - handle receiving OutDone/SetupDone from RXFIFO
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device instance
|
|
|
|
* @epnum: The endpoint received from
|
|
|
|
*
|
|
|
|
* The RXFIFO has delivered an OutDone event, which means that the data
|
|
|
|
* transfer for an OUT endpoint has been completed, either by a short
|
|
|
|
* packet or by the finish of a transfer.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_handle_outdone(struct dwc2_hsotg *hsotg, int epnum)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 epsize = dwc2_readl(hsotg->regs + DOEPTSIZ(epnum));
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = hsotg->eps_out[epnum];
|
|
|
|
struct dwc2_hsotg_req *hs_req = hs_ep->req;
|
2009-06-02 07:58:06 -06:00
|
|
|
struct usb_request *req = &hs_req->req;
|
2017-01-17 21:30:27 -07:00
|
|
|
unsigned int size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
|
2009-06-02 07:58:06 -06:00
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
if (!hs_req) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: no request active\n", __func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:58 -07:00
|
|
|
if (epnum == 0 && hsotg->ep0_state == DWC2_EP0_STATUS_OUT) {
|
|
|
|
dev_dbg(hsotg->dev, "zlp packet received\n");
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
|
|
|
|
dwc2_hsotg_enqueue_setup(hsotg);
|
2015-01-09 05:38:58 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:26 -07:00
|
|
|
if (using_desc_dma(hsotg))
|
|
|
|
size_left = dwc2_gadget_get_xfersize_ddma(hs_ep);
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (using_dma(hsotg)) {
|
2017-01-17 21:30:27 -07:00
|
|
|
unsigned int size_done;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* Calculate the size of the transfer by checking how much
|
2009-06-02 07:58:06 -06:00
|
|
|
* is left in the endpoint size register and then working it
|
|
|
|
* out from the amount we loaded for the transfer.
|
|
|
|
*
|
|
|
|
* We need to do this as DMA pointers are always 32bit aligned
|
|
|
|
* so may overshoot/undershoot the transfer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
size_done = hs_ep->size_loaded - size_left;
|
|
|
|
size_done += hs_ep->last_load;
|
|
|
|
|
|
|
|
req->actual = size_done;
|
|
|
|
}
|
|
|
|
|
2010-07-19 02:40:49 -06:00
|
|
|
/* if there is more request to do, schedule new transfer */
|
|
|
|
if (req->actual < req->length && size_left == 0) {
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, true);
|
2010-07-19 02:40:49 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (req->actual < req->length && req->short_not_ok) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: got %d/%d (short not ok) => error\n",
|
|
|
|
__func__, req->actual, req->length);
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* todo - what should we return here? there's no one else
|
|
|
|
* even bothering to check the status.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:31 -07:00
|
|
|
/* DDMA IN status phase will start from StsPhseRcvd interrupt */
|
|
|
|
if (!using_desc_dma(hsotg) && epnum == 0 &&
|
|
|
|
hsotg->ep0_state == DWC2_EP0_DATA_OUT) {
|
2015-01-09 05:38:58 -07:00
|
|
|
/* Move to STATUS IN */
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ep0_zlp(hsotg, true);
|
2015-01-09 05:38:58 -07:00
|
|
|
return;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-09-10 19:13:43 -06:00
|
|
|
/*
|
|
|
|
* Slave mode OUT transfers do not go through XferComplete so
|
|
|
|
* adjust the ISOC parity here.
|
|
|
|
*/
|
|
|
|
if (!using_dma(hsotg)) {
|
|
|
|
if (hs_ep->isochronous && hs_ep->interval == 1)
|
|
|
|
dwc2_hsotg_change_ep_iso_parity(hsotg, DOEPCTL(epnum));
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
else if (hs_ep->isochronous && hs_ep->interval > 1)
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
2015-09-10 19:13:43 -06:00
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, result);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_handle_rx - RX FIFO has data
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device instance
|
|
|
|
*
|
|
|
|
* The IRQ handler has detected that the RX FIFO has some data in it
|
|
|
|
* that requires processing, so find out what is in there and do the
|
|
|
|
* appropriate read.
|
|
|
|
*
|
2011-03-30 19:57:33 -06:00
|
|
|
* The RXFIFO is a true FIFO, the packets coming out are still in packet
|
2009-06-02 07:58:06 -06:00
|
|
|
* chunks, so if you have x packets received on an endpoint you'll get x
|
|
|
|
* FIFO events delivered, each with a packet's worth of data in it.
|
|
|
|
*
|
|
|
|
* When using DMA, we should not be processing events from the RXFIFO
|
|
|
|
* as the actual data should be sent to the memory directly and we turn
|
|
|
|
* on the completion interrupts to get notifications of transfer completion.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_handle_rx(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 grxstsr = dwc2_readl(hsotg->regs + GRXSTSP);
|
2009-06-02 07:58:06 -06:00
|
|
|
u32 epnum, status, size;
|
|
|
|
|
|
|
|
WARN_ON(using_dma(hsotg));
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
epnum = grxstsr & GRXSTS_EPNUM_MASK;
|
|
|
|
status = grxstsr & GRXSTS_PKTSTS_MASK;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
size = grxstsr & GRXSTS_BYTECNT_MASK;
|
|
|
|
size >>= GRXSTS_BYTECNT_SHIFT;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-01-30 01:09:30 -07:00
|
|
|
dev_dbg(hsotg->dev, "%s: GRXSTSP=0x%08x (%d@%d)\n",
|
2017-01-17 21:30:27 -07:00
|
|
|
__func__, grxstsr, size, epnum);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
switch ((status & GRXSTS_PKTSTS_MASK) >> GRXSTS_PKTSTS_SHIFT) {
|
|
|
|
case GRXSTS_PKTSTS_GLOBALOUTNAK:
|
|
|
|
dev_dbg(hsotg->dev, "GLOBALOUTNAK\n");
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
case GRXSTS_PKTSTS_OUTDONE:
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "OutDone (Frame=0x%08x)\n",
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_read_frameno(hsotg));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (!using_dma(hsotg))
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_handle_outdone(hsotg, epnum);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
case GRXSTS_PKTSTS_SETUPDONE:
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev,
|
|
|
|
"SetupDone (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_read_frameno(hsotg),
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(hsotg->regs + DOEPCTL(0)));
|
2015-01-09 05:38:58 -07:00
|
|
|
/*
|
2015-08-06 17:11:54 -06:00
|
|
|
* Call dwc2_hsotg_handle_outdone here if it was not called from
|
2015-01-09 05:38:58 -07:00
|
|
|
* GRXSTS_PKTSTS_OUTDONE. That is, if the core didn't
|
|
|
|
* generate GRXSTS_PKTSTS_OUTDONE for setup packet.
|
|
|
|
*/
|
|
|
|
if (hsotg->ep0_state == DWC2_EP0_SETUP)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_handle_outdone(hsotg, epnum);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
case GRXSTS_PKTSTS_OUTRX:
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_rx_data(hsotg, epnum, size);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
case GRXSTS_PKTSTS_SETUPRX:
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev,
|
|
|
|
"SetupRX (Frame=0x%08x, DOPEPCTL=0x%08x)\n",
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_read_frameno(hsotg),
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(hsotg->regs + DOEPCTL(0)));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-01-09 05:38:58 -07:00
|
|
|
WARN_ON(hsotg->ep0_state != DWC2_EP0_SETUP);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_rx_data(hsotg, epnum, size);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
dev_warn(hsotg->dev, "%s: unknown status %08x\n",
|
|
|
|
__func__, grxstsr);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_dump(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ep0_mps - turn max packet size into register setting
|
2009-06-02 07:58:06 -06:00
|
|
|
* @mps: The maximum packet size in bytes.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static u32 dwc2_hsotg_ep0_mps(unsigned int mps)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
|
|
|
switch (mps) {
|
|
|
|
case 64:
|
2012-05-04 06:17:14 -06:00
|
|
|
return D0EPCTL_MPS_64;
|
2009-06-02 07:58:06 -06:00
|
|
|
case 32:
|
2012-05-04 06:17:14 -06:00
|
|
|
return D0EPCTL_MPS_32;
|
2009-06-02 07:58:06 -06:00
|
|
|
case 16:
|
2012-05-04 06:17:14 -06:00
|
|
|
return D0EPCTL_MPS_16;
|
2009-06-02 07:58:06 -06:00
|
|
|
case 8:
|
2012-05-04 06:17:14 -06:00
|
|
|
return D0EPCTL_MPS_8;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* bad max packet size, warn and return invalid result */
|
|
|
|
WARN_ON(1);
|
|
|
|
return (u32)-1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_set_ep_maxpacket - set endpoint's max-packet field
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The driver state.
|
|
|
|
* @ep: The index number of the endpoint
|
|
|
|
* @mps: The maximum packet size in bytes
|
2016-11-08 11:57:00 -07:00
|
|
|
* @mc: The multicount value
|
2009-06-02 07:58:06 -06:00
|
|
|
*
|
|
|
|
* Configure the maximum packet size for the given endpoint, updating
|
|
|
|
* the hardware control registers to reflect this.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_set_ep_maxpacket(struct dwc2_hsotg *hsotg,
|
2016-11-08 11:57:00 -07:00
|
|
|
unsigned int ep, unsigned int mps,
|
|
|
|
unsigned int mc, unsigned int dir_in)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep;
|
2009-06-02 07:58:06 -06:00
|
|
|
void __iomem *regs = hsotg->regs;
|
|
|
|
u32 reg;
|
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
hs_ep = index_to_ep(hsotg, ep, dir_in);
|
|
|
|
if (!hs_ep)
|
|
|
|
return;
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (ep == 0) {
|
2016-11-08 11:57:00 -07:00
|
|
|
u32 mps_bytes = mps;
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/* EP0 is a special case */
|
2016-11-08 11:57:00 -07:00
|
|
|
mps = dwc2_hsotg_ep0_mps(mps_bytes);
|
|
|
|
if (mps > 3)
|
2009-06-02 07:58:06 -06:00
|
|
|
goto bad_mps;
|
2016-11-08 11:57:00 -07:00
|
|
|
hs_ep->ep.maxpacket = mps_bytes;
|
2013-10-09 01:00:02 -06:00
|
|
|
hs_ep->mc = 1;
|
2009-06-02 07:58:06 -06:00
|
|
|
} else {
|
2016-11-08 11:57:00 -07:00
|
|
|
if (mps > 1024)
|
2009-06-02 07:58:06 -06:00
|
|
|
goto bad_mps;
|
2016-11-08 11:57:00 -07:00
|
|
|
hs_ep->mc = mc;
|
|
|
|
if (mc > 3)
|
2013-10-09 01:00:02 -06:00
|
|
|
goto bad_mps;
|
2016-11-08 11:57:00 -07:00
|
|
|
hs_ep->ep.maxpacket = mps;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
if (dir_in) {
|
2015-08-20 12:41:07 -06:00
|
|
|
reg = dwc2_readl(regs + DIEPCTL(ep));
|
2015-01-09 05:38:50 -07:00
|
|
|
reg &= ~DXEPCTL_MPS_MASK;
|
2016-11-08 11:57:00 -07:00
|
|
|
reg |= mps;
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(reg, regs + DIEPCTL(ep));
|
2015-01-09 05:38:50 -07:00
|
|
|
} else {
|
2015-08-20 12:41:07 -06:00
|
|
|
reg = dwc2_readl(regs + DOEPCTL(ep));
|
2014-04-14 15:13:34 -06:00
|
|
|
reg &= ~DXEPCTL_MPS_MASK;
|
2016-11-08 11:57:00 -07:00
|
|
|
reg |= mps;
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(reg, regs + DOEPCTL(ep));
|
2012-03-05 22:07:29 -07:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
bad_mps:
|
|
|
|
dev_err(hsotg->dev, "ep%d: bad mps of %d\n", ep, mps);
|
|
|
|
}
|
|
|
|
|
2011-04-21 02:06:41 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_txfifo_flush - flush Tx FIFO
|
2011-04-21 02:06:41 -06:00
|
|
|
* @hsotg: The driver state
|
|
|
|
* @idx: The index for the endpoint (0..15)
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_txfifo_flush(struct dwc2_hsotg *hsotg, unsigned int idx)
|
2011-04-21 02:06:41 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(GRSTCTL_TXFNUM(idx) | GRSTCTL_TXFFLSH,
|
|
|
|
hsotg->regs + GRSTCTL);
|
2011-04-21 02:06:41 -06:00
|
|
|
|
|
|
|
/* wait until the fifo is flushed */
|
2018-01-19 03:39:31 -07:00
|
|
|
if (dwc2_hsotg_wait_bit_clear(hsotg, GRSTCTL, GRSTCTL_TXFFLSH, 100))
|
|
|
|
dev_warn(hsotg->dev, "%s: timeout flushing fifo GRSTCTL_TXFFLSH\n",
|
|
|
|
__func__);
|
2011-04-21 02:06:41 -06:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_trytx - check to see if anything needs transmitting
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The driver state
|
|
|
|
* @hs_ep: The driver endpoint to check.
|
|
|
|
*
|
|
|
|
* Check to see if there is a request that has data to send, and if so
|
|
|
|
* make an attempt to write data into the FIFO.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_trytx(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req = hs_ep->req;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2013-09-19 03:50:19 -06:00
|
|
|
if (!hs_ep->dir_in || !hs_req) {
|
|
|
|
/**
|
|
|
|
* if request is not enqueued, we disable interrupts
|
|
|
|
* for endpoints, excepting ep0
|
|
|
|
*/
|
|
|
|
if (hs_ep->index != 0)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index,
|
2017-01-17 21:30:27 -07:00
|
|
|
hs_ep->dir_in, 0);
|
2009-06-02 07:58:06 -06:00
|
|
|
return 0;
|
2013-09-19 03:50:19 -06:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (hs_req->req.actual < hs_req->req.length) {
|
|
|
|
dev_dbg(hsotg->dev, "trying to write more for ep%d\n",
|
|
|
|
hs_ep->index);
|
2015-08-06 17:11:54 -06:00
|
|
|
return dwc2_hsotg_write_fifo(hsotg, hs_ep, hs_req);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_complete_in - complete IN transfer
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
* @hs_ep: The endpoint that has just completed.
|
|
|
|
*
|
|
|
|
* An IN transfer has been completed, update the transfer's state and then
|
|
|
|
* call the relevant completion routines.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_complete_in(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req = hs_ep->req;
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 epsize = dwc2_readl(hsotg->regs + DIEPTSIZ(hs_ep->index));
|
2009-06-02 07:58:06 -06:00
|
|
|
int size_left, size_done;
|
|
|
|
|
|
|
|
if (!hs_req) {
|
|
|
|
dev_dbg(hsotg->dev, "XferCompl but no req\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:04 -06:00
|
|
|
/* Finish ZLP handling for IN EP0 transactions */
|
2015-01-09 05:38:58 -07:00
|
|
|
if (hs_ep->index == 0 && hsotg->ep0_state == DWC2_EP0_STATUS_IN) {
|
|
|
|
dev_dbg(hsotg->dev, "zlp packet sent\n");
|
2016-11-16 16:33:57 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* While send zlp for DWC2_EP0_STATUS_IN EP direction was
|
|
|
|
* changed to IN. Change back to complete OUT transfer request
|
|
|
|
*/
|
|
|
|
hs_ep->dir_in = 0;
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
|
2015-01-30 01:09:28 -07:00
|
|
|
if (hsotg->test_mode) {
|
|
|
|
int ret;
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_set_test_mode(hsotg, hsotg->test_mode);
|
2015-01-30 01:09:28 -07:00
|
|
|
if (ret < 0) {
|
|
|
|
dev_dbg(hsotg->dev, "Invalid Test #%d\n",
|
2017-01-17 21:30:27 -07:00
|
|
|
hsotg->test_mode);
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_stall_ep0(hsotg);
|
2015-01-30 01:09:28 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_enqueue_setup(hsotg);
|
2012-05-04 06:17:04 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* Calculate the size of the transfer by checking how much is left
|
2009-06-02 07:58:06 -06:00
|
|
|
* in the endpoint size register and then working it out from
|
|
|
|
* the amount we loaded for the transfer.
|
|
|
|
*
|
|
|
|
* We do this even for DMA, as the transfer may have incremented
|
|
|
|
* past the end of the buffer (DMA transfers are always 32bit
|
|
|
|
* aligned).
|
|
|
|
*/
|
2016-11-14 20:16:26 -07:00
|
|
|
if (using_desc_dma(hsotg)) {
|
|
|
|
size_left = dwc2_gadget_get_xfersize_ddma(hs_ep);
|
|
|
|
if (size_left < 0)
|
|
|
|
dev_err(hsotg->dev, "error parsing DDMA results %d\n",
|
|
|
|
size_left);
|
|
|
|
} else {
|
|
|
|
size_left = DXEPTSIZ_XFERSIZE_GET(epsize);
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
size_done = hs_ep->size_loaded - size_left;
|
|
|
|
size_done += hs_ep->last_load;
|
|
|
|
|
|
|
|
if (hs_req->req.actual != size_done)
|
|
|
|
dev_dbg(hsotg->dev, "%s: adjusting size done %d => %d\n",
|
|
|
|
__func__, hs_req->req.actual, size_done);
|
|
|
|
|
|
|
|
hs_req->req.actual = size_done;
|
2012-05-04 06:17:04 -06:00
|
|
|
dev_dbg(hsotg->dev, "req->length:%d req->actual:%d req->zero:%d\n",
|
|
|
|
hs_req->req.length, hs_req->req.actual, hs_req->req.zero);
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
if (!size_left && hs_req->req.actual < hs_req->req.length) {
|
|
|
|
dev_dbg(hsotg->dev, "%s trying more for req...\n", __func__);
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_start_req(hsotg, hs_ep, hs_req, true);
|
2015-01-09 05:38:58 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:59 -07:00
|
|
|
/* Zlp for all endpoints, for ep0 only in DATA IN stage */
|
2015-01-09 05:39:03 -07:00
|
|
|
if (hs_ep->send_zlp) {
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_program_zlp(hsotg, hs_ep);
|
2015-01-09 05:39:03 -07:00
|
|
|
hs_ep->send_zlp = 0;
|
2015-01-09 05:38:59 -07:00
|
|
|
/* transfer will be completed on next complete interrupt */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:58 -07:00
|
|
|
if (hs_ep->index == 0 && hsotg->ep0_state == DWC2_EP0_DATA_IN) {
|
|
|
|
/* Move to STATUS OUT */
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ep0_zlp(hsotg, false);
|
2015-01-09 05:38:58 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req, 0);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:10 -06:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_read_ep_interrupts - reads interrupts for given ep
|
|
|
|
* @hsotg: The device state.
|
|
|
|
* @idx: Index of ep.
|
|
|
|
* @dir_in: Endpoint direction 1-in 0-out.
|
|
|
|
*
|
|
|
|
* Reads for endpoint with given index and direction, by masking
|
|
|
|
* epint_reg with coresponding mask.
|
|
|
|
*/
|
|
|
|
static u32 dwc2_gadget_read_ep_interrupts(struct dwc2_hsotg *hsotg,
|
|
|
|
unsigned int idx, int dir_in)
|
|
|
|
{
|
|
|
|
u32 epmsk_reg = dir_in ? DIEPMSK : DOEPMSK;
|
|
|
|
u32 epint_reg = dir_in ? DIEPINT(idx) : DOEPINT(idx);
|
|
|
|
u32 ints;
|
|
|
|
u32 mask;
|
|
|
|
u32 diepempmsk;
|
|
|
|
|
|
|
|
mask = dwc2_readl(hsotg->regs + epmsk_reg);
|
|
|
|
diepempmsk = dwc2_readl(hsotg->regs + DIEPEMPMSK);
|
|
|
|
mask |= ((diepempmsk >> idx) & 0x1) ? DIEPMSK_TXFIFOEMPTY : 0;
|
|
|
|
mask |= DXEPINT_SETUP_RCVD;
|
|
|
|
|
|
|
|
ints = dwc2_readl(hsotg->regs + epint_reg);
|
|
|
|
ints &= mask;
|
|
|
|
return ints;
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:19 -06:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_handle_ep_disabled - handle DXEPINT_EPDISBLD
|
|
|
|
* @hs_ep: The endpoint on which interrupt is asserted.
|
|
|
|
*
|
|
|
|
* This interrupt indicates that the endpoint has been disabled per the
|
|
|
|
* application's request.
|
|
|
|
*
|
|
|
|
* For IN endpoints flushes txfifo, in case of BULK clears DCTL_CGNPINNAK,
|
|
|
|
* in case of ISOC completes current request.
|
|
|
|
*
|
|
|
|
* For ISOC-OUT endpoints completes expired requests. If there is remaining
|
|
|
|
* request starts it.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_handle_ep_disabled(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
struct dwc2_hsotg_req *hs_req;
|
|
|
|
unsigned char idx = hs_ep->index;
|
|
|
|
int dir_in = hs_ep->dir_in;
|
|
|
|
u32 epctl_reg = dir_in ? DIEPCTL(idx) : DOEPCTL(idx);
|
|
|
|
int dctl = dwc2_readl(hsotg->regs + DCTL);
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: EPDisbld\n", __func__);
|
|
|
|
|
|
|
|
if (dir_in) {
|
|
|
|
int epctl = dwc2_readl(hsotg->regs + epctl_reg);
|
|
|
|
|
|
|
|
dwc2_hsotg_txfifo_flush(hsotg, hs_ep->fifo_index);
|
|
|
|
|
|
|
|
if (hs_ep->isochronous) {
|
|
|
|
dwc2_hsotg_complete_in(hsotg, hs_ep);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((epctl & DXEPCTL_STALL) && (epctl & DXEPCTL_EPTYPE_BULK)) {
|
|
|
|
int dctl = dwc2_readl(hsotg->regs + DCTL);
|
|
|
|
|
|
|
|
dctl |= DCTL_CGNPINNAK;
|
|
|
|
dwc2_writel(dctl, hsotg->regs + DCTL);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dctl & DCTL_GOUTNAKSTS) {
|
|
|
|
dctl |= DCTL_CGOUTNAK;
|
|
|
|
dwc2_writel(dctl, hsotg->regs + DCTL);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!hs_ep->isochronous)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (list_empty(&hs_ep->queue)) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: complete_ep 0x%p, ep->queue empty!\n",
|
|
|
|
__func__, hs_ep);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
|
|
|
hs_req = get_ep_head(hs_ep);
|
|
|
|
if (hs_req)
|
|
|
|
dwc2_hsotg_complete_request(hsotg, hs_ep, hs_req,
|
|
|
|
-ENODATA);
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
|
|
|
} while (dwc2_gadget_target_frame_elapsed(hs_ep));
|
|
|
|
|
|
|
|
dwc2_gadget_start_next_request(hs_ep);
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:14 -06:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_handle_out_token_ep_disabled - handle DXEPINT_OUTTKNEPDIS
|
|
|
|
* @hs_ep: The endpoint on which interrupt is asserted.
|
|
|
|
*
|
|
|
|
* This is starting point for ISOC-OUT transfer, synchronization done with
|
|
|
|
* first out token received from host while corresponding EP is disabled.
|
|
|
|
*
|
|
|
|
* Device does not know initial frame in which out token will come. For this
|
|
|
|
* HW generates OUTTKNEPDIS - out token is received while EP is disabled. Upon
|
|
|
|
* getting this interrupt SW starts calculation for next transfer frame.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_handle_out_token_ep_disabled(struct dwc2_hsotg_ep *ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = ep->parent;
|
|
|
|
int dir_in = ep->dir_in;
|
|
|
|
u32 doepmsk;
|
2016-11-14 20:16:41 -07:00
|
|
|
u32 tmp;
|
2016-05-25 19:07:14 -06:00
|
|
|
|
|
|
|
if (dir_in || !ep->isochronous)
|
|
|
|
return;
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
/*
|
|
|
|
* Store frame in which irq was asserted here, as
|
|
|
|
* it can change while completing request below.
|
|
|
|
*/
|
|
|
|
tmp = dwc2_hsotg_read_frameno(hsotg);
|
|
|
|
|
2016-05-25 19:07:14 -06:00
|
|
|
dwc2_hsotg_complete_request(hsotg, ep, get_ep_head(ep), -ENODATA);
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
if (using_desc_dma(hsotg)) {
|
|
|
|
if (ep->target_frame == TARGET_FRAME_INITIAL) {
|
|
|
|
/* Start first ISO Out */
|
|
|
|
ep->target_frame = tmp;
|
|
|
|
dwc2_gadget_start_isoc_ddma(ep);
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:14 -06:00
|
|
|
if (ep->interval > 1 &&
|
|
|
|
ep->target_frame == TARGET_FRAME_INITIAL) {
|
|
|
|
u32 dsts;
|
|
|
|
u32 ctrl;
|
|
|
|
|
|
|
|
dsts = dwc2_readl(hsotg->regs + DSTS);
|
|
|
|
ep->target_frame = dwc2_hsotg_read_frameno(hsotg);
|
|
|
|
dwc2_gadget_incr_frame_num(ep);
|
|
|
|
|
|
|
|
ctrl = dwc2_readl(hsotg->regs + DOEPCTL(ep->index));
|
|
|
|
if (ep->target_frame & 0x1)
|
|
|
|
ctrl |= DXEPCTL_SETODDFR;
|
|
|
|
else
|
|
|
|
ctrl |= DXEPCTL_SETEVENFR;
|
|
|
|
|
|
|
|
dwc2_writel(ctrl, hsotg->regs + DOEPCTL(ep->index));
|
|
|
|
}
|
|
|
|
|
|
|
|
dwc2_gadget_start_next_request(ep);
|
|
|
|
doepmsk = dwc2_readl(hsotg->regs + DOEPMSK);
|
|
|
|
doepmsk &= ~DOEPMSK_OUTTKNEPDISMSK;
|
|
|
|
dwc2_writel(doepmsk, hsotg->regs + DOEPMSK);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2017-01-17 21:31:13 -07:00
|
|
|
* dwc2_gadget_handle_nak - handle NAK interrupt
|
|
|
|
* @hs_ep: The endpoint on which interrupt is asserted.
|
|
|
|
*
|
|
|
|
* This is starting point for ISOC-IN transfer, synchronization done with
|
|
|
|
* first IN token received from host while corresponding EP is disabled.
|
|
|
|
*
|
|
|
|
* Device does not know when first one token will arrive from host. On first
|
|
|
|
* token arrival HW generates 2 interrupts: 'in token received while FIFO empty'
|
|
|
|
* and 'NAK'. NAK interrupt for ISOC-IN means that token has arrived and ZLP was
|
|
|
|
* sent in response to that as there was no data in FIFO. SW is basing on this
|
|
|
|
* interrupt to obtain frame in which token has come and then based on the
|
|
|
|
* interval calculates next frame for transfer.
|
|
|
|
*/
|
2016-05-25 19:07:14 -06:00
|
|
|
static void dwc2_gadget_handle_nak(struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
|
|
|
int dir_in = hs_ep->dir_in;
|
|
|
|
|
|
|
|
if (!dir_in || !hs_ep->isochronous)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (hs_ep->target_frame == TARGET_FRAME_INITIAL) {
|
|
|
|
hs_ep->target_frame = dwc2_hsotg_read_frameno(hsotg);
|
2016-11-14 20:16:41 -07:00
|
|
|
|
|
|
|
if (using_desc_dma(hsotg)) {
|
|
|
|
dwc2_gadget_start_isoc_ddma(hs_ep);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:14 -06:00
|
|
|
if (hs_ep->interval > 1) {
|
|
|
|
u32 ctrl = dwc2_readl(hsotg->regs +
|
|
|
|
DIEPCTL(hs_ep->index));
|
|
|
|
if (hs_ep->target_frame & 0x1)
|
|
|
|
ctrl |= DXEPCTL_SETODDFR;
|
|
|
|
else
|
|
|
|
ctrl |= DXEPCTL_SETEVENFR;
|
|
|
|
|
|
|
|
dwc2_writel(ctrl, hsotg->regs + DIEPCTL(hs_ep->index));
|
|
|
|
}
|
|
|
|
|
|
|
|
dwc2_hsotg_complete_request(hsotg, hs_ep,
|
|
|
|
get_ep_head(hs_ep), 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_epint - handle an in/out endpoint interrupt
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The driver state
|
|
|
|
* @idx: The index for the endpoint (0..15)
|
|
|
|
* @dir_in: Set if this is an IN endpoint
|
|
|
|
*
|
|
|
|
* Process and clear any interrupt pending for an individual endpoint
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_epint(struct dwc2_hsotg *hsotg, unsigned int idx,
|
2017-01-17 21:30:27 -07:00
|
|
|
int dir_in)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = index_to_ep(hsotg, idx, dir_in);
|
2012-05-04 06:17:14 -06:00
|
|
|
u32 epint_reg = dir_in ? DIEPINT(idx) : DOEPINT(idx);
|
|
|
|
u32 epctl_reg = dir_in ? DIEPCTL(idx) : DOEPCTL(idx);
|
|
|
|
u32 epsiz_reg = dir_in ? DIEPTSIZ(idx) : DOEPTSIZ(idx);
|
2009-06-02 07:58:06 -06:00
|
|
|
u32 ints;
|
2013-10-09 00:41:57 -06:00
|
|
|
u32 ctrl;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2016-05-25 19:07:10 -06:00
|
|
|
ints = dwc2_gadget_read_ep_interrupts(hsotg, idx, dir_in);
|
2015-08-20 12:41:07 -06:00
|
|
|
ctrl = dwc2_readl(hsotg->regs + epctl_reg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2011-04-21 02:06:39 -06:00
|
|
|
/* Clear endpoint interrupts */
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(ints, hsotg->regs + epint_reg);
|
2011-04-21 02:06:39 -06:00
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
if (!hs_ep) {
|
|
|
|
dev_err(hsotg->dev, "%s:Interrupt for unconfigured ep%d(%s)\n",
|
2017-01-17 21:30:27 -07:00
|
|
|
__func__, idx, dir_in ? "in" : "out");
|
2015-01-09 05:38:50 -07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: ep%d(%s) DxEPINT=0x%08x\n",
|
|
|
|
__func__, idx, dir_in ? "in" : "out", ints);
|
|
|
|
|
2015-01-09 05:38:43 -07:00
|
|
|
/* Don't process XferCompl interrupt if it is a setup packet */
|
|
|
|
if (idx == 0 && (ints & (DXEPINT_SETUP | DXEPINT_SETUP_RCVD)))
|
|
|
|
ints &= ~DXEPINT_XFERCOMPL;
|
|
|
|
|
2016-11-14 20:16:48 -07:00
|
|
|
/*
|
|
|
|
* Don't process XferCompl interrupt in DDMA if EP0 is still in SETUP
|
|
|
|
* stage and xfercomplete was generated without SETUP phase done
|
|
|
|
* interrupt. SW should parse received setup packet only after host's
|
|
|
|
* exit from setup phase of control transfer.
|
|
|
|
*/
|
|
|
|
if (using_desc_dma(hsotg) && idx == 0 && !hs_ep->dir_in &&
|
|
|
|
hsotg->ep0_state == DWC2_EP0_SETUP && !(ints & DXEPINT_SETUP))
|
|
|
|
ints &= ~DXEPINT_XFERCOMPL;
|
|
|
|
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (ints & DXEPINT_XFERCOMPL) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev,
|
2014-04-14 15:13:34 -06:00
|
|
|
"%s: XferCompl: DxEPCTL=0x%08x, DXEPTSIZ=%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
__func__, dwc2_readl(hsotg->regs + epctl_reg),
|
|
|
|
dwc2_readl(hsotg->regs + epsiz_reg));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
/* In DDMA handle isochronous requests separately */
|
|
|
|
if (using_desc_dma(hsotg) && hs_ep->isochronous) {
|
|
|
|
dwc2_gadget_complete_isoc_request_ddma(hs_ep);
|
|
|
|
/* Try to start next isoc request */
|
|
|
|
dwc2_gadget_start_next_isoc_ddma(hs_ep);
|
|
|
|
} else if (dir_in) {
|
|
|
|
/*
|
|
|
|
* We get OutDone from the FIFO, so we only
|
|
|
|
* need to look at completing IN requests here
|
|
|
|
* if operating slave mode
|
|
|
|
*/
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (hs_ep->isochronous && hs_ep->interval > 1)
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_complete_in(hsotg, hs_ep);
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (ints & DXEPINT_NAKINTRPT)
|
|
|
|
ints &= ~DXEPINT_NAKINTRPT;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2010-07-19 02:40:46 -06:00
|
|
|
if (idx == 0 && !hs_ep->req)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_enqueue_setup(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
} else if (using_dma(hsotg)) {
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* We're using DMA, we need to fire an OutDone here
|
|
|
|
* as we ignore the RXFIFO.
|
|
|
|
*/
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (hs_ep->isochronous && hs_ep->interval > 1)
|
|
|
|
dwc2_gadget_incr_frame_num(hs_ep);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_handle_outdone(hsotg, idx);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:19 -06:00
|
|
|
if (ints & DXEPINT_EPDISBLD)
|
|
|
|
dwc2_gadget_handle_ep_disabled(hs_ep);
|
2011-04-21 02:06:41 -06:00
|
|
|
|
2016-05-25 19:07:14 -06:00
|
|
|
if (ints & DXEPINT_OUTTKNEPDIS)
|
|
|
|
dwc2_gadget_handle_out_token_ep_disabled(hs_ep);
|
|
|
|
|
|
|
|
if (ints & DXEPINT_NAKINTRPT)
|
|
|
|
dwc2_gadget_handle_nak(hs_ep);
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (ints & DXEPINT_AHBERR)
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: AHBErr\n", __func__);
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (ints & DXEPINT_SETUP) { /* Setup or Timeout */
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: Setup/Timeout\n", __func__);
|
|
|
|
|
|
|
|
if (using_dma(hsotg) && idx == 0) {
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* this is the notification we've received a
|
2009-06-02 07:58:06 -06:00
|
|
|
* setup packet. In non-DMA mode we'd get this
|
|
|
|
* from the RXFIFO, instead we need to process
|
2012-05-04 06:17:11 -06:00
|
|
|
* the setup here.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (dir_in)
|
|
|
|
WARN_ON_ONCE(1);
|
|
|
|
else
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_handle_outdone(hsotg, 0);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:31 -07:00
|
|
|
if (ints & DXEPINT_STSPHSERCVD) {
|
2016-11-14 20:16:29 -07:00
|
|
|
dev_dbg(hsotg->dev, "%s: StsPhseRcvd\n", __func__);
|
|
|
|
|
2018-01-16 05:03:58 -07:00
|
|
|
/* Safety check EP0 state when STSPHSERCVD asserted */
|
|
|
|
if (hsotg->ep0_state == DWC2_EP0_DATA_OUT) {
|
|
|
|
/* Move to STATUS IN for DDMA */
|
|
|
|
if (using_desc_dma(hsotg))
|
|
|
|
dwc2_hsotg_ep0_zlp(hsotg, true);
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:31 -07:00
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (ints & DXEPINT_BACK2BACKSETUP)
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: B2BSetup/INEPNakEff\n", __func__);
|
|
|
|
|
2016-11-14 20:16:41 -07:00
|
|
|
if (ints & DXEPINT_BNAINTR) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: BNA interrupt\n", __func__);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Try to start next isoc request, if any.
|
|
|
|
* Sometimes the endpoint remains enabled after BNA interrupt
|
|
|
|
* assertion, which is not expected, hence we can enter here
|
|
|
|
* couple of times.
|
|
|
|
*/
|
|
|
|
if (hs_ep->isochronous)
|
|
|
|
dwc2_gadget_start_next_isoc_ddma(hs_ep);
|
|
|
|
}
|
|
|
|
|
2013-10-09 00:41:57 -06:00
|
|
|
if (dir_in && !hs_ep->isochronous) {
|
2012-05-04 06:17:11 -06:00
|
|
|
/* not sure if this is important, but we'll clear it anyway */
|
2016-05-25 19:07:00 -06:00
|
|
|
if (ints & DXEPINT_INTKNTXFEMP) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: ep%d: INTknTXFEmpMsk\n",
|
|
|
|
__func__, idx);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* this probably means something bad is happening */
|
2016-05-25 19:07:00 -06:00
|
|
|
if (ints & DXEPINT_INTKNEPMIS) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_warn(hsotg->dev, "%s: ep%d: INTknEP\n",
|
|
|
|
__func__, idx);
|
|
|
|
}
|
2010-07-19 02:40:44 -06:00
|
|
|
|
|
|
|
/* FIFO has space or is empty (see GAHBCFG) */
|
|
|
|
if (hsotg->dedicated_fifos &&
|
2016-05-25 19:07:00 -06:00
|
|
|
ints & DXEPINT_TXFEMP) {
|
2010-07-19 02:40:44 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: ep%d: TxFIFOEmpty\n",
|
|
|
|
__func__, idx);
|
2012-03-05 22:08:29 -07:00
|
|
|
if (!using_dma(hsotg))
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_trytx(hsotg, hs_ep);
|
2010-07-19 02:40:44 -06:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_irq_enumdone - Handle EnumDone interrupt (enumeration done)
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
*
|
|
|
|
* Handle updating the device settings after the enumeration phase has
|
|
|
|
* been completed.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_irq_enumdone(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 dsts = dwc2_readl(hsotg->regs + DSTS);
|
2014-08-19 21:04:09 -06:00
|
|
|
int ep0_mps = 0, ep_mps = 8;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* This should signal the finish of the enumeration phase
|
2009-06-02 07:58:06 -06:00
|
|
|
* of the USB handshaking, so we should now know what rate
|
2012-05-04 06:17:11 -06:00
|
|
|
* we connected at.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "EnumDone (DSTS=0x%08x)\n", dsts);
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* note, since we're limited by the size of transfer on EP0, and
|
2009-06-02 07:58:06 -06:00
|
|
|
* it seems IN transfers must be a even number of packets we do
|
2012-05-04 06:17:11 -06:00
|
|
|
* not advertise a 64byte MPS on EP0.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* catch both EnumSpd_FS and EnumSpd_FS48 */
|
2015-12-17 19:26:17 -07:00
|
|
|
switch ((dsts & DSTS_ENUMSPD_MASK) >> DSTS_ENUMSPD_SHIFT) {
|
2014-04-14 15:13:34 -06:00
|
|
|
case DSTS_ENUMSPD_FS:
|
|
|
|
case DSTS_ENUMSPD_FS48:
|
2009-06-02 07:58:06 -06:00
|
|
|
hsotg->gadget.speed = USB_SPEED_FULL;
|
|
|
|
ep0_mps = EP0_MPS_LIMIT;
|
2013-12-06 05:03:44 -07:00
|
|
|
ep_mps = 1023;
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
case DSTS_ENUMSPD_HS:
|
2009-06-02 07:58:06 -06:00
|
|
|
hsotg->gadget.speed = USB_SPEED_HIGH;
|
|
|
|
ep0_mps = EP0_MPS_LIMIT;
|
2013-12-06 05:03:44 -07:00
|
|
|
ep_mps = 1024;
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
case DSTS_ENUMSPD_LS:
|
2009-06-02 07:58:06 -06:00
|
|
|
hsotg->gadget.speed = USB_SPEED_LOW;
|
2016-11-14 20:17:00 -07:00
|
|
|
ep0_mps = 8;
|
|
|
|
ep_mps = 8;
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* note, we don't actually support LS in this driver at the
|
2009-06-02 07:58:06 -06:00
|
|
|
* moment, and the documentation seems to imply that it isn't
|
|
|
|
* supported by the PHYs on some of the devices.
|
|
|
|
*/
|
|
|
|
break;
|
|
|
|
}
|
2011-08-30 09:11:19 -06:00
|
|
|
dev_info(hsotg->dev, "new device is %s\n",
|
|
|
|
usb_speed_string(hsotg->gadget.speed));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* we should now know the maximum packet size for an
|
|
|
|
* endpoint, so set the endpoints to a default value.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (ep0_mps) {
|
|
|
|
int i;
|
2015-01-09 05:38:50 -07:00
|
|
|
/* Initialize ep0 for both in and out directions */
|
2016-11-08 11:57:00 -07:00
|
|
|
dwc2_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 0, 1);
|
|
|
|
dwc2_hsotg_set_ep_maxpacket(hsotg, 0, ep0_mps, 0, 0);
|
2015-01-09 05:38:50 -07:00
|
|
|
for (i = 1; i < hsotg->num_of_eps; i++) {
|
|
|
|
if (hsotg->eps_in[i])
|
2016-11-08 11:57:00 -07:00
|
|
|
dwc2_hsotg_set_ep_maxpacket(hsotg, i, ep_mps,
|
|
|
|
0, 1);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (hsotg->eps_out[i])
|
2016-11-08 11:57:00 -07:00
|
|
|
dwc2_hsotg_set_ep_maxpacket(hsotg, i, ep_mps,
|
|
|
|
0, 0);
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* ensure after enumeration our EP0 is active */
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_enqueue_setup(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(hsotg->regs + DIEPCTL0),
|
|
|
|
dwc2_readl(hsotg->regs + DOEPCTL0));
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* kill_all_requests - remove all requests from the endpoint's queue
|
|
|
|
* @hsotg: The device state.
|
|
|
|
* @ep: The endpoint the requests may be on.
|
|
|
|
* @result: The result code to use.
|
|
|
|
*
|
|
|
|
* Go through the requests on the given endpoint and mark them
|
|
|
|
* completed with the given result code.
|
|
|
|
*/
|
2014-11-11 10:13:33 -07:00
|
|
|
static void kill_all_requests(struct dwc2_hsotg *hsotg,
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep,
|
2014-12-16 03:51:44 -07:00
|
|
|
int result)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *req, *treq;
|
2017-01-17 21:30:27 -07:00
|
|
|
unsigned int size;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-12-16 03:51:44 -07:00
|
|
|
ep->req = NULL;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-12-16 03:51:44 -07:00
|
|
|
list_for_each_entry_safe(req, treq, &ep->queue, queue)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_complete_request(hsotg, ep, req,
|
2017-01-17 21:30:27 -07:00
|
|
|
result);
|
2014-12-16 03:51:44 -07:00
|
|
|
|
2014-09-09 02:44:56 -06:00
|
|
|
if (!hsotg->dedicated_fifos)
|
|
|
|
return;
|
2016-08-29 14:38:50 -06:00
|
|
|
size = (dwc2_readl(hsotg->regs + DTXFSTS(ep->fifo_index)) & 0xffff) * 4;
|
2014-09-09 02:44:56 -06:00
|
|
|
if (size < ep->fifo_size)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_txfifo_flush(hsotg, ep->fifo_index);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_disconnect - disconnect service
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
*
|
2012-05-04 06:17:07 -06:00
|
|
|
* The device has been disconnected. Remove all current
|
|
|
|
* transactions and signal the gadget driver that this
|
|
|
|
* has happened.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
void dwc2_hsotg_disconnect(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2017-01-17 21:30:27 -07:00
|
|
|
unsigned int ep;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-11-21 07:14:47 -07:00
|
|
|
if (!hsotg->connected)
|
|
|
|
return;
|
|
|
|
|
|
|
|
hsotg->connected = 0;
|
2015-01-30 01:09:28 -07:00
|
|
|
hsotg->test_mode = 0;
|
2015-01-09 05:38:50 -07:00
|
|
|
|
|
|
|
for (ep = 0; ep < hsotg->num_of_eps; ep++) {
|
|
|
|
if (hsotg->eps_in[ep])
|
|
|
|
kill_all_requests(hsotg, hsotg->eps_in[ep],
|
2017-01-17 21:30:27 -07:00
|
|
|
-ESHUTDOWN);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (hsotg->eps_out[ep])
|
|
|
|
kill_all_requests(hsotg, hsotg->eps_out[ep],
|
2017-01-17 21:30:27 -07:00
|
|
|
-ESHUTDOWN);
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
call_gadget(hsotg, disconnect);
|
2015-09-22 07:16:54 -06:00
|
|
|
hsotg->lx_state = DWC2_L3;
|
2017-10-23 15:32:50 -06:00
|
|
|
|
|
|
|
usb_gadget_set_state(&hsotg->gadget, USB_STATE_NOTATTACHED);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_irq_fifoempty - TX FIFO empty interrupt handler
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state:
|
|
|
|
* @periodic: True if this is a periodic FIFO interrupt
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_irq_fifoempty(struct dwc2_hsotg *hsotg, bool periodic)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *ep;
|
2009-06-02 07:58:06 -06:00
|
|
|
int epno, ret;
|
|
|
|
|
|
|
|
/* look through for any more data to transmit */
|
2012-05-04 06:17:09 -06:00
|
|
|
for (epno = 0; epno < hsotg->num_of_eps; epno++) {
|
2015-01-09 05:38:50 -07:00
|
|
|
ep = index_to_ep(hsotg, epno, 1);
|
|
|
|
|
|
|
|
if (!ep)
|
|
|
|
continue;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (!ep->dir_in)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if ((periodic && !ep->periodic) ||
|
|
|
|
(!periodic && ep->periodic))
|
|
|
|
continue;
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_trytx(hsotg, ep);
|
2009-06-02 07:58:06 -06:00
|
|
|
if (ret < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* IRQ flags which will trigger a retry around the IRQ loop */
|
2014-04-14 15:13:34 -06:00
|
|
|
#define IRQ_RETRY_MASK (GINTSTS_NPTXFEMP | \
|
|
|
|
GINTSTS_PTXFEMP | \
|
|
|
|
GINTSTS_RXFLVL)
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_core_init - issue softreset to the core
|
2012-05-04 06:17:11 -06:00
|
|
|
* @hsotg: The device state
|
|
|
|
*
|
|
|
|
* Issue a soft reset to the core, and await the core finishing it.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
void dwc2_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
bool is_usb_reset)
|
2012-05-04 06:17:05 -06:00
|
|
|
{
|
2015-09-29 04:08:27 -06:00
|
|
|
u32 intmsk;
|
2015-01-30 01:09:32 -07:00
|
|
|
u32 val;
|
2016-03-16 16:10:26 -06:00
|
|
|
u32 usbcfg;
|
2016-11-14 20:16:55 -07:00
|
|
|
u32 dcfg = 0;
|
2015-01-30 01:09:32 -07:00
|
|
|
|
2015-09-29 04:08:25 -06:00
|
|
|
/* Kill any ep0 requests as controller will be reinitialized */
|
|
|
|
kill_all_requests(hsotg, hsotg->eps_out[0], -ECONNRESET);
|
|
|
|
|
2015-01-30 01:09:32 -07:00
|
|
|
if (!is_usb_reset)
|
2017-01-23 15:59:14 -07:00
|
|
|
if (dwc2_core_reset(hsotg, true))
|
2015-09-29 04:08:21 -06:00
|
|
|
return;
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* we must now enable ep0 ready for host detection and then
|
|
|
|
* set configuration.
|
|
|
|
*/
|
|
|
|
|
2016-03-16 16:10:26 -06:00
|
|
|
/* keep other bits untouched (so e.g. forced modes are not lost) */
|
|
|
|
usbcfg = dwc2_readl(hsotg->regs + GUSBCFG);
|
|
|
|
usbcfg &= ~(GUSBCFG_TOUTCAL_MASK | GUSBCFG_PHYIF16 | GUSBCFG_SRPCAP |
|
2017-01-12 08:09:44 -07:00
|
|
|
GUSBCFG_HNPCAP | GUSBCFG_USBTRDTIM_MASK);
|
2016-03-16 16:10:26 -06:00
|
|
|
|
2016-11-14 20:16:55 -07:00
|
|
|
if (hsotg->params.phy_type == DWC2_PHY_TYPE_PARAM_FS &&
|
2016-11-14 20:17:03 -07:00
|
|
|
(hsotg->params.speed == DWC2_SPEED_PARAM_FULL ||
|
|
|
|
hsotg->params.speed == DWC2_SPEED_PARAM_LOW)) {
|
2016-11-14 20:16:55 -07:00
|
|
|
/* FS/LS Dedicated Transceiver Interface */
|
|
|
|
usbcfg |= GUSBCFG_PHYSEL;
|
|
|
|
} else {
|
|
|
|
/* set the PLL on, remove the HNP/SRP and set the PHY */
|
|
|
|
val = (hsotg->phyif == GUSBCFG_PHYIF8) ? 9 : 5;
|
|
|
|
usbcfg |= hsotg->phyif | GUSBCFG_TOUTCAL(7) |
|
|
|
|
(val << GUSBCFG_USBTRDTIM_SHIFT);
|
|
|
|
}
|
2016-03-16 16:10:26 -06:00
|
|
|
dwc2_writel(usbcfg, hsotg->regs + GUSBCFG);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_init_fifo(hsotg);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2015-01-30 01:09:32 -07:00
|
|
|
if (!is_usb_reset)
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_SFTDISCON);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2016-11-14 20:16:55 -07:00
|
|
|
dcfg |= DCFG_EPMISCNT(1);
|
2016-11-14 20:17:03 -07:00
|
|
|
|
|
|
|
switch (hsotg->params.speed) {
|
|
|
|
case DWC2_SPEED_PARAM_LOW:
|
|
|
|
dcfg |= DCFG_DEVSPD_LS;
|
|
|
|
break;
|
|
|
|
case DWC2_SPEED_PARAM_FULL:
|
2016-11-14 20:16:55 -07:00
|
|
|
if (hsotg->params.phy_type == DWC2_PHY_TYPE_PARAM_FS)
|
|
|
|
dcfg |= DCFG_DEVSPD_FS48;
|
|
|
|
else
|
|
|
|
dcfg |= DCFG_DEVSPD_FS;
|
2016-11-14 20:17:03 -07:00
|
|
|
break;
|
|
|
|
default:
|
2016-11-14 20:16:55 -07:00
|
|
|
dcfg |= DCFG_DEVSPD_HS;
|
|
|
|
}
|
2016-11-14 20:17:03 -07:00
|
|
|
|
2016-11-14 20:16:55 -07:00
|
|
|
dwc2_writel(dcfg, hsotg->regs + DCFG);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/* Clear any pending OTG interrupts */
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(0xffffffff, hsotg->regs + GOTGINT);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/* Clear any pending interrupts */
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(0xffffffff, hsotg->regs + GINTSTS);
|
2015-09-29 04:08:27 -06:00
|
|
|
intmsk = GINTSTS_ERLYSUSP | GINTSTS_SESSREQINT |
|
2014-04-14 15:13:34 -06:00
|
|
|
GINTSTS_GOUTNAKEFF | GINTSTS_GINNAKEFF |
|
2015-09-29 04:08:27 -06:00
|
|
|
GINTSTS_USBRST | GINTSTS_RESETDET |
|
|
|
|
GINTSTS_ENUMDONE | GINTSTS_OTGINT |
|
2018-01-24 06:43:06 -07:00
|
|
|
GINTSTS_USBSUSP | GINTSTS_WKUPINT |
|
|
|
|
GINTSTS_LPMTRANRCVD;
|
2016-11-14 20:16:38 -07:00
|
|
|
|
|
|
|
if (!using_desc_dma(hsotg))
|
|
|
|
intmsk |= GINTSTS_INCOMPL_SOIN | GINTSTS_INCOMPL_SOOUT;
|
2015-09-29 04:08:27 -06:00
|
|
|
|
2017-01-23 15:57:26 -07:00
|
|
|
if (!hsotg->params.external_id_pin_ctl)
|
2015-09-29 04:08:27 -06:00
|
|
|
intmsk |= GINTSTS_CONIDSTSCHNG;
|
|
|
|
|
|
|
|
dwc2_writel(intmsk, hsotg->regs + GINTMSK);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2016-11-14 20:16:34 -07:00
|
|
|
if (using_dma(hsotg)) {
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(GAHBCFG_GLBL_INTR_EN | GAHBCFG_DMA_EN |
|
2018-01-19 03:39:57 -07:00
|
|
|
hsotg->params.ahbcfg,
|
2015-08-20 12:41:07 -06:00
|
|
|
hsotg->regs + GAHBCFG);
|
2016-11-14 20:16:34 -07:00
|
|
|
|
|
|
|
/* Set DDMA mode support in the core if needed */
|
|
|
|
if (using_desc_dma(hsotg))
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCFG, DCFG_DESCDMA_EN);
|
2016-11-14 20:16:34 -07:00
|
|
|
|
|
|
|
} else {
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(((hsotg->dedicated_fifos) ?
|
|
|
|
(GAHBCFG_NP_TXF_EMP_LVL |
|
|
|
|
GAHBCFG_P_TXF_EMP_LVL) : 0) |
|
|
|
|
GAHBCFG_GLBL_INTR_EN, hsotg->regs + GAHBCFG);
|
2016-11-14 20:16:34 -07:00
|
|
|
}
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/*
|
2013-09-19 03:50:23 -06:00
|
|
|
* If INTknTXFEmpMsk is enabled, it's important to disable ep interrupts
|
|
|
|
* when we have no data to transfer. Otherwise we get being flooded by
|
|
|
|
* interrupts.
|
2012-05-04 06:17:05 -06:00
|
|
|
*/
|
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(((hsotg->dedicated_fifos && !using_dma(hsotg)) ?
|
2015-01-09 05:38:42 -07:00
|
|
|
DIEPMSK_TXFIFOEMPTY | DIEPMSK_INTKNTXFEMPMSK : 0) |
|
2014-04-14 15:13:34 -06:00
|
|
|
DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK |
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK,
|
2014-04-14 15:13:34 -06:00
|
|
|
hsotg->regs + DIEPMSK);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* don't need XferCompl, we get that from RXFIFO in slave mode. In
|
2016-11-14 20:16:29 -07:00
|
|
|
* DMA mode we may need this and StsPhseRcvd.
|
2012-05-04 06:17:05 -06:00
|
|
|
*/
|
2016-11-14 20:16:29 -07:00
|
|
|
dwc2_writel((using_dma(hsotg) ? (DIEPMSK_XFERCOMPLMSK |
|
|
|
|
DOEPMSK_STSPHSERCVDMSK) : 0) |
|
2014-04-14 15:13:34 -06:00
|
|
|
DOEPMSK_EPDISBLDMSK | DOEPMSK_AHBERRMSK |
|
2016-11-14 20:16:29 -07:00
|
|
|
DOEPMSK_SETUPMSK,
|
2014-04-14 15:13:34 -06:00
|
|
|
hsotg->regs + DOEPMSK);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2016-11-14 20:16:43 -07:00
|
|
|
/* Enable BNA interrupt for DDMA */
|
|
|
|
if (using_desc_dma(hsotg))
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DOEPMSK, DOEPMSK_BNAMSK);
|
2016-11-14 20:16:43 -07:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(0, hsotg->regs + DAINTMSK);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(hsotg->regs + DIEPCTL0),
|
|
|
|
dwc2_readl(hsotg->regs + DOEPCTL0));
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/* enable in and out endpoint interrupts */
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_en_gsint(hsotg, GINTSTS_OEPINT | GINTSTS_IEPINT);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Enable the RXFIFO when in slave mode, as this is how we collect
|
|
|
|
* the data. In DMA mode, we get events from the FIFO but also
|
|
|
|
* things we cannot process, so do not use it.
|
|
|
|
*/
|
|
|
|
if (!using_dma(hsotg))
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_en_gsint(hsotg, GINTSTS_RXFLVL);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/* Enable interrupts for EP0 in and out */
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ctrl_epint(hsotg, 0, 0, 1);
|
|
|
|
dwc2_hsotg_ctrl_epint(hsotg, 0, 1, 1);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2015-01-30 01:09:32 -07:00
|
|
|
if (!is_usb_reset) {
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
|
2015-01-30 01:09:32 -07:00
|
|
|
udelay(10); /* see openiboot */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_clear_bit(hsotg->regs + DCTL, DCTL_PWRONPRGDONE);
|
2015-01-30 01:09:32 -07:00
|
|
|
}
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dev_dbg(hsotg->dev, "DCTL=0x%08x\n", dwc2_readl(hsotg->regs + DCTL));
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/*
|
2012-05-04 06:17:14 -06:00
|
|
|
* DxEPCTL_USBActEp says RO in manual, but seems to be set by
|
2012-05-04 06:17:05 -06:00
|
|
|
* writing to the EPCTL register..
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* set to read 1 8byte packet */
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(DXEPTSIZ_MC(1) | DXEPTSIZ_PKTCNT(1) |
|
2014-04-14 15:13:34 -06:00
|
|
|
DXEPTSIZ_XFERSIZE(8), hsotg->regs + DOEPTSIZ0);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(dwc2_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
|
2014-04-14 15:13:34 -06:00
|
|
|
DXEPCTL_CNAK | DXEPCTL_EPENA |
|
|
|
|
DXEPCTL_USBACTEP,
|
2012-05-04 06:17:14 -06:00
|
|
|
hsotg->regs + DOEPCTL0);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/* enable, but don't activate EP0in */
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(dwc2_hsotg_ep0_mps(hsotg->eps_out[0]->ep.maxpacket) |
|
2014-04-14 15:13:34 -06:00
|
|
|
DXEPCTL_USBACTEP, hsotg->regs + DIEPCTL0);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
|
|
|
/* clear global NAKs */
|
2015-01-30 01:09:32 -07:00
|
|
|
val = DCTL_CGOUTNAK | DCTL_CGNPINNAK;
|
|
|
|
if (!is_usb_reset)
|
|
|
|
val |= DCTL_SFTDISCON;
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, val);
|
2012-05-04 06:17:05 -06:00
|
|
|
|
2018-01-24 06:43:32 -07:00
|
|
|
/* configure the core to support LPM */
|
|
|
|
dwc2_gadget_init_lpm(hsotg);
|
|
|
|
|
2012-05-04 06:17:05 -06:00
|
|
|
/* must be at-least 3ms to allow bus to see disconnect */
|
|
|
|
mdelay(3);
|
|
|
|
|
2015-09-22 07:16:54 -06:00
|
|
|
hsotg->lx_state = DWC2_L0;
|
2018-01-16 05:04:24 -07:00
|
|
|
|
|
|
|
dwc2_hsotg_enqueue_setup(hsotg);
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "EP0: DIEPCTL0=0x%08x, DOEPCTL0=0x%08x\n",
|
|
|
|
dwc2_readl(hsotg->regs + DIEPCTL0),
|
|
|
|
dwc2_readl(hsotg->regs + DOEPCTL0));
|
2014-10-20 04:45:36 -06:00
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_core_disconnect(struct dwc2_hsotg *hsotg)
|
2014-10-20 04:45:36 -06:00
|
|
|
{
|
|
|
|
/* set the soft-disconnect bit */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_SFTDISCON);
|
2014-10-20 04:45:36 -06:00
|
|
|
}
|
2014-10-20 04:45:35 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
void dwc2_hsotg_core_connect(struct dwc2_hsotg *hsotg)
|
2014-10-20 04:45:36 -06:00
|
|
|
{
|
2012-05-04 06:17:05 -06:00
|
|
|
/* remove the soft-disconnect and let's go */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_clear_bit(hsotg->regs + DCTL, DCTL_SFTDISCON);
|
2012-05-04 06:17:05 -06:00
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
/**
|
|
|
|
* dwc2_gadget_handle_incomplete_isoc_in - handle incomplete ISO IN Interrupt.
|
|
|
|
* @hsotg: The device state:
|
|
|
|
*
|
|
|
|
* This interrupt indicates one of the following conditions occurred while
|
|
|
|
* transmitting an ISOC transaction.
|
|
|
|
* - Corrupted IN Token for ISOC EP.
|
|
|
|
* - Packet not complete in FIFO.
|
|
|
|
*
|
|
|
|
* The following actions will be taken:
|
|
|
|
* - Determine the EP
|
|
|
|
* - Disable EP; when 'Endpoint Disabled' interrupt is received Flush FIFO
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_handle_incomplete_isoc_in(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
struct dwc2_hsotg_ep *hs_ep;
|
|
|
|
u32 epctrl;
|
2018-01-19 03:40:49 -07:00
|
|
|
u32 daintmsk;
|
2016-05-25 19:07:17 -06:00
|
|
|
u32 idx;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "Incomplete isoc in interrupt received:\n");
|
|
|
|
|
2018-01-19 03:40:49 -07:00
|
|
|
daintmsk = dwc2_readl(hsotg->regs + DAINTMSK);
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
for (idx = 1; idx <= hsotg->num_of_eps; idx++) {
|
|
|
|
hs_ep = hsotg->eps_in[idx];
|
2018-01-19 03:40:49 -07:00
|
|
|
/* Proceed only unmasked ISOC EPs */
|
|
|
|
if (!hs_ep->isochronous || (BIT(idx) & ~daintmsk))
|
|
|
|
continue;
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
epctrl = dwc2_readl(hsotg->regs + DIEPCTL(idx));
|
2018-01-19 03:40:49 -07:00
|
|
|
if ((epctrl & DXEPCTL_EPENA) &&
|
2016-05-25 19:07:17 -06:00
|
|
|
dwc2_gadget_target_frame_elapsed(hs_ep)) {
|
|
|
|
epctrl |= DXEPCTL_SNAK;
|
|
|
|
epctrl |= DXEPCTL_EPDIS;
|
|
|
|
dwc2_writel(epctrl, hsotg->regs + DIEPCTL(idx));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear interrupt */
|
|
|
|
dwc2_writel(GINTSTS_INCOMPL_SOIN, hsotg->regs + GINTSTS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_gadget_handle_incomplete_isoc_out - handle incomplete ISO OUT Interrupt
|
|
|
|
* @hsotg: The device state:
|
|
|
|
*
|
|
|
|
* This interrupt indicates one of the following conditions occurred while
|
|
|
|
* transmitting an ISOC transaction.
|
|
|
|
* - Corrupted OUT Token for ISOC EP.
|
|
|
|
* - Packet not complete in FIFO.
|
|
|
|
*
|
|
|
|
* The following actions will be taken:
|
|
|
|
* - Determine the EP
|
|
|
|
* - Set DCTL_SGOUTNAK and unmask GOUTNAKEFF if target frame elapsed.
|
|
|
|
*/
|
|
|
|
static void dwc2_gadget_handle_incomplete_isoc_out(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
u32 gintsts;
|
|
|
|
u32 gintmsk;
|
2018-01-19 03:41:16 -07:00
|
|
|
u32 daintmsk;
|
2016-05-25 19:07:17 -06:00
|
|
|
u32 epctrl;
|
|
|
|
struct dwc2_hsotg_ep *hs_ep;
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: GINTSTS_INCOMPL_SOOUT\n", __func__);
|
|
|
|
|
2018-01-19 03:41:16 -07:00
|
|
|
daintmsk = dwc2_readl(hsotg->regs + DAINTMSK);
|
|
|
|
daintmsk >>= DAINT_OUTEP_SHIFT;
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
for (idx = 1; idx <= hsotg->num_of_eps; idx++) {
|
|
|
|
hs_ep = hsotg->eps_out[idx];
|
2018-01-19 03:41:16 -07:00
|
|
|
/* Proceed only unmasked ISOC EPs */
|
|
|
|
if (!hs_ep->isochronous || (BIT(idx) & ~daintmsk))
|
|
|
|
continue;
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
epctrl = dwc2_readl(hsotg->regs + DOEPCTL(idx));
|
2018-01-19 03:41:16 -07:00
|
|
|
if ((epctrl & DXEPCTL_EPENA) &&
|
2016-05-25 19:07:17 -06:00
|
|
|
dwc2_gadget_target_frame_elapsed(hs_ep)) {
|
|
|
|
/* Unmask GOUTNAKEFF interrupt */
|
|
|
|
gintmsk = dwc2_readl(hsotg->regs + GINTMSK);
|
|
|
|
gintmsk |= GINTSTS_GOUTNAKEFF;
|
|
|
|
dwc2_writel(gintmsk, hsotg->regs + GINTMSK);
|
|
|
|
|
|
|
|
gintsts = dwc2_readl(hsotg->regs + GINTSTS);
|
2018-01-19 03:41:16 -07:00
|
|
|
if (!(gintsts & GINTSTS_GOUTNAKEFF)) {
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_SGOUTNAK);
|
2018-01-19 03:41:16 -07:00
|
|
|
break;
|
|
|
|
}
|
2016-05-25 19:07:17 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Clear interrupt */
|
|
|
|
dwc2_writel(GINTSTS_INCOMPL_SOOUT, hsotg->regs + GINTSTS);
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_irq - handle device interrupt
|
2009-06-02 07:58:06 -06:00
|
|
|
* @irq: The IRQ number triggered
|
|
|
|
* @pw: The pw value when registered the handler.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static irqreturn_t dwc2_hsotg_irq(int irq, void *pw)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = pw;
|
2009-06-02 07:58:06 -06:00
|
|
|
int retry_count = 8;
|
|
|
|
u32 gintsts;
|
|
|
|
u32 gintmsk;
|
|
|
|
|
2016-04-27 21:20:48 -06:00
|
|
|
if (!dwc2_is_device_mode(hsotg))
|
|
|
|
return IRQ_NONE;
|
|
|
|
|
2012-06-14 02:02:26 -06:00
|
|
|
spin_lock(&hsotg->lock);
|
2009-06-02 07:58:06 -06:00
|
|
|
irq_retry:
|
2015-08-20 12:41:07 -06:00
|
|
|
gintsts = dwc2_readl(hsotg->regs + GINTSTS);
|
|
|
|
gintmsk = dwc2_readl(hsotg->regs + GINTMSK);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: %08x %08x (%08x) retry %d\n",
|
|
|
|
__func__, gintsts, gintsts & gintmsk, gintmsk, retry_count);
|
|
|
|
|
|
|
|
gintsts &= gintmsk;
|
|
|
|
|
2015-09-29 04:08:29 -06:00
|
|
|
if (gintsts & GINTSTS_RESETDET) {
|
|
|
|
dev_dbg(hsotg->dev, "%s: USBRstDet\n", __func__);
|
|
|
|
|
|
|
|
dwc2_writel(GINTSTS_RESETDET, hsotg->regs + GINTSTS);
|
|
|
|
|
|
|
|
/* This event must be used only if controller is suspended */
|
|
|
|
if (hsotg->lx_state == DWC2_L2) {
|
2018-02-16 03:06:36 -07:00
|
|
|
dwc2_exit_partial_power_down(hsotg, true);
|
2015-09-29 04:08:29 -06:00
|
|
|
hsotg->lx_state = DWC2_L0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (gintsts & (GINTSTS_USBRST | GINTSTS_RESETDET)) {
|
|
|
|
u32 usb_status = dwc2_readl(hsotg->regs + GOTGCTL);
|
|
|
|
u32 connected = hsotg->connected;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: USBRst\n", __func__);
|
|
|
|
dev_dbg(hsotg->dev, "GNPTXSTS=%08x\n",
|
|
|
|
dwc2_readl(hsotg->regs + GNPTXSTS));
|
|
|
|
|
|
|
|
dwc2_writel(GINTSTS_USBRST, hsotg->regs + GINTSTS);
|
|
|
|
|
|
|
|
/* Report disconnection if it is not already done. */
|
|
|
|
dwc2_hsotg_disconnect(hsotg);
|
|
|
|
|
2017-07-11 04:25:13 -06:00
|
|
|
/* Reset device address to zero */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_clear_bit(hsotg->regs + DCFG, DCFG_DEVADDR_MASK);
|
2017-07-11 04:25:13 -06:00
|
|
|
|
2015-09-29 04:08:29 -06:00
|
|
|
if (usb_status & GOTGCTL_BSESVLD && connected)
|
|
|
|
dwc2_hsotg_core_init_disconnected(hsotg, true);
|
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & GINTSTS_ENUMDONE) {
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(GINTSTS_ENUMDONE, hsotg->regs + GINTSTS);
|
2011-04-21 02:06:39 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_irq_enumdone(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & (GINTSTS_OEPINT | GINTSTS_IEPINT)) {
|
2015-08-20 12:41:07 -06:00
|
|
|
u32 daint = dwc2_readl(hsotg->regs + DAINT);
|
|
|
|
u32 daintmsk = dwc2_readl(hsotg->regs + DAINTMSK);
|
2013-09-19 03:50:20 -06:00
|
|
|
u32 daint_out, daint_in;
|
2009-06-02 07:58:06 -06:00
|
|
|
int ep;
|
|
|
|
|
2013-09-19 03:50:20 -06:00
|
|
|
daint &= daintmsk;
|
2014-04-14 15:13:34 -06:00
|
|
|
daint_out = daint >> DAINT_OUTEP_SHIFT;
|
|
|
|
daint_in = daint & ~(daint_out << DAINT_OUTEP_SHIFT);
|
2013-09-19 03:50:20 -06:00
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: daint=%08x\n", __func__, daint);
|
|
|
|
|
2015-01-09 05:38:51 -07:00
|
|
|
for (ep = 0; ep < hsotg->num_of_eps && daint_out;
|
|
|
|
ep++, daint_out >>= 1) {
|
2009-06-02 07:58:06 -06:00
|
|
|
if (daint_out & 1)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_epint(hsotg, ep, 0);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:51 -07:00
|
|
|
for (ep = 0; ep < hsotg->num_of_eps && daint_in;
|
|
|
|
ep++, daint_in >>= 1) {
|
2009-06-02 07:58:06 -06:00
|
|
|
if (daint_in & 1)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_epint(hsotg, ep, 1);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* check both FIFOs */
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & GINTSTS_NPTXFEMP) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "NPTxFEmp\n");
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* Disable the interrupt to stop it happening again
|
2009-06-02 07:58:06 -06:00
|
|
|
* unless one of these endpoint routines decides that
|
2012-05-04 06:17:11 -06:00
|
|
|
* it needs re-enabling
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_disable_gsint(hsotg, GINTSTS_NPTXFEMP);
|
|
|
|
dwc2_hsotg_irq_fifoempty(hsotg, false);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & GINTSTS_PTXFEMP) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "PTxFEmp\n");
|
|
|
|
|
2012-05-04 06:17:14 -06:00
|
|
|
/* See note in GINTSTS_NPTxFEmp */
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_disable_gsint(hsotg, GINTSTS_PTXFEMP);
|
|
|
|
dwc2_hsotg_irq_fifoempty(hsotg, true);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & GINTSTS_RXFLVL) {
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* note, since GINTSTS_RxFLvl doubles as FIFO-not-empty,
|
2015-08-06 17:11:54 -06:00
|
|
|
* we need to retry dwc2_hsotg_handle_rx if this is still
|
2012-05-04 06:17:11 -06:00
|
|
|
* set.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_handle_rx(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & GINTSTS_ERLYSUSP) {
|
2012-05-04 06:17:14 -06:00
|
|
|
dev_dbg(hsotg->dev, "GINTSTS_ErlySusp\n");
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(GINTSTS_ERLYSUSP, hsotg->regs + GINTSTS);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* these next two seem to crop-up occasionally causing the core
|
2009-06-02 07:58:06 -06:00
|
|
|
* to shutdown the USB transfer, so try clearing them and logging
|
2012-05-04 06:17:11 -06:00
|
|
|
* the occurrence.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & GINTSTS_GOUTNAKEFF) {
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
u8 idx;
|
|
|
|
u32 epctrl;
|
|
|
|
u32 gintmsk;
|
2018-01-19 03:41:42 -07:00
|
|
|
u32 daintmsk;
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep;
|
|
|
|
|
2018-01-19 03:41:42 -07:00
|
|
|
daintmsk = dwc2_readl(hsotg->regs + DAINTMSK);
|
|
|
|
daintmsk >>= DAINT_OUTEP_SHIFT;
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
/* Mask this interrupt */
|
|
|
|
gintmsk = dwc2_readl(hsotg->regs + GINTMSK);
|
|
|
|
gintmsk &= ~GINTSTS_GOUTNAKEFF;
|
|
|
|
dwc2_writel(gintmsk, hsotg->regs + GINTMSK);
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "GOUTNakEff triggered\n");
|
|
|
|
for (idx = 1; idx <= hsotg->num_of_eps; idx++) {
|
|
|
|
hs_ep = hsotg->eps_out[idx];
|
2018-01-19 03:41:42 -07:00
|
|
|
/* Proceed only unmasked ISOC EPs */
|
|
|
|
if (!hs_ep->isochronous || (BIT(idx) & ~daintmsk))
|
|
|
|
continue;
|
|
|
|
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
epctrl = dwc2_readl(hsotg->regs + DOEPCTL(idx));
|
|
|
|
|
2018-01-19 03:41:42 -07:00
|
|
|
if (epctrl & DXEPCTL_EPENA) {
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
epctrl |= DXEPCTL_SNAK;
|
|
|
|
epctrl |= DXEPCTL_EPDIS;
|
|
|
|
dwc2_writel(epctrl, hsotg->regs + DOEPCTL(idx));
|
|
|
|
}
|
|
|
|
}
|
2011-04-21 02:06:39 -06:00
|
|
|
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
/* This interrupt bit is cleared in DXEPINT_EPDISBLD handler */
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
if (gintsts & GINTSTS_GINNAKEFF) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_info(hsotg->dev, "GINNakEff triggered\n");
|
|
|
|
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_CGNPINNAK);
|
2011-04-21 02:06:39 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_dump(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
if (gintsts & GINTSTS_INCOMPL_SOIN)
|
|
|
|
dwc2_gadget_handle_incomplete_isoc_in(hsotg);
|
2015-09-10 19:13:43 -06:00
|
|
|
|
2016-05-25 19:07:17 -06:00
|
|
|
if (gintsts & GINTSTS_INCOMPL_SOOUT)
|
|
|
|
dwc2_gadget_handle_incomplete_isoc_out(hsotg);
|
2015-09-10 19:13:43 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* if we've had fifo events, we should try and go around the
|
|
|
|
* loop again to see if there's any point in returning yet.
|
|
|
|
*/
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (gintsts & IRQ_RETRY_MASK && --retry_count > 0)
|
2017-01-17 21:32:12 -07:00
|
|
|
goto irq_retry;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-06-14 02:02:26 -06:00
|
|
|
spin_unlock(&hsotg->lock);
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
return IRQ_HANDLED;
|
|
|
|
}
|
|
|
|
|
2016-11-14 20:16:53 -07:00
|
|
|
static void dwc2_hsotg_ep_stop_xfr(struct dwc2_hsotg *hsotg,
|
|
|
|
struct dwc2_hsotg_ep *hs_ep)
|
|
|
|
{
|
|
|
|
u32 epctrl_reg;
|
|
|
|
u32 epint_reg;
|
|
|
|
|
|
|
|
epctrl_reg = hs_ep->dir_in ? DIEPCTL(hs_ep->index) :
|
|
|
|
DOEPCTL(hs_ep->index);
|
|
|
|
epint_reg = hs_ep->dir_in ? DIEPINT(hs_ep->index) :
|
|
|
|
DOEPINT(hs_ep->index);
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: stopping transfer on %s\n", __func__,
|
|
|
|
hs_ep->name);
|
|
|
|
|
|
|
|
if (hs_ep->dir_in) {
|
|
|
|
if (hsotg->dedicated_fifos || hs_ep->periodic) {
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + epctrl_reg, DXEPCTL_SNAK);
|
2016-11-14 20:16:53 -07:00
|
|
|
/* Wait for Nak effect */
|
|
|
|
if (dwc2_hsotg_wait_bit_set(hsotg, epint_reg,
|
|
|
|
DXEPINT_INEPNAKEFF, 100))
|
|
|
|
dev_warn(hsotg->dev,
|
|
|
|
"%s: timeout DIEPINT.NAKEFF\n",
|
|
|
|
__func__);
|
|
|
|
} else {
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_SGNPINNAK);
|
2016-11-14 20:16:53 -07:00
|
|
|
/* Wait for Nak effect */
|
|
|
|
if (dwc2_hsotg_wait_bit_set(hsotg, GINTSTS,
|
|
|
|
GINTSTS_GINNAKEFF, 100))
|
|
|
|
dev_warn(hsotg->dev,
|
|
|
|
"%s: timeout GINTSTS.GINNAKEFF\n",
|
|
|
|
__func__);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!(dwc2_readl(hsotg->regs + GINTSTS) & GINTSTS_GOUTNAKEFF))
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_SGOUTNAK);
|
2016-11-14 20:16:53 -07:00
|
|
|
|
|
|
|
/* Wait for global nak to take effect */
|
|
|
|
if (dwc2_hsotg_wait_bit_set(hsotg, GINTSTS,
|
|
|
|
GINTSTS_GOUTNAKEFF, 100))
|
|
|
|
dev_warn(hsotg->dev, "%s: timeout GINTSTS.GOUTNAKEFF\n",
|
|
|
|
__func__);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Disable ep */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + epctrl_reg, DXEPCTL_EPDIS | DXEPCTL_SNAK);
|
2016-11-14 20:16:53 -07:00
|
|
|
|
|
|
|
/* Wait for ep to be disabled */
|
|
|
|
if (dwc2_hsotg_wait_bit_set(hsotg, epint_reg, DXEPINT_EPDISBLD, 100))
|
|
|
|
dev_warn(hsotg->dev,
|
|
|
|
"%s: timeout DOEPCTL.EPDisable\n", __func__);
|
|
|
|
|
|
|
|
/* Clear EPDISBLD interrupt */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + epint_reg, DXEPINT_EPDISBLD);
|
2016-11-14 20:16:53 -07:00
|
|
|
|
|
|
|
if (hs_ep->dir_in) {
|
|
|
|
unsigned short fifo_index;
|
|
|
|
|
|
|
|
if (hsotg->dedicated_fifos || hs_ep->periodic)
|
|
|
|
fifo_index = hs_ep->fifo_index;
|
|
|
|
else
|
|
|
|
fifo_index = 0;
|
|
|
|
|
|
|
|
/* Flush TX FIFO */
|
|
|
|
dwc2_flush_tx_fifo(hsotg, fifo_index);
|
|
|
|
|
|
|
|
/* Clear Global In NP NAK in Shared FIFO for non periodic ep */
|
|
|
|
if (!hsotg->dedicated_fifos && !hs_ep->periodic)
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_CGNPINNAK);
|
2016-11-14 20:16:53 -07:00
|
|
|
|
|
|
|
} else {
|
|
|
|
/* Remove global NAKs */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_CGOUTNAK);
|
2016-11-14 20:16:53 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ep_enable - enable the given endpoint
|
2009-06-02 07:58:06 -06:00
|
|
|
* @ep: The USB endpint to configure
|
|
|
|
* @desc: The USB endpoint descriptor to configure with.
|
|
|
|
*
|
|
|
|
* This is called from the USB gadget code's usb_ep_enable().
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_ep_enable(struct usb_ep *ep,
|
2017-01-17 21:30:27 -07:00
|
|
|
const struct usb_endpoint_descriptor *desc)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
2009-06-02 07:58:06 -06:00
|
|
|
unsigned long flags;
|
2015-01-09 05:39:04 -07:00
|
|
|
unsigned int index = hs_ep->index;
|
2009-06-02 07:58:06 -06:00
|
|
|
u32 epctrl_reg;
|
|
|
|
u32 epctrl;
|
|
|
|
u32 mps;
|
2016-11-08 11:57:00 -07:00
|
|
|
u32 mc;
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
u32 mask;
|
2015-01-09 05:39:04 -07:00
|
|
|
unsigned int dir_in;
|
|
|
|
unsigned int i, val, size;
|
2010-03-29 09:36:44 -06:00
|
|
|
int ret = 0;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev,
|
|
|
|
"%s: ep %s: a 0x%02x, attr 0x%02x, mps 0x%04x, intr %d\n",
|
|
|
|
__func__, ep->name, desc->bEndpointAddress, desc->bmAttributes,
|
|
|
|
desc->wMaxPacketSize, desc->bInterval);
|
|
|
|
|
|
|
|
/* not to be called for EP0 */
|
2016-04-27 21:20:46 -06:00
|
|
|
if (index == 0) {
|
|
|
|
dev_err(hsotg->dev, "%s: called for EP 0\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dir_in = (desc->bEndpointAddress & USB_ENDPOINT_DIR_MASK) ? 1 : 0;
|
|
|
|
if (dir_in != hs_ep->dir_in) {
|
|
|
|
dev_err(hsotg->dev, "%s: direction mismatch!\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-08-23 04:12:03 -06:00
|
|
|
mps = usb_endpoint_maxp(desc);
|
2016-11-08 11:57:00 -07:00
|
|
|
mc = usb_endpoint_maxp_mult(desc);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
/* note, we handle this here instead of dwc2_hsotg_set_ep_maxpacket */
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:14 -06:00
|
|
|
epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
|
2015-08-20 12:41:07 -06:00
|
|
|
epctrl = dwc2_readl(hsotg->regs + epctrl_reg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x from 0x%08x\n",
|
|
|
|
__func__, epctrl, epctrl_reg);
|
|
|
|
|
2016-11-09 20:28:03 -07:00
|
|
|
/* Allocate DMA descriptor chain for non-ctrl endpoints */
|
2017-01-05 19:01:48 -07:00
|
|
|
if (using_desc_dma(hsotg) && !hs_ep->desc_list) {
|
|
|
|
hs_ep->desc_list = dmam_alloc_coherent(hsotg->dev,
|
2016-11-09 20:28:03 -07:00
|
|
|
MAX_DMA_DESC_NUM_GENERIC *
|
|
|
|
sizeof(struct dwc2_dma_desc),
|
2016-12-01 02:02:11 -07:00
|
|
|
&hs_ep->desc_list_dma, GFP_ATOMIC);
|
2016-11-09 20:28:03 -07:00
|
|
|
if (!hs_ep->desc_list) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
epctrl &= ~(DXEPCTL_EPTYPE_MASK | DXEPCTL_MPS_MASK);
|
|
|
|
epctrl |= DXEPCTL_MPS(mps);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* mark the endpoint as active, otherwise the core may ignore
|
|
|
|
* transactions entirely for this endpoint
|
|
|
|
*/
|
2014-04-14 15:13:34 -06:00
|
|
|
epctrl |= DXEPCTL_USBACTEP;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* update the endpoint state */
|
2016-11-08 11:57:00 -07:00
|
|
|
dwc2_hsotg_set_ep_maxpacket(hsotg, hs_ep->index, mps, mc, dir_in);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* default, set to non-periodic */
|
2013-10-09 00:41:57 -06:00
|
|
|
hs_ep->isochronous = 0;
|
2009-06-02 07:58:06 -06:00
|
|
|
hs_ep->periodic = 0;
|
2013-09-19 03:50:21 -06:00
|
|
|
hs_ep->halted = 0;
|
2013-10-09 00:41:57 -06:00
|
|
|
hs_ep->interval = desc->bInterval;
|
2013-10-09 01:00:02 -06:00
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) {
|
|
|
|
case USB_ENDPOINT_XFER_ISOC:
|
2014-04-14 15:13:34 -06:00
|
|
|
epctrl |= DXEPCTL_EPTYPE_ISO;
|
|
|
|
epctrl |= DXEPCTL_SETEVENFR;
|
2013-10-09 00:41:57 -06:00
|
|
|
hs_ep->isochronous = 1;
|
2016-05-25 19:07:07 -06:00
|
|
|
hs_ep->interval = 1 << (desc->bInterval - 1);
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
hs_ep->target_frame = TARGET_FRAME_INITIAL;
|
2016-11-14 20:16:36 -07:00
|
|
|
hs_ep->isoc_chain_num = 0;
|
|
|
|
hs_ep->next_desc = 0;
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (dir_in) {
|
2013-10-09 00:41:57 -06:00
|
|
|
hs_ep->periodic = 1;
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
mask = dwc2_readl(hsotg->regs + DIEPMSK);
|
|
|
|
mask |= DIEPMSK_NAKMSK;
|
|
|
|
dwc2_writel(mask, hsotg->regs + DIEPMSK);
|
|
|
|
} else {
|
|
|
|
mask = dwc2_readl(hsotg->regs + DOEPMSK);
|
|
|
|
mask |= DOEPMSK_OUTTKNEPDISMSK;
|
|
|
|
dwc2_writel(mask, hsotg->regs + DOEPMSK);
|
|
|
|
}
|
2013-10-09 00:41:57 -06:00
|
|
|
break;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
case USB_ENDPOINT_XFER_BULK:
|
2014-04-14 15:13:34 -06:00
|
|
|
epctrl |= DXEPCTL_EPTYPE_BULK;
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_ENDPOINT_XFER_INT:
|
2014-09-09 02:44:56 -06:00
|
|
|
if (dir_in)
|
2009-06-02 07:58:06 -06:00
|
|
|
hs_ep->periodic = 1;
|
|
|
|
|
2016-05-25 19:07:07 -06:00
|
|
|
if (hsotg->gadget.speed == USB_SPEED_HIGH)
|
|
|
|
hs_ep->interval = 1 << (desc->bInterval - 1);
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
epctrl |= DXEPCTL_EPTYPE_INTERRUPT;
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
|
|
|
|
case USB_ENDPOINT_XFER_CONTROL:
|
2014-04-14 15:13:34 -06:00
|
|
|
epctrl |= DXEPCTL_EPTYPE_CONTROL;
|
2009-06-02 07:58:06 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* if the hardware has dedicated fifos, we must give each IN EP
|
2010-07-19 02:40:44 -06:00
|
|
|
* a unique tx-fifo even if it is non-periodic.
|
|
|
|
*/
|
2016-08-29 14:38:57 -06:00
|
|
|
if (dir_in && hsotg->dedicated_fifos) {
|
2015-01-09 05:39:04 -07:00
|
|
|
u32 fifo_index = 0;
|
|
|
|
u32 fifo_size = UINT_MAX;
|
2017-01-17 21:30:27 -07:00
|
|
|
|
|
|
|
size = hs_ep->ep.maxpacket * hs_ep->mc;
|
2015-01-09 05:38:56 -07:00
|
|
|
for (i = 1; i < hsotg->num_of_eps; ++i) {
|
2017-01-17 21:30:27 -07:00
|
|
|
if (hsotg->fifo_map & (1 << i))
|
2014-09-09 02:44:56 -06:00
|
|
|
continue;
|
2015-08-20 12:41:07 -06:00
|
|
|
val = dwc2_readl(hsotg->regs + DPTXFSIZN(i));
|
2017-01-17 21:30:27 -07:00
|
|
|
val = (val >> FIFOSIZE_DEPTH_SHIFT) * 4;
|
2014-09-09 02:44:56 -06:00
|
|
|
if (val < size)
|
|
|
|
continue;
|
2015-01-09 05:39:04 -07:00
|
|
|
/* Search for smallest acceptable fifo */
|
|
|
|
if (val < fifo_size) {
|
|
|
|
fifo_size = val;
|
|
|
|
fifo_index = i;
|
|
|
|
}
|
2014-09-09 02:44:56 -06:00
|
|
|
}
|
2015-01-09 05:39:04 -07:00
|
|
|
if (!fifo_index) {
|
2015-01-09 05:38:56 -07:00
|
|
|
dev_err(hsotg->dev,
|
|
|
|
"%s: No suitable fifo found\n", __func__);
|
2014-10-16 22:44:02 -06:00
|
|
|
ret = -ENOMEM;
|
2016-11-09 20:28:03 -07:00
|
|
|
goto error1;
|
2014-10-16 22:44:02 -06:00
|
|
|
}
|
2015-01-09 05:39:04 -07:00
|
|
|
hsotg->fifo_map |= 1 << fifo_index;
|
|
|
|
epctrl |= DXEPCTL_TXFNUM(fifo_index);
|
|
|
|
hs_ep->fifo_index = fifo_index;
|
|
|
|
hs_ep->fifo_size = fifo_size;
|
2014-09-09 02:44:56 -06:00
|
|
|
}
|
2010-07-19 02:40:44 -06:00
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
/* for non control endpoints, set PID to D0 */
|
usb: dwc2: gadget: Final fixes for BDMA ISOC
Done fixes and tested hsotg gadget's BDMA mode. Tested Control,
Bulk, Isoc, Inter transfers. Added code for isoc transfers,
removed unusable code, done minor fixes. Affected functions
and IRQ handlers:
- dwc2_hsotg_start_req(),
- dwc2_hsotg_ep_enable(),
- dwc2_hsotg_ep_queue(),
- dwc2_hsotg_handle_outdone(),
- GINTSTS_GOUTNAKEFF handler,
Removed 'has_correct_parity' flag from 'dwc2_hsotg_ep' struct.
Before this patch series, to set the data pid the DWC2 gadget
driver was toggling the even/odd until it match, then were
leaving it set. But now I have added mechanism to set pid and
excluded all code where this flag was set.
Tested-by: John Keeping <john@metanate.com>
Signed-off-by: Vardan Mikayelyan <mvardan@synopsys.com>
Signed-off-by: John Youn <johnyoun@synopsys.com>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2016-05-25 19:07:22 -06:00
|
|
|
if (index && !hs_ep->isochronous)
|
2014-04-14 15:13:34 -06:00
|
|
|
epctrl |= DXEPCTL_SETD0PID;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: write DxEPCTL=0x%08x\n",
|
|
|
|
__func__, epctrl);
|
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(epctrl, hsotg->regs + epctrl_reg);
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: read DxEPCTL=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
__func__, dwc2_readl(hsotg->regs + epctrl_reg));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* enable the endpoint interrupt */
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ctrl_epint(hsotg, index, dir_in, 1);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2016-11-09 20:28:03 -07:00
|
|
|
error1:
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
2016-11-09 20:28:03 -07:00
|
|
|
|
|
|
|
error2:
|
|
|
|
if (ret && using_desc_dma(hsotg) && hs_ep->desc_list) {
|
2017-01-05 19:01:48 -07:00
|
|
|
dmam_free_coherent(hsotg->dev, MAX_DMA_DESC_NUM_GENERIC *
|
2016-11-09 20:28:03 -07:00
|
|
|
sizeof(struct dwc2_dma_desc),
|
|
|
|
hs_ep->desc_list, hs_ep->desc_list_dma);
|
|
|
|
hs_ep->desc_list = NULL;
|
|
|
|
}
|
|
|
|
|
2010-03-29 09:36:44 -06:00
|
|
|
return ret;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ep_disable - disable given endpoint
|
2012-05-04 06:17:11 -06:00
|
|
|
* @ep: The endpoint to disable.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_ep_disable(struct usb_ep *ep)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = hs_ep->parent;
|
2009-06-02 07:58:06 -06:00
|
|
|
int dir_in = hs_ep->dir_in;
|
|
|
|
int index = hs_ep->index;
|
|
|
|
unsigned long flags;
|
|
|
|
u32 epctrl_reg;
|
|
|
|
u32 ctrl;
|
|
|
|
|
2014-09-09 02:44:54 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s(ep %p)\n", __func__, ep);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
if (ep == &hsotg->eps_out[0]->ep) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_err(hsotg->dev, "%s: called for ep0\n", __func__);
|
|
|
|
return -EINVAL;
|
usb: dwc2: Error out of dwc2_hsotg_ep_disable() if we're in host mode
We've found that while in host mode, using Android, if one runs
the command:
stop adbd
The existing usb devices being utilized in host mode are disconnected.
This is most visible with usb networking devices.
This seems to be due to adbd closing the file:
/dev/usb-ffs/adb/ep0
Which calls ffs_ep0_release() and the following backtrace:
[<ffffff800875a430>] dwc2_hsotg_ep_disable+0x148/0x150
[<ffffff800875a498>] dwc2_hsotg_udc_stop+0x60/0x110
[<ffffff8008787950>] usb_gadget_remove_driver+0x58/0x78
[<ffffff80087879e4>] usb_gadget_unregister_driver+0x74/0xe8
[<ffffff80087850c0>] unregister_gadget+0x28/0x58
[<ffffff800878511c>] unregister_gadget_item+0x2c/0x40
[<ffffff8008790ea8>] ffs_data_clear+0xe8/0xf8
[<ffffff8008790ed8>] ffs_data_reset+0x20/0x58
[<ffffff8008793218>] ffs_data_closed+0x98/0xe8
[<ffffff80087932d8>] ffs_ep0_release+0x20/0x30
Then when dwc2_hsotg_ep_disable() is called, we call
kill_all_requests() which causes a bunch of the following
messages:
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
dwc2 f72c0000.usb: Mode Mismatch Interrupt: currently in Host mode
init: Service 'adbd' (pid 1915) killed by signal 9
init: Sending signal 9 to service 'adbd' (pid 1915) process group...
init: Successfully killed process cgroup uid 0 pid 1915 in 0ms
init: processing action (init.svc.adbd=stopped) from (/init.usb.configfs.rc:15)
dwc2 f72c0000.usb: dwc2_hc_chhltd_intr_dma: Channel 8 - ChHltd set, but reason is unknown
dwc2 f72c0000.usb: hcint 0x00000002, intsts 0x04200029
dwc2 f72c0000.usb: dwc2_hc_chhltd_intr_dma: Channel 12 - ChHltd set, but reason is unknown
dwc2 f72c0000.usb: hcint 0x00000002, intsts 0x04200029
dwc2 f72c0000.usb: dwc2_hc_chhltd_intr_dma: Channel 15 - ChHltd set, but reason is unknown
dwc2 f72c0000.usb: hcint 0x00000002, intsts 0x04200029
dwc2 f72c0000.usb: dwc2_hc_chhltd_intr_dma: Channel 3 - ChHltd set, but reason is unknown
dwc2 f72c0000.usb: hcint 0x00000002, intsts 0x04200029
dwc2 f72c0000.usb: dwc2_hc_chhltd_intr_dma: Channel 4 - ChHltd set, but reason is unknown
dwc2 f72c0000.usb: hcint 0x00000002, intsts 0x04200029
dwc2 f72c0000.usb: dwc2_update_urb_state_abn(): trimming xfer length
And the usb devices connected are basically hung at this point.
It seems like if we're in host mode, we probably shouldn't run
the dwc2_hostg_ep_disable logic, so this patch returns an error
in that case.
With this patch (along with the previous patch in this set), we avoid
the mismatched interrupts and connected usb devices continue to function.
I'm not sure if some other solution would be better here, but this seems
to work, so I wanted to send it out for input on what the right approach
should be.
Cc: Wei Xu <xuwei5@hisilicon.com>
Cc: Guodong Xu <guodong.xu@linaro.org>
Cc: Amit Pundir <amit.pundir@linaro.org>
Cc: YongQin Liu <yongqin.liu@linaro.org>
Cc: John Youn <johnyoun@synopsys.com>
Cc: Minas Harutyunyan <Minas.Harutyunyan@synopsys.com>
Cc: Douglas Anderson <dianders@chromium.org>
Cc: Chen Yu <chenyu56@huawei.com>
Cc: Felipe Balbi <felipe.balbi@linux.intel.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: linux-usb@vger.kernel.org
Acked-by: Minas Harutyunyan <hminas@synopsys.com>
Tested-by: Minas Harutyunyan <hminas@synopsys.com>
Reported-by: YongQin Liu <yongqin.liu@linaro.org>
Signed-off-by: John Stultz <john.stultz@linaro.org>
Signed-off-by: Felipe Balbi <felipe.balbi@linux.intel.com>
2017-10-23 15:32:49 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (hsotg->op_state != OTG_STATE_B_PERIPHERAL) {
|
|
|
|
dev_err(hsotg->dev, "%s: called in host mode?\n", __func__);
|
|
|
|
return -EINVAL;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:14 -06:00
|
|
|
epctrl_reg = dir_in ? DIEPCTL(index) : DOEPCTL(index);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-06-14 02:02:26 -06:00
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
ctrl = dwc2_readl(hsotg->regs + epctrl_reg);
|
2016-11-14 20:16:53 -07:00
|
|
|
|
|
|
|
if (ctrl & DXEPCTL_EPENA)
|
|
|
|
dwc2_hsotg_ep_stop_xfr(hsotg, hs_ep);
|
|
|
|
|
2014-04-14 15:13:34 -06:00
|
|
|
ctrl &= ~DXEPCTL_EPENA;
|
|
|
|
ctrl &= ~DXEPCTL_USBACTEP;
|
|
|
|
ctrl |= DXEPCTL_SNAK;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: DxEPCTL=0x%08x\n", __func__, ctrl);
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(ctrl, hsotg->regs + epctrl_reg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* disable endpoint interrupts */
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ctrl_epint(hsotg, hs_ep->index, hs_ep->dir_in, 0);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-01-09 05:38:57 -07:00
|
|
|
/* terminate all requests with shutdown */
|
|
|
|
kill_all_requests(hsotg, hs_ep, -ESHUTDOWN);
|
|
|
|
|
2016-08-29 14:39:00 -06:00
|
|
|
hsotg->fifo_map &= ~(1 << hs_ep->fifo_index);
|
|
|
|
hs_ep->fifo_index = 0;
|
|
|
|
hs_ep->fifo_size = 0;
|
|
|
|
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
2009-06-02 07:58:06 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* on_list - check request is on the given endpoint
|
|
|
|
* @ep: The endpoint to check.
|
|
|
|
* @test: The request to test if it is on the endpoint.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static bool on_list(struct dwc2_hsotg_ep *ep, struct dwc2_hsotg_req *test)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *req, *treq;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
list_for_each_entry_safe(req, treq, &ep->queue, queue) {
|
|
|
|
if (req == test)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ep_dequeue - dequeue given endpoint
|
2012-05-04 06:17:11 -06:00
|
|
|
* @ep: The endpoint to dequeue.
|
|
|
|
* @req: The request to be removed from a queue.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_ep_dequeue(struct usb_ep *ep, struct usb_request *req)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_req *hs_req = our_req(req);
|
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hs = hs_ep->parent;
|
2009-06-02 07:58:06 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2014-09-09 02:44:54 -06:00
|
|
|
dev_dbg(hs->dev, "ep_dequeue(%p,%p)\n", ep, req);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_lock_irqsave(&hs->lock, flags);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
if (!on_list(hs_ep, hs_req)) {
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_unlock_irqrestore(&hs->lock, flags);
|
2009-06-02 07:58:06 -06:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2015-09-29 04:08:24 -06:00
|
|
|
/* Dequeue already started request */
|
|
|
|
if (req == &hs_ep->req->req)
|
|
|
|
dwc2_hsotg_ep_stop_xfr(hs, hs_ep);
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_complete_request(hs, hs_ep, hs_req, -ECONNRESET);
|
2012-06-14 02:02:24 -06:00
|
|
|
spin_unlock_irqrestore(&hs->lock, flags);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ep_sethalt - set halt on a given endpoint
|
2012-05-04 06:17:11 -06:00
|
|
|
* @ep: The endpoint to set halt.
|
|
|
|
* @value: Set or unset the halt.
|
2016-05-23 23:41:57 -06:00
|
|
|
* @now: If true, stall the endpoint now. Otherwise return -EAGAIN if
|
|
|
|
* the endpoint is busy processing requests.
|
|
|
|
*
|
|
|
|
* We need to stall the endpoint immediately if request comes from set_feature
|
|
|
|
* protocol command handler.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2016-05-23 23:41:57 -06:00
|
|
|
static int dwc2_hsotg_ep_sethalt(struct usb_ep *ep, int value, bool now)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hs = hs_ep->parent;
|
2009-06-02 07:58:06 -06:00
|
|
|
int index = hs_ep->index;
|
|
|
|
u32 epreg;
|
|
|
|
u32 epctl;
|
2011-04-21 02:06:41 -06:00
|
|
|
u32 xfertype;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_info(hs->dev, "%s(ep %p %s, %d)\n", __func__, ep, ep->name, value);
|
|
|
|
|
2014-01-14 00:36:00 -07:00
|
|
|
if (index == 0) {
|
|
|
|
if (value)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_stall_ep0(hs);
|
2014-01-14 00:36:00 -07:00
|
|
|
else
|
|
|
|
dev_warn(hs->dev,
|
|
|
|
"%s: can't clear halt on ep0\n", __func__);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2016-05-23 23:41:59 -06:00
|
|
|
if (hs_ep->isochronous) {
|
|
|
|
dev_err(hs->dev, "%s is Isochronous Endpoint\n", ep->name);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2016-05-23 23:41:57 -06:00
|
|
|
if (!now && value && !list_empty(&hs_ep->queue)) {
|
|
|
|
dev_dbg(hs->dev, "%s request is pending, cannot halt\n",
|
|
|
|
ep->name);
|
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
if (hs_ep->dir_in) {
|
|
|
|
epreg = DIEPCTL(index);
|
2015-08-20 12:41:07 -06:00
|
|
|
epctl = dwc2_readl(hs->regs + epreg);
|
2015-01-09 05:38:50 -07:00
|
|
|
|
|
|
|
if (value) {
|
2015-06-29 19:17:22 -06:00
|
|
|
epctl |= DXEPCTL_STALL | DXEPCTL_SNAK;
|
2015-01-09 05:38:50 -07:00
|
|
|
if (epctl & DXEPCTL_EPENA)
|
|
|
|
epctl |= DXEPCTL_EPDIS;
|
|
|
|
} else {
|
|
|
|
epctl &= ~DXEPCTL_STALL;
|
|
|
|
xfertype = epctl & DXEPCTL_EPTYPE_MASK;
|
|
|
|
if (xfertype == DXEPCTL_EPTYPE_BULK ||
|
2017-01-17 21:30:27 -07:00
|
|
|
xfertype == DXEPCTL_EPTYPE_INTERRUPT)
|
2017-01-17 21:32:12 -07:00
|
|
|
epctl |= DXEPCTL_SETD0PID;
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(epctl, hs->regs + epreg);
|
2011-04-21 02:06:41 -06:00
|
|
|
} else {
|
2015-01-09 05:38:50 -07:00
|
|
|
epreg = DOEPCTL(index);
|
2015-08-20 12:41:07 -06:00
|
|
|
epctl = dwc2_readl(hs->regs + epreg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2017-01-17 21:31:43 -07:00
|
|
|
if (value) {
|
2015-01-09 05:38:50 -07:00
|
|
|
epctl |= DXEPCTL_STALL;
|
2017-01-17 21:31:43 -07:00
|
|
|
} else {
|
2015-01-09 05:38:50 -07:00
|
|
|
epctl &= ~DXEPCTL_STALL;
|
|
|
|
xfertype = epctl & DXEPCTL_EPTYPE_MASK;
|
|
|
|
if (xfertype == DXEPCTL_EPTYPE_BULK ||
|
2017-01-17 21:30:27 -07:00
|
|
|
xfertype == DXEPCTL_EPTYPE_INTERRUPT)
|
2017-01-17 21:32:12 -07:00
|
|
|
epctl |= DXEPCTL_SETD0PID;
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(epctl, hs->regs + epreg);
|
2011-04-21 02:06:41 -06:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2013-09-19 03:50:21 -06:00
|
|
|
hs_ep->halted = value;
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-06-14 02:02:26 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_ep_sethalt_lock - set halt on a given endpoint with lock held
|
2012-06-14 02:02:26 -06:00
|
|
|
* @ep: The endpoint to set halt.
|
|
|
|
* @value: Set or unset the halt.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_ep_sethalt_lock(struct usb_ep *ep, int value)
|
2012-06-14 02:02:26 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
struct dwc2_hsotg_ep *hs_ep = our_ep(ep);
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hs = hs_ep->parent;
|
2012-06-14 02:02:26 -06:00
|
|
|
unsigned long flags = 0;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&hs->lock, flags);
|
2016-05-23 23:41:57 -06:00
|
|
|
ret = dwc2_hsotg_ep_sethalt(ep, value, false);
|
2012-06-14 02:02:26 -06:00
|
|
|
spin_unlock_irqrestore(&hs->lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-08-12 06:04:55 -06:00
|
|
|
static const struct usb_ep_ops dwc2_hsotg_ep_ops = {
|
2015-08-06 17:11:54 -06:00
|
|
|
.enable = dwc2_hsotg_ep_enable,
|
|
|
|
.disable = dwc2_hsotg_ep_disable,
|
|
|
|
.alloc_request = dwc2_hsotg_ep_alloc_request,
|
|
|
|
.free_request = dwc2_hsotg_ep_free_request,
|
|
|
|
.queue = dwc2_hsotg_ep_queue_lock,
|
|
|
|
.dequeue = dwc2_hsotg_ep_dequeue,
|
|
|
|
.set_halt = dwc2_hsotg_ep_sethalt_lock,
|
2011-03-30 19:57:33 -06:00
|
|
|
/* note, don't believe we have any call for the fifo routines */
|
2009-06-02 07:58:06 -06:00
|
|
|
};
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2017-01-17 21:30:27 -07:00
|
|
|
* dwc2_hsotg_init - initialize the usb core
|
2012-05-04 06:17:11 -06:00
|
|
|
* @hsotg: The driver state
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_init(struct dwc2_hsotg *hsotg)
|
2012-05-04 06:17:09 -06:00
|
|
|
{
|
2015-01-30 01:09:35 -07:00
|
|
|
u32 trdtim;
|
2016-03-16 16:10:26 -06:00
|
|
|
u32 usbcfg;
|
2012-05-04 06:17:09 -06:00
|
|
|
/* unmask subset of endpoint interrupts */
|
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
|
|
|
|
DIEPMSK_EPDISBLDMSK | DIEPMSK_XFERCOMPLMSK,
|
|
|
|
hsotg->regs + DIEPMSK);
|
2012-05-04 06:17:09 -06:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(DOEPMSK_SETUPMSK | DOEPMSK_AHBERRMSK |
|
|
|
|
DOEPMSK_EPDISBLDMSK | DOEPMSK_XFERCOMPLMSK,
|
|
|
|
hsotg->regs + DOEPMSK);
|
2012-05-04 06:17:09 -06:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(0, hsotg->regs + DAINTMSK);
|
2012-05-04 06:17:09 -06:00
|
|
|
|
|
|
|
/* Be in disconnected state until gadget is registered */
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + DCTL, DCTL_SFTDISCON);
|
2012-05-04 06:17:09 -06:00
|
|
|
|
|
|
|
/* setup fifos */
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(hsotg->regs + GRXFSIZ),
|
|
|
|
dwc2_readl(hsotg->regs + GNPTXFSIZ));
|
2012-05-04 06:17:09 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_init_fifo(hsotg);
|
2012-05-04 06:17:09 -06:00
|
|
|
|
2016-03-16 16:10:26 -06:00
|
|
|
/* keep other bits untouched (so e.g. forced modes are not lost) */
|
|
|
|
usbcfg = dwc2_readl(hsotg->regs + GUSBCFG);
|
|
|
|
usbcfg &= ~(GUSBCFG_TOUTCAL_MASK | GUSBCFG_PHYIF16 | GUSBCFG_SRPCAP |
|
2017-01-12 08:09:44 -07:00
|
|
|
GUSBCFG_HNPCAP | GUSBCFG_USBTRDTIM_MASK);
|
2016-03-16 16:10:26 -06:00
|
|
|
|
2012-05-04 06:17:09 -06:00
|
|
|
/* set the PLL on, remove the HNP/SRP and set the PHY */
|
2015-01-30 01:09:35 -07:00
|
|
|
trdtim = (hsotg->phyif == GUSBCFG_PHYIF8) ? 9 : 5;
|
2016-03-16 16:10:26 -06:00
|
|
|
usbcfg |= hsotg->phyif | GUSBCFG_TOUTCAL(7) |
|
|
|
|
(trdtim << GUSBCFG_USBTRDTIM_SHIFT);
|
|
|
|
dwc2_writel(usbcfg, hsotg->regs + GUSBCFG);
|
2012-05-04 06:17:09 -06:00
|
|
|
|
2015-01-09 05:38:47 -07:00
|
|
|
if (using_dma(hsotg))
|
2018-01-19 03:42:08 -07:00
|
|
|
dwc2_set_bit(hsotg->regs + GAHBCFG, GAHBCFG_DMA_EN);
|
2012-05-04 06:17:09 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_udc_start - prepare the udc for work
|
2012-05-04 06:17:11 -06:00
|
|
|
* @gadget: The usb gadget state
|
|
|
|
* @driver: The usb gadget driver
|
|
|
|
*
|
|
|
|
* Perform initialization to prepare udc device and driver
|
|
|
|
* to work.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_udc_start(struct usb_gadget *gadget,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct usb_gadget_driver *driver)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = to_hsotg(gadget);
|
2014-10-20 04:45:38 -06:00
|
|
|
unsigned long flags;
|
2009-06-02 07:58:06 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!hsotg) {
|
2013-09-30 06:56:02 -06:00
|
|
|
pr_err("%s: called with no device\n", __func__);
|
2009-06-02 07:58:06 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!driver) {
|
|
|
|
dev_err(hsotg->dev, "%s: no driver\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2011-11-19 10:27:38 -07:00
|
|
|
if (driver->max_speed < USB_SPEED_FULL)
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_err(hsotg->dev, "%s: bad speed\n", __func__);
|
|
|
|
|
2012-05-04 06:17:10 -06:00
|
|
|
if (!driver->setup) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_err(hsotg->dev, "%s: missing entry points\n", __func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
WARN_ON(hsotg->driver);
|
|
|
|
|
|
|
|
driver->driver.bus = NULL;
|
|
|
|
hsotg->driver = driver;
|
2012-06-26 08:27:10 -06:00
|
|
|
hsotg->gadget.dev.of_node = hsotg->dev->of_node;
|
2009-06-02 07:58:06 -06:00
|
|
|
hsotg->gadget.speed = USB_SPEED_UNKNOWN;
|
|
|
|
|
2015-10-14 00:52:29 -06:00
|
|
|
if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL) {
|
|
|
|
ret = dwc2_lowlevel_hw_enable(hsotg);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:41 -07:00
|
|
|
if (!IS_ERR_OR_NULL(hsotg->uphy))
|
|
|
|
otg_set_peripheral(hsotg->uphy->otg, &hsotg->gadget);
|
2014-10-20 04:45:37 -06:00
|
|
|
|
2014-10-20 04:45:38 -06:00
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
2016-09-07 20:39:37 -06:00
|
|
|
if (dwc2_hw_is_device(hsotg)) {
|
|
|
|
dwc2_hsotg_init(hsotg);
|
|
|
|
dwc2_hsotg_core_init_disconnected(hsotg, false);
|
|
|
|
}
|
|
|
|
|
2014-11-21 07:14:49 -07:00
|
|
|
hsotg->enabled = 0;
|
2014-10-20 04:45:38 -06:00
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_info(hsotg->dev, "bound driver %s\n", driver->driver.name);
|
2014-10-20 04:45:38 -06:00
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err:
|
|
|
|
hsotg->driver = NULL;
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_udc_stop - stop the udc
|
2012-05-04 06:17:11 -06:00
|
|
|
* @gadget: The usb gadget state
|
|
|
|
* @driver: The usb gadget driver
|
|
|
|
*
|
|
|
|
* Stop udc hw block and stay tunned for future transmissions
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_udc_stop(struct usb_gadget *gadget)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = to_hsotg(gadget);
|
2012-06-14 02:02:25 -06:00
|
|
|
unsigned long flags = 0;
|
2009-06-02 07:58:06 -06:00
|
|
|
int ep;
|
|
|
|
|
|
|
|
if (!hsotg)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* all endpoints should be shutdown */
|
2015-01-09 05:38:50 -07:00
|
|
|
for (ep = 1; ep < hsotg->num_of_eps; ep++) {
|
|
|
|
if (hsotg->eps_in[ep])
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (hsotg->eps_out[ep])
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-06-14 02:02:25 -06:00
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
|
|
|
|
2014-10-20 04:45:33 -06:00
|
|
|
hsotg->driver = NULL;
|
2009-06-02 07:58:06 -06:00
|
|
|
hsotg->gadget.speed = USB_SPEED_UNKNOWN;
|
2014-11-21 07:14:49 -07:00
|
|
|
hsotg->enabled = 0;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2012-06-14 02:02:25 -06:00
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
|
|
|
|
2015-01-09 05:38:41 -07:00
|
|
|
if (!IS_ERR_OR_NULL(hsotg->uphy))
|
|
|
|
otg_set_peripheral(hsotg->uphy->otg, NULL);
|
2014-10-20 04:45:37 -06:00
|
|
|
|
2015-10-14 00:52:29 -06:00
|
|
|
if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)
|
|
|
|
dwc2_lowlevel_hw_disable(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_gadget_getframe - read the frame number
|
2012-05-04 06:17:11 -06:00
|
|
|
* @gadget: The usb gadget state
|
|
|
|
*
|
|
|
|
* Read the {micro} frame number
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_gadget_getframe(struct usb_gadget *gadget)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-08-06 17:11:54 -06:00
|
|
|
return dwc2_hsotg_read_frameno(to_hsotg(gadget));
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2012-06-22 01:29:56 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_pullup - connect/disconnect the USB PHY
|
2012-06-22 01:29:56 -06:00
|
|
|
* @gadget: The usb gadget state
|
|
|
|
* @is_on: Current state of the USB PHY
|
|
|
|
*
|
|
|
|
* Connect/Disconnect the USB PHY pullup
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_pullup(struct usb_gadget *gadget, int is_on)
|
2012-06-22 01:29:56 -06:00
|
|
|
{
|
2014-11-11 10:13:33 -07:00
|
|
|
struct dwc2_hsotg *hsotg = to_hsotg(gadget);
|
2012-06-22 01:29:56 -06:00
|
|
|
unsigned long flags = 0;
|
|
|
|
|
2015-09-29 04:08:19 -06:00
|
|
|
dev_dbg(hsotg->dev, "%s: is_on: %d op_state: %d\n", __func__, is_on,
|
2017-01-17 21:30:27 -07:00
|
|
|
hsotg->op_state);
|
2015-09-29 04:08:19 -06:00
|
|
|
|
|
|
|
/* Don't modify pullup state while in host mode */
|
|
|
|
if (hsotg->op_state != OTG_STATE_B_PERIPHERAL) {
|
|
|
|
hsotg->enabled = is_on;
|
|
|
|
return 0;
|
|
|
|
}
|
2012-06-22 01:29:56 -06:00
|
|
|
|
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
|
|
|
if (is_on) {
|
2014-11-21 07:14:49 -07:00
|
|
|
hsotg->enabled = 1;
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_init_disconnected(hsotg, false);
|
2018-01-24 06:40:29 -07:00
|
|
|
/* Enable ACG feature in device mode,if supported */
|
|
|
|
dwc2_enable_acg(hsotg);
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_connect(hsotg);
|
2012-06-22 01:29:56 -06:00
|
|
|
} else {
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_disconnect(hsotg);
|
|
|
|
dwc2_hsotg_disconnect(hsotg);
|
2014-11-21 07:14:49 -07:00
|
|
|
hsotg->enabled = 0;
|
2012-06-22 01:29:56 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
hsotg->gadget.speed = USB_SPEED_UNKNOWN;
|
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_vbus_session(struct usb_gadget *gadget, int is_active)
|
2015-01-09 05:39:02 -07:00
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = to_hsotg(gadget);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s: is_active: %d\n", __func__, is_active);
|
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
|
|
|
|
2015-09-29 04:08:28 -06:00
|
|
|
/*
|
2018-02-16 03:06:36 -07:00
|
|
|
* If controller is hibernated, it must exit from power_down
|
2015-09-29 04:08:28 -06:00
|
|
|
* before being initialized / de-initialized
|
|
|
|
*/
|
|
|
|
if (hsotg->lx_state == DWC2_L2)
|
2018-02-16 03:06:36 -07:00
|
|
|
dwc2_exit_partial_power_down(hsotg, false);
|
2015-09-29 04:08:28 -06:00
|
|
|
|
2015-01-09 05:39:02 -07:00
|
|
|
if (is_active) {
|
2015-09-29 04:08:20 -06:00
|
|
|
hsotg->op_state = OTG_STATE_B_PERIPHERAL;
|
2015-09-22 07:16:54 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_init_disconnected(hsotg, false);
|
2018-01-24 06:40:29 -07:00
|
|
|
if (hsotg->enabled) {
|
|
|
|
/* Enable ACG feature in device mode,if supported */
|
|
|
|
dwc2_enable_acg(hsotg);
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_connect(hsotg);
|
2018-01-24 06:40:29 -07:00
|
|
|
}
|
2015-01-09 05:39:02 -07:00
|
|
|
} else {
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_disconnect(hsotg);
|
|
|
|
dwc2_hsotg_disconnect(hsotg);
|
2015-01-09 05:39:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-01-09 05:39:08 -07:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_vbus_draw - report bMaxPower field
|
2015-01-09 05:39:08 -07:00
|
|
|
* @gadget: The usb gadget state
|
|
|
|
* @mA: Amount of current
|
|
|
|
*
|
|
|
|
* Report how much power the device may consume to the phy.
|
|
|
|
*/
|
2017-01-17 21:30:27 -07:00
|
|
|
static int dwc2_hsotg_vbus_draw(struct usb_gadget *gadget, unsigned int mA)
|
2015-01-09 05:39:08 -07:00
|
|
|
{
|
|
|
|
struct dwc2_hsotg *hsotg = to_hsotg(gadget);
|
|
|
|
|
|
|
|
if (IS_ERR_OR_NULL(hsotg->uphy))
|
|
|
|
return -ENOTSUPP;
|
|
|
|
return usb_phy_set_power(hsotg->uphy, mA);
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
static const struct usb_gadget_ops dwc2_hsotg_gadget_ops = {
|
|
|
|
.get_frame = dwc2_hsotg_gadget_getframe,
|
|
|
|
.udc_start = dwc2_hsotg_udc_start,
|
|
|
|
.udc_stop = dwc2_hsotg_udc_stop,
|
|
|
|
.pullup = dwc2_hsotg_pullup,
|
|
|
|
.vbus_session = dwc2_hsotg_vbus_session,
|
|
|
|
.vbus_draw = dwc2_hsotg_vbus_draw,
|
2009-06-02 07:58:06 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_initep - initialise a single endpoint
|
2009-06-02 07:58:06 -06:00
|
|
|
* @hsotg: The device state.
|
|
|
|
* @hs_ep: The endpoint to be initialised.
|
|
|
|
* @epnum: The endpoint number
|
|
|
|
*
|
|
|
|
* Initialise the given endpoint (as part of the probe and device state
|
|
|
|
* creation) to give to the gadget driver. Setup the endpoint name, any
|
|
|
|
* direction information and other state that may be required.
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_initep(struct dwc2_hsotg *hsotg,
|
2017-01-17 21:30:27 -07:00
|
|
|
struct dwc2_hsotg_ep *hs_ep,
|
2015-01-09 05:38:50 -07:00
|
|
|
int epnum,
|
|
|
|
bool dir_in)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
|
|
|
char *dir;
|
|
|
|
|
|
|
|
if (epnum == 0)
|
|
|
|
dir = "";
|
2015-01-09 05:38:50 -07:00
|
|
|
else if (dir_in)
|
2009-06-02 07:58:06 -06:00
|
|
|
dir = "in";
|
2015-01-09 05:38:50 -07:00
|
|
|
else
|
|
|
|
dir = "out";
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
hs_ep->dir_in = dir_in;
|
2009-06-02 07:58:06 -06:00
|
|
|
hs_ep->index = epnum;
|
|
|
|
|
|
|
|
snprintf(hs_ep->name, sizeof(hs_ep->name), "ep%d%s", epnum, dir);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&hs_ep->queue);
|
|
|
|
INIT_LIST_HEAD(&hs_ep->ep.ep_list);
|
|
|
|
|
|
|
|
/* add to the list of endpoints known by the gadget driver */
|
|
|
|
if (epnum)
|
|
|
|
list_add_tail(&hs_ep->ep.ep_list, &hsotg->gadget.ep_list);
|
|
|
|
|
|
|
|
hs_ep->parent = hsotg;
|
|
|
|
hs_ep->ep.name = hs_ep->name;
|
2016-11-14 20:17:03 -07:00
|
|
|
|
|
|
|
if (hsotg->params.speed == DWC2_SPEED_PARAM_LOW)
|
|
|
|
usb_ep_set_maxpacket_limit(&hs_ep->ep, 8);
|
|
|
|
else
|
|
|
|
usb_ep_set_maxpacket_limit(&hs_ep->ep,
|
|
|
|
epnum ? 1024 : EP0_MPS_LIMIT);
|
2015-08-06 17:11:54 -06:00
|
|
|
hs_ep->ep.ops = &dwc2_hsotg_ep_ops;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-07-31 08:00:18 -06:00
|
|
|
if (epnum == 0) {
|
|
|
|
hs_ep->ep.caps.type_control = true;
|
|
|
|
} else {
|
2016-11-14 20:17:03 -07:00
|
|
|
if (hsotg->params.speed != DWC2_SPEED_PARAM_LOW) {
|
|
|
|
hs_ep->ep.caps.type_iso = true;
|
|
|
|
hs_ep->ep.caps.type_bulk = true;
|
|
|
|
}
|
2015-07-31 08:00:18 -06:00
|
|
|
hs_ep->ep.caps.type_int = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dir_in)
|
|
|
|
hs_ep->ep.caps.dir_in = true;
|
|
|
|
else
|
|
|
|
hs_ep->ep.caps.dir_out = true;
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/*
|
|
|
|
* if we're using dma, we need to set the next-endpoint pointer
|
2009-06-02 07:58:06 -06:00
|
|
|
* to be something valid.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (using_dma(hsotg)) {
|
2014-04-14 15:13:34 -06:00
|
|
|
u32 next = DXEPCTL_NEXTEP((epnum + 1) % 15);
|
2017-01-17 21:30:27 -07:00
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
if (dir_in)
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(next, hsotg->regs + DIEPCTL(epnum));
|
2015-01-09 05:38:50 -07:00
|
|
|
else
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_writel(next, hsotg->regs + DOEPCTL(epnum));
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:09 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_hw_cfg - read HW configuration registers
|
2012-05-04 06:17:09 -06:00
|
|
|
* @param: The device state
|
|
|
|
*
|
|
|
|
* Read the USB core HW configuration registers
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static int dwc2_hsotg_hw_cfg(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2015-01-09 05:38:50 -07:00
|
|
|
u32 cfg;
|
|
|
|
u32 ep_type;
|
|
|
|
u32 i;
|
|
|
|
|
2012-05-04 06:17:09 -06:00
|
|
|
/* check hardware configuration */
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-12-17 12:17:45 -07:00
|
|
|
hsotg->num_of_eps = hsotg->hw_params.num_dev_ep;
|
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
/* Add ep0 */
|
|
|
|
hsotg->num_of_eps++;
|
2010-07-19 02:40:44 -06:00
|
|
|
|
2017-01-17 21:31:58 -07:00
|
|
|
hsotg->eps_in[0] = devm_kzalloc(hsotg->dev,
|
|
|
|
sizeof(struct dwc2_hsotg_ep),
|
|
|
|
GFP_KERNEL);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (!hsotg->eps_in[0])
|
|
|
|
return -ENOMEM;
|
2015-08-06 17:11:54 -06:00
|
|
|
/* Same dwc2_hsotg_ep is used in both directions for ep0 */
|
2015-01-09 05:38:50 -07:00
|
|
|
hsotg->eps_out[0] = hsotg->eps_in[0];
|
|
|
|
|
2015-12-17 12:17:45 -07:00
|
|
|
cfg = hsotg->hw_params.dev_ep_dirs;
|
2015-02-02 15:55:38 -07:00
|
|
|
for (i = 1, cfg >>= 2; i < hsotg->num_of_eps; i++, cfg >>= 2) {
|
2015-01-09 05:38:50 -07:00
|
|
|
ep_type = cfg & 3;
|
|
|
|
/* Direction in or both */
|
|
|
|
if (!(ep_type & 2)) {
|
|
|
|
hsotg->eps_in[i] = devm_kzalloc(hsotg->dev,
|
2015-08-06 17:11:54 -06:00
|
|
|
sizeof(struct dwc2_hsotg_ep), GFP_KERNEL);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (!hsotg->eps_in[i])
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
/* Direction out or both */
|
|
|
|
if (!(ep_type & 1)) {
|
|
|
|
hsotg->eps_out[i] = devm_kzalloc(hsotg->dev,
|
2015-08-06 17:11:54 -06:00
|
|
|
sizeof(struct dwc2_hsotg_ep), GFP_KERNEL);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (!hsotg->eps_out[i])
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-17 12:17:45 -07:00
|
|
|
hsotg->fifo_mem = hsotg->hw_params.total_fifo_size;
|
|
|
|
hsotg->dedicated_fifos = hsotg->hw_params.en_multiple_tx_fifo;
|
2010-07-19 02:40:44 -06:00
|
|
|
|
2014-09-09 02:44:55 -06:00
|
|
|
dev_info(hsotg->dev, "EPs: %d, %s fifos, %d entries in SPRAM\n",
|
|
|
|
hsotg->num_of_eps,
|
|
|
|
hsotg->dedicated_fifos ? "dedicated" : "shared",
|
|
|
|
hsotg->fifo_mem);
|
2015-01-09 05:38:50 -07:00
|
|
|
return 0;
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_dump - dump state of the udc
|
2012-05-04 06:17:11 -06:00
|
|
|
* @param: The device state
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
static void dwc2_hsotg_dump(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2011-06-01 10:16:15 -06:00
|
|
|
#ifdef DEBUG
|
2009-06-02 07:58:06 -06:00
|
|
|
struct device *dev = hsotg->dev;
|
|
|
|
void __iomem *regs = hsotg->regs;
|
|
|
|
u32 val;
|
|
|
|
int idx;
|
|
|
|
|
|
|
|
dev_info(dev, "DCFG=0x%08x, DCTL=0x%08x, DIEPMSK=%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(regs + DCFG), dwc2_readl(regs + DCTL),
|
|
|
|
dwc2_readl(regs + DIEPMSK));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-01-30 01:09:36 -07:00
|
|
|
dev_info(dev, "GAHBCFG=0x%08x, GHWCFG1=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(regs + GAHBCFG), dwc2_readl(regs + GHWCFG1));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
dev_info(dev, "GRXFSIZ=0x%08x, GNPTXFSIZ=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(regs + GRXFSIZ), dwc2_readl(regs + GNPTXFSIZ));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* show periodic fifo settings */
|
|
|
|
|
2015-01-09 05:38:55 -07:00
|
|
|
for (idx = 1; idx < hsotg->num_of_eps; idx++) {
|
2015-08-20 12:41:07 -06:00
|
|
|
val = dwc2_readl(regs + DPTXFSIZN(idx));
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_info(dev, "DPTx[%d] FSize=%d, StAddr=0x%08x\n", idx,
|
2014-04-14 15:13:34 -06:00
|
|
|
val >> FIFOSIZE_DEPTH_SHIFT,
|
|
|
|
val & FIFOSIZE_STARTADDR_MASK);
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:55 -07:00
|
|
|
for (idx = 0; idx < hsotg->num_of_eps; idx++) {
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_info(dev,
|
|
|
|
"ep%d-in: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n", idx,
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(regs + DIEPCTL(idx)),
|
|
|
|
dwc2_readl(regs + DIEPTSIZ(idx)),
|
|
|
|
dwc2_readl(regs + DIEPDMA(idx)));
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-20 12:41:07 -06:00
|
|
|
val = dwc2_readl(regs + DOEPCTL(idx));
|
2009-06-02 07:58:06 -06:00
|
|
|
dev_info(dev,
|
|
|
|
"ep%d-out: EPCTL=0x%08x, SIZ=0x%08x, DMA=0x%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
idx, dwc2_readl(regs + DOEPCTL(idx)),
|
|
|
|
dwc2_readl(regs + DOEPTSIZ(idx)),
|
|
|
|
dwc2_readl(regs + DOEPDMA(idx)));
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
dev_info(dev, "DVBUSDIS=0x%08x, DVBUSPULSE=%08x\n",
|
2015-08-20 12:41:07 -06:00
|
|
|
dwc2_readl(regs + DVBUSDIS), dwc2_readl(regs + DVBUSPULSE));
|
2011-06-01 10:16:15 -06:00
|
|
|
#endif
|
2009-06-02 07:58:06 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2014-11-11 10:13:34 -07:00
|
|
|
* dwc2_gadget_init - init function for gadget
|
|
|
|
* @dwc2: The data structure for the DWC2 driver.
|
2012-05-04 06:17:11 -06:00
|
|
|
*/
|
2017-12-25 04:17:45 -07:00
|
|
|
int dwc2_gadget_init(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2014-11-11 10:13:34 -07:00
|
|
|
struct device *dev = hsotg->dev;
|
2009-06-02 07:58:06 -06:00
|
|
|
int epnum;
|
|
|
|
int ret;
|
2015-12-17 12:17:45 -07:00
|
|
|
|
2015-01-09 05:38:52 -07:00
|
|
|
/* Dump fifo information */
|
|
|
|
dev_dbg(dev, "NonPeriodic TXFIFO size: %d\n",
|
2016-11-03 18:56:05 -06:00
|
|
|
hsotg->params.g_np_tx_fifo_size);
|
|
|
|
dev_dbg(dev, "RXFIFO size: %d\n", hsotg->params.g_rx_fifo_size);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2011-11-19 10:27:37 -07:00
|
|
|
hsotg->gadget.max_speed = USB_SPEED_HIGH;
|
2015-08-06 17:11:54 -06:00
|
|
|
hsotg->gadget.ops = &dwc2_hsotg_gadget_ops;
|
2009-06-02 07:58:06 -06:00
|
|
|
hsotg->gadget.name = dev_name(dev);
|
2018-02-16 03:08:53 -07:00
|
|
|
hsotg->remote_wakeup_allowed = 0;
|
2018-01-24 06:44:51 -07:00
|
|
|
|
|
|
|
if (hsotg->params.lpm)
|
|
|
|
hsotg->gadget.lpm_capable = true;
|
|
|
|
|
2015-04-29 14:09:10 -06:00
|
|
|
if (hsotg->dr_mode == USB_DR_MODE_OTG)
|
|
|
|
hsotg->gadget.is_otg = 1;
|
2015-09-22 07:16:55 -06:00
|
|
|
else if (hsotg->dr_mode == USB_DR_MODE_PERIPHERAL)
|
|
|
|
hsotg->op_state = OTG_STATE_B_PERIPHERAL;
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
ret = dwc2_hsotg_hw_cfg(hsotg);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev, "Hardware configuration failed: %d\n", ret);
|
2015-10-14 00:52:29 -06:00
|
|
|
return ret;
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
|
|
|
|
2015-01-09 05:38:44 -07:00
|
|
|
hsotg->ctrl_buff = devm_kzalloc(hsotg->dev,
|
|
|
|
DWC2_CTRL_BUFF_SIZE, GFP_KERNEL);
|
2016-08-25 11:39:02 -06:00
|
|
|
if (!hsotg->ctrl_buff)
|
2015-10-14 00:52:29 -06:00
|
|
|
return -ENOMEM;
|
2015-01-09 05:38:44 -07:00
|
|
|
|
|
|
|
hsotg->ep0_buff = devm_kzalloc(hsotg->dev,
|
|
|
|
DWC2_CTRL_BUFF_SIZE, GFP_KERNEL);
|
2016-08-25 11:39:02 -06:00
|
|
|
if (!hsotg->ep0_buff)
|
2015-10-14 00:52:29 -06:00
|
|
|
return -ENOMEM;
|
2015-01-09 05:38:44 -07:00
|
|
|
|
2016-11-09 20:27:56 -07:00
|
|
|
if (using_desc_dma(hsotg)) {
|
|
|
|
ret = dwc2_gadget_alloc_ctrl_desc_chains(hsotg);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2017-12-25 04:17:45 -07:00
|
|
|
ret = devm_request_irq(hsotg->dev, hsotg->irq, dwc2_hsotg_irq,
|
|
|
|
IRQF_SHARED, dev_name(hsotg->dev), hsotg);
|
2014-09-09 02:44:12 -06:00
|
|
|
if (ret < 0) {
|
2014-11-11 10:13:37 -07:00
|
|
|
dev_err(dev, "cannot claim IRQ for gadget\n");
|
2015-10-14 00:52:29 -06:00
|
|
|
return ret;
|
2014-09-09 02:44:12 -06:00
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:09 -06:00
|
|
|
/* hsotg->num_of_eps holds number of EPs other than ep0 */
|
|
|
|
|
|
|
|
if (hsotg->num_of_eps == 0) {
|
|
|
|
dev_err(dev, "wrong number of EPs (zero)\n");
|
2015-10-14 00:52:29 -06:00
|
|
|
return -EINVAL;
|
2012-05-04 06:17:09 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* setup endpoint information */
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&hsotg->gadget.ep_list);
|
2015-01-09 05:38:50 -07:00
|
|
|
hsotg->gadget.ep0 = &hsotg->eps_out[0]->ep;
|
2012-05-04 06:17:09 -06:00
|
|
|
|
|
|
|
/* allocate EP0 request */
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
hsotg->ctrl_req = dwc2_hsotg_ep_alloc_request(&hsotg->eps_out[0]->ep,
|
2012-05-04 06:17:09 -06:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!hsotg->ctrl_req) {
|
|
|
|
dev_err(dev, "failed to allocate ctrl req\n");
|
2015-10-14 00:52:29 -06:00
|
|
|
return -ENOMEM;
|
2012-05-04 06:17:09 -06:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
/* initialise the endpoints now the core has been initialised */
|
2015-01-09 05:38:50 -07:00
|
|
|
for (epnum = 0; epnum < hsotg->num_of_eps; epnum++) {
|
|
|
|
if (hsotg->eps_in[epnum])
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_initep(hsotg, hsotg->eps_in[epnum],
|
2017-01-17 21:30:27 -07:00
|
|
|
epnum, 1);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (hsotg->eps_out[epnum])
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_initep(hsotg, hsotg->eps_out[epnum],
|
2017-01-17 21:30:27 -07:00
|
|
|
epnum, 0);
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
2009-06-02 07:58:06 -06:00
|
|
|
|
2014-11-11 10:13:34 -07:00
|
|
|
ret = usb_add_gadget_udc(dev, &hsotg->gadget);
|
2011-06-28 07:33:47 -06:00
|
|
|
if (ret)
|
2015-10-14 00:52:29 -06:00
|
|
|
return ret;
|
2011-06-28 07:33:47 -06:00
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_dump(hsotg);
|
2009-06-02 07:58:06 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-04 06:17:11 -06:00
|
|
|
/**
|
2015-08-06 17:11:54 -06:00
|
|
|
* dwc2_hsotg_remove - remove function for hsotg driver
|
2012-05-04 06:17:11 -06:00
|
|
|
* @pdev: The platform information for the driver
|
|
|
|
*/
|
2015-08-06 17:11:54 -06:00
|
|
|
int dwc2_hsotg_remove(struct dwc2_hsotg *hsotg)
|
2009-06-02 07:58:06 -06:00
|
|
|
{
|
2011-06-28 07:33:47 -06:00
|
|
|
usb_del_gadget_udc(&hsotg->gadget);
|
2010-07-19 08:01:42 -06:00
|
|
|
|
2009-06-02 07:58:06 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
int dwc2_hsotg_suspend(struct dwc2_hsotg *hsotg)
|
2014-02-28 05:06:11 -07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2015-04-29 14:09:07 -06:00
|
|
|
if (hsotg->lx_state != DWC2_L0)
|
2015-10-14 00:52:29 -06:00
|
|
|
return 0;
|
2015-04-29 14:09:07 -06:00
|
|
|
|
2014-11-21 07:14:49 -07:00
|
|
|
if (hsotg->driver) {
|
|
|
|
int ep;
|
|
|
|
|
2014-02-28 05:06:11 -07:00
|
|
|
dev_info(hsotg->dev, "suspending usb gadget %s\n",
|
|
|
|
hsotg->driver->driver.name);
|
|
|
|
|
2014-11-21 07:14:49 -07:00
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
|
|
|
if (hsotg->enabled)
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_disconnect(hsotg);
|
|
|
|
dwc2_hsotg_disconnect(hsotg);
|
2014-11-21 07:14:49 -07:00
|
|
|
hsotg->gadget.speed = USB_SPEED_UNKNOWN;
|
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
2014-02-28 05:06:11 -07:00
|
|
|
|
2015-01-09 05:38:50 -07:00
|
|
|
for (ep = 0; ep < hsotg->num_of_eps; ep++) {
|
|
|
|
if (hsotg->eps_in[ep])
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ep_disable(&hsotg->eps_in[ep]->ep);
|
2015-01-09 05:38:50 -07:00
|
|
|
if (hsotg->eps_out[ep])
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_ep_disable(&hsotg->eps_out[ep]->ep);
|
2015-01-09 05:38:50 -07:00
|
|
|
}
|
2014-02-28 05:06:11 -07:00
|
|
|
}
|
|
|
|
|
2015-10-14 00:52:29 -06:00
|
|
|
return 0;
|
2014-02-28 05:06:11 -07:00
|
|
|
}
|
|
|
|
|
2015-08-06 17:11:54 -06:00
|
|
|
int dwc2_hsotg_resume(struct dwc2_hsotg *hsotg)
|
2014-02-28 05:06:11 -07:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2015-04-29 14:09:07 -06:00
|
|
|
if (hsotg->lx_state == DWC2_L2)
|
2015-10-14 00:52:29 -06:00
|
|
|
return 0;
|
2015-04-29 14:09:07 -06:00
|
|
|
|
2014-02-28 05:06:11 -07:00
|
|
|
if (hsotg->driver) {
|
|
|
|
dev_info(hsotg->dev, "resuming usb gadget %s\n",
|
|
|
|
hsotg->driver->driver.name);
|
2014-09-09 02:44:57 -06:00
|
|
|
|
2014-11-21 07:14:49 -07:00
|
|
|
spin_lock_irqsave(&hsotg->lock, flags);
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_init_disconnected(hsotg, false);
|
2018-01-24 06:40:29 -07:00
|
|
|
if (hsotg->enabled) {
|
|
|
|
/* Enable ACG feature in device mode,if supported */
|
|
|
|
dwc2_enable_acg(hsotg);
|
2015-08-06 17:11:54 -06:00
|
|
|
dwc2_hsotg_core_connect(hsotg);
|
2018-01-24 06:40:29 -07:00
|
|
|
}
|
2014-11-21 07:14:49 -07:00
|
|
|
spin_unlock_irqrestore(&hsotg->lock, flags);
|
|
|
|
}
|
2014-02-28 05:06:11 -07:00
|
|
|
|
2015-10-14 00:52:29 -06:00
|
|
|
return 0;
|
2014-02-28 05:06:11 -07:00
|
|
|
}
|
2016-02-23 20:54:57 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_backup_device_registers() - Backup controller device registers.
|
|
|
|
* When suspending usb bus, registers needs to be backuped
|
|
|
|
* if controller power is disabled once suspended.
|
|
|
|
*
|
|
|
|
* @hsotg: Programming view of the DWC_otg controller
|
|
|
|
*/
|
|
|
|
int dwc2_backup_device_registers(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
struct dwc2_dregs_backup *dr;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s\n", __func__);
|
|
|
|
|
|
|
|
/* Backup dev regs */
|
|
|
|
dr = &hsotg->dr_backup;
|
|
|
|
|
|
|
|
dr->dcfg = dwc2_readl(hsotg->regs + DCFG);
|
|
|
|
dr->dctl = dwc2_readl(hsotg->regs + DCTL);
|
|
|
|
dr->daintmsk = dwc2_readl(hsotg->regs + DAINTMSK);
|
|
|
|
dr->diepmsk = dwc2_readl(hsotg->regs + DIEPMSK);
|
|
|
|
dr->doepmsk = dwc2_readl(hsotg->regs + DOEPMSK);
|
|
|
|
|
|
|
|
for (i = 0; i < hsotg->num_of_eps; i++) {
|
|
|
|
/* Backup IN EPs */
|
|
|
|
dr->diepctl[i] = dwc2_readl(hsotg->regs + DIEPCTL(i));
|
|
|
|
|
|
|
|
/* Ensure DATA PID is correctly configured */
|
|
|
|
if (dr->diepctl[i] & DXEPCTL_DPID)
|
|
|
|
dr->diepctl[i] |= DXEPCTL_SETD1PID;
|
|
|
|
else
|
|
|
|
dr->diepctl[i] |= DXEPCTL_SETD0PID;
|
|
|
|
|
|
|
|
dr->dieptsiz[i] = dwc2_readl(hsotg->regs + DIEPTSIZ(i));
|
|
|
|
dr->diepdma[i] = dwc2_readl(hsotg->regs + DIEPDMA(i));
|
|
|
|
|
|
|
|
/* Backup OUT EPs */
|
|
|
|
dr->doepctl[i] = dwc2_readl(hsotg->regs + DOEPCTL(i));
|
|
|
|
|
|
|
|
/* Ensure DATA PID is correctly configured */
|
|
|
|
if (dr->doepctl[i] & DXEPCTL_DPID)
|
|
|
|
dr->doepctl[i] |= DXEPCTL_SETD1PID;
|
|
|
|
else
|
|
|
|
dr->doepctl[i] |= DXEPCTL_SETD0PID;
|
|
|
|
|
|
|
|
dr->doeptsiz[i] = dwc2_readl(hsotg->regs + DOEPTSIZ(i));
|
|
|
|
dr->doepdma[i] = dwc2_readl(hsotg->regs + DOEPDMA(i));
|
2018-02-16 03:07:33 -07:00
|
|
|
dr->dtxfsiz[i] = dwc2_readl(hsotg->regs + DPTXFSIZN(i));
|
2016-02-23 20:54:57 -07:00
|
|
|
}
|
|
|
|
dr->valid = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_restore_device_registers() - Restore controller device registers.
|
|
|
|
* When resuming usb bus, device registers needs to be restored
|
|
|
|
* if controller power were disabled.
|
|
|
|
*
|
|
|
|
* @hsotg: Programming view of the DWC_otg controller
|
2018-02-16 03:08:00 -07:00
|
|
|
* @remote_wakeup: Indicates whether resume is initiated by Device or Host.
|
|
|
|
*
|
|
|
|
* Return: 0 if successful, negative error code otherwise
|
2016-02-23 20:54:57 -07:00
|
|
|
*/
|
2018-02-16 03:08:00 -07:00
|
|
|
int dwc2_restore_device_registers(struct dwc2_hsotg *hsotg, int remote_wakeup)
|
2016-02-23 20:54:57 -07:00
|
|
|
{
|
|
|
|
struct dwc2_dregs_backup *dr;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dev_dbg(hsotg->dev, "%s\n", __func__);
|
|
|
|
|
|
|
|
/* Restore dev regs */
|
|
|
|
dr = &hsotg->dr_backup;
|
|
|
|
if (!dr->valid) {
|
|
|
|
dev_err(hsotg->dev, "%s: no device registers to restore\n",
|
|
|
|
__func__);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
dr->valid = false;
|
|
|
|
|
2018-02-16 03:08:00 -07:00
|
|
|
if (!remote_wakeup)
|
|
|
|
dwc2_writel(dr->dctl, hsotg->regs + DCTL);
|
|
|
|
|
2016-02-23 20:54:57 -07:00
|
|
|
dwc2_writel(dr->daintmsk, hsotg->regs + DAINTMSK);
|
|
|
|
dwc2_writel(dr->diepmsk, hsotg->regs + DIEPMSK);
|
|
|
|
dwc2_writel(dr->doepmsk, hsotg->regs + DOEPMSK);
|
|
|
|
|
|
|
|
for (i = 0; i < hsotg->num_of_eps; i++) {
|
|
|
|
/* Restore IN EPs */
|
|
|
|
dwc2_writel(dr->dieptsiz[i], hsotg->regs + DIEPTSIZ(i));
|
|
|
|
dwc2_writel(dr->diepdma[i], hsotg->regs + DIEPDMA(i));
|
2018-02-16 03:08:00 -07:00
|
|
|
dwc2_writel(dr->doeptsiz[i], hsotg->regs + DOEPTSIZ(i));
|
|
|
|
/** WA for enabled EPx's IN in DDMA mode. On entering to
|
|
|
|
* hibernation wrong value read and saved from DIEPDMAx,
|
|
|
|
* as result BNA interrupt asserted on hibernation exit
|
|
|
|
* by restoring from saved area.
|
|
|
|
*/
|
|
|
|
if (hsotg->params.g_dma_desc &&
|
|
|
|
(dr->diepctl[i] & DXEPCTL_EPENA))
|
|
|
|
dr->diepdma[i] = hsotg->eps_in[i]->desc_list_dma;
|
2018-02-16 03:07:33 -07:00
|
|
|
dwc2_writel(dr->dtxfsiz[i], hsotg->regs + DPTXFSIZN(i));
|
2018-02-16 03:08:00 -07:00
|
|
|
dwc2_writel(dr->diepctl[i], hsotg->regs + DIEPCTL(i));
|
2016-02-23 20:54:57 -07:00
|
|
|
/* Restore OUT EPs */
|
|
|
|
dwc2_writel(dr->doeptsiz[i], hsotg->regs + DOEPTSIZ(i));
|
2018-02-16 03:08:00 -07:00
|
|
|
/* WA for enabled EPx's OUT in DDMA mode. On entering to
|
|
|
|
* hibernation wrong value read and saved from DOEPDMAx,
|
|
|
|
* as result BNA interrupt asserted on hibernation exit
|
|
|
|
* by restoring from saved area.
|
|
|
|
*/
|
|
|
|
if (hsotg->params.g_dma_desc &&
|
|
|
|
(dr->doepctl[i] & DXEPCTL_EPENA))
|
|
|
|
dr->doepdma[i] = hsotg->eps_out[i]->desc_list_dma;
|
2016-02-23 20:54:57 -07:00
|
|
|
dwc2_writel(dr->doepdma[i], hsotg->regs + DOEPDMA(i));
|
2018-02-16 03:08:00 -07:00
|
|
|
dwc2_writel(dr->doepctl[i], hsotg->regs + DOEPCTL(i));
|
2016-02-23 20:54:57 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2018-01-24 06:43:32 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_gadget_init_lpm - Configure the core to support LPM in device mode
|
|
|
|
*
|
|
|
|
* @hsotg: Programming view of DWC_otg controller
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
void dwc2_gadget_init_lpm(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
u32 val;
|
|
|
|
|
|
|
|
if (!hsotg->params.lpm)
|
|
|
|
return;
|
|
|
|
|
|
|
|
val = GLPMCFG_LPMCAP | GLPMCFG_APPL1RES;
|
|
|
|
val |= hsotg->params.hird_threshold_en ? GLPMCFG_HIRD_THRES_EN : 0;
|
|
|
|
val |= hsotg->params.lpm_clock_gating ? GLPMCFG_ENBLSLPM : 0;
|
|
|
|
val |= hsotg->params.hird_threshold << GLPMCFG_HIRD_THRES_SHIFT;
|
|
|
|
val |= hsotg->params.besl ? GLPMCFG_ENBESL : 0;
|
|
|
|
dwc2_writel(val, hsotg->regs + GLPMCFG);
|
|
|
|
dev_dbg(hsotg->dev, "GLPMCFG=0x%08x\n", dwc2_readl(hsotg->regs
|
|
|
|
+ GLPMCFG));
|
|
|
|
}
|
2018-02-16 03:10:13 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_gadget_enter_hibernation() - Put controller in Hibernation.
|
|
|
|
*
|
|
|
|
* @hsotg: Programming view of the DWC_otg controller
|
|
|
|
*
|
|
|
|
* Return non-zero if failed to enter to hibernation.
|
|
|
|
*/
|
|
|
|
int dwc2_gadget_enter_hibernation(struct dwc2_hsotg *hsotg)
|
|
|
|
{
|
|
|
|
u32 gpwrdn;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
/* Change to L2(suspend) state */
|
|
|
|
hsotg->lx_state = DWC2_L2;
|
|
|
|
dev_dbg(hsotg->dev, "Start of hibernation completed\n");
|
|
|
|
ret = dwc2_backup_global_registers(hsotg);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev, "%s: failed to backup global registers\n",
|
|
|
|
__func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
ret = dwc2_backup_device_registers(hsotg);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev, "%s: failed to backup device registers\n",
|
|
|
|
__func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
gpwrdn = GPWRDN_PWRDNRSTN;
|
|
|
|
gpwrdn |= GPWRDN_PMUACTV;
|
|
|
|
dwc2_writel(gpwrdn, hsotg->regs + GPWRDN);
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
/* Set flag to indicate that we are in hibernation */
|
|
|
|
hsotg->hibernated = 1;
|
|
|
|
|
|
|
|
/* Enable interrupts from wake up logic */
|
|
|
|
gpwrdn = dwc2_readl(hsotg->regs + GPWRDN);
|
|
|
|
gpwrdn |= GPWRDN_PMUINTSEL;
|
|
|
|
dwc2_writel(gpwrdn, hsotg->regs + GPWRDN);
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
/* Unmask device mode interrupts in GPWRDN */
|
|
|
|
gpwrdn = dwc2_readl(hsotg->regs + GPWRDN);
|
|
|
|
gpwrdn |= GPWRDN_RST_DET_MSK;
|
|
|
|
gpwrdn |= GPWRDN_LNSTSCHG_MSK;
|
|
|
|
gpwrdn |= GPWRDN_STS_CHGINT_MSK;
|
|
|
|
dwc2_writel(gpwrdn, hsotg->regs + GPWRDN);
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
/* Enable Power Down Clamp */
|
|
|
|
gpwrdn = dwc2_readl(hsotg->regs + GPWRDN);
|
|
|
|
gpwrdn |= GPWRDN_PWRDNCLMP;
|
|
|
|
dwc2_writel(gpwrdn, hsotg->regs + GPWRDN);
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
/* Switch off VDD */
|
|
|
|
gpwrdn = dwc2_readl(hsotg->regs + GPWRDN);
|
|
|
|
gpwrdn |= GPWRDN_PWRDNSWTCH;
|
|
|
|
dwc2_writel(gpwrdn, hsotg->regs + GPWRDN);
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
/* Save gpwrdn register for further usage if stschng interrupt */
|
|
|
|
hsotg->gr_backup.gpwrdn = dwc2_readl(hsotg->regs + GPWRDN);
|
|
|
|
dev_dbg(hsotg->dev, "Hibernation completed\n");
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dwc2_gadget_exit_hibernation()
|
|
|
|
* This function is for exiting from Device mode hibernation by host initiated
|
|
|
|
* resume/reset and device initiated remote-wakeup.
|
|
|
|
*
|
|
|
|
* @hsotg: Programming view of the DWC_otg controller
|
|
|
|
* @rem_wakeup: indicates whether resume is initiated by Device or Host.
|
|
|
|
* @param reset: indicates whether resume is initiated by Reset.
|
|
|
|
*
|
|
|
|
* Return non-zero if failed to exit from hibernation.
|
|
|
|
*/
|
|
|
|
int dwc2_gadget_exit_hibernation(struct dwc2_hsotg *hsotg,
|
|
|
|
int rem_wakeup, int reset)
|
|
|
|
{
|
|
|
|
u32 pcgcctl;
|
|
|
|
u32 gpwrdn;
|
|
|
|
u32 dctl;
|
|
|
|
int ret = 0;
|
|
|
|
struct dwc2_gregs_backup *gr;
|
|
|
|
struct dwc2_dregs_backup *dr;
|
|
|
|
|
|
|
|
gr = &hsotg->gr_backup;
|
|
|
|
dr = &hsotg->dr_backup;
|
|
|
|
|
|
|
|
if (!hsotg->hibernated) {
|
|
|
|
dev_dbg(hsotg->dev, "Already exited from Hibernation\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
dev_dbg(hsotg->dev,
|
|
|
|
"%s: called with rem_wakeup = %d reset = %d\n",
|
|
|
|
__func__, rem_wakeup, reset);
|
|
|
|
|
|
|
|
dwc2_hib_restore_common(hsotg, rem_wakeup, 0);
|
|
|
|
|
|
|
|
if (!reset) {
|
|
|
|
/* Clear all pending interupts */
|
|
|
|
dwc2_writel(0xffffffff, hsotg->regs + GINTSTS);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* De-assert Restore */
|
|
|
|
gpwrdn = dwc2_readl(hsotg->regs + GPWRDN);
|
|
|
|
gpwrdn &= ~GPWRDN_RESTORE;
|
|
|
|
dwc2_writel(gpwrdn, hsotg->regs + GPWRDN);
|
|
|
|
udelay(10);
|
|
|
|
|
|
|
|
if (!rem_wakeup) {
|
|
|
|
pcgcctl = dwc2_readl(hsotg->regs + PCGCTL);
|
|
|
|
pcgcctl &= ~PCGCTL_RSTPDWNMODULE;
|
|
|
|
dwc2_writel(pcgcctl, hsotg->regs + PCGCTL);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore GUSBCFG, DCFG and DCTL */
|
|
|
|
dwc2_writel(gr->gusbcfg, hsotg->regs + GUSBCFG);
|
|
|
|
dwc2_writel(dr->dcfg, hsotg->regs + DCFG);
|
|
|
|
dwc2_writel(dr->dctl, hsotg->regs + DCTL);
|
|
|
|
|
|
|
|
/* De-assert Wakeup Logic */
|
|
|
|
gpwrdn = dwc2_readl(hsotg->regs + GPWRDN);
|
|
|
|
gpwrdn &= ~GPWRDN_PMUACTV;
|
|
|
|
dwc2_writel(gpwrdn, hsotg->regs + GPWRDN);
|
|
|
|
|
|
|
|
if (rem_wakeup) {
|
|
|
|
udelay(10);
|
|
|
|
/* Start Remote Wakeup Signaling */
|
|
|
|
dwc2_writel(dr->dctl | DCTL_RMTWKUPSIG, hsotg->regs + DCTL);
|
|
|
|
} else {
|
|
|
|
udelay(50);
|
|
|
|
/* Set Device programming done bit */
|
|
|
|
dctl = dwc2_readl(hsotg->regs + DCTL);
|
|
|
|
dctl |= DCTL_PWRONPRGDONE;
|
|
|
|
dwc2_writel(dctl, hsotg->regs + DCTL);
|
|
|
|
}
|
|
|
|
/* Wait for interrupts which must be cleared */
|
|
|
|
mdelay(2);
|
|
|
|
/* Clear all pending interupts */
|
|
|
|
dwc2_writel(0xffffffff, hsotg->regs + GINTSTS);
|
|
|
|
|
|
|
|
/* Restore global registers */
|
|
|
|
ret = dwc2_restore_global_registers(hsotg);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev, "%s: failed to restore registers\n",
|
|
|
|
__func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Restore device registers */
|
|
|
|
ret = dwc2_restore_device_registers(hsotg, rem_wakeup);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(hsotg->dev, "%s: failed to restore device registers\n",
|
|
|
|
__func__);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rem_wakeup) {
|
|
|
|
mdelay(10);
|
|
|
|
dctl = dwc2_readl(hsotg->regs + DCTL);
|
|
|
|
dctl &= ~DCTL_RMTWKUPSIG;
|
|
|
|
dwc2_writel(dctl, hsotg->regs + DCTL);
|
|
|
|
}
|
|
|
|
|
|
|
|
hsotg->hibernated = 0;
|
|
|
|
hsotg->lx_state = DWC2_L0;
|
|
|
|
dev_dbg(hsotg->dev, "Hibernation recovery completes here\n");
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|