lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

usb gadget stack: remove usb_ep_*_buffer(), part 2

Browse Source 
This patch removes controller driver infrastructure which supported
the now-removed usb_ep_{alloc,free}_buffer() calls.

As can be seen, many of the implementations of this were broken to
various degrees.  Many didn't properly return dma-coherent mappings;
those which did so were necessarily ugly because of bogosity in the
underlying dma_free_coherent() calls ... which on many platforms
can't be called from the same contexts (notably in_irq) from which
their dma_alloc_coherent() sibling can be called.

The main potential downside of removing this is that gadget drivers
wouldn't have specific knowledge that the controller drivers have:
endpoints that aren't dma-capable don't need any dma mappings at all.

Signed-off-by: David Brownell <dbrownell@users.sourceforge.net>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
This commit is contained in:
David Brownell
2007-07-01 12:21:00 -07:00
committed by Greg Kroah-Hartman
parent 9d8bab58b7
commit c67ab134ba
10 changed files with 0 additions and 436 deletions
Download Patch File Download Diff File Expand all files Collapse all files

97
drivers/usb/gadget/net2280.c
View File

@@ -450,100 +450,6 @@ net2280_free_request (struct usb_ep *_ep, struct usb_request *_req)
/*-------------------------------------------------------------------------*/
/*
* dma-coherent memory allocation (for dma-capable endpoints)
*
* NOTE: the dma_*_coherent() API calls suck. Most implementations are
* (a) page-oriented, so small buffers lose big; and (b) asymmetric with
* respect to calls with irqs disabled: alloc is safe, free is not.
* We currently work around (b), but not (a).
*/
static void *
net2280_alloc_buffer (
struct usb_ep *_ep,
unsigned bytes,
dma_addr_t *dma,
gfp_t gfp_flags
)
{
void *retval;
struct net2280_ep *ep;
ep = container_of (_ep, struct net2280_ep, ep);
if (!_ep)
return NULL;
*dma = DMA_ADDR_INVALID;
if (ep->dma)
retval = dma_alloc_coherent(&ep->dev->pdev->dev,
bytes, dma, gfp_flags);
else
retval = kmalloc(bytes, gfp_flags);
return retval;
}
static DEFINE_SPINLOCK(buflock);
static LIST_HEAD(buffers);
struct free_record {
struct list_head list;
struct device *dev;
unsigned bytes;
dma_addr_t dma;
};
static void do_free(unsigned long ignored)
{
spin_lock_irq(&buflock);
while (!list_empty(&buffers)) {
struct free_record *buf;
buf = list_entry(buffers.next, struct free_record, list);
list_del(&buf->list);
spin_unlock_irq(&buflock);
dma_free_coherent(buf->dev, buf->bytes, buf, buf->dma);
spin_lock_irq(&buflock);
}
spin_unlock_irq(&buflock);
}
static DECLARE_TASKLET(deferred_free, do_free, 0);
static void
net2280_free_buffer (
struct usb_ep *_ep,
void *address,
dma_addr_t dma,
unsigned bytes
) {
/* free memory into the right allocator */
if (dma != DMA_ADDR_INVALID) {
struct net2280_ep *ep;
struct free_record *buf = address;
unsigned long flags;
ep = container_of(_ep, struct net2280_ep, ep);
if (!_ep)
return;
ep = container_of (_ep, struct net2280_ep, ep);
buf->dev = &ep->dev->pdev->dev;
buf->bytes = bytes;
buf->dma = dma;
spin_lock_irqsave(&buflock, flags);
list_add_tail(&buf->list, &buffers);
tasklet_schedule(&deferred_free);
spin_unlock_irqrestore(&buflock, flags);
} else
kfree (address);
}
/*-------------------------------------------------------------------------*/
/* load a packet into the fifo we use for usb IN transfers.
* works for all endpoints.
*
@@ -1392,9 +1298,6 @@ static const struct usb_ep_ops net2280_ep_ops = {
.alloc_request = net2280_alloc_request,
.free_request = net2280_free_request,
.alloc_buffer = net2280_alloc_buffer,
.free_buffer = net2280_free_buffer,
.queue = net2280_queue,
.dequeue = net2280_dequeue,