Skip to content

L
linux-davinci
Commit ba4cd005 authored by Tony Lindgren's avatar Tony Lindgren
Browse files
Options

musb_hdrc: Search and replace pRequest with request 

Search and replace pRequest with request
Signed-off-by: default avatarTony Lindgren <tony@atomide.com>
parent a71a647e
Hide whitespace changes
Inline Side-by-side
Showing with 130 additions and 130 deletions
drivers/usb/musb/g_ep0.c
View file @ ba4cd005
......@@ -484,31 +484,31 @@ static void ep0_rxstate(struct musb *this)
static void ep0_txstate(struct musb *musb)
{
void __iomem *regs = musb->control_ep->regs;
struct usb_request *pRequest = next_ep0_request(musb);
struct usb_request *request = next_ep0_request(musb);
u16 wCsrVal = MGC_M_CSR0_TXPKTRDY;
u8 *pFifoSource;
u8 fifo_count;
if (!pRequest) {
if (!request) {
// WARN_ON(1);
DBG(2, "odd; csr0 %04x\n", musb_readw(regs, MGC_O_HDRC_CSR0));
return;
}
/* load the data */
pFifoSource = (u8 *) pRequest->buf + pRequest->actual;
pFifoSource = (u8 *) request->buf + request->actual;
fifo_count = min((unsigned) MGC_END0_FIFOSIZE,
pRequest->length - pRequest->actual);
request->length - request->actual);
musb_write_fifo(&musb->endpoints[0], fifo_count, pFifoSource);
pRequest->actual += fifo_count;
request->actual += fifo_count;
/* update the flags */
if (fifo_count < MUSB_MAX_END0_PACKET
|| pRequest->actual == pRequest->length) {
|| request->actual == request->length) {
musb->ep0_state = MGC_END0_STAGE_STATUSOUT;
wCsrVal |= MGC_M_CSR0_P_DATAEND;
} else
pRequest = NULL;
request = NULL;
/* send it out, triggering a "txpktrdy cleared" irq */
musb_writew(regs, MGC_O_HDRC_CSR0, wCsrVal);
......@@ -518,8 +518,8 @@ static void ep0_txstate(struct musb *musb)
* very precise fault reporting, needed by USB TMC; possible with
* this hardware, but not usable from portable gadget drivers.)
*/
if (pRequest)
musb_g_ep0_giveback(musb, pRequest);
if (request)
musb_g_ep0_giveback(musb, request);
}
/*
......
drivers/usb/musb/musb_gadget.c
View file @ ba4cd005
......@@ -94,13 +94,13 @@ Handling completion
/*
* Immediately complete a request.
*
* @param pRequest the request to complete
* @param request the request to complete
* @param status the status to complete the request with
* Context: controller locked, IRQs blocked.
*/
void musb_g_giveback(
struct musb_ep *ep,
struct usb_request *pRequest,
struct usb_request *request,
int status)
__releases(ep->musb->lock)
__acquires(ep->musb->lock)
......@@ -109,9 +109,9 @@ __acquires(ep->musb->lock)
struct musb *musb;
int busy = ep->busy;
req = to_musb_request(pRequest);
req = to_musb_request(request);
list_del(&pRequest->list);
list_del(&request->list);
if (req->request.status == -EINPROGRESS)
req->request.status = status;
musb = req->musb;
......@@ -136,15 +136,15 @@ __acquires(ep->musb->lock)
? DMA_TO_DEVICE
: DMA_FROM_DEVICE);
}
if (pRequest->status == 0)
if (request->status == 0)
DBG(5, "%s done request %p, %d/%d\n",
ep->end_point.name, pRequest,
ep->end_point.name, request,
req->request.actual, req->request.length);
else
DBG(2, "%s request %p, %d/%d fault %d\n",
ep->end_point.name, pRequest,
ep->end_point.name, request,
req->request.actual, req->request.length,
pRequest->status);
request->status);
req->request.complete(&req->ep->end_point, &req->request);
spin_lock(&musb->lock);
ep->busy = busy;
......@@ -255,7 +255,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
u8 epnum = req->epnum;
struct musb_ep *musb_ep;
void __iomem *epio = musb->endpoints[epnum].regs;
struct usb_request *pRequest;
struct usb_request *request;
u16 fifo_count = 0, wCsrVal;
int use_dma = 0;
......@@ -270,9 +270,9 @@ static void txstate(struct musb *musb, struct musb_request *req)
/* read TXCSR before */
wCsrVal = musb_readw(epio, MGC_O_HDRC_TXCSR);
pRequest = &req->request;
request = &req->request;
fifo_count = min(max_ep_writesize(musb, musb_ep),
(int)(pRequest->length - pRequest->actual));
(int)(request->length - request->actual));
if (wCsrVal & MGC_M_TXCSR_TXPKTRDY) {
DBG(5, "%s old packet still ready , txcsr %03x\n",
......@@ -294,7 +294,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
if (is_dma_capable() && musb_ep->dma) {
struct dma_controller *c = musb->dma_controller;
use_dma = (pRequest->dma != DMA_ADDR_INVALID);
use_dma = (request->dma != DMA_ADDR_INVALID);
/* MGC_M_TXCSR_P_ISO is still set correctly */
......@@ -303,7 +303,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
size_t request_size;
/* setup DMA, then program endpoint CSR */
request_size = min(pRequest->length,
request_size = min(request->length,
musb_ep->dma->max_len);
if (request_size <= musb_ep->wPacketSize)
musb_ep->dma->desired_mode = 0;
......@@ -313,7 +313,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
use_dma = use_dma && c->channel_program(
musb_ep->dma, musb_ep->wPacketSize,
musb_ep->dma->desired_mode,
pRequest->dma, request_size);
request->dma, request_size);
if (use_dma) {
if (musb_ep->dma->desired_mode == 0) {
/* ASSERT: DMAENAB is clear */
......@@ -361,8 +361,8 @@ static void txstate(struct musb *musb, struct musb_request *req)
use_dma = use_dma && c->channel_program(
musb_ep->dma, musb_ep->wPacketSize,
0,
pRequest->dma,
pRequest->length);
request->dma,
request->length);
if (!use_dma) {
c->channel_release(musb_ep->dma);
musb_ep->dma = NULL;
......@@ -373,17 +373,17 @@ static void txstate(struct musb *musb, struct musb_request *req)
#elif defined(CONFIG_USB_TUSB_OMAP_DMA)
use_dma = use_dma && c->channel_program(
musb_ep->dma, musb_ep->wPacketSize,
pRequest->zero,
pRequest->dma,
pRequest->length);
request->zero,
request->dma,
request->length);
#endif
}
#endif
if (!use_dma) {
musb_write_fifo(musb_ep->hw_ep, fifo_count,
(u8 *) (pRequest->buf + pRequest->actual));
pRequest->actual += fifo_count;
(u8 *) (request->buf + request->actual));
request->actual += fifo_count;
wCsrVal |= MGC_M_TXCSR_TXPKTRDY;
wCsrVal &= ~MGC_M_TXCSR_P_UNDERRUN;
musb_writew(epio, MGC_O_HDRC_TXCSR, wCsrVal);
......@@ -392,7 +392,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
/* host may already have the data when this message shows... */
DBG(3, "%s TX/IN %s len %d/%d, txcsr %04x, fifo %d/%d\n",
musb_ep->end_point.name, use_dma ? "dma" : "pio",
pRequest->actual, pRequest->length,
request->actual, request->length,
musb_readw(epio, MGC_O_HDRC_TXCSR),
fifo_count,
musb_readw(epio, MGC_O_HDRC_TXMAXP));
......@@ -405,14 +405,14 @@ static void txstate(struct musb *musb, struct musb_request *req)
void musb_g_tx(struct musb *musb, u8 epnum)
{
u16 wCsrVal;
struct usb_request *pRequest;
struct usb_request *request;
u8 __iomem *mbase = musb->mregs;
struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_in;
void __iomem *epio = musb->endpoints[epnum].regs;
struct dma_channel *dma;
musb_ep_select(mbase, epnum);
pRequest = next_request(musb_ep);
request = next_request(musb_ep);
wCsrVal = musb_readw(epio, MGC_O_HDRC_TXCSR);
DBG(4, "<== %s, txcsr %04x\n", musb_ep->end_point.name, wCsrVal);
......@@ -431,8 +431,8 @@ void musb_g_tx(struct musb *musb, u8 epnum)
musb->dma_controller->channel_abort(dma);
}
if (pRequest)
musb_g_giveback(musb_ep, pRequest, -EPIPE);
if (request)
musb_g_giveback(musb_ep, request, -EPIPE);
break;
}
......@@ -443,7 +443,7 @@ void musb_g_tx(struct musb *musb, u8 epnum)
wCsrVal &= ~(MGC_M_TXCSR_P_UNDERRUN
| MGC_M_TXCSR_TXPKTRDY);
musb_writew(epio, MGC_O_HDRC_TXCSR, wCsrVal);
DBG(20, "underrun on ep%d, req %p\n", epnum, pRequest);
DBG(20, "underrun on ep%d, req %p\n", epnum, request);
}
if (dma_channel_status(dma) == MGC_DMA_STATUS_BUSY) {
......@@ -454,7 +454,7 @@ void musb_g_tx(struct musb *musb, u8 epnum)
break;
}
if (pRequest) {
if (request) {
u8 is_dma = 0;
if (dma && (wCsrVal & MGC_M_TXCSR_DMAENAB)) {
......@@ -466,29 +466,29 @@ void musb_g_tx(struct musb *musb, u8 epnum)
musb_writew(epio, MGC_O_HDRC_TXCSR, wCsrVal);
/* ensure writebuffer is empty */
wCsrVal = musb_readw(epio, MGC_O_HDRC_TXCSR);
pRequest->actual += musb_ep->dma->actual_len;
request->actual += musb_ep->dma->actual_len;
DBG(4, "TXCSR%d %04x, dma off, "
"len %Zd, req %p\n",
epnum, wCsrVal,
musb_ep->dma->actual_len,
pRequest);
request);
}
if (is_dma || pRequest->actual == pRequest->length) {
if (is_dma || request->actual == request->length) {
/* First, maybe a terminating short packet.
* Some DMA engines might handle this by
* themselves.
*/
if ((pRequest->zero
&& pRequest->length
&& (pRequest->length
if ((request->zero
&& request->length
&& (request->length
% musb_ep->wPacketSize)
== 0)
#ifdef CONFIG_USB_INVENTRA_DMA
|| (is_dma &&
((!dma->desired_mode) ||
(pRequest->actual &
(request->actual &
(musb_ep->wPacketSize - 1))))
#endif
) {
......@@ -502,11 +502,11 @@ void musb_g_tx(struct musb *musb, u8 epnum)
musb_writew(epio, MGC_O_HDRC_TXCSR,
MGC_M_TXCSR_MODE
| MGC_M_TXCSR_TXPKTRDY);
pRequest->zero = 0;
request->zero = 0;
}
/* ... or if not, then complete it */
musb_g_giveback(musb_ep, pRequest, 0);
musb_g_giveback(musb_ep, request, 0);
/* kickstart next transfer if appropriate;
* the packet that just completed might not
......@@ -518,17 +518,17 @@ void musb_g_tx(struct musb *musb, u8 epnum)
wCsrVal = musb_readw(epio, MGC_O_HDRC_TXCSR);
if (wCsrVal & MGC_M_TXCSR_FIFONOTEMPTY)
break;
pRequest = musb_ep->desc
request = musb_ep->desc
? next_request(musb_ep)
: NULL;
if (!pRequest) {
if (!request) {
DBG(4, "%s idle now\n",
musb_ep->end_point.name);
break;
}
}
txstate(musb, to_musb_request(pRequest));
txstate(musb, to_musb_request(request));
}
} while (0);
......@@ -574,7 +574,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
{
u16 wCsrVal = 0;
const u8 epnum = req->epnum;
struct usb_request *pRequest = &req->request;
struct usb_request *request = &req->request;
struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_out;
void __iomem *epio = musb->endpoints[epnum].regs;
u16 fifo_count = 0;
......@@ -593,9 +593,9 @@ static void rxstate(struct musb *musb, struct musb_request *req)
*/
if (c->channel_program(channel,
musb_ep->wPacketSize,
!pRequest->short_not_ok,
pRequest->dma + pRequest->actual,
pRequest->length - pRequest->actual)) {
!request->short_not_ok,
request->dma + request->actual,
request->length - request->actual)) {
/* make sure that if an rxpkt arrived after the irq,
* the cppi engine will be ready to take it as soon
......@@ -611,7 +611,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
if (wCsrVal & MGC_M_RXCSR_RXPKTRDY) {
len = musb_readw(epio, MGC_O_HDRC_RXCOUNT);
if (pRequest->actual < pRequest->length) {
if (request->actual < request->length) {
#ifdef CONFIG_USB_INVENTRA_DMA
if (is_dma_capable() && musb_ep->dma) {
struct dma_controller *c;
......@@ -657,10 +657,10 @@ static void rxstate(struct musb *musb, struct musb_request *req)
musb_writew(epio, MGC_O_HDRC_RXCSR,
wCsrVal);
if (pRequest->actual < pRequest->length) {
if (request->actual < request->length) {
int transfer_size = 0;
#ifdef USE_MODE1
transfer_size = min(pRequest->length,
transfer_size = min(request->length,
channel->max_len);
#else
transfer_size = len;
......@@ -674,8 +674,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
channel,
musb_ep->wPacketSize,
channel->desired_mode,
pRequest->dma
+ pRequest->actual,
request->dma
+ request->actual,
transfer_size);
}
......@@ -684,7 +684,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
}
#endif /* Mentor's USB */
fifo_count = pRequest->length - pRequest->actual;
fifo_count = request->length - request->actual;
DBG(3, "%s OUT/RX pio fifo %d/%d, maxpacket %d\n",
musb_ep->end_point.name,
len, fifo_count,
......@@ -696,7 +696,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
if (tusb_dma_omap() && musb_ep->dma) {
struct dma_controller *c = musb->dma_controller;
struct dma_channel *channel = musb_ep->dma;
u32 dma_addr = pRequest->dma + pRequest->actual;
u32 dma_addr = request->dma + request->actual;
int ret;
ret = c->channel_program(channel,
......@@ -710,8 +710,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
#endif
musb_read_fifo(musb_ep->hw_ep, fifo_count, (u8 *)
(pRequest->buf + pRequest->actual));
pRequest->actual += fifo_count;
(request->buf + request->actual));
request->actual += fifo_count;
/* REVISIT if we left anything in the fifo, flush
* it and report -EOVERFLOW
......@@ -725,8 +725,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
}
/* reach the end or short packet detected */
if (pRequest->actual == pRequest->length || len < musb_ep->wPacketSize)
musb_g_giveback(musb_ep, pRequest, 0);
if (request->actual == request->length || len < musb_ep->wPacketSize)
musb_g_giveback(musb_ep, request, 0);
}
/*
......@@ -735,7 +735,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
void musb_g_rx(struct musb *musb, u8 epnum)
{
u16 wCsrVal;
struct usb_request *pRequest;
struct usb_request *request;
void __iomem *mbase = musb->mregs;
struct musb_ep *musb_ep = &musb->endpoints[epnum].ep_out;
void __iomem *epio = musb->endpoints[epnum].regs;
......@@ -743,27 +743,27 @@ void musb_g_rx(struct musb *musb, u8 epnum)
musb_ep_select(mbase, epnum);
pRequest = next_request(musb_ep);
request = next_request(musb_ep);
wCsrVal = musb_readw(epio, MGC_O_HDRC_RXCSR);
dma = is_dma_capable() ? musb_ep->dma : NULL;
DBG(4, "<== %s, rxcsr %04x%s %p\n", musb_ep->end_point.name,
wCsrVal, dma ? " (dma)" : "", pRequest);
wCsrVal, dma ? " (dma)" : "", request);
if (wCsrVal & MGC_M_RXCSR_P_SENTSTALL) {
if (dma_channel_status(dma) == MGC_DMA_STATUS_BUSY) {
dma->status = MGC_DMA_STATUS_CORE_ABORT;
(void) musb->dma_controller->channel_abort(dma);
pRequest->actual += musb_ep->dma->actual_len;
request->actual += musb_ep->dma->actual_len;
}
wCsrVal |= MGC_M_RXCSR_P_WZC_BITS;
wCsrVal &= ~MGC_M_RXCSR_P_SENTSTALL;
musb_writew(epio, MGC_O_HDRC_RXCSR, wCsrVal);
if (pRequest)
musb_g_giveback(musb_ep, pRequest, -EPIPE);
if (request)
musb_g_giveback(musb_ep, request, -EPIPE);
goto done;
}
......@@ -772,9 +772,9 @@ void musb_g_rx(struct musb *musb, u8 epnum)
wCsrVal &= ~MGC_M_RXCSR_P_OVERRUN;
musb_writew(epio, MGC_O_HDRC_RXCSR, wCsrVal);
DBG(3, "%s iso overrun on %p\n", musb_ep->name, pRequest);
if (pRequest && pRequest->status == -EINPROGRESS)
pRequest->status = -EOVERFLOW;
DBG(3, "%s iso overrun on %p\n", musb_ep->name, request);
if (request && request->status == -EINPROGRESS)
request->status = -EOVERFLOW;
}
if (wCsrVal & MGC_M_RXCSR_INCOMPRX) {
/* REVISIT not necessarily an error */
......@@ -796,12 +796,12 @@ void musb_g_rx(struct musb *musb, u8 epnum)
musb_writew(epio, MGC_O_HDRC_RXCSR,
MGC_M_RXCSR_P_WZC_BITS | wCsrVal);
pRequest->actual += musb_ep->dma->actual_len;
request->actual += musb_ep->dma->actual_len;
DBG(4, "RXCSR%d %04x, dma off, %04x, len %Zd, req %p\n",
epnum, wCsrVal,
musb_readw(epio, MGC_O_HDRC_RXCSR),
musb_ep->dma->actual_len, pRequest);
musb_ep->dma->actual_len, request);
#if defined(CONFIG_USB_INVENTRA_DMA) || defined(CONFIG_USB_TUSB_OMAP_DMA)
/* Autoclear doesn't clear RxPktRdy for short packets */
......@@ -814,15 +814,15 @@ void musb_g_rx(struct musb *musb, u8 epnum)
}
/* incomplete, and not short? wait for next IN packet */
if ((pRequest->actual < pRequest->length)
if ((request->actual < request->length)
&& (musb_ep->dma->actual_len
== musb_ep->wPacketSize))
goto done;
#endif
musb_g_giveback(musb_ep, pRequest, 0);
musb_g_giveback(musb_ep, request, 0);
pRequest = next_request(musb_ep);
if (!pRequest)
request = next_request(musb_ep);
if (!request)
goto done;
/* don't start more i/o till the stall clears */
......@@ -834,8 +834,8 @@ void musb_g_rx(struct musb *musb, u8 epnum)
/* analyze request if the ep is hot */
if (pRequest)
rxstate(musb, to_musb_request(pRequest));
if (request)
rxstate(musb, to_musb_request(request));
else
DBG(3, "packet waiting for %s%s request\n",
musb_ep->desc ? "" : "inactive ",
......@@ -1046,17 +1046,17 @@ static int musb_gadget_disable(struct usb_ep *ep)
struct usb_request *musb_alloc_request(struct usb_ep *ep, gfp_t gfp_flags)
{
struct musb_ep *musb_ep = to_musb_ep(ep);
struct musb_request *pRequest = NULL;
pRequest = kzalloc(sizeof *pRequest, gfp_flags);
if (pRequest) {
INIT_LIST_HEAD(&pRequest->request.list);
pRequest->request.dma = DMA_ADDR_INVALID;
pRequest->epnum = musb_ep->current_epnum;
pRequest->ep = musb_ep;
struct musb_request *request = NULL;
request = kzalloc(sizeof *request, gfp_flags);
if (request) {
INIT_LIST_HEAD(&request->request.list);
request->request.dma = DMA_ADDR_INVALID;
request->epnum = musb_ep->current_epnum;
request->ep = musb_ep;
}
return &pRequest->request;
return &request->request;
}
/*
......@@ -1097,7 +1097,7 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
gfp_t gfp_flags)
{
struct musb_ep *musb_ep;
struct musb_request *pRequest;
struct musb_request *request;
struct musb *musb;
int status = 0;
unsigned long lockflags;
......@@ -1110,43 +1110,43 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
musb_ep = to_musb_ep(ep);
musb = musb_ep->musb;
pRequest = to_musb_request(req);
pRequest->musb = musb;
request = to_musb_request(req);
request->musb = musb;
if (pRequest->ep != musb_ep)
if (request->ep != musb_ep)
return -EINVAL;
DBG(4, "<== to %s request=%p\n", ep->name, req);
/* request is mine now... */
pRequest->request.actual = 0;
pRequest->request.status = -EINPROGRESS;
pRequest->epnum = musb_ep->current_epnum;
pRequest->bTx = musb_ep->is_in;
request->request.actual = 0;
request->request.status = -EINPROGRESS;
request->epnum = musb_ep->current_epnum;
request->bTx = musb_ep->is_in;
if (is_dma_capable() && musb_ep->dma) {
if (pRequest->request.dma == DMA_ADDR_INVALID) {
pRequest->request.dma = dma_map_single(
if (request->request.dma == DMA_ADDR_INVALID) {
request->request.dma = dma_map_single(
musb->controller,
pRequest->request.buf,
pRequest->request.length,
pRequest->bTx
request->request.buf,
request->request.length,
request->bTx
? DMA_TO_DEVICE
: DMA_FROM_DEVICE);
pRequest->mapped = 1;
request->mapped = 1;
} else {
dma_sync_single_for_device(musb->controller,
pRequest->request.dma,
pRequest->request.length,
pRequest->bTx
request->request.dma,
request->request.length,
request->bTx
? DMA_TO_DEVICE
: DMA_FROM_DEVICE);
pRequest->mapped = 0;
request->mapped = 0;
}
} else if (!req->buf) {
return -ENODATA;
} else
pRequest->mapped = 0;
request->mapped = 0;
spin_lock_irqsave(&musb->lock, lockflags);
......@@ -1158,19 +1158,19 @@ static int musb_gadget_queue(struct usb_ep *ep, struct usb_request *req,
goto cleanup;
}
/* add pRequest to the list */
list_add_tail(&(pRequest->request.list), &(musb_ep->req_list));
/* add request to the list */
list_add_tail(&(request->request.list), &(musb_ep->req_list));
/* it this is the head of the queue, start i/o ... */
if (!musb_ep->busy && &pRequest->request.list == musb_ep->req_list.next)
musb_ep_restart(musb, pRequest);
if (!musb_ep->busy && &request->request.list == musb_ep->req_list.next)
musb_ep_restart(musb, request);
cleanup:
spin_unlock_irqrestore(&musb->lock, lockflags);
return status;
}
static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *pRequest)
static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *request)
{
struct musb_ep *musb_ep = to_musb_ep(ep);
struct usb_request *r;
......@@ -1178,24 +1178,24 @@ static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *pRequest)
int status = 0;
struct musb *musb = musb_ep->musb;
if (!ep || !pRequest || to_musb_request(pRequest)->ep != musb_ep)
if (!ep || !request || to_musb_request(request)->ep != musb_ep)
return -EINVAL;
spin_lock_irqsave(&musb->lock, flags);
list_for_each_entry(r, &musb_ep->req_list, list) {
if (r == pRequest)
if (r == request)
break;
}
if (r != pRequest) {
DBG(3, "request %p not queued to %s\n", pRequest, ep->name);
if (r != request) {
DBG(3, "request %p not queued to %s\n", request, ep->name);
status = -EINVAL;
goto done;
}
/* if the hardware doesn't have the request, easy ... */
if (musb_ep->req_list.next != &pRequest->list || musb_ep->busy)
musb_g_giveback(musb_ep, pRequest, -ECONNRESET);
if (musb_ep->req_list.next != &request->list || musb_ep->busy)
musb_g_giveback(musb_ep, request, -ECONNRESET);
/* ... else abort the dma transfer ... */
else if (is_dma_capable() && musb_ep->dma) {
......@@ -1207,12 +1207,12 @@ static int musb_gadget_dequeue(struct usb_ep *ep, struct usb_request *pRequest)
else
status = -EBUSY;
if (status == 0)
musb_g_giveback(musb_ep, pRequest, -ECONNRESET);
musb_g_giveback(musb_ep, request, -ECONNRESET);
} else {
/* NOTE: by sticking to easily tested hardware/driver states,
* we leave counting of in-flight packets imprecise.
*/
musb_g_giveback(musb_ep, pRequest, -ECONNRESET);
musb_g_giveback(musb_ep, request, -ECONNRESET);
}
done:
......@@ -1235,7 +1235,7 @@ int musb_gadget_set_halt(struct usb_ep *ep, int value)
void __iomem *mbase;
unsigned long flags;
u16 wCsr;
struct musb_request *pRequest = NULL;
struct musb_request *request = NULL;
int status = 0;
if (!ep)
......@@ -1252,7 +1252,7 @@ int musb_gadget_set_halt(struct usb_ep *ep, int value)
musb_ep_select(mbase, epnum);
/* cannot portably stall with non-empty FIFO */
pRequest = to_musb_request(next_request(musb_ep));
request = to_musb_request(next_request(musb_ep));
if (value && musb_ep->is_in) {
wCsr = musb_readw(epio, MGC_O_HDRC_TXCSR);
if (wCsr & MGC_M_TXCSR_FIFONOTEMPTY) {
......@@ -1294,9 +1294,9 @@ int musb_gadget_set_halt(struct usb_ep *ep, int value)
done:
/* maybe start the first request in the queue */
if (!musb_ep->busy && !value && pRequest) {
if (!musb_ep->busy && !value && request) {
DBG(3, "restarting the request\n");
musb_ep_restart(musb, pRequest);
musb_ep_restart(musb, request);
}
spin_unlock_irqrestore(&musb->lock, flags);
......
drivers/usb/musb/musb_host.c
View file @ ba4cd005
......@@ -950,7 +950,7 @@ static int musb_h_ep0_continue(struct musb *musb,
u16 fifo_count = 0;
struct musb_hw_ep *hw_ep = musb->control_ep;
struct musb_qh *qh = hw_ep->in_qh;
struct usb_ctrlrequest *pRequest;
struct usb_ctrlrequest *request;
switch (musb->ep0_stage) {
case MGC_END0_IN:
......@@ -972,12 +972,12 @@ static int musb_h_ep0_continue(struct musb *musb,
bMore = TRUE;
break;
case MGC_END0_START:
pRequest = (struct usb_ctrlrequest *) pUrb->setup_packet;
request = (struct usb_ctrlrequest *) pUrb->setup_packet;
if (!pRequest->wLength) {
if (!request->wLength) {
DBG(4, "start no-DATA\n");
break;
} else if (pRequest->bRequestType & USB_DIR_IN) {
} else if (request->bRequestType & USB_DIR_IN) {
DBG(4, "start IN-DATA\n");
musb->ep0_stage = MGC_END0_IN;
bMore = TRUE;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment