2008-04-27 08:59:45 +02:00
|
|
|
/*
|
|
|
|
* c67x00-sched.c: Cypress C67X00 USB Host Controller Driver - TD scheduling
|
|
|
|
*
|
|
|
|
* Copyright (C) 2006-2008 Barco N.V.
|
|
|
|
* Derived from the Cypress cy7c67200/300 ezusb linux driver and
|
|
|
|
* based on multiple host controller drivers inside the linux kernel.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
|
|
* MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kthread.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 09:04:11 +01:00
|
|
|
#include <linux/slab.h>
|
2008-04-27 08:59:45 +02:00
|
|
|
|
|
|
|
#include "c67x00.h"
|
|
|
|
#include "c67x00-hcd.h"
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These are the stages for a control urb, they are kept
|
|
|
|
* in both urb->interval and td->privdata.
|
|
|
|
*/
|
|
|
|
#define SETUP_STAGE 0
|
|
|
|
#define DATA_STAGE 1
|
|
|
|
#define STATUS_STAGE 2
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct c67x00_ep_data: Host endpoint data structure
|
|
|
|
*/
|
|
|
|
struct c67x00_ep_data {
|
|
|
|
struct list_head queue;
|
|
|
|
struct list_head node;
|
|
|
|
struct usb_host_endpoint *hep;
|
|
|
|
struct usb_device *dev;
|
|
|
|
u16 next_frame; /* For int/isoc transactions */
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* struct c67x00_td
|
|
|
|
*
|
|
|
|
* Hardware parts are little endiannes, SW in CPU endianess.
|
|
|
|
*/
|
|
|
|
struct c67x00_td {
|
|
|
|
/* HW specific part */
|
|
|
|
__le16 ly_base_addr; /* Bytes 0-1 */
|
|
|
|
__le16 port_length; /* Bytes 2-3 */
|
|
|
|
u8 pid_ep; /* Byte 4 */
|
|
|
|
u8 dev_addr; /* Byte 5 */
|
|
|
|
u8 ctrl_reg; /* Byte 6 */
|
|
|
|
u8 status; /* Byte 7 */
|
|
|
|
u8 retry_cnt; /* Byte 8 */
|
|
|
|
#define TT_OFFSET 2
|
|
|
|
#define TT_CONTROL 0
|
|
|
|
#define TT_ISOCHRONOUS 1
|
|
|
|
#define TT_BULK 2
|
|
|
|
#define TT_INTERRUPT 3
|
|
|
|
u8 residue; /* Byte 9 */
|
|
|
|
__le16 next_td_addr; /* Bytes 10-11 */
|
|
|
|
/* SW part */
|
|
|
|
struct list_head td_list;
|
|
|
|
u16 td_addr;
|
|
|
|
void *data;
|
|
|
|
struct urb *urb;
|
|
|
|
unsigned long privdata;
|
|
|
|
|
|
|
|
/* These are needed for handling the toggle bits:
|
|
|
|
* an urb can be dequeued while a td is in progress
|
|
|
|
* after checking the td, the toggle bit might need to
|
|
|
|
* be fixed */
|
|
|
|
struct c67x00_ep_data *ep_data;
|
|
|
|
unsigned int pipe;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct c67x00_urb_priv {
|
|
|
|
struct list_head hep_node;
|
|
|
|
struct urb *urb;
|
|
|
|
int port;
|
|
|
|
int cnt; /* packet number for isoc */
|
|
|
|
int status;
|
|
|
|
struct c67x00_ep_data *ep_data;
|
|
|
|
};
|
|
|
|
|
|
|
|
#define td_udev(td) ((td)->ep_data->dev)
|
|
|
|
|
|
|
|
#define CY_TD_SIZE 12
|
|
|
|
|
|
|
|
#define TD_PIDEP_OFFSET 0x04
|
|
|
|
#define TD_PIDEPMASK_PID 0xF0
|
|
|
|
#define TD_PIDEPMASK_EP 0x0F
|
|
|
|
#define TD_PORTLENMASK_DL 0x02FF
|
|
|
|
#define TD_PORTLENMASK_PN 0xC000
|
|
|
|
|
|
|
|
#define TD_STATUS_OFFSET 0x07
|
|
|
|
#define TD_STATUSMASK_ACK 0x01
|
|
|
|
#define TD_STATUSMASK_ERR 0x02
|
|
|
|
#define TD_STATUSMASK_TMOUT 0x04
|
|
|
|
#define TD_STATUSMASK_SEQ 0x08
|
|
|
|
#define TD_STATUSMASK_SETUP 0x10
|
|
|
|
#define TD_STATUSMASK_OVF 0x20
|
|
|
|
#define TD_STATUSMASK_NAK 0x40
|
|
|
|
#define TD_STATUSMASK_STALL 0x80
|
|
|
|
|
|
|
|
#define TD_ERROR_MASK (TD_STATUSMASK_ERR | TD_STATUSMASK_TMOUT | \
|
|
|
|
TD_STATUSMASK_STALL)
|
|
|
|
|
|
|
|
#define TD_RETRYCNT_OFFSET 0x08
|
|
|
|
#define TD_RETRYCNTMASK_ACT_FLG 0x10
|
|
|
|
#define TD_RETRYCNTMASK_TX_TYPE 0x0C
|
|
|
|
#define TD_RETRYCNTMASK_RTY_CNT 0x03
|
|
|
|
|
|
|
|
#define TD_RESIDUE_OVERFLOW 0x80
|
|
|
|
|
|
|
|
#define TD_PID_IN 0x90
|
|
|
|
|
|
|
|
/* Residue: signed 8bits, neg -> OVERFLOW, pos -> UNDERFLOW */
|
|
|
|
#define td_residue(td) ((__s8)(td->residue))
|
|
|
|
#define td_ly_base_addr(td) (__le16_to_cpu((td)->ly_base_addr))
|
|
|
|
#define td_port_length(td) (__le16_to_cpu((td)->port_length))
|
|
|
|
#define td_next_td_addr(td) (__le16_to_cpu((td)->next_td_addr))
|
|
|
|
|
|
|
|
#define td_active(td) ((td)->retry_cnt & TD_RETRYCNTMASK_ACT_FLG)
|
|
|
|
#define td_length(td) (td_port_length(td) & TD_PORTLENMASK_DL)
|
|
|
|
|
|
|
|
#define td_sequence_ok(td) (!td->status || \
|
|
|
|
(!(td->status & TD_STATUSMASK_SEQ) == \
|
|
|
|
!(td->ctrl_reg & SEQ_SEL)))
|
|
|
|
|
|
|
|
#define td_acked(td) (!td->status || \
|
|
|
|
(td->status & TD_STATUSMASK_ACK))
|
|
|
|
#define td_actual_bytes(td) (td_length(td) - td_residue(td))
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
|
|
|
|
/**
|
|
|
|
* dbg_td - Dump the contents of the TD
|
|
|
|
*/
|
|
|
|
static void dbg_td(struct c67x00_hcd *c67x00, struct c67x00_td *td, char *msg)
|
|
|
|
{
|
|
|
|
struct device *dev = c67x00_hcd_dev(c67x00);
|
|
|
|
|
|
|
|
dev_dbg(dev, "### %s at 0x%04x\n", msg, td->td_addr);
|
|
|
|
dev_dbg(dev, "urb: 0x%p\n", td->urb);
|
|
|
|
dev_dbg(dev, "endpoint: %4d\n", usb_pipeendpoint(td->pipe));
|
|
|
|
dev_dbg(dev, "pipeout: %4d\n", usb_pipeout(td->pipe));
|
|
|
|
dev_dbg(dev, "ly_base_addr: 0x%04x\n", td_ly_base_addr(td));
|
|
|
|
dev_dbg(dev, "port_length: 0x%04x\n", td_port_length(td));
|
|
|
|
dev_dbg(dev, "pid_ep: 0x%02x\n", td->pid_ep);
|
|
|
|
dev_dbg(dev, "dev_addr: 0x%02x\n", td->dev_addr);
|
|
|
|
dev_dbg(dev, "ctrl_reg: 0x%02x\n", td->ctrl_reg);
|
|
|
|
dev_dbg(dev, "status: 0x%02x\n", td->status);
|
|
|
|
dev_dbg(dev, "retry_cnt: 0x%02x\n", td->retry_cnt);
|
|
|
|
dev_dbg(dev, "residue: 0x%02x\n", td->residue);
|
|
|
|
dev_dbg(dev, "next_td_addr: 0x%04x\n", td_next_td_addr(td));
|
|
|
|
dev_dbg(dev, "data:");
|
|
|
|
print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 16, 1,
|
|
|
|
td->data, td_length(td), 1);
|
|
|
|
}
|
|
|
|
#else /* DEBUG */
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
dbg_td(struct c67x00_hcd *c67x00, struct c67x00_td *td, char *msg) { }
|
|
|
|
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
/* Helper functions */
|
|
|
|
|
|
|
|
static inline u16 c67x00_get_current_frame_number(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
return c67x00_ll_husb_get_frame(c67x00->sie) & HOST_FRAME_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* frame_add
|
|
|
|
* Software wraparound for framenumbers.
|
|
|
|
*/
|
|
|
|
static inline u16 frame_add(u16 a, u16 b)
|
|
|
|
{
|
|
|
|
return (a + b) & HOST_FRAME_MASK;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* frame_after - is frame a after frame b
|
|
|
|
*/
|
|
|
|
static inline int frame_after(u16 a, u16 b)
|
|
|
|
{
|
|
|
|
return ((HOST_FRAME_MASK + a - b) & HOST_FRAME_MASK) <
|
|
|
|
(HOST_FRAME_MASK / 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* frame_after_eq - is frame a after or equal to frame b
|
|
|
|
*/
|
|
|
|
static inline int frame_after_eq(u16 a, u16 b)
|
|
|
|
{
|
|
|
|
return ((HOST_FRAME_MASK + 1 + a - b) & HOST_FRAME_MASK) <
|
|
|
|
(HOST_FRAME_MASK / 2);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* c67x00_release_urb - remove link from all tds to this urb
|
|
|
|
* Disconnects the urb from it's tds, so that it can be given back.
|
|
|
|
* pre: urb->hcpriv != NULL
|
|
|
|
*/
|
|
|
|
static void c67x00_release_urb(struct c67x00_hcd *c67x00, struct urb *urb)
|
|
|
|
{
|
|
|
|
struct c67x00_td *td;
|
|
|
|
struct c67x00_urb_priv *urbp;
|
|
|
|
|
|
|
|
BUG_ON(!urb);
|
|
|
|
|
|
|
|
c67x00->urb_count--;
|
|
|
|
|
|
|
|
if (usb_pipetype(urb->pipe) == PIPE_ISOCHRONOUS) {
|
|
|
|
c67x00->urb_iso_count--;
|
|
|
|
if (c67x00->urb_iso_count == 0)
|
|
|
|
c67x00->max_frame_bw = MAX_FRAME_BW_STD;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO this might be not so efficient when we've got many urbs!
|
|
|
|
* Alternatives:
|
|
|
|
* * only clear when needed
|
|
|
|
* * keep a list of tds with each urbp
|
|
|
|
*/
|
|
|
|
list_for_each_entry(td, &c67x00->td_list, td_list)
|
|
|
|
if (urb == td->urb)
|
|
|
|
td->urb = NULL;
|
|
|
|
|
|
|
|
urbp = urb->hcpriv;
|
|
|
|
urb->hcpriv = NULL;
|
|
|
|
list_del(&urbp->hep_node);
|
|
|
|
kfree(urbp);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static struct c67x00_ep_data *
|
|
|
|
c67x00_ep_data_alloc(struct c67x00_hcd *c67x00, struct urb *urb)
|
|
|
|
{
|
|
|
|
struct usb_host_endpoint *hep = urb->ep;
|
|
|
|
struct c67x00_ep_data *ep_data;
|
|
|
|
int type;
|
|
|
|
|
|
|
|
c67x00->current_frame = c67x00_get_current_frame_number(c67x00);
|
|
|
|
|
|
|
|
/* Check if endpoint already has a c67x00_ep_data struct allocated */
|
|
|
|
if (hep->hcpriv) {
|
|
|
|
ep_data = hep->hcpriv;
|
|
|
|
if (frame_after(c67x00->current_frame, ep_data->next_frame))
|
|
|
|
ep_data->next_frame =
|
|
|
|
frame_add(c67x00->current_frame, 1);
|
|
|
|
return hep->hcpriv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Allocate and initialize a new c67x00 endpoint data structure */
|
|
|
|
ep_data = kzalloc(sizeof(*ep_data), GFP_ATOMIC);
|
|
|
|
if (!ep_data)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&ep_data->queue);
|
|
|
|
INIT_LIST_HEAD(&ep_data->node);
|
|
|
|
ep_data->hep = hep;
|
|
|
|
|
|
|
|
/* hold a reference to udev as long as this endpoint lives,
|
|
|
|
* this is needed to possibly fix the data toggle */
|
|
|
|
ep_data->dev = usb_get_dev(urb->dev);
|
|
|
|
hep->hcpriv = ep_data;
|
|
|
|
|
|
|
|
/* For ISOC and INT endpoints, start ASAP: */
|
|
|
|
ep_data->next_frame = frame_add(c67x00->current_frame, 1);
|
|
|
|
|
|
|
|
/* Add the endpoint data to one of the pipe lists; must be added
|
|
|
|
in order of endpoint address */
|
|
|
|
type = usb_pipetype(urb->pipe);
|
|
|
|
if (list_empty(&ep_data->node)) {
|
|
|
|
list_add(&ep_data->node, &c67x00->list[type]);
|
|
|
|
} else {
|
|
|
|
struct c67x00_ep_data *prev;
|
|
|
|
|
|
|
|
list_for_each_entry(prev, &c67x00->list[type], node) {
|
|
|
|
if (prev->hep->desc.bEndpointAddress >
|
|
|
|
hep->desc.bEndpointAddress) {
|
|
|
|
list_add(&ep_data->node, prev->node.prev);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return ep_data;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int c67x00_ep_data_free(struct usb_host_endpoint *hep)
|
|
|
|
{
|
|
|
|
struct c67x00_ep_data *ep_data = hep->hcpriv;
|
|
|
|
|
|
|
|
if (!ep_data)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (!list_empty(&ep_data->queue))
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
usb_put_dev(ep_data->dev);
|
|
|
|
list_del(&ep_data->queue);
|
|
|
|
list_del(&ep_data->node);
|
|
|
|
|
|
|
|
kfree(ep_data);
|
|
|
|
hep->hcpriv = NULL;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void c67x00_endpoint_disable(struct usb_hcd *hcd, struct usb_host_endpoint *ep)
|
|
|
|
{
|
|
|
|
struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (!list_empty(&ep->urb_list))
|
|
|
|
dev_warn(c67x00_hcd_dev(c67x00), "error: urb list not empty\n");
|
|
|
|
|
|
|
|
spin_lock_irqsave(&c67x00->lock, flags);
|
|
|
|
|
|
|
|
/* loop waiting for all transfers in the endpoint queue to complete */
|
|
|
|
while (c67x00_ep_data_free(ep)) {
|
|
|
|
/* Drop the lock so we can sleep waiting for the hardware */
|
|
|
|
spin_unlock_irqrestore(&c67x00->lock, flags);
|
|
|
|
|
|
|
|
/* it could happen that we reinitialize this completion, while
|
|
|
|
* somebody was waiting for that completion. The timeout and
|
|
|
|
* while loop handle such cases, but this might be improved */
|
|
|
|
INIT_COMPLETION(c67x00->endpoint_disable);
|
|
|
|
c67x00_sched_kick(c67x00);
|
|
|
|
wait_for_completion_timeout(&c67x00->endpoint_disable, 1 * HZ);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&c67x00->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&c67x00->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static inline int get_root_port(struct usb_device *dev)
|
|
|
|
{
|
|
|
|
while (dev->parent->parent)
|
|
|
|
dev = dev->parent;
|
|
|
|
return dev->portnum;
|
|
|
|
}
|
|
|
|
|
|
|
|
int c67x00_urb_enqueue(struct usb_hcd *hcd,
|
|
|
|
struct urb *urb, gfp_t mem_flags)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
unsigned long flags;
|
|
|
|
struct c67x00_urb_priv *urbp;
|
|
|
|
struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
|
|
|
|
int port = get_root_port(urb->dev)-1;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&c67x00->lock, flags);
|
|
|
|
|
|
|
|
/* Make sure host controller is running */
|
|
|
|
if (!HC_IS_RUNNING(hcd->state)) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto err_not_linked;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = usb_hcd_link_urb_to_ep(hcd, urb);
|
|
|
|
if (ret)
|
|
|
|
goto err_not_linked;
|
|
|
|
|
|
|
|
/* Allocate and initialize urb private data */
|
|
|
|
urbp = kzalloc(sizeof(*urbp), mem_flags);
|
|
|
|
if (!urbp) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_urbp;
|
|
|
|
}
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&urbp->hep_node);
|
|
|
|
urbp->urb = urb;
|
|
|
|
urbp->port = port;
|
|
|
|
|
|
|
|
urbp->ep_data = c67x00_ep_data_alloc(c67x00, urb);
|
|
|
|
|
|
|
|
if (!urbp->ep_data) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto err_epdata;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* TODO claim bandwidth with usb_claim_bandwidth?
|
|
|
|
* also release it somewhere! */
|
|
|
|
|
|
|
|
urb->hcpriv = urbp;
|
|
|
|
|
|
|
|
urb->actual_length = 0; /* Nothing received/transmitted yet */
|
|
|
|
|
|
|
|
switch (usb_pipetype(urb->pipe)) {
|
|
|
|
case PIPE_CONTROL:
|
|
|
|
urb->interval = SETUP_STAGE;
|
|
|
|
break;
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
break;
|
|
|
|
case PIPE_BULK:
|
|
|
|
break;
|
|
|
|
case PIPE_ISOCHRONOUS:
|
|
|
|
if (c67x00->urb_iso_count == 0)
|
|
|
|
c67x00->max_frame_bw = MAX_FRAME_BW_ISO;
|
|
|
|
c67x00->urb_iso_count++;
|
|
|
|
/* Assume always URB_ISO_ASAP, FIXME */
|
|
|
|
if (list_empty(&urbp->ep_data->queue))
|
|
|
|
urb->start_frame = urbp->ep_data->next_frame;
|
|
|
|
else {
|
|
|
|
/* Go right after the last one */
|
|
|
|
struct urb *last_urb;
|
|
|
|
|
|
|
|
last_urb = list_entry(urbp->ep_data->queue.prev,
|
|
|
|
struct c67x00_urb_priv,
|
|
|
|
hep_node)->urb;
|
|
|
|
urb->start_frame =
|
|
|
|
frame_add(last_urb->start_frame,
|
|
|
|
last_urb->number_of_packets *
|
|
|
|
last_urb->interval);
|
|
|
|
}
|
|
|
|
urbp->cnt = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add the URB to the endpoint queue */
|
|
|
|
list_add_tail(&urbp->hep_node, &urbp->ep_data->queue);
|
|
|
|
|
|
|
|
/* If this is the only URB, kick start the controller */
|
|
|
|
if (!c67x00->urb_count++)
|
|
|
|
c67x00_ll_hpi_enable_sofeop(c67x00->sie);
|
|
|
|
|
|
|
|
c67x00_sched_kick(c67x00);
|
|
|
|
spin_unlock_irqrestore(&c67x00->lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_epdata:
|
|
|
|
kfree(urbp);
|
|
|
|
err_urbp:
|
|
|
|
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
|
|
|
err_not_linked:
|
|
|
|
spin_unlock_irqrestore(&c67x00->lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int c67x00_urb_dequeue(struct usb_hcd *hcd, struct urb *urb, int status)
|
|
|
|
{
|
|
|
|
struct c67x00_hcd *c67x00 = hcd_to_c67x00_hcd(hcd);
|
|
|
|
unsigned long flags;
|
|
|
|
int rc;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&c67x00->lock, flags);
|
|
|
|
rc = usb_hcd_check_unlink_urb(hcd, urb, status);
|
|
|
|
if (rc)
|
|
|
|
goto done;
|
|
|
|
|
|
|
|
c67x00_release_urb(c67x00, urb);
|
|
|
|
usb_hcd_unlink_urb_from_ep(hcd, urb);
|
|
|
|
|
|
|
|
spin_unlock(&c67x00->lock);
|
|
|
|
usb_hcd_giveback_urb(hcd, urb, status);
|
|
|
|
spin_lock(&c67x00->lock);
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&c67x00->lock, flags);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
done:
|
|
|
|
spin_unlock_irqrestore(&c67x00->lock, flags);
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* pre: c67x00 locked, urb unlocked
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
c67x00_giveback_urb(struct c67x00_hcd *c67x00, struct urb *urb, int status)
|
|
|
|
{
|
|
|
|
struct c67x00_urb_priv *urbp;
|
|
|
|
|
|
|
|
if (!urb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
urbp = urb->hcpriv;
|
|
|
|
urbp->status = status;
|
|
|
|
|
|
|
|
list_del_init(&urbp->hep_node);
|
|
|
|
|
|
|
|
c67x00_release_urb(c67x00, urb);
|
|
|
|
usb_hcd_unlink_urb_from_ep(c67x00_hcd_to_hcd(c67x00), urb);
|
|
|
|
spin_unlock(&c67x00->lock);
|
|
|
|
usb_hcd_giveback_urb(c67x00_hcd_to_hcd(c67x00), urb, urbp->status);
|
|
|
|
spin_lock(&c67x00->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int c67x00_claim_frame_bw(struct c67x00_hcd *c67x00, struct urb *urb,
|
|
|
|
int len, int periodic)
|
|
|
|
{
|
|
|
|
struct c67x00_urb_priv *urbp = urb->hcpriv;
|
|
|
|
int bit_time;
|
|
|
|
|
|
|
|
/* According to the C67x00 BIOS user manual, page 3-18,19, the
|
|
|
|
* following calculations provide the full speed bit times for
|
|
|
|
* a transaction.
|
|
|
|
*
|
|
|
|
* FS(in) = 112.5 + 9.36*BC + HOST_DELAY
|
|
|
|
* FS(in,iso) = 90.5 + 9.36*BC + HOST_DELAY
|
|
|
|
* FS(out) = 112.5 + 9.36*BC + HOST_DELAY
|
|
|
|
* FS(out,iso) = 78.4 + 9.36*BC + HOST_DELAY
|
|
|
|
* LS(in) = 802.4 + 75.78*BC + HOST_DELAY
|
|
|
|
* LS(out) = 802.6 + 74.67*BC + HOST_DELAY
|
|
|
|
*
|
|
|
|
* HOST_DELAY == 106 for the c67200 and c67300.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* make calculations in 1/100 bit times to maintain resolution */
|
|
|
|
if (urbp->ep_data->dev->speed == USB_SPEED_LOW) {
|
|
|
|
/* Low speed pipe */
|
|
|
|
if (usb_pipein(urb->pipe))
|
|
|
|
bit_time = 80240 + 7578*len;
|
|
|
|
else
|
|
|
|
bit_time = 80260 + 7467*len;
|
|
|
|
} else {
|
|
|
|
/* FS pipes */
|
|
|
|
if (usb_pipeisoc(urb->pipe))
|
|
|
|
bit_time = usb_pipein(urb->pipe) ? 9050 : 7840;
|
|
|
|
else
|
|
|
|
bit_time = 11250;
|
|
|
|
bit_time += 936*len;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Scale back down to integer bit times. Use a host delay of 106.
|
|
|
|
* (this is the only place it is used) */
|
|
|
|
bit_time = ((bit_time+50) / 100) + 106;
|
|
|
|
|
|
|
|
if (unlikely(bit_time + c67x00->bandwidth_allocated >=
|
|
|
|
c67x00->max_frame_bw))
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
if (unlikely(c67x00->next_td_addr + CY_TD_SIZE >=
|
|
|
|
c67x00->td_base_addr + SIE_TD_SIZE))
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
if (unlikely(c67x00->next_buf_addr + len >=
|
|
|
|
c67x00->buf_base_addr + SIE_TD_BUF_SIZE))
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
if (periodic) {
|
|
|
|
if (unlikely(bit_time + c67x00->periodic_bw_allocated >=
|
|
|
|
MAX_PERIODIC_BW(c67x00->max_frame_bw)))
|
|
|
|
return -EMSGSIZE;
|
|
|
|
c67x00->periodic_bw_allocated += bit_time;
|
|
|
|
}
|
|
|
|
|
|
|
|
c67x00->bandwidth_allocated += bit_time;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* td_addr and buf_addr must be word aligned
|
|
|
|
*/
|
|
|
|
static int c67x00_create_td(struct c67x00_hcd *c67x00, struct urb *urb,
|
|
|
|
void *data, int len, int pid, int toggle,
|
|
|
|
unsigned long privdata)
|
|
|
|
{
|
|
|
|
struct c67x00_td *td;
|
|
|
|
struct c67x00_urb_priv *urbp = urb->hcpriv;
|
|
|
|
const __u8 active_flag = 1, retry_cnt = 1;
|
|
|
|
__u8 cmd = 0;
|
|
|
|
int tt = 0;
|
|
|
|
|
|
|
|
if (c67x00_claim_frame_bw(c67x00, urb, len, usb_pipeisoc(urb->pipe)
|
|
|
|
|| usb_pipeint(urb->pipe)))
|
|
|
|
return -EMSGSIZE; /* Not really an error, but expected */
|
|
|
|
|
|
|
|
td = kzalloc(sizeof(*td), GFP_ATOMIC);
|
|
|
|
if (!td)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
td->pipe = urb->pipe;
|
|
|
|
td->ep_data = urbp->ep_data;
|
|
|
|
|
|
|
|
if ((td_udev(td)->speed == USB_SPEED_LOW) &&
|
|
|
|
!(c67x00->low_speed_ports & (1 << urbp->port)))
|
|
|
|
cmd |= PREAMBLE_EN;
|
|
|
|
|
|
|
|
switch (usb_pipetype(td->pipe)) {
|
|
|
|
case PIPE_ISOCHRONOUS:
|
|
|
|
tt = TT_ISOCHRONOUS;
|
|
|
|
cmd |= ISO_EN;
|
|
|
|
break;
|
|
|
|
case PIPE_CONTROL:
|
|
|
|
tt = TT_CONTROL;
|
|
|
|
break;
|
|
|
|
case PIPE_BULK:
|
|
|
|
tt = TT_BULK;
|
|
|
|
break;
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
tt = TT_INTERRUPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (toggle)
|
|
|
|
cmd |= SEQ_SEL;
|
|
|
|
|
|
|
|
cmd |= ARM_EN;
|
|
|
|
|
|
|
|
/* SW part */
|
|
|
|
td->td_addr = c67x00->next_td_addr;
|
|
|
|
c67x00->next_td_addr = c67x00->next_td_addr + CY_TD_SIZE;
|
|
|
|
|
|
|
|
/* HW part */
|
|
|
|
td->ly_base_addr = __cpu_to_le16(c67x00->next_buf_addr);
|
|
|
|
td->port_length = __cpu_to_le16((c67x00->sie->sie_num << 15) |
|
|
|
|
(urbp->port << 14) | (len & 0x3FF));
|
|
|
|
td->pid_ep = ((pid & 0xF) << TD_PIDEP_OFFSET) |
|
|
|
|
(usb_pipeendpoint(td->pipe) & 0xF);
|
|
|
|
td->dev_addr = usb_pipedevice(td->pipe) & 0x7F;
|
|
|
|
td->ctrl_reg = cmd;
|
|
|
|
td->status = 0;
|
|
|
|
td->retry_cnt = (tt << TT_OFFSET) | (active_flag << 4) | retry_cnt;
|
|
|
|
td->residue = 0;
|
|
|
|
td->next_td_addr = __cpu_to_le16(c67x00->next_td_addr);
|
|
|
|
|
|
|
|
/* SW part */
|
|
|
|
td->data = data;
|
|
|
|
td->urb = urb;
|
|
|
|
td->privdata = privdata;
|
|
|
|
|
|
|
|
c67x00->next_buf_addr += (len + 1) & ~0x01; /* properly align */
|
|
|
|
|
|
|
|
list_add_tail(&td->td_list, &c67x00->td_list);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void c67x00_release_td(struct c67x00_td *td)
|
|
|
|
{
|
|
|
|
list_del_init(&td->td_list);
|
|
|
|
kfree(td);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int c67x00_add_data_urb(struct c67x00_hcd *c67x00, struct urb *urb)
|
|
|
|
{
|
|
|
|
int remaining;
|
|
|
|
int toggle;
|
|
|
|
int pid;
|
|
|
|
int ret = 0;
|
|
|
|
int maxps;
|
|
|
|
int need_empty;
|
|
|
|
|
|
|
|
toggle = usb_gettoggle(urb->dev, usb_pipeendpoint(urb->pipe),
|
|
|
|
usb_pipeout(urb->pipe));
|
|
|
|
remaining = urb->transfer_buffer_length - urb->actual_length;
|
|
|
|
|
|
|
|
maxps = usb_maxpacket(urb->dev, urb->pipe, usb_pipeout(urb->pipe));
|
|
|
|
|
|
|
|
need_empty = (urb->transfer_flags & URB_ZERO_PACKET) &&
|
|
|
|
usb_pipeout(urb->pipe) && !(remaining % maxps);
|
|
|
|
|
|
|
|
while (remaining || need_empty) {
|
|
|
|
int len;
|
|
|
|
char *td_buf;
|
|
|
|
|
|
|
|
len = (remaining > maxps) ? maxps : remaining;
|
|
|
|
if (!len)
|
|
|
|
need_empty = 0;
|
|
|
|
|
|
|
|
pid = usb_pipeout(urb->pipe) ? USB_PID_OUT : USB_PID_IN;
|
|
|
|
td_buf = urb->transfer_buffer + urb->transfer_buffer_length -
|
|
|
|
remaining;
|
|
|
|
ret = c67x00_create_td(c67x00, urb, td_buf, len, pid, toggle,
|
|
|
|
DATA_STAGE);
|
|
|
|
if (ret)
|
|
|
|
return ret; /* td wasn't created */
|
|
|
|
|
|
|
|
toggle ^= 1;
|
|
|
|
remaining -= len;
|
|
|
|
if (usb_pipecontrol(urb->pipe))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* return 0 in case more bandwidth is available, else errorcode
|
|
|
|
*/
|
|
|
|
static int c67x00_add_ctrl_urb(struct c67x00_hcd *c67x00, struct urb *urb)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
int pid;
|
|
|
|
|
|
|
|
switch (urb->interval) {
|
|
|
|
default:
|
|
|
|
case SETUP_STAGE:
|
|
|
|
ret = c67x00_create_td(c67x00, urb, urb->setup_packet,
|
|
|
|
8, USB_PID_SETUP, 0, SETUP_STAGE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
urb->interval = SETUP_STAGE;
|
|
|
|
usb_settoggle(urb->dev, usb_pipeendpoint(urb->pipe),
|
|
|
|
usb_pipeout(urb->pipe), 1);
|
|
|
|
break;
|
|
|
|
case DATA_STAGE:
|
|
|
|
if (urb->transfer_buffer_length) {
|
|
|
|
ret = c67x00_add_data_urb(c67x00, urb);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
break;
|
|
|
|
} /* else fallthrough */
|
|
|
|
case STATUS_STAGE:
|
|
|
|
pid = !usb_pipeout(urb->pipe) ? USB_PID_OUT : USB_PID_IN;
|
|
|
|
ret = c67x00_create_td(c67x00, urb, NULL, 0, pid, 1,
|
|
|
|
STATUS_STAGE);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* return 0 in case more bandwidth is available, else errorcode
|
|
|
|
*/
|
|
|
|
static int c67x00_add_int_urb(struct c67x00_hcd *c67x00, struct urb *urb)
|
|
|
|
{
|
|
|
|
struct c67x00_urb_priv *urbp = urb->hcpriv;
|
|
|
|
|
|
|
|
if (frame_after_eq(c67x00->current_frame, urbp->ep_data->next_frame)) {
|
|
|
|
urbp->ep_data->next_frame =
|
|
|
|
frame_add(urbp->ep_data->next_frame, urb->interval);
|
|
|
|
return c67x00_add_data_urb(c67x00, urb);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int c67x00_add_iso_urb(struct c67x00_hcd *c67x00, struct urb *urb)
|
|
|
|
{
|
|
|
|
struct c67x00_urb_priv *urbp = urb->hcpriv;
|
|
|
|
|
|
|
|
if (frame_after_eq(c67x00->current_frame, urbp->ep_data->next_frame)) {
|
|
|
|
char *td_buf;
|
|
|
|
int len, pid, ret;
|
|
|
|
|
|
|
|
BUG_ON(urbp->cnt >= urb->number_of_packets);
|
|
|
|
|
|
|
|
td_buf = urb->transfer_buffer +
|
|
|
|
urb->iso_frame_desc[urbp->cnt].offset;
|
|
|
|
len = urb->iso_frame_desc[urbp->cnt].length;
|
|
|
|
pid = usb_pipeout(urb->pipe) ? USB_PID_OUT : USB_PID_IN;
|
|
|
|
|
|
|
|
ret = c67x00_create_td(c67x00, urb, td_buf, len, pid, 0,
|
|
|
|
urbp->cnt);
|
|
|
|
if (ret) {
|
|
|
|
printk(KERN_DEBUG "create failed: %d\n", ret);
|
|
|
|
urb->iso_frame_desc[urbp->cnt].actual_length = 0;
|
|
|
|
urb->iso_frame_desc[urbp->cnt].status = ret;
|
|
|
|
if (urbp->cnt + 1 == urb->number_of_packets)
|
|
|
|
c67x00_giveback_urb(c67x00, urb, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
urbp->ep_data->next_frame =
|
|
|
|
frame_add(urbp->ep_data->next_frame, urb->interval);
|
|
|
|
urbp->cnt++;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static void c67x00_fill_from_list(struct c67x00_hcd *c67x00, int type,
|
|
|
|
int (*add)(struct c67x00_hcd *, struct urb *))
|
|
|
|
{
|
|
|
|
struct c67x00_ep_data *ep_data;
|
|
|
|
struct urb *urb;
|
|
|
|
|
|
|
|
/* traverse every endpoint on the list */
|
|
|
|
list_for_each_entry(ep_data, &c67x00->list[type], node) {
|
|
|
|
if (!list_empty(&ep_data->queue)) {
|
|
|
|
/* and add the first urb */
|
|
|
|
/* isochronous transfer rely on this */
|
|
|
|
urb = list_entry(ep_data->queue.next,
|
|
|
|
struct c67x00_urb_priv,
|
|
|
|
hep_node)->urb;
|
|
|
|
add(c67x00, urb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void c67x00_fill_frame(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
struct c67x00_td *td, *ttd;
|
|
|
|
|
|
|
|
/* Check if we can proceed */
|
|
|
|
if (!list_empty(&c67x00->td_list)) {
|
|
|
|
dev_warn(c67x00_hcd_dev(c67x00),
|
|
|
|
"TD list not empty! This should not happen!\n");
|
|
|
|
list_for_each_entry_safe(td, ttd, &c67x00->td_list, td_list) {
|
|
|
|
dbg_td(c67x00, td, "Unprocessed td");
|
|
|
|
c67x00_release_td(td);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Reinitialize variables */
|
|
|
|
c67x00->bandwidth_allocated = 0;
|
|
|
|
c67x00->periodic_bw_allocated = 0;
|
|
|
|
|
|
|
|
c67x00->next_td_addr = c67x00->td_base_addr;
|
|
|
|
c67x00->next_buf_addr = c67x00->buf_base_addr;
|
|
|
|
|
|
|
|
/* Fill the list */
|
|
|
|
c67x00_fill_from_list(c67x00, PIPE_ISOCHRONOUS, c67x00_add_iso_urb);
|
|
|
|
c67x00_fill_from_list(c67x00, PIPE_INTERRUPT, c67x00_add_int_urb);
|
|
|
|
c67x00_fill_from_list(c67x00, PIPE_CONTROL, c67x00_add_ctrl_urb);
|
|
|
|
c67x00_fill_from_list(c67x00, PIPE_BULK, c67x00_add_data_urb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Get TD from C67X00
|
|
|
|
*/
|
|
|
|
static inline void
|
|
|
|
c67x00_parse_td(struct c67x00_hcd *c67x00, struct c67x00_td *td)
|
|
|
|
{
|
|
|
|
c67x00_ll_read_mem_le16(c67x00->sie->dev,
|
|
|
|
td->td_addr, td, CY_TD_SIZE);
|
|
|
|
|
|
|
|
if (usb_pipein(td->pipe) && td_actual_bytes(td))
|
|
|
|
c67x00_ll_read_mem_le16(c67x00->sie->dev, td_ly_base_addr(td),
|
|
|
|
td->data, td_actual_bytes(td));
|
|
|
|
}
|
|
|
|
|
|
|
|
static int c67x00_td_to_error(struct c67x00_hcd *c67x00, struct c67x00_td *td)
|
|
|
|
{
|
|
|
|
if (td->status & TD_STATUSMASK_ERR) {
|
|
|
|
dbg_td(c67x00, td, "ERROR_FLAG");
|
|
|
|
return -EILSEQ;
|
|
|
|
}
|
|
|
|
if (td->status & TD_STATUSMASK_STALL) {
|
|
|
|
/* dbg_td(c67x00, td, "STALL"); */
|
|
|
|
return -EPIPE;
|
|
|
|
}
|
|
|
|
if (td->status & TD_STATUSMASK_TMOUT) {
|
|
|
|
dbg_td(c67x00, td, "TIMEOUT");
|
|
|
|
return -ETIMEDOUT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int c67x00_end_of_data(struct c67x00_td *td)
|
|
|
|
{
|
|
|
|
int maxps, need_empty, remaining;
|
|
|
|
struct urb *urb = td->urb;
|
|
|
|
int act_bytes;
|
|
|
|
|
|
|
|
act_bytes = td_actual_bytes(td);
|
|
|
|
|
|
|
|
if (unlikely(!act_bytes))
|
|
|
|
return 1; /* This was an empty packet */
|
|
|
|
|
|
|
|
maxps = usb_maxpacket(td_udev(td), td->pipe, usb_pipeout(td->pipe));
|
|
|
|
|
|
|
|
if (unlikely(act_bytes < maxps))
|
|
|
|
return 1; /* Smaller then full packet */
|
|
|
|
|
|
|
|
remaining = urb->transfer_buffer_length - urb->actual_length;
|
|
|
|
need_empty = (urb->transfer_flags & URB_ZERO_PACKET) &&
|
|
|
|
usb_pipeout(urb->pipe) && !(remaining % maxps);
|
|
|
|
|
|
|
|
if (unlikely(!remaining && !need_empty))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/* Remove all td's from the list which come
|
|
|
|
* after last_td and are meant for the same pipe.
|
2011-03-31 03:57:33 +02:00
|
|
|
* This is used when a short packet has occurred */
|
2008-04-27 08:59:45 +02:00
|
|
|
static inline void c67x00_clear_pipe(struct c67x00_hcd *c67x00,
|
|
|
|
struct c67x00_td *last_td)
|
|
|
|
{
|
|
|
|
struct c67x00_td *td, *tmp;
|
|
|
|
td = last_td;
|
|
|
|
tmp = last_td;
|
|
|
|
while (td->td_list.next != &c67x00->td_list) {
|
|
|
|
td = list_entry(td->td_list.next, struct c67x00_td, td_list);
|
|
|
|
if (td->pipe == last_td->pipe) {
|
|
|
|
c67x00_release_td(td);
|
|
|
|
td = tmp;
|
|
|
|
}
|
|
|
|
tmp = td;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static void c67x00_handle_successful_td(struct c67x00_hcd *c67x00,
|
|
|
|
struct c67x00_td *td)
|
|
|
|
{
|
|
|
|
struct urb *urb = td->urb;
|
|
|
|
|
|
|
|
if (!urb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
urb->actual_length += td_actual_bytes(td);
|
|
|
|
|
|
|
|
switch (usb_pipetype(td->pipe)) {
|
|
|
|
/* isochronous tds are handled separately */
|
|
|
|
case PIPE_CONTROL:
|
|
|
|
switch (td->privdata) {
|
|
|
|
case SETUP_STAGE:
|
|
|
|
urb->interval =
|
|
|
|
urb->transfer_buffer_length ?
|
|
|
|
DATA_STAGE : STATUS_STAGE;
|
|
|
|
/* Don't count setup_packet with normal data: */
|
|
|
|
urb->actual_length = 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DATA_STAGE:
|
|
|
|
if (c67x00_end_of_data(td)) {
|
|
|
|
urb->interval = STATUS_STAGE;
|
|
|
|
c67x00_clear_pipe(c67x00, td);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case STATUS_STAGE:
|
|
|
|
urb->interval = 0;
|
|
|
|
c67x00_giveback_urb(c67x00, urb, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case PIPE_INTERRUPT:
|
|
|
|
case PIPE_BULK:
|
|
|
|
if (unlikely(c67x00_end_of_data(td))) {
|
|
|
|
c67x00_clear_pipe(c67x00, td);
|
|
|
|
c67x00_giveback_urb(c67x00, urb, 0);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void c67x00_handle_isoc(struct c67x00_hcd *c67x00, struct c67x00_td *td)
|
|
|
|
{
|
|
|
|
struct urb *urb = td->urb;
|
|
|
|
struct c67x00_urb_priv *urbp;
|
|
|
|
int cnt;
|
|
|
|
|
|
|
|
if (!urb)
|
|
|
|
return;
|
|
|
|
|
|
|
|
urbp = urb->hcpriv;
|
|
|
|
cnt = td->privdata;
|
|
|
|
|
|
|
|
if (td->status & TD_ERROR_MASK)
|
|
|
|
urb->error_count++;
|
|
|
|
|
|
|
|
urb->iso_frame_desc[cnt].actual_length = td_actual_bytes(td);
|
|
|
|
urb->iso_frame_desc[cnt].status = c67x00_td_to_error(c67x00, td);
|
|
|
|
if (cnt + 1 == urb->number_of_packets) /* Last packet */
|
|
|
|
c67x00_giveback_urb(c67x00, urb, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* c67x00_check_td_list - handle tds which have been processed by the c67x00
|
|
|
|
* pre: current_td == 0
|
|
|
|
*/
|
|
|
|
static inline void c67x00_check_td_list(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
struct c67x00_td *td, *tmp;
|
|
|
|
struct urb *urb;
|
|
|
|
int ack_ok;
|
|
|
|
int clear_endpoint;
|
|
|
|
|
|
|
|
list_for_each_entry_safe(td, tmp, &c67x00->td_list, td_list) {
|
|
|
|
/* get the TD */
|
|
|
|
c67x00_parse_td(c67x00, td);
|
|
|
|
urb = td->urb; /* urb can be NULL! */
|
|
|
|
ack_ok = 0;
|
|
|
|
clear_endpoint = 1;
|
|
|
|
|
|
|
|
/* Handle isochronous transfers separately */
|
|
|
|
if (usb_pipeisoc(td->pipe)) {
|
|
|
|
clear_endpoint = 0;
|
|
|
|
c67x00_handle_isoc(c67x00, td);
|
|
|
|
goto cont;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* When an error occurs, all td's for that pipe go into an
|
|
|
|
* inactive state. This state matches successful transfers so
|
|
|
|
* we must make sure not to service them. */
|
|
|
|
if (td->status & TD_ERROR_MASK) {
|
|
|
|
c67x00_giveback_urb(c67x00, urb,
|
|
|
|
c67x00_td_to_error(c67x00, td));
|
|
|
|
goto cont;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((td->status & TD_STATUSMASK_NAK) || !td_sequence_ok(td) ||
|
|
|
|
!td_acked(td))
|
|
|
|
goto cont;
|
|
|
|
|
|
|
|
/* Sequence ok and acked, don't need to fix toggle */
|
|
|
|
ack_ok = 1;
|
|
|
|
|
|
|
|
if (unlikely(td->status & TD_STATUSMASK_OVF)) {
|
|
|
|
if (td_residue(td) & TD_RESIDUE_OVERFLOW) {
|
|
|
|
/* Overflow */
|
|
|
|
c67x00_giveback_urb(c67x00, urb, -EOVERFLOW);
|
|
|
|
goto cont;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
clear_endpoint = 0;
|
|
|
|
c67x00_handle_successful_td(c67x00, td);
|
|
|
|
|
|
|
|
cont:
|
|
|
|
if (clear_endpoint)
|
|
|
|
c67x00_clear_pipe(c67x00, td);
|
|
|
|
if (ack_ok)
|
|
|
|
usb_settoggle(td_udev(td), usb_pipeendpoint(td->pipe),
|
|
|
|
usb_pipeout(td->pipe),
|
|
|
|
!(td->ctrl_reg & SEQ_SEL));
|
|
|
|
/* next in list could have been removed, due to clear_pipe! */
|
|
|
|
tmp = list_entry(td->td_list.next, typeof(*td), td_list);
|
|
|
|
c67x00_release_td(td);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static inline int c67x00_all_tds_processed(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
/* If all tds are processed, we can check the previous frame (if
|
|
|
|
* there was any) and start our next frame.
|
|
|
|
*/
|
|
|
|
return !c67x00_ll_husb_get_current_td(c67x00->sie);
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Send td to C67X00
|
|
|
|
*/
|
|
|
|
static void c67x00_send_td(struct c67x00_hcd *c67x00, struct c67x00_td *td)
|
|
|
|
{
|
|
|
|
int len = td_length(td);
|
|
|
|
|
|
|
|
if (len && ((td->pid_ep & TD_PIDEPMASK_PID) != TD_PID_IN))
|
|
|
|
c67x00_ll_write_mem_le16(c67x00->sie->dev, td_ly_base_addr(td),
|
|
|
|
td->data, len);
|
|
|
|
|
|
|
|
c67x00_ll_write_mem_le16(c67x00->sie->dev,
|
|
|
|
td->td_addr, td, CY_TD_SIZE);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void c67x00_send_frame(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
struct c67x00_td *td;
|
|
|
|
|
|
|
|
if (list_empty(&c67x00->td_list))
|
|
|
|
dev_warn(c67x00_hcd_dev(c67x00),
|
|
|
|
"%s: td list should not be empty here!\n",
|
|
|
|
__func__);
|
|
|
|
|
|
|
|
list_for_each_entry(td, &c67x00->td_list, td_list) {
|
|
|
|
if (td->td_list.next == &c67x00->td_list)
|
|
|
|
td->next_td_addr = 0; /* Last td in list */
|
|
|
|
|
|
|
|
c67x00_send_td(c67x00, td);
|
|
|
|
}
|
|
|
|
|
|
|
|
c67x00_ll_husb_set_current_td(c67x00->sie, c67x00->td_base_addr);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/**
|
|
|
|
* c67x00_do_work - Schedulers state machine
|
|
|
|
*/
|
|
|
|
static void c67x00_do_work(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
spin_lock(&c67x00->lock);
|
|
|
|
/* Make sure all tds are processed */
|
|
|
|
if (!c67x00_all_tds_processed(c67x00))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
c67x00_check_td_list(c67x00);
|
|
|
|
|
|
|
|
/* no td's are being processed (current == 0)
|
|
|
|
* and all have been "checked" */
|
|
|
|
complete(&c67x00->endpoint_disable);
|
|
|
|
|
|
|
|
if (!list_empty(&c67x00->td_list))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
c67x00->current_frame = c67x00_get_current_frame_number(c67x00);
|
|
|
|
if (c67x00->current_frame == c67x00->last_frame)
|
|
|
|
goto out; /* Don't send tds in same frame */
|
|
|
|
c67x00->last_frame = c67x00->current_frame;
|
|
|
|
|
|
|
|
/* If no urbs are scheduled, our work is done */
|
|
|
|
if (!c67x00->urb_count) {
|
|
|
|
c67x00_ll_hpi_disable_sofeop(c67x00->sie);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
c67x00_fill_frame(c67x00);
|
|
|
|
if (!list_empty(&c67x00->td_list))
|
|
|
|
/* TD's have been added to the frame */
|
|
|
|
c67x00_send_frame(c67x00);
|
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&c67x00->lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static void c67x00_sched_tasklet(unsigned long __c67x00)
|
|
|
|
{
|
|
|
|
struct c67x00_hcd *c67x00 = (struct c67x00_hcd *)__c67x00;
|
|
|
|
c67x00_do_work(c67x00);
|
|
|
|
}
|
|
|
|
|
|
|
|
void c67x00_sched_kick(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
tasklet_hi_schedule(&c67x00->tasklet);
|
|
|
|
}
|
|
|
|
|
|
|
|
int c67x00_sched_start_scheduler(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
tasklet_init(&c67x00->tasklet, c67x00_sched_tasklet,
|
|
|
|
(unsigned long)c67x00);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void c67x00_sched_stop_scheduler(struct c67x00_hcd *c67x00)
|
|
|
|
{
|
|
|
|
tasklet_kill(&c67x00->tasklet);
|
|
|
|
}
|