Firebee/FireBee_SVN
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

reformatted

Browse Source
This commit is contained in:
Markus Fröschle
2013-11-03 17:18:12 +00:00
parent 8977191d84
commit 70d2a312eb
2 changed files with 170 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files

282
sources/ohci-hcd.c
View File

@@ -147,12 +147,12 @@ static void urb_free_priv(urb_priv_t *urb)
int i; int i;
struct td *td; struct td *td;
int last = urb->length - 1; int last = urb->length - 1;
if(last >= 0) if (last >= 0)
{ {
for(i = 0; i <= last; i++) for(i = 0; i <= last; i++)
{ {
td = urb->td[i]; td = urb->td[i];
if(td) if (td)
{ {
td->usb_dev = NULL; td->usb_dev = NULL;
urb->td[i] = NULL; urb->td[i] = NULL;
@@ -186,17 +186,17 @@ static void pkt_print(ohci_t *ohci, urb_priv_t *purb, struct usb_device *dev,
(purb ? purb->actual_length : 0), (purb ? purb->actual_length : 0),
transfer_len, dev->status); transfer_len, dev->status);
#ifdef OHCI_VERBOSE_DEBUG #ifdef OHCI_VERBOSE_DEBUG
if(!small) if (!small)
{ {
int i, len; int i, len;
if(usb_pipecontrol(pipe)) if (usb_pipecontrol(pipe))
{ {
board_printf(__FILE__ ": cmd(8):"); board_printf(__FILE__ ": cmd(8):");
for(i = 0; i < 8 ; i++) for(i = 0; i < 8 ; i++)
board_printf(" %02x", ((uint8_t *)setup)[i]); board_printf(" %02x", ((uint8_t *)setup)[i]);
board_printf("\r\n"); board_printf("\r\n");
} }
if(transfer_len > 0 && buffer) if (transfer_len > 0 && buffer)
{ {
board_printf(__FILE__ ": data(%d/%d):", (purb ? purb->actual_length : 0), transfer_len); board_printf(__FILE__ ": data(%d/%d):", (purb ? purb->actual_length : 0), transfer_len);
len = usb_pipeout(pipe)? transfer_len : (purb ? purb->actual_length : 0); len = usb_pipeout(pipe)? transfer_len : (purb ? purb->actual_length : 0);
@@ -218,7 +218,7 @@ static void ep_print_int_eds(ohci_t *ohci, char *str)
{ {
j = 5; j = 5;
ed_p = &(ohci->hcca->int_table[i]); ed_p = &(ohci->hcca->int_table[i]);
if(*ed_p == 0) if (*ed_p == 0)
continue; continue;
board_printf(__FILE__ ": %s branch int %2d(%2x):", str, i, i); board_printf(__FILE__ ": %s branch int %2d(%2x):", str, i, i);
while(*ed_p != 0 && j--) while(*ed_p != 0 && j--)
@@ -253,7 +253,7 @@ static void maybe_print_eds(ohci_t *controller, char *label, uint32_t value)
ed_t *edp; ed_t *edp;
value += controller->dma_offset; value += controller->dma_offset;
edp = (ed_t *)value; edp = (ed_t *)value;
if(value && (value < 0xDFFFF0)) /* STRAM */ if (value && (value < 0xDFFFF0)) /* STRAM */
{ {
dbg("%s %08x", label, value); dbg("%s %08x", label, value);
dbg("%08x", edp->hwINFO); dbg("%08x", edp->hwINFO);
@@ -280,7 +280,7 @@ static void ohci_dump_status(ohci_t *controller)
{ {
struct ohci_regs *regs = controller->regs; struct ohci_regs *regs = controller->regs;
uint32_t temp = readl(&regs->revision) & 0xff; uint32_t temp = readl(&regs->revision) & 0xff;
if(temp != 0x10) if (temp != 0x10)
dbg("spec %d.%d", (temp >> 4), (temp & 0x0f)); dbg("spec %d.%d", (temp >> 4), (temp & 0x0f));
temp = readl(&regs->control); temp = readl(&regs->control);
dbg("control: 0x%08x%s%s%s HCFS=%s%s%s%s%s CBSR=%d", temp, dbg("control: 0x%08x%s%s%s HCFS=%s%s%s%s%s CBSR=%d", temp,
@@ -318,7 +318,7 @@ static void ohci_dump_roothub(ohci_t *controller, int verbose)
temp = roothub_a(controller); temp = roothub_a(controller);
// ndp = (temp & RH_A_NDP); // ndp = (temp & RH_A_NDP);
ndp = controller->ndp; ndp = controller->ndp;
if(verbose) if (verbose)
{ {
dbg("roothub.a: %08x POTPGT=%d%s%s%s%s%s NDP=%d", temp, dbg("roothub.a: %08x POTPGT=%d%s%s%s%s%s NDP=%d", temp,
((temp & RH_A_POTPGT) >> 24) & 0xff, ((temp & RH_A_POTPGT) >> 24) & 0xff,
@@ -375,7 +375,7 @@ static void ohci_dump(ohci_t *ohci, int verbose)
dbg("OHCI controller usb-%s-%c state", ohci->slot_name, (char)ohci->controller + '0'); dbg("OHCI controller usb-%s-%c state", ohci->slot_name, (char)ohci->controller + '0');
/* dumps some of the state we know about */ /* dumps some of the state we know about */
ohci_dump_status(ohci); ohci_dump_status(ohci);
if(verbose) if (verbose)
ep_print_int_eds(ohci, "hcca"); ep_print_int_eds(ohci, "hcca");
dbg("hcca frame #%04x", ohci->hcca->frame_no); dbg("hcca frame #%04x", ohci->hcca->frame_no);
ohci_dump_roothub(ohci, 1); ohci_dump_roothub(ohci, 1);
@@ -400,7 +400,7 @@ static int sohci_submit_job(ohci_t *ohci, urb_priv_t *urb, struct devrequest *se
int interval = urb->interval; int interval = urb->interval;
/* when controller's hung, permit only roothub cleanup attempts /* when controller's hung, permit only roothub cleanup attempts
* such as powering down ports */ * such as powering down ports */
if(ohci->disabled) if (ohci->disabled)
{ {
urb_free_priv(purb_priv); // added urb_free_priv(purb_priv); // added
err("sohci_submit_job: EPIPE"); err("sohci_submit_job: EPIPE");
@@ -411,7 +411,7 @@ static int sohci_submit_job(ohci_t *ohci, urb_priv_t *urb, struct devrequest *se
urb->finished = 0; urb->finished = 0;
/* every endpoint has a ed, locate and fill it */ /* every endpoint has a ed, locate and fill it */
ed = ep_add_ed(ohci, dev, pipe, interval, 1); ed = ep_add_ed(ohci, dev, pipe, interval, 1);
if(!ed) if (!ed)
{ {
urb_free_priv(purb_priv); // added urb_free_priv(purb_priv); // added
err("sohci_submit_job: ENOMEM"); err("sohci_submit_job: ENOMEM");
@@ -431,7 +431,7 @@ static int sohci_submit_job(ohci_t *ohci, urb_priv_t *urb, struct devrequest *se
break; break;
} }
ed->purb = urb; ed->purb = urb;
if(size >= (N_URB_TD - 1)) if (size >= (N_URB_TD - 1))
{ {
urb_free_priv(purb_priv); // added urb_free_priv(purb_priv); // added
err("need %d TDs, only have %d", size, N_URB_TD); err("need %d TDs, only have %d", size, N_URB_TD);
@@ -447,7 +447,7 @@ static int sohci_submit_job(ohci_t *ohci, urb_priv_t *urb, struct devrequest *se
for(i = 0; i < size; i++) for(i = 0; i < size; i++)
{ {
purb_priv->td[i] = td_alloc(dev); purb_priv->td[i] = td_alloc(dev);
if(!purb_priv->td[i]) if (!purb_priv->td[i])
{ {
purb_priv->length = i; purb_priv->length = i;
urb_free_priv(purb_priv); urb_free_priv(purb_priv);
@@ -455,14 +455,14 @@ static int sohci_submit_job(ohci_t *ohci, urb_priv_t *urb, struct devrequest *se
return -1; return -1;
} }
} }
if(ed->state == ED_NEW || (ed->state & ED_DEL)) if (ed->state == ED_NEW || (ed->state & ED_DEL))
{ {
urb_free_priv(purb_priv); urb_free_priv(purb_priv);
err("sohci_submit_job: EINVAL"); err("sohci_submit_job: EINVAL");
return -1; return -1;
} }
/* link the ed into a chain if is not already */ /* link the ed into a chain if is not already */
if(ed->state != ED_OPER) if (ed->state != ED_OPER)
ep_link(ohci, ed); ep_link(ohci, ed);
/* fill the TDs and link it to the ed */ /* fill the TDs and link it to the ed */
td_submit_job(ohci, dev, pipe, buffer, transfer_len, setup, purb_priv, interval); td_submit_job(ohci, dev, pipe, buffer, transfer_len, setup, purb_priv, interval);
@@ -476,7 +476,7 @@ static inline int sohci_return_job(ohci_t *ohci, urb_priv_t *urb)
{ {
case PIPE_INTERRUPT: case PIPE_INTERRUPT:
/* implicitly requeued */ /* implicitly requeued */
if((urb->dev->irq_handle != NULL) && (urb->dev->irq_act_len = urb->actual_length)) if ((urb->dev->irq_handle != NULL) && (urb->dev->irq_act_len = urb->actual_length))
{ {
writel(OHCI_INTR_WDH, &regs->intrenable); writel(OHCI_INTR_WDH, &regs->intrenable);
readl(&regs->intrenable); /* PCI posting flush */ readl(&regs->intrenable); /* PCI posting flush */
@@ -526,7 +526,7 @@ static int ep_int_ballance(ohci_t *ohci, int interval, int load)
*/ */
for(i = 0; i < 32; i++) for(i = 0; i < 32; i++)
{ {
if(ohci->ohci_int_load[branch] > ohci->ohci_int_load[i]) if (ohci->ohci_int_load[branch] > ohci->ohci_int_load[i])
branch = i; branch = i;
} }
branch = branch % interval; branch = branch % interval;
@@ -580,13 +580,13 @@ static int ep_link(ohci_t *ohci, ed_t *edi)
{ {
case PIPE_CONTROL: case PIPE_CONTROL:
ed->hwNextED = 0; ed->hwNextED = 0;
if(ohci->ed_controltail == NULL) if (ohci->ed_controltail == NULL)
writel(ed - ohci->dma_offset, &ohci->regs->ed_controlhead); writel(ed - ohci->dma_offset, &ohci->regs->ed_controlhead);
else else
ohci->ed_controltail->hwNextED = swpl((uint32_t)ed - ohci->dma_offset); ohci->ed_controltail->hwNextED = swpl((uint32_t)ed - ohci->dma_offset);
ed->ed_prev = ohci->ed_controltail; ed->ed_prev = ohci->ed_controltail;
if(!ohci->ed_controltail && !ohci->ed_rm_list[0] && !ohci->ed_rm_list[1] && !ohci->sleeping) if (!ohci->ed_controltail && !ohci->ed_rm_list[0] && !ohci->ed_rm_list[1] && !ohci->sleeping)
{ {
ohci->hc_control |= OHCI_CTRL_CLE; ohci->hc_control |= OHCI_CTRL_CLE;
writel(ohci->hc_control, &ohci->regs->control); writel(ohci->hc_control, &ohci->regs->control);
@@ -595,12 +595,12 @@ static int ep_link(ohci_t *ohci, ed_t *edi)
break; break;
case PIPE_BULK: case PIPE_BULK:
ed->hwNextED = 0; ed->hwNextED = 0;
if(ohci->ed_bulktail == NULL) if (ohci->ed_bulktail == NULL)
writel(ed - ohci->dma_offset, &ohci->regs->ed_bulkhead); writel(ed - ohci->dma_offset, &ohci->regs->ed_bulkhead);
else else
ohci->ed_bulktail->hwNextED = swpl((uint32_t)ed - ohci->dma_offset); ohci->ed_bulktail->hwNextED = swpl((uint32_t)ed - ohci->dma_offset);
ed->ed_prev = ohci->ed_bulktail; ed->ed_prev = ohci->ed_bulktail;
if(!ohci->ed_bulktail && !ohci->ed_rm_list[0] && !ohci->ed_rm_list[1] && !ohci->sleeping) if (!ohci->ed_bulktail && !ohci->ed_rm_list[0] && !ohci->ed_rm_list[1] && !ohci->sleeping)
{ {
ohci->hc_control |= OHCI_CTRL_BLE; ohci->hc_control |= OHCI_CTRL_BLE;
writel(ohci->hc_control, &ohci->regs->control); writel(ohci->hc_control, &ohci->regs->control);
@@ -639,7 +639,7 @@ static void periodic_unlink(struct ohci *ohci, volatile struct ed *ed, unsigned
/* ED might have been unlinked through another path */ /* ED might have been unlinked through another path */
while(*ed_p != 0) while(*ed_p != 0)
{ {
if((uint32_t)*ed_p == swpl((uint32_t)ed - ohci->dma_offset)) /* changed */ if ((uint32_t)*ed_p == swpl((uint32_t)ed - ohci->dma_offset)) /* changed */
{ {
*ed_p = ed->hwNextED; *ed_p = ed->hwNextED;
break; break;
@@ -662,9 +662,9 @@ static int ep_unlink(ohci_t *ohci, ed_t *edi)
switch(ed->type) switch(ed->type)
{ {
case PIPE_CONTROL: case PIPE_CONTROL:
if(ed->ed_prev == NULL) if (ed->ed_prev == NULL)
{ {
if(!ed->hwNextED) if (!ed->hwNextED)
{ {
ohci->hc_control &= ~OHCI_CTRL_CLE; ohci->hc_control &= ~OHCI_CTRL_CLE;
writel(ohci->hc_control, &ohci->regs->control); writel(ohci->hc_control, &ohci->regs->control);
@@ -673,15 +673,15 @@ static int ep_unlink(ohci_t *ohci, ed_t *edi)
} }
else else
ed->ed_prev->hwNextED = ed->hwNextED; ed->ed_prev->hwNextED = ed->hwNextED;
if(ohci->ed_controltail == ed) if (ohci->ed_controltail == ed)
ohci->ed_controltail = ed->ed_prev; ohci->ed_controltail = ed->ed_prev;
else else
((ed_t *)(swpl(*((uint32_t *)&ed->hwNextED)) + ohci->dma_offset))->ed_prev = ed->ed_prev; ((ed_t *)(swpl(*((uint32_t *)&ed->hwNextED)) + ohci->dma_offset))->ed_prev = ed->ed_prev;
break; break;
case PIPE_BULK: case PIPE_BULK:
if(ed->ed_prev == NULL) if (ed->ed_prev == NULL)
{ {
if(!ed->hwNextED) if (!ed->hwNextED)
{ {
ohci->hc_control &= ~OHCI_CTRL_BLE; ohci->hc_control &= ~OHCI_CTRL_BLE;
writel(ohci->hc_control, &ohci->regs->control); writel(ohci->hc_control, &ohci->regs->control);
@@ -690,7 +690,7 @@ static int ep_unlink(ohci_t *ohci, ed_t *edi)
} }
else else
ed->ed_prev->hwNextED = ed->hwNextED; ed->ed_prev->hwNextED = ed->hwNextED;
if(ohci->ed_bulktail == ed) if (ohci->ed_bulktail == ed)
ohci->ed_bulktail = ed->ed_prev; ohci->ed_bulktail = ed->ed_prev;
else else
((ed_t *)(swpl(*((uint32_t *)&ed->hwNextED)) + ohci->dma_offset))->ed_prev = ed->ed_prev; ((ed_t *)(swpl(*((uint32_t *)&ed->hwNextED)) + ohci->dma_offset))->ed_prev = ed->ed_prev;
@@ -722,13 +722,13 @@ static ed_t *ep_add_ed(ohci_t *ohci, struct usb_device *usb_dev, uint32_t pipe,
volatile ed_t *ed; volatile ed_t *ed;
struct ohci_device *ohci_dev = ohci->ohci_dev; struct ohci_device *ohci_dev = ohci->ohci_dev;
ed = ed_ret = &ohci_dev->ed[(usb_pipeendpoint(pipe) << 1) | (usb_pipecontrol(pipe)? 0: usb_pipeout(pipe))]; ed = ed_ret = &ohci_dev->ed[(usb_pipeendpoint(pipe) << 1) | (usb_pipecontrol(pipe)? 0: usb_pipeout(pipe))];
if((ed->state & ED_DEL) || (ed->state & ED_URB_DEL)) if ((ed->state & ED_DEL) || (ed->state & ED_URB_DEL))
{ {
err("ep_add_ed: pending delete"); err("ep_add_ed: pending delete");
/* pending delete request */ /* pending delete request */
return NULL; return NULL;
} }
if(ed->state == ED_NEW) if (ed->state == ED_NEW)
{ {
/* dummy td; end of td list for ed */ /* dummy td; end of td list for ed */
td = td_alloc(usb_dev); td = td_alloc(usb_dev);
@@ -744,7 +744,7 @@ static ed_t *ep_add_ed(ohci_t *ohci, struct usb_device *usb_dev, uint32_t pipe,
| (usb_pipecontrol(pipe)? 0: (usb_pipeout(pipe)? 0x800: 0x1000)) | (usb_pipecontrol(pipe)? 0: (usb_pipeout(pipe)? 0x800: 0x1000))
| usb_pipeslow(pipe) << 13 | usb_pipeslow(pipe) << 13
| usb_maxpacket(usb_dev, pipe) << 16); | usb_maxpacket(usb_dev, pipe) << 16);
if(ed->type == PIPE_INTERRUPT && ed->state == ED_UNLINK) if (ed->type == PIPE_INTERRUPT && ed->state == ED_UNLINK)
{ {
ed->int_period = interval; ed->int_period = interval;
ed->int_load = load; ed->int_load = load;
@@ -765,7 +765,7 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
#ifdef OHCI_FILL_TRACE #ifdef OHCI_FILL_TRACE
int i; int i;
#endif #endif
if(index > urb_priv->length) if (index > urb_priv->length)
{ {
err("index > length"); err("index > length");
return; return;
@@ -780,17 +780,17 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
td->index = index; td->index = index;
td->data = (uint32_t)data; td->data = (uint32_t)data;
#ifdef OHCI_FILL_TRACE #ifdef OHCI_FILL_TRACE
if(usb_pipebulk(urb_priv->pipe) && usb_pipeout(urb_priv->pipe)) if (usb_pipebulk(urb_priv->pipe) && usb_pipeout(urb_priv->pipe))
{ {
for(i = 0; i < len; i++) for(i = 0; i < len; i++)
board_printf("td->data[%d] %#2x ", i, ((unsigned char *)td->data)[i]); board_printf("td->data[%d] %#2x ", i, ((unsigned char *)td->data)[i]);
board_printf("\r\n"); board_printf("\r\n");
} }
#endif #endif
if(!len) if (!len)
data = NULL; data = NULL;
td->hwINFO = swpl(info); td->hwINFO = swpl(info);
if(data != NULL) if (data != NULL)
{ {
td->hwCBP = swpl((uint32_t)data - ohci->dma_offset); td->hwCBP = swpl((uint32_t)data - ohci->dma_offset);
td->hwBE = swpl((uint32_t)(data + len - 1 - ohci->dma_offset)); td->hwBE = swpl((uint32_t)(data + len - 1 - ohci->dma_offset));
@@ -804,7 +804,7 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
/* append to queue */ /* append to queue */
td->ed->hwTailP = td->hwNextTD; td->ed->hwTailP = td->hwNextTD;
#if 0 #if 0
if(data) if (data)
{ {
int i; int i;
board_printf("td_fill: %08x %08x %08X %08X at 0x%08X\r\n", board_printf("td_fill: %08x %08x %08X %08X at 0x%08X\r\n",
@@ -833,7 +833,7 @@ static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
unsigned int toggle = 0; unsigned int toggle = 0;
/* OHCI handles the DATA-toggles itself, we just use the USB-toggle /* OHCI handles the DATA-toggles itself, we just use the USB-toggle
* bits for reseting */ * bits for reseting */
if(usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe))) if (usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)))
toggle = TD_T_TOGGLE; toggle = TD_T_TOGGLE;
else else
{ {
@@ -841,7 +841,7 @@ static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 1); usb_settoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe), 1);
} }
urb->td_cnt = 0; urb->td_cnt = 0;
if(data_len) if (data_len)
data = buffer; data = buffer;
else else
data = NULL; data = NULL;
@@ -857,7 +857,7 @@ static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
info = usb_pipeout(pipe) ? TD_CC | TD_DP_OUT : TD_CC | TD_R | TD_DP_IN ; info = usb_pipeout(pipe) ? TD_CC | TD_DP_OUT : TD_CC | TD_R | TD_DP_IN ;
td_fill(ohci, info | (cnt? TD_T_TOGGLE:toggle), data, data_len, dev, cnt, urb); td_fill(ohci, info | (cnt? TD_T_TOGGLE:toggle), data, data_len, dev, cnt, urb);
cnt++; cnt++;
if(!ohci->sleeping) /* start bulk list */ if (!ohci->sleeping) /* start bulk list */
writel(OHCI_BLF, &ohci->regs->cmdstatus); writel(OHCI_BLF, &ohci->regs->cmdstatus);
break; break;
case PIPE_CONTROL: case PIPE_CONTROL:
@@ -865,7 +865,7 @@ static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
info = TD_CC | TD_DP_SETUP | TD_T_DATA0; info = TD_CC | TD_DP_SETUP | TD_T_DATA0;
td_fill(ohci, info, setup, 8, dev, cnt++, urb); td_fill(ohci, info, setup, 8, dev, cnt++, urb);
/* Optional Data phase */ /* Optional Data phase */
if(data_len > 0) if (data_len > 0)
{ {
info = usb_pipeout(pipe) ? TD_CC | TD_R | TD_DP_OUT | TD_T_DATA1 : TD_CC | TD_R | TD_DP_IN | TD_T_DATA1; info = usb_pipeout(pipe) ? TD_CC | TD_R | TD_DP_OUT | TD_T_DATA1 : TD_CC | TD_R | TD_DP_IN | TD_T_DATA1;
/* NOTE: mishandles transfers >8K, some >4K */ /* NOTE: mishandles transfers >8K, some >4K */
@@ -874,7 +874,7 @@ static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
/* Status phase */ /* Status phase */
info = usb_pipeout(pipe) ? TD_CC | TD_DP_IN | TD_T_DATA1 : TD_CC | TD_DP_OUT | TD_T_DATA1; info = usb_pipeout(pipe) ? TD_CC | TD_DP_IN | TD_T_DATA1 : TD_CC | TD_DP_OUT | TD_T_DATA1;
td_fill(ohci, info, data, 0, dev, cnt++, urb); td_fill(ohci, info, data, 0, dev, cnt++, urb);
if(!ohci->sleeping) /* start Control list */ if (!ohci->sleeping) /* start Control list */
writel(OHCI_CLF, &ohci->regs->cmdstatus); writel(OHCI_CLF, &ohci->regs->cmdstatus);
break; break;
case PIPE_INTERRUPT: case PIPE_INTERRUPT:
@@ -882,7 +882,7 @@ static void td_submit_job(ohci_t *ohci, struct usb_device *dev, uint32_t pipe,
td_fill(ohci, info, data, data_len, dev, cnt++, urb); td_fill(ohci, info, data, data_len, dev, cnt++, urb);
break; break;
} }
if(urb->length != cnt) if (urb->length != cnt)
dbg("TD LENGTH %d != CNT %d", urb->length, cnt); dbg("TD LENGTH %d != CNT %d", urb->length, cnt);
} }
@@ -899,15 +899,15 @@ static void dl_transfer_length(ohci_t *ohci, td_t *td)
tdINFO = swpl(td->hwINFO); tdINFO = swpl(td->hwINFO);
tdBE = swpl(td->hwBE); tdBE = swpl(td->hwBE);
tdCBP = swpl(td->hwCBP); tdCBP = swpl(td->hwCBP);
if(tdBE) if (tdBE)
tdBE += ohci->dma_offset; tdBE += ohci->dma_offset;
if(tdCBP) if (tdCBP)
tdCBP += ohci->dma_offset; tdCBP += ohci->dma_offset;
if(!(usb_pipecontrol(lurb_priv->pipe) && ((td->index == 0) || (td->index == lurb_priv->length - 1)))) if (!(usb_pipecontrol(lurb_priv->pipe) && ((td->index == 0) || (td->index == lurb_priv->length - 1))))
{ {
if(tdBE != 0) if (tdBE != 0)
{ {
if(td->hwCBP == 0) if (td->hwCBP == 0)
lurb_priv->actual_length += (tdBE - td->data + 1); lurb_priv->actual_length += (tdBE - td->data + 1);
else else
lurb_priv->actual_length += (tdCBP - td->data); lurb_priv->actual_length += (tdCBP - td->data);
@@ -922,12 +922,12 @@ static void check_status(ohci_t *ohci, td_t *td_list)
int urb_len = lurb_priv->length; int urb_len = lurb_priv->length;
uint32_t *phwHeadP = &td_list->ed->hwHeadP; uint32_t *phwHeadP = &td_list->ed->hwHeadP;
int cc = TD_CC_GET(swpl(td_list->hwINFO)); int cc = TD_CC_GET(swpl(td_list->hwINFO));
if(cc) if (cc)
{ {
err("OHCI usb-%s-%c error: %s (%x)", ohci->slot_name, (char)ohci->controller + '0', cc_to_string[cc], cc); err("OHCI usb-%s-%c error: %s (%x)", ohci->slot_name, (char)ohci->controller + '0', cc_to_string[cc], cc);
if(*phwHeadP & swpl(0x1)) if (*phwHeadP & swpl(0x1))
{ {
if(lurb_priv && ((td_list->index + 1) < urb_len)) if (lurb_priv && ((td_list->index + 1) < urb_len))
{ {
*phwHeadP = (lurb_priv->td[urb_len - 1]->hwNextTD & swpl(0xfffffff0)) | (*phwHeadP & swpl(0x2)); *phwHeadP = (lurb_priv->td[urb_len - 1]->hwNextTD & swpl(0xfffffff0)) | (*phwHeadP & swpl(0x2));
lurb_priv->td_cnt += urb_len - td_list->index - 1; lurb_priv->td_cnt += urb_len - td_list->index - 1;
@@ -949,7 +949,7 @@ static td_t *dl_reverse_done_list(ohci_t *ohci)
td_t *td_rev = NULL; td_t *td_rev = NULL;
td_t *td_list = NULL; td_t *td_list = NULL;
td_list_hc = swpl(ohci->hcca->done_head) & ~0xf; td_list_hc = swpl(ohci->hcca->done_head) & ~0xf;
if(td_list_hc) if (td_list_hc)
td_list_hc += ohci->dma_offset; td_list_hc += ohci->dma_offset;
ohci->hcca->done_head = 0; ohci->hcca->done_head = 0;
while(td_list_hc) while(td_list_hc)
@@ -959,7 +959,7 @@ static td_t *dl_reverse_done_list(ohci_t *ohci)
td_list->next_dl_td = td_rev; td_list->next_dl_td = td_rev;
td_rev = td_list; td_rev = td_list;
td_list_hc = swpl(td_list->hwNextTD) & ~0xf; td_list_hc = swpl(td_list->hwNextTD) & ~0xf;
if(td_list_hc) if (td_list_hc)
td_list_hc += ohci->dma_offset; td_list_hc += ohci->dma_offset;
} }
return td_list; return td_list;
@@ -970,7 +970,7 @@ static td_t *dl_reverse_done_list(ohci_t *ohci)
static void finish_urb(ohci_t *ohci, urb_priv_t *urb, int status) static void finish_urb(ohci_t *ohci, urb_priv_t *urb, int status)
{ {
if((status & (ED_OPER | ED_UNLINK)) && (urb->state != URB_DEL)) if ((status & (ED_OPER | ED_UNLINK)) && (urb->state != URB_DEL))
urb->finished = sohci_return_job(ohci, urb); urb->finished = sohci_return_job(ohci, urb);
else else
dbg("finish_urb: strange.., ED state %x, \r\n", status); dbg("finish_urb: strange.., ED state %x, \r\n", status);
@@ -992,7 +992,7 @@ static int takeback_td(ohci_t *ohci, td_t *td_list)
uint32_t tdINFO, edHeadP, edTailP; uint32_t tdINFO, edHeadP, edTailP;
tdINFO = swpl(td_list->hwINFO); tdINFO = swpl(td_list->hwINFO);
ed = td_list->ed; ed = td_list->ed;
if(ed == NULL) if (ed == NULL)
{ {
err("OHCI usb-%s-%c cannot get error code ED is null", ohci->slot_name, (char)ohci->controller + '0'); err("OHCI usb-%s-%c cannot get error code ED is null", ohci->slot_name, (char)ohci->controller + '0');
return stat; return stat;
@@ -1002,26 +1002,26 @@ static int takeback_td(ohci_t *ohci, td_t *td_list)
lurb_priv->td_cnt++; lurb_priv->td_cnt++;
/* error code of transfer */ /* error code of transfer */
cc = TD_CC_GET(tdINFO); cc = TD_CC_GET(tdINFO);
if(cc) if (cc)
{ {
err("OHCI usb-%s-%c error: %s (%x)", ohci->slot_name, (char)ohci->controller + '0', cc_to_string[cc], cc); err("OHCI usb-%s-%c error: %s (%x)", ohci->slot_name, (char)ohci->controller + '0', cc_to_string[cc], cc);
stat = cc_to_error[cc]; stat = cc_to_error[cc];
} }
/* see if this done list makes for all TD's of current URB, /* see if this done list makes for all TD's of current URB,
* and mark the URB finished if so */ * and mark the URB finished if so */
if(lurb_priv->td_cnt == lurb_priv->length) if (lurb_priv->td_cnt == lurb_priv->length)
finish_urb(ohci, lurb_priv, ed->state); finish_urb(ohci, lurb_priv, ed->state);
if(ohci->irq) if (ohci->irq)
dbg("dl_done_list: processing TD %x, len %x", lurb_priv->td_cnt, lurb_priv->length); dbg("dl_done_list: processing TD %x, len %x", lurb_priv->td_cnt, lurb_priv->length);
if(ed->state != ED_NEW && (!usb_pipeint(lurb_priv->pipe))) if (ed->state != ED_NEW && (!usb_pipeint(lurb_priv->pipe)))
{ {
edHeadP = swpl(ed->hwHeadP) & ~0xf; edHeadP = swpl(ed->hwHeadP) & ~0xf;
edTailP = swpl(ed->hwTailP); edTailP = swpl(ed->hwTailP);
/* unlink eds if they are not busy */ /* unlink eds if they are not busy */
if((edHeadP == edTailP) && (ed->state == ED_OPER)) if ((edHeadP == edTailP) && (ed->state == ED_OPER))
ep_unlink(ohci, ed); ep_unlink(ohci, ed);
} }
if(cc && (ed->type == PIPE_INTERRUPT)) /* added, but it's not the better method */ if (cc && (ed->type == PIPE_INTERRUPT)) /* added, but it's not the better method */
ep_unlink(ohci, ed); ep_unlink(ohci, ed);
return stat; return stat;
} }
@@ -1169,13 +1169,13 @@ int rh_check_port_status(ohci_t *controller)
{ {
temp = roothub_portstatus(controller, i); temp = roothub_portstatus(controller, i);
/* check for a device disconnect */ /* check for a device disconnect */
if(((temp & (RH_PS_PESC | RH_PS_CSC)) == (RH_PS_PESC | RH_PS_CSC)) && ((temp & RH_PS_CCS) == 0)) if (((temp & (RH_PS_PESC | RH_PS_CSC)) == (RH_PS_PESC | RH_PS_CSC)) && ((temp & RH_PS_CCS) == 0))
{ {
res = i; res = i;
break; break;
} }
/* check for a device connect */ /* check for a device connect */
if((temp & RH_PS_CSC) && (temp & RH_PS_CCS)) if ((temp & RH_PS_CSC) && (temp & RH_PS_CCS))
{ {
res = i; res = i;
break; break;
@@ -1200,10 +1200,10 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
#ifdef DEBUG #ifdef DEBUG
pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, cmd, "SUB(rh)", usb_pipein(pipe)); pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, cmd, "SUB(rh)", usb_pipein(pipe));
#else #else
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
#endif #endif
if(usb_pipeint(pipe)) if (usb_pipeint(pipe))
{ {
info("Root-Hub submit IRQ: NOT implemented"); info("Root-Hub submit IRQ: NOT implemented");
return 0; return 0;
@@ -1270,7 +1270,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
WR_RH_PORTSTAT(RH_PS_PSS); WR_RH_PORTSTAT(RH_PS_PSS);
OK(0); OK(0);
case (RH_PORT_RESET): /* BUG IN HUP CODE *********/ case (RH_PORT_RESET): /* BUG IN HUP CODE *********/
if(RD_RH_PORTSTAT & RH_PS_CCS) if (RD_RH_PORTSTAT & RH_PS_CCS)
WR_RH_PORTSTAT(RH_PS_PRS); WR_RH_PORTSTAT(RH_PS_PRS);
OK(0); OK(0);
case (RH_PORT_POWER): case (RH_PORT_POWER):
@@ -1278,7 +1278,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
wait(100 * 1000); wait(100 * 1000);
OK(0); OK(0);
case (RH_PORT_ENABLE): /* BUG IN HUP CODE *********/ case (RH_PORT_ENABLE): /* BUG IN HUP CODE *********/
if(RD_RH_PORTSTAT & RH_PS_CCS) if (RD_RH_PORTSTAT & RH_PS_CCS)
WR_RH_PORTSTAT(RH_PS_PES); WR_RH_PORTSTAT(RH_PS_PES);
OK(0); OK(0);
} }
@@ -1298,13 +1298,13 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
data_buf = root_hub_config_des; data_buf = root_hub_config_des;
OK(len); OK(len);
case(0x03): /* string descriptors */ case(0x03): /* string descriptors */
if(wValue == 0x0300) if (wValue == 0x0300)
{ {
len = min_t(unsigned int, leni, min_t(unsigned int, sizeof(root_hub_str_index0), wLength)); len = min_t(unsigned int, leni, min_t(unsigned int, sizeof(root_hub_str_index0), wLength));
data_buf = root_hub_str_index0; data_buf = root_hub_str_index0;
OK(len); OK(len);
} }
if(wValue == 0x0301) if (wValue == 0x0301)
{ {
len = min_t(unsigned int, leni, min_t(unsigned int, sizeof(root_hub_str_index1), wLength)); len = min_t(unsigned int, leni, min_t(unsigned int, sizeof(root_hub_str_index1), wLength));
data_buf = root_hub_str_index1; data_buf = root_hub_str_index1;
@@ -1322,18 +1322,18 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
// data_buf[2] = temp & RH_A_NDP; // data_buf[2] = temp & RH_A_NDP;
data_buf[2] = (uint8_t)ohci->ndp; data_buf[2] = (uint8_t)ohci->ndp;
data_buf[3] = 0; data_buf[3] = 0;
if(temp & RH_A_PSM) /* per-port power switching? */ if (temp & RH_A_PSM) /* per-port power switching? */
data_buf[3] |= 0x1; data_buf[3] |= 0x1;
if(temp & RH_A_NOCP) /* no overcurrent reporting? */ if (temp & RH_A_NOCP) /* no overcurrent reporting? */
data_buf[3] |= 0x10; data_buf[3] |= 0x10;
else if(temp & RH_A_OCPM) /* per-port overcurrent reporting? */ else if (temp & RH_A_OCPM) /* per-port overcurrent reporting? */
data_buf[3] |= 0x8; data_buf[3] |= 0x8;
/* corresponds to data_buf[4-7] */ /* corresponds to data_buf[4-7] */
datab[1] = 0; datab[1] = 0;
data_buf[5] = (temp & RH_A_POTPGT) >> 24; data_buf[5] = (temp & RH_A_POTPGT) >> 24;
temp = roothub_b(ohci); temp = roothub_b(ohci);
data_buf[7] = temp & RH_B_DR; data_buf[7] = temp & RH_B_DR;
if(data_buf[2] < 7) if (data_buf[2] < 7)
data_buf[8] = 0xff; data_buf[8] = 0xff;
else else
{ {
@@ -1353,18 +1353,18 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pip
#ifdef DEBUG #ifdef DEBUG
ohci_dump_roothub(ohci, 1); ohci_dump_roothub(ohci, 1);
#else #else
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
#endif #endif
len = min_t(int, len, leni); len = min_t(int, len, leni);
if(data != data_buf) if (data != data_buf)
memcpy(data, data_buf, len); memcpy(data, data_buf, len);
dev->act_len = len; dev->act_len = len;
dev->status = stat; dev->status = stat;
#ifdef DEBUG #ifdef DEBUG
pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, cmd, "RET(rh)", 0/*usb_pipein(pipe)*/); pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, cmd, "RET(rh)", 0/*usb_pipein(pipe)*/);
#else #else
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
#endif #endif
return stat; return stat;
@@ -1381,7 +1381,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
int maxsize = usb_maxpacket(dev, pipe); int maxsize = usb_maxpacket(dev, pipe);
int timeout; int timeout;
urb_priv_t *urb = (urb_priv_t *)usb_malloc(sizeof(urb_priv_t)); urb_priv_t *urb = (urb_priv_t *)usb_malloc(sizeof(urb_priv_t));
if(urb == NULL) if (urb == NULL)
{ {
err("submit_common_msg malloc failed"); err("submit_common_msg malloc failed");
return -1; return -1;
@@ -1393,7 +1393,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
urb->transfer_buffer_length = transfer_len; urb->transfer_buffer_length = transfer_len;
urb->interval = interval; urb->interval = interval;
/* device pulled? Shortcut the action. */ /* device pulled? Shortcut the action. */
if(ohci->devgone == dev) if (ohci->devgone == dev)
{ {
dev->status = USB_ST_CRC_ERR; dev->status = USB_ST_CRC_ERR;
return 0; return 0;
@@ -1402,15 +1402,15 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
urb->actual_length = 0; urb->actual_length = 0;
pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe)); pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe));
#else #else
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
#endif #endif
if(!maxsize) if (!maxsize)
{ {
err("submit_common_message: pipesize for pipe %lx is zero", pipe); err("submit_common_message: pipesize for pipe %lx is zero", pipe);
return -1; return -1;
} }
if(sohci_submit_job(ohci, urb, setup) < 0) if (sohci_submit_job(ohci, urb, setup) < 0)
{ {
err("sohci_submit_job failed"); err("sohci_submit_job failed");
return -1; return -1;
@@ -1421,7 +1421,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
#endif #endif
/* allow more time for a BULK device to react - some are slow */ /* allow more time for a BULK device to react - some are slow */
#define BULK_TO 5000 /* timeout in milliseconds */ #define BULK_TO 5000 /* timeout in milliseconds */
if(usb_pipebulk(pipe)) if (usb_pipebulk(pipe))
timeout = BULK_TO; timeout = BULK_TO;
else else
timeout = 1000; timeout = 1000;
@@ -1431,12 +1431,12 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
/* check whether the controller is done */ /* check whether the controller is done */
flush_data_cache(ohci); flush_data_cache(ohci);
#ifndef CONFIG_USB_INTERRUPT_POLLING #ifndef CONFIG_USB_INTERRUPT_POLLING
if(ohci->irq_enabled) if (ohci->irq_enabled)
stat = ohci->stat_irq; stat = ohci->stat_irq;
else else
#endif #endif
stat = hc_interrupt(ohci); stat = hc_interrupt(ohci);
if(stat < 0) if (stat < 0)
{ {
stat = USB_ST_CRC_ERR; stat = USB_ST_CRC_ERR;
break; break;
@@ -1450,15 +1450,15 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
* finished we need to re-iterate this loop so as * finished we need to re-iterate this loop so as
* hc_interrupt() gets called again as there needs to be some * hc_interrupt() gets called again as there needs to be some
* more TD's to process still */ * more TD's to process still */
if((stat >= 0) && (stat != 0xff) && (urb->finished)) if ((stat >= 0) && (stat != 0xff) && (urb->finished))
{ {
/* 0xff is returned for an SF-interrupt */ /* 0xff is returned for an SF-interrupt */
break; break;
} }
if(--timeout) if (--timeout)
{ {
wait(1 * 1000); wait(1 * 1000);
// if(!urb->finished) // if (!urb->finished)
// dbg("*"); // dbg("*");
} }
else else
@@ -1475,11 +1475,11 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, uint32_t pipe
#ifdef DEBUG #ifdef DEBUG
pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "RET(ctlr)", usb_pipein(pipe)); pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "RET(ctlr)", usb_pipein(pipe));
#else #else
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
#endif #endif
/* free TDs in urb_priv */ /* free TDs in urb_priv */
if(!usb_pipeint(pipe)) if (!usb_pipeint(pipe))
urb_free_priv(urb); urb_free_priv(urb);
return 0; return 0;
} }
@@ -1499,15 +1499,15 @@ int ohci_submit_control_msg(struct usb_device *dev, uint32_t pipe, void *buffer,
#ifdef DEBUG #ifdef DEBUG
pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe)); pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe));
#else #else
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
#endif #endif
if(!maxsize) if (!maxsize)
{ {
err("submit_control_message: pipesize for pipe %lx is zero", pipe); err("submit_control_message: pipesize for pipe %lx is zero", pipe);
return -1; return -1;
} }
if(((pipe >> 8) & 0x7f) == ohci->rh.devnum) if (((pipe >> 8) & 0x7f) == ohci->rh.devnum)
{ {
ohci->rh.dev = dev; ohci->rh.dev = dev;
/* root hub - redirect */ /* root hub - redirect */
@@ -1533,7 +1533,7 @@ static int hc_reset(ohci_t *ohci)
int timeout = 30; int timeout = 30;
int smm_timeout = 50; /* 0,5 sec */ int smm_timeout = 50; /* 0,5 sec */
dbg("%s\r\n", __FUNCTION__); dbg("%s\r\n", __FUNCTION__);
if((ohci->ent->vendor == PCI_VENDOR_ID_PHILIPS) if ((ohci->ent->vendor == PCI_VENDOR_ID_PHILIPS)
&& (ohci->ent->device == PCI_DEVICE_ID_PHILIPS_ISP1561)) && (ohci->ent->device == PCI_DEVICE_ID_PHILIPS_ISP1561))
{ {
#define EHCI_USBCMD_OFF 0x20 #define EHCI_USBCMD_OFF 0x20
@@ -1560,16 +1560,16 @@ static int hc_reset(ohci_t *ohci)
unsigned short flags; unsigned short flags;
do do
{ {
if(!(pci_rsc_desc->flags & FLG_IO)) if (!(pci_rsc_desc->flags & FLG_IO))
{ {
if(usb_base_addr == 0xFFFFFFFF) if (usb_base_addr == 0xFFFFFFFF)
{ {
uint32_t base = pci_rsc_desc->offset + pci_rsc_desc->start; uint32_t base = pci_rsc_desc->offset + pci_rsc_desc->start;
usb_base_addr = pci_rsc_desc->start; usb_base_addr = pci_rsc_desc->start;
writel(readl(base + EHCI_USBCMD_OFF) | EHCI_USBCMD_HCRESET, base + EHCI_USBCMD_OFF); writel(readl(base + EHCI_USBCMD_OFF) | EHCI_USBCMD_HCRESET, base + EHCI_USBCMD_OFF);
while(readl(base + EHCI_USBCMD_OFF) & EHCI_USBCMD_HCRESET) while(readl(base + EHCI_USBCMD_OFF) & EHCI_USBCMD_HCRESET)
{ {
if(timeout-- <= 0) if (timeout-- <= 0)
{ {
err("USB RootHub reset timed out!\r\n"); err("USB RootHub reset timed out!\r\n");
break; break;
@@ -1588,10 +1588,10 @@ static int hc_reset(ohci_t *ohci)
} }
while(handle >= 0); while(handle >= 0);
} }
if((ohci->controller == 0) && (ohci->ent->vendor == PCI_VENDOR_ID_NEC) if ((ohci->controller == 0) && (ohci->ent->vendor == PCI_VENDOR_ID_NEC)
&& (ohci->ent->device == PCI_DEVICE_ID_NEC_USB)) && (ohci->ent->device == PCI_DEVICE_ID_NEC_USB))
{ {
if(ohci->handle == 1) /* NEC on motherboard has FPGA clock */ if (ohci->handle == 1) /* NEC on motherboard has FPGA clock */
{ {
dbg("USB OHCI set 48MHz clock\r\n"); dbg("USB OHCI set 48MHz clock\r\n");
pci_write_config_longword(ohci->handle, 0xE4, 0x21); // oscillator & disable ehci pci_write_config_longword(ohci->handle, 0xE4, 0x21); // oscillator & disable ehci
@@ -1604,7 +1604,7 @@ static int hc_reset(ohci_t *ohci)
} }
} }
if(readl(&ohci->regs->control) & OHCI_CTRL_IR) if (readl(&ohci->regs->control) & OHCI_CTRL_IR)
{ {
/* SMM owns the HC */ /* SMM owns the HC */
writel(OHCI_OCR, &ohci->regs->cmdstatus);/* request ownership */ writel(OHCI_OCR, &ohci->regs->cmdstatus);/* request ownership */
@@ -1612,7 +1612,7 @@ static int hc_reset(ohci_t *ohci)
while(readl(&ohci->regs->control) & OHCI_CTRL_IR) while(readl(&ohci->regs->control) & OHCI_CTRL_IR)
{ {
wait(10 * 1000); wait(10 * 1000);
if(--smm_timeout == 0) if (--smm_timeout == 0)
{ {
err("USB HC TakeOver failed!"); err("USB HC TakeOver failed!");
return -1; return -1;
@@ -1630,7 +1630,7 @@ static int hc_reset(ohci_t *ohci)
writel(OHCI_HCR, &ohci->regs->cmdstatus); writel(OHCI_HCR, &ohci->regs->cmdstatus);
while((readl(&ohci->regs->cmdstatus) & OHCI_HCR) != 0) while((readl(&ohci->regs->cmdstatus) & OHCI_HCR) != 0)
{ {
if(--timeout == 0) if (--timeout == 0)
{ {
err("USB HC reset timed out!"); err("USB HC reset timed out!");
return -1; return -1;
@@ -1701,21 +1701,21 @@ static void flush_data_cache(ohci_t *ohci)
/* Poll USB interrupt. */ /* Poll USB interrupt. */
void ohci_usb_event_poll(int interrupt) void ohci_usb_event_poll(int interrupt)
{ {
if(ohci_inited) if (ohci_inited)
{ {
int i; int i;
for(i = 0; i < (sizeof(gohci) / sizeof(ohci_t)); i++) for(i = 0; i < (sizeof(gohci) / sizeof(ohci_t)); i++)
{ {
ohci_t *ohci = &gohci[i]; ohci_t *ohci = &gohci[i];
if(!ohci->handle || ohci->disabled) if (!ohci->handle || ohci->disabled)
continue; continue;
else else
{ {
flush_data_cache(ohci); flush_data_cache(ohci);
if(interrupt) if (interrupt)
ohci->irq = 0; ohci->irq = 0;
hc_interrupt(ohci); hc_interrupt(ohci);
if(interrupt) if (interrupt)
ohci->irq = -1; ohci->irq = -1;
} }
} }
@@ -1729,12 +1729,12 @@ static int hc_interrupt(ohci_t *ohci)
{ {
struct ohci_regs *regs = ohci->regs; struct ohci_regs *regs = ohci->regs;
int ints, stat = -1; int ints, stat = -1;
if((ohci->hcca->done_head != 0) && !(swpl(ohci->hcca->done_head) & 0x01)) if ((ohci->hcca->done_head != 0) && !(swpl(ohci->hcca->done_head) & 0x01))
ints = OHCI_INTR_WDH; ints = OHCI_INTR_WDH;
else else
{ {
ints = readl(&regs->intrstatus); ints = readl(&regs->intrstatus);
if(ints == ~(uint32_t)0) if (ints == ~(uint32_t)0)
{ {
ohci->disabled++; ohci->disabled++;
err("OHCI usb-%s-%c device removed!", ohci->slot_name, (char)ohci->controller + '0'); err("OHCI usb-%s-%c device removed!", ohci->slot_name, (char)ohci->controller + '0');
@@ -1743,21 +1743,21 @@ static int hc_interrupt(ohci_t *ohci)
else else
{ {
ints &= readl(&regs->intrenable); ints &= readl(&regs->intrenable);
if(ints == 0) if (ints == 0)
{ {
// dbg("hc_interrupt: returning..\r\n"); // dbg("hc_interrupt: returning..\r\n");
return 0xff; return 0xff;
} }
} }
} }
if(ohci->irq) if (ohci->irq)
dbg("Interrupt: 0x%x frame: 0x%x bus: %d", ints, le16_to_cpu(ohci->hcca->frame_no), ohci->controller); dbg("Interrupt: 0x%x frame: 0x%x bus: %d", ints, le16_to_cpu(ohci->hcca->frame_no), ohci->controller);
if(ints & OHCI_INTR_RHSC) /* root hub status change */ if (ints & OHCI_INTR_RHSC) /* root hub status change */
{ {
#ifdef USB_POLL_HUB #ifdef USB_POLL_HUB
if((queue_poll_hub != NULL) && (rh_check_port_status(ohci) >= 0)) if ((queue_poll_hub != NULL) && (rh_check_port_status(ohci) >= 0))
{ {
if(ohci->irq) if (ohci->irq)
xQueueAltSend(queue_poll_hub, (void *)&ohci->usbnum, 0); xQueueAltSend(queue_poll_hub, (void *)&ohci->usbnum, 0);
else else
{ {
@@ -1779,7 +1779,7 @@ static int hc_interrupt(ohci_t *ohci)
#ifdef DEBUG #ifdef DEBUG
ohci_dump(ohci, 1); ohci_dump(ohci, 1);
#else #else
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
#endif #endif
/* HC Reset */ /* HC Reset */
@@ -1787,9 +1787,9 @@ static int hc_interrupt(ohci_t *ohci)
writel(ohci->hc_control, &ohci->regs->control); writel(ohci->hc_control, &ohci->regs->control);
return -1; return -1;
} }
if(ints & OHCI_INTR_WDH) if (ints & OHCI_INTR_WDH)
{ {
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
writel(OHCI_INTR_WDH, &regs->intrdisable); writel(OHCI_INTR_WDH, &regs->intrdisable);
(void)readl(&regs->intrdisable); /* flush */ (void)readl(&regs->intrdisable); /* flush */
@@ -1797,20 +1797,20 @@ static int hc_interrupt(ohci_t *ohci)
writel(OHCI_INTR_WDH, &regs->intrenable); writel(OHCI_INTR_WDH, &regs->intrenable);
(void)readl(&regs->intrdisable); /* flush */ (void)readl(&regs->intrdisable); /* flush */
} }
if(ints & OHCI_INTR_SO) if (ints & OHCI_INTR_SO)
{ {
dbg("USB Schedule overrun\r\n"); dbg("USB Schedule overrun\r\n");
writel(OHCI_INTR_SO, &regs->intrenable); writel(OHCI_INTR_SO, &regs->intrenable);
stat = -1; stat = -1;
} }
/* FIXME: this assumes SOF (1/ms) interrupts don't get lost... */ /* FIXME: this assumes SOF (1/ms) interrupts don't get lost... */
if(ints & OHCI_INTR_SF) if (ints & OHCI_INTR_SF)
{ {
unsigned int frame = swpw(ohci->hcca->frame_no) & 1; unsigned int frame = swpw(ohci->hcca->frame_no) & 1;
if(ohci->irq) if (ohci->irq)
wait(1 * 1000); wait(1 * 1000);
writel(OHCI_INTR_SF, &regs->intrdisable); writel(OHCI_INTR_SF, &regs->intrdisable);
if(ohci->ed_rm_list[frame] != NULL) if (ohci->ed_rm_list[frame] != NULL)
writel(OHCI_INTR_SF, &regs->intrenable); writel(OHCI_INTR_SF, &regs->intrenable);
stat = 0xff; stat = 0xff;
} }
@@ -1822,7 +1822,7 @@ static int hc_interrupt(ohci_t *ohci)
static int handle_usb_interrupt(ohci_t *ohci) static int handle_usb_interrupt(ohci_t *ohci)
{ {
if(!ohci->irq_enabled) if (!ohci->irq_enabled)
return 0; return 0;
flush_data_cache(ohci); flush_data_cache(ohci);
ohci->irq = 0; ohci->irq = 0;
@@ -1838,10 +1838,10 @@ void ohci_usb_enable_interrupt(int enable)
for(i = 0; i < (sizeof(gohci) / sizeof(ohci_t)); i++) for(i = 0; i < (sizeof(gohci) / sizeof(ohci_t)); i++)
{ {
ohci_t *ohci = &gohci[i]; ohci_t *ohci = &gohci[i];
if(!ohci->handle) if (!ohci->handle)
continue; continue;
ohci->irq_enabled = enable; ohci->irq_enabled = enable;
if(enable) if (enable)
writel(OHCI_INTR_MIE, &ohci->regs->intrenable); writel(OHCI_INTR_MIE, &ohci->regs->intrenable);
else else
writel(OHCI_INTR_MIE, &ohci->regs->intrdisable); writel(OHCI_INTR_MIE, &ohci->regs->intrdisable);
@@ -1859,23 +1859,23 @@ void ohci_usb_enable_interrupt(int enable)
static void hc_release_ohci(ohci_t *ohci) static void hc_release_ohci(ohci_t *ohci)
{ {
dbg("USB HC release OHCI usb-%s-%c", ohci->slot_name, (char)ohci->controller + '0'); dbg("USB HC release OHCI usb-%s-%c", ohci->slot_name, (char)ohci->controller + '0');
if(!ohci->disabled) if (!ohci->disabled)
hc_reset(ohci); hc_reset(ohci);
} }
static void hc_free_buffers(ohci_t *ohci) static void hc_free_buffers(ohci_t *ohci)
{ {
if(ohci->td_unaligned != NULL) if (ohci->td_unaligned != NULL)
{ {
/* FIXME: usb_free(ohci->td_unaligned); */ /* FIXME: usb_free(ohci->td_unaligned); */
ohci->td_unaligned = NULL; ohci->td_unaligned = NULL;
} }
if(ohci->ohci_dev_unaligned != NULL) if (ohci->ohci_dev_unaligned != NULL)
{ {
/* FIXME: usb_free(ohci->ohci_dev_unaligned); */ /* FIXME: usb_free(ohci->ohci_dev_unaligned); */
ohci->ohci_dev_unaligned = NULL; ohci->ohci_dev_unaligned = NULL;
} }
if(ohci->hcca_unaligned != NULL) if (ohci->hcca_unaligned != NULL)
{ {
/* FIXME: usb_free(ohci->hcca_unaligned); */ /* FIXME: usb_free(ohci->hcca_unaligned); */
ohci->hcca_unaligned = NULL; ohci->hcca_unaligned = NULL;
@@ -1899,14 +1899,14 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
ohci->handle = handle; ohci->handle = handle;
ohci->ent = ent; ohci->ent = ent;
} }
else if(!ohci->handle) /* for restart USB cmd */ else if (!ohci->handle) /* for restart USB cmd */
return(-1); return(-1);
info("ohci %p", ohci); info("ohci %p", ohci);
ohci->controller = (ohci->handle >> 16) & 3; /* PCI function */ ohci->controller = (ohci->handle >> 16) & 3; /* PCI function */
/* this must be aligned to a 256 byte boundary */ /* this must be aligned to a 256 byte boundary */
ohci->hcca_unaligned = (struct ohci_hcca *)usb_malloc(sizeof(struct ohci_hcca) + 256); ohci->hcca_unaligned = (struct ohci_hcca *)usb_malloc(sizeof(struct ohci_hcca) + 256);
if(ohci->hcca_unaligned == NULL) if (ohci->hcca_unaligned == NULL)
{ {
err("HCCA malloc failed"); err("HCCA malloc failed");
return(-1); return(-1);
@@ -1916,7 +1916,7 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
memset(ohci->hcca, 0, sizeof(struct ohci_hcca)); memset(ohci->hcca, 0, sizeof(struct ohci_hcca));
info("aligned ghcca %p", ohci->hcca); info("aligned ghcca %p", ohci->hcca);
ohci->ohci_dev_unaligned = (struct ohci_device *)usb_malloc(sizeof(struct ohci_device) + 8); ohci->ohci_dev_unaligned = (struct ohci_device *)usb_malloc(sizeof(struct ohci_device) + 8);
if(ohci->ohci_dev_unaligned == NULL) if (ohci->ohci_dev_unaligned == NULL)
{ {
err("EDs malloc failed"); err("EDs malloc failed");
hc_free_buffers(ohci); hc_free_buffers(ohci);
@@ -1926,7 +1926,7 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
memset(ohci->ohci_dev, 0, sizeof(struct ohci_device)); memset(ohci->ohci_dev, 0, sizeof(struct ohci_device));
info("aligned EDs %p", ohci->ohci_dev); info("aligned EDs %p", ohci->ohci_dev);
ohci->td_unaligned = (td_t *)usb_malloc(sizeof(td_t) * (NUM_TD + 1)); ohci->td_unaligned = (td_t *)usb_malloc(sizeof(td_t) * (NUM_TD + 1));
if(ohci->td_unaligned == NULL) if (ohci->td_unaligned == NULL)
{ {
err("TDs malloc failed"); err("TDs malloc failed");
hc_free_buffers(ohci); hc_free_buffers(ohci);
@@ -1939,23 +1939,23 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
ohci->disabled = 1; ohci->disabled = 1;
ohci->sleeping = 0; ohci->sleeping = 0;
ohci->irq = -1; ohci->irq = -1;
if((long)pci_rsc_desc >= 0) if ((long)pci_rsc_desc >= 0)
{ {
unsigned short flags; unsigned short flags;
do do
{ {
dbg("PCI USB descriptors: flags 0x%04x start 0x%08lx \r\n offset 0x%08lx dmaoffset 0x%08lx length 0x%08lx", dbg("PCI USB descriptors: flags 0x%04x start 0x%08lx \r\n offset 0x%08lx dmaoffset 0x%08lx length 0x%08lx",
pci_rsc_desc->flags, pci_rsc_desc->start, pci_rsc_desc->offset, pci_rsc_desc->dmaoffset, pci_rsc_desc->length); pci_rsc_desc->flags, pci_rsc_desc->start, pci_rsc_desc->offset, pci_rsc_desc->dmaoffset, pci_rsc_desc->length);
if(!(pci_rsc_desc->flags & FLG_IO)) if (!(pci_rsc_desc->flags & FLG_IO))
{ {
if(usb_base_addr == 0xFFFFFFFF) if (usb_base_addr == 0xFFFFFFFF)
{ {
usb_base_addr = pci_rsc_desc->start; usb_base_addr = pci_rsc_desc->start;
ohci->offset = pci_rsc_desc->offset; ohci->offset = pci_rsc_desc->offset;
ohci->regs = (void *)(pci_rsc_desc->offset + pci_rsc_desc->start); ohci->regs = (void *)(pci_rsc_desc->offset + pci_rsc_desc->start);
ohci->dma_offset = pci_rsc_desc->dmaoffset; ohci->dma_offset = pci_rsc_desc->dmaoffset;
/* big_endian unused actually */ /* big_endian unused actually */
if((pci_rsc_desc->flags & FLG_ENDMASK) == ORD_MOTOROLA) if ((pci_rsc_desc->flags & FLG_ENDMASK) == ORD_MOTOROLA)
ohci->big_endian = 0; /* host bridge make swapping intel -> motorola */ ohci->big_endian = 0; /* host bridge make swapping intel -> motorola */
else else
ohci->big_endian = 1; /* driver must swapping intel -> motorola */ ohci->big_endian = 1; /* driver must swapping intel -> motorola */
@@ -1971,12 +1971,12 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
hc_free_buffers(ohci); hc_free_buffers(ohci);
return(-1); /* get_resource error */ return(-1); /* get_resource error */
} }
if(usb_base_addr == 0xFFFFFFFF) if (usb_base_addr == 0xFFFFFFFF)
{ {
hc_free_buffers(ohci); hc_free_buffers(ohci);
return(-1); return(-1);
} }
if(handle && (ent != NULL)) if (handle && (ent != NULL))
{ {
ohci->flags = 0; ohci->flags = 0;
switch(ent->vendor) switch(ent->vendor)
@@ -1988,14 +1988,14 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
} }
} }
xprintf("OHCI usb-%s-%c, regs address 0x%08X, PCI handle 0x%X\r\n", ohci->slot_name, (char)ohci->controller + '0', ohci->regs, handle); xprintf("OHCI usb-%s-%c, regs address 0x%08X, PCI handle 0x%X\r\n", ohci->slot_name, (char)ohci->controller + '0', ohci->regs, handle);
if(hc_reset(ohci) < 0) if (hc_reset(ohci) < 0)
{ {
err("Can't reset OHCI usb-%s-%c", ohci->slot_name, (char)ohci->controller + '0'); err("Can't reset OHCI usb-%s-%c", ohci->slot_name, (char)ohci->controller + '0');
hc_release_ohci(ohci); hc_release_ohci(ohci);
hc_free_buffers(ohci); hc_free_buffers(ohci);
return(-1); return(-1);
} }
if(hc_start(ohci) < 0) if (hc_start(ohci) < 0)
{ {
err("Can't start OHCI usb-%s-%c", ohci->slot_name, (char)ohci->controller + '0'); err("Can't start OHCI usb-%s-%c", ohci->slot_name, (char)ohci->controller + '0');
hc_release_ohci(ohci); hc_release_ohci(ohci);
@@ -2007,7 +2007,7 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
ohci_dump(ohci, 1); ohci_dump(ohci, 1);
#endif #endif
pci_hook_interrupt(handle, handle_usb_interrupt, ohci); pci_hook_interrupt(handle, handle_usb_interrupt, ohci);
if(priv != NULL) if (priv != NULL)
*priv = (void *)ohci; *priv = (void *)ohci;
ohci_inited = 1; ohci_inited = 1;
return(0); return(0);
@@ -2018,9 +2018,9 @@ int ohci_usb_lowlevel_stop(void *priv)
/* this gets called really early - before the controller has */ /* this gets called really early - before the controller has */
/* even been initialized! */ /* even been initialized! */
ohci_t *ohci = (ohci_t *)priv; ohci_t *ohci = (ohci_t *)priv;
if(!ohci_inited) if (!ohci_inited)
return(0); return(0);
if(ohci == NULL) if (ohci == NULL)
ohci = &gohci[0]; ohci = &gohci[0];
pci_unhook_interrupt(ohci->handle); pci_unhook_interrupt(ohci->handle);

58
sources/usb_mem.c
View File

@@ -75,7 +75,7 @@ static void *xmgetblk(void)
int i; int i;
for(i = 0; i < MAXMD; i++) for(i = 0; i < MAXMD; i++)
{ {
if(tab_md[i].m_own == NULL) if (tab_md[i].m_own == NULL)
{ {
tab_md[i].m_own = (void*)1L; tab_md[i].m_own = (void*)1L;
return(&tab_md[i]); return(&tab_md[i]);
@@ -87,7 +87,7 @@ static void *xmgetblk(void)
static void xmfreblk(void *m) static void xmfreblk(void *m)
{ {
int i = (int)(((long)m - (long)tab_md) / sizeof(MD)); int i = (int)(((long)m - (long)tab_md) / sizeof(MD));
if((i > 0) && (i < MAXMD)) if ((i > 0) && (i < MAXMD))
tab_md[i].m_own = NULL; tab_md[i].m_own = NULL;
} }
@@ -96,35 +96,35 @@ static MD *ffit(long amount, MPB *mp)
MD *p,*q,*p1; /* free list is composed of MD's */ MD *p,*q,*p1; /* free list is composed of MD's */
int maxflg; int maxflg;
long maxval; long maxval;
if(amount != -1) if (amount != -1)
{ {
amount += 15; /* 16 bytes alignment */ amount += 15; /* 16 bytes alignment */
amount &= 0xFFFFFFF0; amount &= 0xFFFFFFF0;
} }
if((q = mp->mp_rover) == 0) /* get rotating pointer */ if ((q = mp->mp_rover) == 0) /* get rotating pointer */
return(0) ; return(0) ;
maxval = 0; maxval = 0;
maxflg = ((amount == -1) ? TRUE : FALSE) ; maxflg = ((amount == -1) ? TRUE : FALSE) ;
p = q->m_link; /* start with next MD */ p = q->m_link; /* start with next MD */
do /* search the list for an MD with enough space */ do /* search the list for an MD with enough space */
{ {
if(p == 0) if (p == 0)
{ {
/* at end of list, wrap back to start */ /* at end of list, wrap back to start */
q = (MD *) &mp->mp_mfl; /* q => mfl field */ q = (MD *) &mp->mp_mfl; /* q => mfl field */
p = q->m_link; /* p => 1st MD */ p = q->m_link; /* p => 1st MD */
} }
if((!maxflg) && (p->m_length >= amount)) if ((!maxflg) && (p->m_length >= amount))
{ {
/* big enough */ /* big enough */
if(p->m_length == amount) if (p->m_length == amount)
q->m_link = p->m_link; /* take the whole thing */ q->m_link = p->m_link; /* take the whole thing */
else else
{ {
/* break it up - 1st allocate a new /* break it up - 1st allocate a new
MD to describe the remainder */ MD to describe the remainder */
p1 = xmgetblk(); p1 = xmgetblk();
if(p1 == NULL) if (p1 == NULL)
return(NULL); return(NULL);
/* init new MD */ /* init new MD */
p1->m_length = p->m_length - amount; p1->m_length = p->m_length - amount;
@@ -140,16 +140,16 @@ static MD *ffit(long amount, MPB *mp)
mp->mp_rover = (q == (MD *) &mp->mp_mfl ? q->m_link : q); mp->mp_rover = (q == (MD *) &mp->mp_mfl ? q->m_link : q);
return(p); /* got some */ return(p); /* got some */
} }
else if(p->m_length > maxval) else if (p->m_length > maxval)
maxval = p->m_length; maxval = p->m_length;
p = ( q=p )->m_link; p = ( q=p )->m_link;
} }
while(q != mp->mp_rover); while(q != mp->mp_rover);
/* return either the max, or 0 (error) */ /* return either the max, or 0 (error) */
if(maxflg) if (maxflg)
{ {
maxval -= 15; /* 16 bytes alignment */ maxval -= 15; /* 16 bytes alignment */
if(maxval < 0) if (maxval < 0)
maxval = 0; maxval = 0;
else else
maxval &= 0xFFFFFFF0; maxval &= 0xFFFFFFF0;
@@ -163,34 +163,34 @@ static void freeit(MD *m, MPB *mp)
q = 0; q = 0;
for(p = mp->mp_mfl; p ; p = (q=p) -> m_link) for(p = mp->mp_mfl; p ; p = (q=p) -> m_link)
{ {
if(m->m_start <= p->m_start) if (m->m_start <= p->m_start)
break; break;
} }
m->m_link = p; m->m_link = p;
if(q) if (q)
q->m_link = m; q->m_link = m;
else else
mp->mp_mfl = m; mp->mp_mfl = m;
if(!mp->mp_rover) if (!mp->mp_rover)
mp->mp_rover = m; mp->mp_rover = m;
if(p) if (p)
{ {
if(m->m_start + m->m_length == p->m_start) if (m->m_start + m->m_length == p->m_start)
{ /* join to higher neighbor */ { /* join to higher neighbor */
m->m_length += p->m_length; m->m_length += p->m_length;
m->m_link = p->m_link; m->m_link = p->m_link;
if(p == mp->mp_rover) if (p == mp->mp_rover)
mp->mp_rover = m; mp->mp_rover = m;
xmfreblk(p); xmfreblk(p);
} }
} }
if(q) if (q)
{ {
if(q->m_start + q->m_length == m->m_start) if (q->m_start + q->m_length == m->m_start)
{ /* join to lower neighbor */ { /* join to lower neighbor */
q->m_length += m->m_length; q->m_length += m->m_length;
q->m_link = m->m_link; q->m_link = m->m_link;
if(m == mp->mp_rover) if (m == mp->mp_rover)
mp->mp_rover = q; mp->mp_rover = q;
xmfreblk(m); xmfreblk(m);
} }
@@ -206,10 +206,10 @@ int usb_free(void *addr)
level = asm_set_ipl(7); level = asm_set_ipl(7);
for(p = *(q = &mpb->mp_mal); p; p = *(q = &p->m_link)) for(p = *(q = &mpb->mp_mal); p; p = *(q = &p->m_link))
{ {
if((long)addr == p->m_start) if ((long)addr == p->m_start)
break; break;
} }
if(!p) if (!p)
{ {
asm_set_ipl(level); asm_set_ipl(level);
return(-1); return(-1);
@@ -226,15 +226,15 @@ void *usb_malloc(long amount)
void *ret = NULL; void *ret = NULL;
int level; int level;
MD *m; MD *m;
if(amount == -1L) if (amount == -1L)
return((void *)ffit(-1L,&pmd)); return((void *)ffit(-1L, &pmd));
if(amount <= 0 ) if (amount <= 0 )
return(0); return(0);
if((amount & 1)) if ((amount & 1))
amount++; amount++;
level = asm_set_ipl(7); level = asm_set_ipl(7);
m = ffit(amount, &pmd); m = ffit(amount, &pmd);
if(m != NULL) if (m != NULL)
ret = (void *)m->m_start; ret = (void *)m->m_start;
asm_set_ipl(level); asm_set_ipl(level);
USB_MEM_PRINTF("usb_malloc(%d) = 0x%08X\r\n", amount, ret); USB_MEM_PRINTF("usb_malloc(%d) = 0x%08X\r\n", amount, ret);
@@ -247,7 +247,7 @@ int usb_mem_init(void)
{ {
#ifdef USE_RADEON_MEMORY #ifdef USE_RADEON_MEMORY
usb_buffer = (void *)offscren_reserved(); usb_buffer = (void *)offscren_reserved();
if(usb_buffer == NULL) if (usb_buffer == NULL)
#else #else
#endif #endif
memset(usb_buffer, 0, USB_BUFFER_SIZE); memset(usb_buffer, 0, USB_BUFFER_SIZE);
@@ -269,7 +269,7 @@ void usb_mem_stop(void)
{ {
#ifndef CONFIG_USB_MEM_NO_CACHE #ifndef CONFIG_USB_MEM_NO_CACHE
#ifdef USE_RADEON_MEMORY #ifdef USE_RADEON_MEMORY
if(usb_buffer == (void *)offscren_reserved()) if (usb_buffer == (void *)offscren_reserved())
return; return;
#endif #endif
#endif #endif