2017-11-03 17:28:30 +07:00
|
|
|
// SPDX-License-Identifier: GPL-2.0+
|
2009-01-10 09:03:21 +07:00
|
|
|
/*
|
|
|
|
|
* Freescale QUICC Engine USB Host Controller Driver
|
|
|
|
|
*
|
|
|
|
|
* Copyright (c) Freescale Semicondutor, Inc. 2006.
|
|
|
|
|
* Shlomi Gridish <gridish@freescale.com>
|
|
|
|
|
* Jerry Huang <Chang-Ming.Huang@freescale.com>
|
|
|
|
|
* Copyright (c) Logic Product Development, Inc. 2007
|
|
|
|
|
* Peter Barada <peterb@logicpd.com>
|
|
|
|
|
* Copyright (c) MontaVista Software, Inc. 2008.
|
|
|
|
|
* Anton Vorontsov <avorontsov@ru.mvista.com>
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
|
#include <linux/types.h>
|
|
|
|
|
#include <linux/errno.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 15:04:11 +07:00
|
|
|
#include <linux/slab.h>
|
2009-01-10 09:03:21 +07:00
|
|
|
#include <linux/list.h>
|
|
|
|
|
#include <linux/io.h>
|
|
|
|
|
#include <linux/usb.h>
|
2010-04-25 04:21:52 +07:00
|
|
|
#include <linux/usb/hcd.h>
|
2009-01-10 09:03:21 +07:00
|
|
|
#include "fhci.h"
|
|
|
|
|
|
|
|
|
|
#define DUMMY_BD_BUFFER 0xdeadbeef
|
|
|
|
|
#define DUMMY2_BD_BUFFER 0xbaadf00d
|
|
|
|
|
|
|
|
|
|
/* Transaction Descriptors bits */
|
|
|
|
|
#define TD_R 0x8000 /* ready bit */
|
|
|
|
|
#define TD_W 0x2000 /* wrap bit */
|
|
|
|
|
#define TD_I 0x1000 /* interrupt on completion */
|
|
|
|
|
#define TD_L 0x0800 /* last */
|
|
|
|
|
#define TD_TC 0x0400 /* transmit CRC */
|
|
|
|
|
#define TD_CNF 0x0200 /* CNF - Must be always 1 */
|
|
|
|
|
#define TD_LSP 0x0100 /* Low-speed transaction */
|
|
|
|
|
#define TD_PID 0x00c0 /* packet id */
|
|
|
|
|
#define TD_RXER 0x0020 /* Rx error or not */
|
|
|
|
|
|
|
|
|
|
#define TD_NAK 0x0010 /* No ack. */
|
2011-03-31 08:57:33 +07:00
|
|
|
#define TD_STAL 0x0008 /* Stall received */
|
2009-01-10 09:03:21 +07:00
|
|
|
#define TD_TO 0x0004 /* time out */
|
|
|
|
|
#define TD_UN 0x0002 /* underrun */
|
|
|
|
|
#define TD_NO 0x0010 /* Rx Non Octet Aligned Packet */
|
|
|
|
|
#define TD_AB 0x0008 /* Frame Aborted */
|
|
|
|
|
#define TD_CR 0x0004 /* CRC Error */
|
|
|
|
|
#define TD_OV 0x0002 /* Overrun */
|
|
|
|
|
#define TD_BOV 0x0001 /* Buffer Overrun */
|
|
|
|
|
|
|
|
|
|
#define TD_ERRORS (TD_NAK | TD_STAL | TD_TO | TD_UN | \
|
|
|
|
|
TD_NO | TD_AB | TD_CR | TD_OV | TD_BOV)
|
|
|
|
|
|
|
|
|
|
#define TD_PID_DATA0 0x0080 /* Data 0 toggle */
|
|
|
|
|
#define TD_PID_DATA1 0x00c0 /* Data 1 toggle */
|
|
|
|
|
#define TD_PID_TOGGLE 0x00c0 /* Data 0/1 toggle mask */
|
|
|
|
|
|
|
|
|
|
#define TD_TOK_SETUP 0x0000
|
|
|
|
|
#define TD_TOK_OUT 0x4000
|
|
|
|
|
#define TD_TOK_IN 0x8000
|
|
|
|
|
#define TD_ISO 0x1000
|
|
|
|
|
#define TD_ENDP 0x0780
|
|
|
|
|
#define TD_ADDR 0x007f
|
|
|
|
|
|
|
|
|
|
#define TD_ENDP_SHIFT 7
|
|
|
|
|
|
|
|
|
|
struct usb_td {
|
|
|
|
|
__be16 status;
|
|
|
|
|
__be16 length;
|
|
|
|
|
__be32 buf_ptr;
|
|
|
|
|
__be16 extra;
|
|
|
|
|
__be16 reserved;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static struct usb_td __iomem *next_bd(struct usb_td __iomem *base,
|
|
|
|
|
struct usb_td __iomem *td,
|
|
|
|
|
u16 status)
|
|
|
|
|
{
|
|
|
|
|
if (status & TD_W)
|
|
|
|
|
return base;
|
|
|
|
|
else
|
|
|
|
|
return ++td;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void fhci_push_dummy_bd(struct endpoint *ep)
|
|
|
|
|
{
|
2015-12-03 04:45:47 +07:00
|
|
|
if (!ep->already_pushed_dummy_bd) {
|
2009-01-10 09:03:21 +07:00
|
|
|
u16 td_status = in_be16(&ep->empty_td->status);
|
|
|
|
|
|
|
|
|
|
out_be32(&ep->empty_td->buf_ptr, DUMMY_BD_BUFFER);
|
|
|
|
|
/* get the next TD in the ring */
|
|
|
|
|
ep->empty_td = next_bd(ep->td_base, ep->empty_td, td_status);
|
|
|
|
|
ep->already_pushed_dummy_bd = true;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* destroy an USB endpoint */
|
|
|
|
|
void fhci_ep0_free(struct fhci_usb *usb)
|
|
|
|
|
{
|
|
|
|
|
struct endpoint *ep;
|
|
|
|
|
int size;
|
|
|
|
|
|
|
|
|
|
ep = usb->ep0;
|
|
|
|
|
if (ep) {
|
|
|
|
|
if (ep->td_base)
|
|
|
|
|
cpm_muram_free(cpm_muram_offset(ep->td_base));
|
|
|
|
|
|
2010-01-27 21:09:36 +07:00
|
|
|
if (kfifo_initialized(&ep->conf_frame_Q)) {
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
size = cq_howmany(&ep->conf_frame_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
for (; size; size--) {
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
struct packet *pkt = cq_get(&ep->conf_frame_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
|
|
|
|
kfree(pkt);
|
|
|
|
|
}
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
cq_delete(&ep->conf_frame_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
}
|
|
|
|
|
|
2010-01-27 21:09:36 +07:00
|
|
|
if (kfifo_initialized(&ep->empty_frame_Q)) {
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
size = cq_howmany(&ep->empty_frame_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
for (; size; size--) {
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
struct packet *pkt = cq_get(&ep->empty_frame_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
|
|
|
|
kfree(pkt);
|
|
|
|
|
}
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
cq_delete(&ep->empty_frame_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
}
|
|
|
|
|
|
2010-01-27 21:09:36 +07:00
|
|
|
if (kfifo_initialized(&ep->dummy_packets_Q)) {
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
size = cq_howmany(&ep->dummy_packets_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
for (; size; size--) {
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
u8 *buff = cq_get(&ep->dummy_packets_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
|
|
|
|
kfree(buff);
|
|
|
|
|
}
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
cq_delete(&ep->dummy_packets_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
kfree(ep);
|
|
|
|
|
usb->ep0 = NULL;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* create the endpoint structure
|
|
|
|
|
*
|
|
|
|
|
* arguments:
|
|
|
|
|
* usb A pointer to the data structure of the USB
|
|
|
|
|
* data_mem The data memory partition(BUS)
|
|
|
|
|
* ring_len TD ring length
|
|
|
|
|
*/
|
|
|
|
|
u32 fhci_create_ep(struct fhci_usb *usb, enum fhci_mem_alloc data_mem,
|
|
|
|
|
u32 ring_len)
|
|
|
|
|
{
|
|
|
|
|
struct endpoint *ep;
|
|
|
|
|
struct usb_td __iomem *td;
|
|
|
|
|
unsigned long ep_offset;
|
2012-04-18 22:04:46 +07:00
|
|
|
char *err_for = "endpoint PRAM";
|
2009-01-10 09:03:21 +07:00
|
|
|
int ep_mem_size;
|
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
|
|
/* we need at least 3 TDs in the ring */
|
|
|
|
|
if (!(ring_len > 2)) {
|
|
|
|
|
fhci_err(usb->fhci, "illegal TD ring length parameters\n");
|
|
|
|
|
return -EINVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ep = kzalloc(sizeof(*ep), GFP_KERNEL);
|
|
|
|
|
if (!ep)
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
|
|
ep_mem_size = ring_len * sizeof(*td) + sizeof(struct fhci_ep_pram);
|
|
|
|
|
ep_offset = cpm_muram_alloc(ep_mem_size, 32);
|
|
|
|
|
if (IS_ERR_VALUE(ep_offset))
|
|
|
|
|
goto err;
|
|
|
|
|
ep->td_base = cpm_muram_addr(ep_offset);
|
|
|
|
|
|
|
|
|
|
/* zero all queue pointers */
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
if (cq_new(&ep->conf_frame_Q, ring_len + 2) ||
|
|
|
|
|
cq_new(&ep->empty_frame_Q, ring_len + 2) ||
|
|
|
|
|
cq_new(&ep->dummy_packets_Q, ring_len + 2)) {
|
2009-01-10 09:03:21 +07:00
|
|
|
err_for = "frame_queues";
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < (ring_len + 1); i++) {
|
|
|
|
|
struct packet *pkt;
|
|
|
|
|
u8 *buff;
|
|
|
|
|
|
|
|
|
|
pkt = kmalloc(sizeof(*pkt), GFP_KERNEL);
|
|
|
|
|
if (!pkt) {
|
|
|
|
|
err_for = "frame";
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
|
|
|
|
|
treewide: kmalloc() -> kmalloc_array()
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This
patch replaces cases of:
kmalloc(a * b, gfp)
with:
kmalloc_array(a * b, gfp)
as well as handling cases of:
kmalloc(a * b * c, gfp)
with:
kmalloc(array3_size(a, b, c), gfp)
as it's slightly less ugly than:
kmalloc_array(array_size(a, b), c, gfp)
This does, however, attempt to ignore constant size factors like:
kmalloc(4 * 1024, gfp)
though any constants defined via macros get caught up in the conversion.
Any factors with a sizeof() of "unsigned char", "char", and "u8" were
dropped, since they're redundant.
The tools/ directory was manually excluded, since it has its own
implementation of kmalloc().
The Coccinelle script used for this was:
// Fix redundant parens around sizeof().
@@
type TYPE;
expression THING, E;
@@
(
kmalloc(
- (sizeof(TYPE)) * E
+ sizeof(TYPE) * E
, ...)
|
kmalloc(
- (sizeof(THING)) * E
+ sizeof(THING) * E
, ...)
)
// Drop single-byte sizes and redundant parens.
@@
expression COUNT;
typedef u8;
typedef __u8;
@@
(
kmalloc(
- sizeof(u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * (COUNT)
+ COUNT
, ...)
|
kmalloc(
- sizeof(u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(__u8) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(char) * COUNT
+ COUNT
, ...)
|
kmalloc(
- sizeof(unsigned char) * COUNT
+ COUNT
, ...)
)
// 2-factor product with sizeof(type/expression) and identifier or constant.
@@
type TYPE;
expression THING;
identifier COUNT_ID;
constant COUNT_CONST;
@@
(
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_ID)
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_ID
+ COUNT_ID, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (COUNT_CONST)
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * COUNT_CONST
+ COUNT_CONST, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_ID)
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_ID
+ COUNT_ID, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (COUNT_CONST)
+ COUNT_CONST, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * COUNT_CONST
+ COUNT_CONST, sizeof(THING)
, ...)
)
// 2-factor product, only identifiers.
@@
identifier SIZE, COUNT;
@@
- kmalloc
+ kmalloc_array
(
- SIZE * COUNT
+ COUNT, SIZE
, ...)
// 3-factor product with 1 sizeof(type) or sizeof(expression), with
// redundant parens removed.
@@
expression THING;
identifier STRIDE, COUNT;
type TYPE;
@@
(
kmalloc(
- sizeof(TYPE) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(TYPE) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(TYPE))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * (COUNT) * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * (STRIDE)
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
|
kmalloc(
- sizeof(THING) * COUNT * STRIDE
+ array3_size(COUNT, STRIDE, sizeof(THING))
, ...)
)
// 3-factor product with 2 sizeof(variable), with redundant parens removed.
@@
expression THING1, THING2;
identifier COUNT;
type TYPE1, TYPE2;
@@
(
kmalloc(
- sizeof(TYPE1) * sizeof(TYPE2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(THING1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(THING1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * COUNT
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
|
kmalloc(
- sizeof(TYPE1) * sizeof(THING2) * (COUNT)
+ array3_size(COUNT, sizeof(TYPE1), sizeof(THING2))
, ...)
)
// 3-factor product, only identifiers, with redundant parens removed.
@@
identifier STRIDE, SIZE, COUNT;
@@
(
kmalloc(
- (COUNT) * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * STRIDE * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- (COUNT) * (STRIDE) * (SIZE)
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
|
kmalloc(
- COUNT * STRIDE * SIZE
+ array3_size(COUNT, STRIDE, SIZE)
, ...)
)
// Any remaining multi-factor products, first at least 3-factor products,
// when they're not all constants...
@@
expression E1, E2, E3;
constant C1, C2, C3;
@@
(
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(
- (E1) * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * E3
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- (E1) * (E2) * (E3)
+ array3_size(E1, E2, E3)
, ...)
|
kmalloc(
- E1 * E2 * E3
+ array3_size(E1, E2, E3)
, ...)
)
// And then all remaining 2 factors products when they're not all constants,
// keeping sizeof() as the second factor argument.
@@
expression THING, E1, E2;
type TYPE;
constant C1, C2, C3;
@@
(
kmalloc(sizeof(THING) * C2, ...)
|
kmalloc(sizeof(TYPE) * C2, ...)
|
kmalloc(C1 * C2 * C3, ...)
|
kmalloc(C1 * C2, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * (E2)
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(TYPE) * E2
+ E2, sizeof(TYPE)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * (E2)
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- sizeof(THING) * E2
+ E2, sizeof(THING)
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * E2
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- (E1) * (E2)
+ E1, E2
, ...)
|
- kmalloc
+ kmalloc_array
(
- E1 * E2
+ E1, E2
, ...)
)
Signed-off-by: Kees Cook <keescook@chromium.org>
2018-06-13 03:55:00 +07:00
|
|
|
buff = kmalloc_array(1028, sizeof(*buff), GFP_KERNEL);
|
2009-01-10 09:03:21 +07:00
|
|
|
if (!buff) {
|
|
|
|
|
kfree(pkt);
|
|
|
|
|
err_for = "buffer";
|
|
|
|
|
goto err;
|
|
|
|
|
}
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
cq_put(&ep->empty_frame_Q, pkt);
|
|
|
|
|
cq_put(&ep->dummy_packets_Q, buff);
|
2009-01-10 09:03:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* we put the endpoint parameter RAM right behind the TD ring */
|
|
|
|
|
ep->ep_pram_ptr = (void __iomem *)ep->td_base + sizeof(*td) * ring_len;
|
|
|
|
|
|
|
|
|
|
ep->conf_td = ep->td_base;
|
|
|
|
|
ep->empty_td = ep->td_base;
|
|
|
|
|
|
|
|
|
|
ep->already_pushed_dummy_bd = false;
|
|
|
|
|
|
|
|
|
|
/* initialize tds */
|
|
|
|
|
td = ep->td_base;
|
|
|
|
|
for (i = 0; i < ring_len; i++) {
|
|
|
|
|
out_be32(&td->buf_ptr, 0);
|
|
|
|
|
out_be16(&td->status, 0);
|
|
|
|
|
out_be16(&td->length, 0);
|
|
|
|
|
out_be16(&td->extra, 0);
|
|
|
|
|
td++;
|
|
|
|
|
}
|
|
|
|
|
td--;
|
|
|
|
|
out_be16(&td->status, TD_W); /* for last TD set Wrap bit */
|
|
|
|
|
out_be16(&td->length, 0);
|
|
|
|
|
|
|
|
|
|
/* endpoint structure has been created */
|
|
|
|
|
usb->ep0 = ep;
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
err:
|
|
|
|
|
fhci_ep0_free(usb);
|
|
|
|
|
kfree(ep);
|
|
|
|
|
fhci_err(usb->fhci, "no memory for the %s\n", err_for);
|
|
|
|
|
return -ENOMEM;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* initialize the endpoint register according to the given parameters
|
|
|
|
|
*
|
|
|
|
|
* artuments:
|
|
|
|
|
* usb A pointer to the data strucutre of the USB
|
|
|
|
|
* ep A pointer to the endpoint structre
|
|
|
|
|
* data_mem The data memory partition(BUS)
|
|
|
|
|
*/
|
|
|
|
|
void fhci_init_ep_registers(struct fhci_usb *usb, struct endpoint *ep,
|
|
|
|
|
enum fhci_mem_alloc data_mem)
|
|
|
|
|
{
|
|
|
|
|
u8 rt;
|
|
|
|
|
|
|
|
|
|
/* set the endpoint registers according to the endpoint */
|
2012-06-24 07:24:30 +07:00
|
|
|
out_be16(&usb->fhci->regs->usb_usep[0],
|
2009-01-10 09:03:21 +07:00
|
|
|
USB_TRANS_CTR | USB_EP_MF | USB_EP_RTE);
|
|
|
|
|
out_be16(&usb->fhci->pram->ep_ptr[0],
|
|
|
|
|
cpm_muram_offset(ep->ep_pram_ptr));
|
|
|
|
|
|
|
|
|
|
rt = (BUS_MODE_BO_BE | BUS_MODE_GBL);
|
|
|
|
|
#ifdef MULTI_DATA_BUS
|
|
|
|
|
if (data_mem == MEM_SECONDARY)
|
|
|
|
|
rt |= BUS_MODE_DTB;
|
|
|
|
|
#endif
|
|
|
|
|
out_8(&ep->ep_pram_ptr->rx_func_code, rt);
|
|
|
|
|
out_8(&ep->ep_pram_ptr->tx_func_code, rt);
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->rx_buff_len, 1028);
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->rx_base, 0);
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_base, cpm_muram_offset(ep->td_base));
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->rx_bd_ptr, 0);
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr, cpm_muram_offset(ep->td_base));
|
|
|
|
|
out_be32(&ep->ep_pram_ptr->tx_state, 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Collect the submitted frames and inform the application about them
|
2010-12-31 06:07:58 +07:00
|
|
|
* It is also preparing the TDs for new frames. If the Tx interrupts
|
|
|
|
|
* are disabled, the application should call that routine to get
|
2009-01-10 09:03:21 +07:00
|
|
|
* confirmation about the submitted frames. Otherwise, the routine is
|
2011-03-31 08:57:33 +07:00
|
|
|
* called from the interrupt service routine during the Tx interrupt.
|
2009-01-10 09:03:21 +07:00
|
|
|
* In that case the application is informed by calling the application
|
|
|
|
|
* specific 'fhci_transaction_confirm' routine
|
|
|
|
|
*/
|
|
|
|
|
static void fhci_td_transaction_confirm(struct fhci_usb *usb)
|
|
|
|
|
{
|
|
|
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
|
struct packet *pkt;
|
|
|
|
|
struct usb_td __iomem *td;
|
|
|
|
|
u16 extra_data;
|
|
|
|
|
u16 td_status;
|
|
|
|
|
u16 td_length;
|
|
|
|
|
u32 buf;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* collect transmitted BDs from the chip. The routine clears all BDs
|
|
|
|
|
* with R bit = 0 and the pointer to data buffer is not NULL, that is
|
|
|
|
|
* BDs which point to the transmitted data buffer
|
|
|
|
|
*/
|
|
|
|
|
while (1) {
|
|
|
|
|
td = ep->conf_td;
|
|
|
|
|
td_status = in_be16(&td->status);
|
|
|
|
|
td_length = in_be16(&td->length);
|
|
|
|
|
buf = in_be32(&td->buf_ptr);
|
|
|
|
|
extra_data = in_be16(&td->extra);
|
|
|
|
|
|
|
|
|
|
/* check if the TD is empty */
|
|
|
|
|
if (!(!(td_status & TD_R) && ((td_status & ~TD_W) || buf)))
|
|
|
|
|
break;
|
|
|
|
|
/* check if it is a dummy buffer */
|
|
|
|
|
else if ((buf == DUMMY_BD_BUFFER) && !(td_status & ~TD_W))
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* mark TD as empty */
|
|
|
|
|
clrbits16(&td->status, ~TD_W);
|
|
|
|
|
out_be16(&td->length, 0);
|
|
|
|
|
out_be32(&td->buf_ptr, 0);
|
|
|
|
|
out_be16(&td->extra, 0);
|
|
|
|
|
/* advance the TD pointer */
|
|
|
|
|
ep->conf_td = next_bd(ep->td_base, ep->conf_td, td_status);
|
|
|
|
|
|
|
|
|
|
/* check if it is a dummy buffer(type2) */
|
|
|
|
|
if ((buf == DUMMY2_BD_BUFFER) && !(td_status & ~TD_W))
|
|
|
|
|
continue;
|
|
|
|
|
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
pkt = cq_get(&ep->conf_frame_Q);
|
2009-01-10 09:03:21 +07:00
|
|
|
if (!pkt)
|
|
|
|
|
fhci_err(usb->fhci, "no frame to confirm\n");
|
|
|
|
|
|
|
|
|
|
if (td_status & TD_ERRORS) {
|
|
|
|
|
if (td_status & TD_RXER) {
|
|
|
|
|
if (td_status & TD_CR)
|
|
|
|
|
pkt->status = USB_TD_RX_ER_CRC;
|
|
|
|
|
else if (td_status & TD_AB)
|
|
|
|
|
pkt->status = USB_TD_RX_ER_BITSTUFF;
|
|
|
|
|
else if (td_status & TD_OV)
|
|
|
|
|
pkt->status = USB_TD_RX_ER_OVERUN;
|
|
|
|
|
else if (td_status & TD_BOV)
|
|
|
|
|
pkt->status = USB_TD_RX_DATA_OVERUN;
|
|
|
|
|
else if (td_status & TD_NO)
|
|
|
|
|
pkt->status = USB_TD_RX_ER_NONOCT;
|
|
|
|
|
else
|
|
|
|
|
fhci_err(usb->fhci, "illegal error "
|
2011-03-31 08:57:33 +07:00
|
|
|
"occurred\n");
|
2009-01-10 09:03:21 +07:00
|
|
|
} else if (td_status & TD_NAK)
|
|
|
|
|
pkt->status = USB_TD_TX_ER_NAK;
|
|
|
|
|
else if (td_status & TD_TO)
|
|
|
|
|
pkt->status = USB_TD_TX_ER_TIMEOUT;
|
|
|
|
|
else if (td_status & TD_UN)
|
|
|
|
|
pkt->status = USB_TD_TX_ER_UNDERUN;
|
|
|
|
|
else if (td_status & TD_STAL)
|
|
|
|
|
pkt->status = USB_TD_TX_ER_STALL;
|
|
|
|
|
else
|
2011-03-31 08:57:33 +07:00
|
|
|
fhci_err(usb->fhci, "illegal error occurred\n");
|
2009-01-10 09:03:21 +07:00
|
|
|
} else if ((extra_data & TD_TOK_IN) &&
|
|
|
|
|
pkt->len > td_length - CRC_SIZE) {
|
|
|
|
|
pkt->status = USB_TD_RX_DATA_UNDERUN;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (extra_data & TD_TOK_IN)
|
|
|
|
|
pkt->len = td_length - CRC_SIZE;
|
|
|
|
|
else if (pkt->info & PKT_ZLP)
|
|
|
|
|
pkt->len = 0;
|
|
|
|
|
else
|
|
|
|
|
pkt->len = td_length;
|
|
|
|
|
|
|
|
|
|
fhci_transaction_confirm(usb, pkt);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Submitting a data frame to a specified endpoint of a USB device
|
|
|
|
|
* The frame is put in the driver's transmit queue for this endpoint
|
|
|
|
|
*
|
|
|
|
|
* Arguments:
|
|
|
|
|
* usb A pointer to the USB structure
|
|
|
|
|
* pkt A pointer to the user frame structure
|
|
|
|
|
* trans_type Transaction tyep - IN,OUT or SETUP
|
|
|
|
|
* dest_addr Device address - 0~127
|
|
|
|
|
* dest_ep Endpoint number of the device - 0~16
|
|
|
|
|
* trans_mode Pipe type - ISO,Interrupt,bulk or control
|
|
|
|
|
* dest_speed USB speed - Low speed or FULL speed
|
|
|
|
|
* data_toggle Data sequence toggle - 0 or 1
|
|
|
|
|
*/
|
|
|
|
|
u32 fhci_host_transaction(struct fhci_usb *usb,
|
|
|
|
|
struct packet *pkt,
|
|
|
|
|
enum fhci_ta_type trans_type,
|
|
|
|
|
u8 dest_addr,
|
|
|
|
|
u8 dest_ep,
|
|
|
|
|
enum fhci_tf_mode trans_mode,
|
|
|
|
|
enum fhci_speed dest_speed, u8 data_toggle)
|
|
|
|
|
{
|
|
|
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
|
struct usb_td __iomem *td;
|
|
|
|
|
u16 extra_data;
|
|
|
|
|
u16 td_status;
|
|
|
|
|
|
|
|
|
|
fhci_usb_disable_interrupt(usb);
|
|
|
|
|
/* start from the next BD that should be filled */
|
|
|
|
|
td = ep->empty_td;
|
|
|
|
|
td_status = in_be16(&td->status);
|
|
|
|
|
|
|
|
|
|
if (td_status & TD_R && in_be16(&td->length)) {
|
|
|
|
|
/* if the TD is not free */
|
|
|
|
|
fhci_usb_enable_interrupt(usb);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* get the next TD in the ring */
|
|
|
|
|
ep->empty_td = next_bd(ep->td_base, ep->empty_td, td_status);
|
|
|
|
|
fhci_usb_enable_interrupt(usb);
|
|
|
|
|
pkt->priv_data = td;
|
|
|
|
|
out_be32(&td->buf_ptr, virt_to_phys(pkt->data));
|
|
|
|
|
/* sets up transaction parameters - addr,endp,dir,and type */
|
|
|
|
|
extra_data = (dest_ep << TD_ENDP_SHIFT) | dest_addr;
|
|
|
|
|
switch (trans_type) {
|
|
|
|
|
case FHCI_TA_IN:
|
|
|
|
|
extra_data |= TD_TOK_IN;
|
|
|
|
|
break;
|
|
|
|
|
case FHCI_TA_OUT:
|
|
|
|
|
extra_data |= TD_TOK_OUT;
|
|
|
|
|
break;
|
|
|
|
|
case FHCI_TA_SETUP:
|
|
|
|
|
extra_data |= TD_TOK_SETUP;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (trans_mode == FHCI_TF_ISO)
|
|
|
|
|
extra_data |= TD_ISO;
|
|
|
|
|
out_be16(&td->extra, extra_data);
|
|
|
|
|
|
|
|
|
|
/* sets up the buffer descriptor */
|
|
|
|
|
td_status = ((td_status & TD_W) | TD_R | TD_L | TD_I | TD_CNF);
|
|
|
|
|
if (!(pkt->info & PKT_NO_CRC))
|
|
|
|
|
td_status |= TD_TC;
|
|
|
|
|
|
|
|
|
|
switch (trans_type) {
|
|
|
|
|
case FHCI_TA_IN:
|
|
|
|
|
if (data_toggle)
|
|
|
|
|
pkt->info |= PKT_PID_DATA1;
|
|
|
|
|
else
|
|
|
|
|
pkt->info |= PKT_PID_DATA0;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
if (data_toggle) {
|
|
|
|
|
td_status |= TD_PID_DATA1;
|
|
|
|
|
pkt->info |= PKT_PID_DATA1;
|
|
|
|
|
} else {
|
|
|
|
|
td_status |= TD_PID_DATA0;
|
|
|
|
|
pkt->info |= PKT_PID_DATA0;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if ((dest_speed == FHCI_LOW_SPEED) &&
|
|
|
|
|
(usb->port_status == FHCI_PORT_FULL))
|
|
|
|
|
td_status |= TD_LSP;
|
|
|
|
|
|
|
|
|
|
out_be16(&td->status, td_status);
|
|
|
|
|
|
|
|
|
|
/* set up buffer length */
|
|
|
|
|
if (trans_type == FHCI_TA_IN)
|
|
|
|
|
out_be16(&td->length, pkt->len + CRC_SIZE);
|
|
|
|
|
else
|
|
|
|
|
out_be16(&td->length, pkt->len);
|
|
|
|
|
|
|
|
|
|
/* put the frame to the confirmation queue */
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
cq_put(&ep->conf_frame_Q, pkt);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
kfifo: move struct kfifo in place
This is a new generic kernel FIFO implementation.
The current kernel fifo API is not very widely used, because it has to
many constrains. Only 17 files in the current 2.6.31-rc5 used it.
FIFO's are like list's a very basic thing and a kfifo API which handles
the most use case would save a lot of development time and memory
resources.
I think this are the reasons why kfifo is not in use:
- The API is to simple, important functions are missing
- A fifo can be only allocated dynamically
- There is a requirement of a spinlock whether you need it or not
- There is no support for data records inside a fifo
So I decided to extend the kfifo in a more generic way without blowing up
the API to much. The new API has the following benefits:
- Generic usage: For kernel internal use and/or device driver.
- Provide an API for the most use case.
- Slim API: The whole API provides 25 functions.
- Linux style habit.
- DECLARE_KFIFO, DEFINE_KFIFO and INIT_KFIFO Macros
- Direct copy_to_user from the fifo and copy_from_user into the fifo.
- The kfifo itself is an in place member of the using data structure, this save an
indirection access and does not waste the kernel allocator.
- Lockless access: if only one reader and one writer is active on the fifo,
which is the common use case, no additional locking is necessary.
- Remove spinlock - give the user the freedom of choice what kind of locking to use if
one is required.
- Ability to handle records. Three type of records are supported:
- Variable length records between 0-255 bytes, with a record size
field of 1 bytes.
- Variable length records between 0-65535 bytes, with a record size
field of 2 bytes.
- Fixed size records, which no record size field.
- Preserve memory resource.
- Performance!
- Easy to use!
This patch:
Since most users want to have the kfifo as part of another object,
reorganize the code to allow including struct kfifo in another data
structure. This requires changing the kfifo_alloc and kfifo_init
prototypes so that we pass an existing kfifo pointer into them. This
patch changes the implementation and all existing users.
[akpm@linux-foundation.org: fix warning]
Signed-off-by: Stefani Seibold <stefani@seibold.net>
Acked-by: Greg Kroah-Hartman <gregkh@suse.de>
Acked-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Acked-by: Andi Kleen <ak@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2009-12-22 05:37:26 +07:00
|
|
|
if (cq_howmany(&ep->conf_frame_Q) == 1)
|
2012-06-24 07:24:30 +07:00
|
|
|
out_8(&usb->fhci->regs->usb_uscom, USB_CMD_STR_FIFO);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Reset the Tx BD ring */
|
|
|
|
|
void fhci_flush_bds(struct fhci_usb *usb)
|
|
|
|
|
{
|
|
|
|
|
u16 td_status;
|
|
|
|
|
struct usb_td __iomem *td;
|
|
|
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
|
|
|
|
|
|
td = ep->td_base;
|
|
|
|
|
while (1) {
|
|
|
|
|
td_status = in_be16(&td->status);
|
2020-07-06 20:33:39 +07:00
|
|
|
in_be32(&td->buf_ptr);
|
|
|
|
|
in_be16(&td->extra);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
|
|
|
|
/* if the TD is not empty - we'll confirm it as Timeout */
|
|
|
|
|
if (td_status & TD_R)
|
|
|
|
|
out_be16(&td->status, (td_status & ~TD_R) | TD_TO);
|
|
|
|
|
/* if this TD is dummy - let's skip this TD */
|
|
|
|
|
else if (in_be32(&td->buf_ptr) == DUMMY_BD_BUFFER)
|
|
|
|
|
out_be32(&td->buf_ptr, DUMMY2_BD_BUFFER);
|
|
|
|
|
/* if this is the last TD - break */
|
|
|
|
|
if (td_status & TD_W)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
td++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fhci_td_transaction_confirm(usb);
|
|
|
|
|
|
|
|
|
|
td = ep->td_base;
|
|
|
|
|
do {
|
|
|
|
|
out_be16(&td->status, 0);
|
|
|
|
|
out_be16(&td->length, 0);
|
|
|
|
|
out_be32(&td->buf_ptr, 0);
|
|
|
|
|
out_be16(&td->extra, 0);
|
|
|
|
|
td++;
|
|
|
|
|
} while (!(in_be16(&td->status) & TD_W));
|
|
|
|
|
out_be16(&td->status, TD_W); /* for last TD set Wrap bit */
|
|
|
|
|
out_be16(&td->length, 0);
|
|
|
|
|
out_be32(&td->buf_ptr, 0);
|
|
|
|
|
out_be16(&td->extra, 0);
|
|
|
|
|
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr,
|
|
|
|
|
in_be16(&ep->ep_pram_ptr->tx_base));
|
|
|
|
|
out_be32(&ep->ep_pram_ptr->tx_state, 0);
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_cnt, 0);
|
|
|
|
|
ep->empty_td = ep->td_base;
|
|
|
|
|
ep->conf_td = ep->td_base;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Flush all transmitted packets from TDs in the actual frame.
|
|
|
|
|
* This routine is called when something wrong with the controller and
|
|
|
|
|
* we want to get rid of the actual frame and start again next frame
|
|
|
|
|
*/
|
|
|
|
|
void fhci_flush_actual_frame(struct fhci_usb *usb)
|
|
|
|
|
{
|
|
|
|
|
u8 mode;
|
|
|
|
|
u16 tb_ptr;
|
|
|
|
|
u16 td_status;
|
|
|
|
|
u32 buf_ptr;
|
|
|
|
|
struct usb_td __iomem *td;
|
|
|
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
|
|
|
|
|
|
/* disable the USB controller */
|
2012-06-24 07:24:30 +07:00
|
|
|
mode = in_8(&usb->fhci->regs->usb_usmod);
|
|
|
|
|
out_8(&usb->fhci->regs->usb_usmod, mode & ~USB_MODE_EN);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
|
|
|
|
tb_ptr = in_be16(&ep->ep_pram_ptr->tx_bd_ptr);
|
|
|
|
|
td = cpm_muram_addr(tb_ptr);
|
|
|
|
|
td_status = in_be16(&td->status);
|
|
|
|
|
buf_ptr = in_be32(&td->buf_ptr);
|
2020-07-06 20:33:39 +07:00
|
|
|
in_be16(&td->extra);
|
2009-01-10 09:03:21 +07:00
|
|
|
do {
|
|
|
|
|
if (td_status & TD_R) {
|
|
|
|
|
out_be16(&td->status, (td_status & ~TD_R) | TD_TO);
|
|
|
|
|
} else {
|
|
|
|
|
out_be32(&td->buf_ptr, 0);
|
|
|
|
|
ep->already_pushed_dummy_bd = false;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* advance the TD pointer */
|
|
|
|
|
td = next_bd(ep->td_base, td, td_status);
|
|
|
|
|
td_status = in_be16(&td->status);
|
|
|
|
|
buf_ptr = in_be32(&td->buf_ptr);
|
2020-07-06 20:33:39 +07:00
|
|
|
in_be16(&td->extra);
|
2009-01-10 09:03:21 +07:00
|
|
|
} while ((td_status & TD_R) || buf_ptr);
|
|
|
|
|
|
|
|
|
|
fhci_td_transaction_confirm(usb);
|
|
|
|
|
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr,
|
|
|
|
|
in_be16(&ep->ep_pram_ptr->tx_base));
|
|
|
|
|
out_be32(&ep->ep_pram_ptr->tx_state, 0);
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_cnt, 0);
|
|
|
|
|
ep->empty_td = ep->td_base;
|
|
|
|
|
ep->conf_td = ep->td_base;
|
|
|
|
|
|
|
|
|
|
usb->actual_frame->frame_status = FRAME_TIMER_END_TRANSMISSION;
|
|
|
|
|
|
|
|
|
|
/* reset the event register */
|
2012-06-24 07:24:30 +07:00
|
|
|
out_be16(&usb->fhci->regs->usb_usber, 0xffff);
|
2009-01-10 09:03:21 +07:00
|
|
|
/* enable the USB controller */
|
2012-06-24 07:24:30 +07:00
|
|
|
out_8(&usb->fhci->regs->usb_usmod, mode | USB_MODE_EN);
|
2009-01-10 09:03:21 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* handles Tx confirm and Tx error interrupt */
|
|
|
|
|
void fhci_tx_conf_interrupt(struct fhci_usb *usb)
|
|
|
|
|
{
|
|
|
|
|
fhci_td_transaction_confirm(usb);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Schedule another transaction to this frame only if we have
|
|
|
|
|
* already confirmed all transaction in the frame.
|
|
|
|
|
*/
|
|
|
|
|
if (((fhci_get_sof_timer_count(usb) < usb->max_frame_usage) ||
|
|
|
|
|
(usb->actual_frame->frame_status & FRAME_END_TRANSMISSION)) &&
|
|
|
|
|
(list_empty(&usb->actual_frame->tds_list)))
|
|
|
|
|
fhci_schedule_transactions(usb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void fhci_host_transmit_actual_frame(struct fhci_usb *usb)
|
|
|
|
|
{
|
|
|
|
|
u16 tb_ptr;
|
|
|
|
|
u16 td_status;
|
|
|
|
|
struct usb_td __iomem *td;
|
|
|
|
|
struct endpoint *ep = usb->ep0;
|
|
|
|
|
|
|
|
|
|
tb_ptr = in_be16(&ep->ep_pram_ptr->tx_bd_ptr);
|
|
|
|
|
td = cpm_muram_addr(tb_ptr);
|
|
|
|
|
|
|
|
|
|
if (in_be32(&td->buf_ptr) == DUMMY_BD_BUFFER) {
|
|
|
|
|
struct usb_td __iomem *old_td = td;
|
|
|
|
|
|
|
|
|
|
ep->already_pushed_dummy_bd = false;
|
|
|
|
|
td_status = in_be16(&td->status);
|
|
|
|
|
/* gets the next TD in the ring */
|
|
|
|
|
td = next_bd(ep->td_base, td, td_status);
|
|
|
|
|
tb_ptr = cpm_muram_offset(td);
|
|
|
|
|
out_be16(&ep->ep_pram_ptr->tx_bd_ptr, tb_ptr);
|
|
|
|
|
|
|
|
|
|
/* start transmit only if we have something in the TDs */
|
|
|
|
|
if (in_be16(&td->status) & TD_R)
|
2012-06-24 07:24:30 +07:00
|
|
|
out_8(&usb->fhci->regs->usb_uscom, USB_CMD_STR_FIFO);
|
2009-01-10 09:03:21 +07:00
|
|
|
|
|
|
|
|
if (in_be32(&ep->conf_td->buf_ptr) == DUMMY_BD_BUFFER) {
|
|
|
|
|
out_be32(&old_td->buf_ptr, 0);
|
|
|
|
|
ep->conf_td = next_bd(ep->td_base, ep->conf_td,
|
|
|
|
|
td_status);
|
|
|
|
|
} else {
|
|
|
|
|
out_be32(&old_td->buf_ptr, DUMMY2_BD_BUFFER);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|