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

implemented more helper functions needed by usb

Browse Source
This commit is contained in:
Markus Fröschle
2013-11-03 08:19:19 +00:00
parent 8d550a07d7
commit 6b0dcee284
13 changed files with 1829 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
sources/bas_string.c
View File

@@ -42,6 +42,18 @@ void bzero(void *s, size_t n)
((unsigned char *) s)[i] = '\0';
}
void *memset(void *s, int c, size_t n)
{
uint8_t *dst = s;
do
{
*dst++ = c;
} while ((dst - (uint8_t *) s) < n);
return s;
}
int strncmp(const char *s1, const char *s2, int max)
{

125
sources/ehci-hcd.c
View File

@@ -23,6 +23,7 @@
#include "util.h" /* for endian conversions */
#include "wait.h"
#include "usb.h"
#include "ehci.h"
@@ -204,13 +205,13 @@ static void cache_qh(struct QH *qh, int flush)
if((uint32_t)qh & QH_LINK_TYPE_QH)
break;
qh = qh_addr(qh);
qh = (struct QH *)(hc32_to_cpu(qh->qh_link) + gehci.dma_offset);
qh = (struct QH *)(swpl(qh->qh_link) + gehci.dma_offset);
}
qh = qh_addr(qh);
/* Save first qTD pointer, needed for invalidating pass on this QH */
if(flush)
{
qtd = (struct qTD *)(hc32_to_cpu(*(uint32_t *)&qh->qh_overlay) & 0xffffffe0);
qtd = (struct qTD *)(swpl(*(uint32_t *)&qh->qh_overlay) & 0xffffffe0);
if(qtd != NULL)
qtd = (struct qTD *)(gehci.dma_offset + (uint32_t)qtd);
first_qtd = qtd;
@@ -223,7 +224,7 @@ static void cache_qh(struct QH *qh, int flush)
if(qtd == NULL)
break;
cache_qtd(qtd, flush);
next = (struct qTD *)((uint32_t)hc32_to_cpu(qtd->qt_next) & 0xffffffe0);
next = (struct qTD *)((uint32_t)swpl(qtd->qt_next) & 0xffffffe0);
if(next != NULL)
next = (struct qTD *)(gehci.dma_offset + (uint32_t)next);
if(next == qtd)
@@ -396,7 +397,7 @@ static int ehci_td_buffer(struct qTD *td, void *buf, size_t sz)
idx = 0;
while(idx < 5)
{
td->qt_buffer[idx] = cpu_to_hc32(addr - gehci.dma_offset);
td->qt_buffer[idx] = swpl(addr - gehci.dma_offset);
next = (addr + 4096) & ~4095;
delta = next - addr;
if(delta >= sz)
@@ -427,21 +428,21 @@ static int ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *b
debug("dev=%p, pipe=%lx, buffer=%p, length=%d, req=%p\r\n", dev, pipe, buffer, length, req);
if(req != NULL)
debug("ehci_submit_async req=%u (%#x), type=%u (%#x), value=%u (%#x), index=%u\r\n",
req->request, req->request, req->requesttype, req->requesttype, le16_to_cpu(req->value), le16_to_cpu(req->value), le16_to_cpu(req->index));
req->request, req->request, req->requesttype, req->requesttype, swpw(req->value), swpw(req->value), swpw(req->index));
qh = ehci_alloc(sizeof(struct QH), 32);
if(qh == NULL)
{
debug("unable to allocate QH\r\n");
return -1;
}
qh->qh_link = cpu_to_hc32(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH);
qh->qh_link = swpl(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH);
c = (usb_pipespeed(pipe) != USB_SPEED_HIGH && usb_pipeendpoint(pipe) == 0) ? 1 : 0;
endpt = (8 << 28) | (c << 27) | (usb_maxpacket(dev, pipe) << 16) | (0 << 15) | (1 << 14) | (usb_pipespeed(pipe) << 12) | (usb_pipeendpoint(pipe) << 8) | (0 << 7) | (usb_pipedevice(pipe) << 0);
qh->qh_endpt1 = cpu_to_hc32(endpt);
qh->qh_endpt1 = swpl(endpt);
endpt = (1 << 30) | (dev->portnr << 23) | (dev->parent->devnum << 16) | (0 << 8) | (0 << 0);
qh->qh_endpt2 = cpu_to_hc32(endpt);
qh->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
qh->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
qh->qh_endpt2 = swpl(endpt);
qh->qh_overlay.qt_next = swpl(QT_NEXT_TERMINATE);
qh->qh_overlay.qt_altnext = swpl(QT_NEXT_TERMINATE);
td = NULL;
tdp = &qh->qh_overlay.qt_next;
toggle = usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe));
@@ -453,17 +454,17 @@ static int ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *b
debug("unable to allocate SETUP td\r\n");
goto fail;
}
td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
td->qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
td->qt_next = swpl(QT_NEXT_TERMINATE);
td->qt_altnext = swpl(QT_NEXT_TERMINATE);
token = (0 << 31) | (sizeof(*req) << 16) | (0 << 15) | (0 << 12) | (3 << 10) | (2 << 8) | (0x80 << 0);
td->qt_token = cpu_to_hc32(token);
td->qt_token = swpl(token);
if(ehci_td_buffer(td, req, sizeof(*req)) != 0)
{
debug("unable construct SETUP td\r\n");
ehci_free(td, sizeof(*td));
goto fail;
}
*tdp = cpu_to_hc32((uint32_t)td - gehci.dma_offset);
*tdp = swpl((uint32_t)td - gehci.dma_offset);
tdp = &td->qt_next;
toggle = 1;
}
@@ -475,17 +476,17 @@ static int ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *b
debug("unable to allocate DATA td\r\n");
goto fail;
}
td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
td->qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
td->qt_next = swpl(QT_NEXT_TERMINATE);
td->qt_altnext = swpl(QT_NEXT_TERMINATE);
token = (toggle << 31) | (length << 16) | ((req == NULL ? 1 : 0) << 15) | (0 << 12) | (3 << 10) | ((usb_pipein(pipe) ? 1 : 0) << 8) | (0x80 << 0);
td->qt_token = cpu_to_hc32(token);
td->qt_token = swpl(token);
if(ehci_td_buffer(td, buffer, length) != 0)
{
debug("unable construct DATA td\r\n");
ehci_free(td, sizeof(*td));
goto fail;
}
*tdp = cpu_to_hc32((uint32_t)td - gehci.dma_offset);
*tdp = swpl((uint32_t)td - gehci.dma_offset);
tdp = &td->qt_next;
}
if(req != NULL)
@@ -496,14 +497,14 @@ static int ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *b
debug("unable to allocate ACK td\r\n");
goto fail;
}
td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
td->qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
td->qt_next = swpl(QT_NEXT_TERMINATE);
td->qt_altnext = swpl(QT_NEXT_TERMINATE);
token = (toggle << 31) | (0 << 16) | (1 << 15) | (0 << 12) | (3 << 10) | ((usb_pipein(pipe) ? 0 : 1) << 8) | (0x80 << 0);
td->qt_token = cpu_to_hc32(token);
*tdp = cpu_to_hc32((uint32_t)td - gehci.dma_offset);
td->qt_token = swpl(token);
*tdp = swpl((uint32_t)td - gehci.dma_offset);
tdp = &td->qt_next;
}
gehci.qh_list->qh_link = cpu_to_hc32(((uint32_t)qh - gehci.dma_offset) | QH_LINK_TYPE_QH);
gehci.qh_list->qh_link = swpl(((uint32_t)qh - gehci.dma_offset) | QH_LINK_TYPE_QH);
/* Flush dcache */
ehci_flush_dcache(gehci.qh_list);
usbsts = ehci_readl(&gehci.hcor->or_usbsts);
@@ -525,10 +526,10 @@ static int ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *b
{
/* Invalidate dcache */
ehci_invalidate_dcache(gehci.qh_list);
token = hc32_to_cpu(vtd->qt_token);
token = swpl(vtd->qt_token);
if(!(token & 0x80))
break;
wait_ms(1);
wait(1 * 1000);
ts++;
}
while(ts < 1000);
@@ -542,8 +543,8 @@ static int ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *b
err("EHCI fail timeout STD_ASS reset (usbsts=%#x)", ehci_readl(&gehci.hcor->or_usbsts));
goto fail;
}
gehci.qh_list->qh_link = cpu_to_hc32(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH);
token = hc32_to_cpu(qh->qh_overlay.qt_token);
gehci.qh_list->qh_link = swpl(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH);
token = swpl(qh->qh_overlay.qt_token);
if(!(token & 0x80))
{
debug("TOKEN=%#x\r\n", token);
@@ -579,14 +580,14 @@ static int ehci_submit_async(struct usb_device *dev, unsigned long pipe, void *b
}
return (dev->status != USB_ST_NOT_PROC) ? 0 : -1;
fail:
td = (void *)hc32_to_cpu(qh->qh_overlay.qt_next);
td = (void *)swpl(qh->qh_overlay.qt_next);
if(td != (void *)QT_NEXT_TERMINATE)
td = (struct qTD *)(gehci.dma_offset + (uint32_t)td);
while(td != (void *)QT_NEXT_TERMINATE)
{
qh->qh_overlay.qt_next = td->qt_next;
ehci_free(td, sizeof(*td));
td = (void *)hc32_to_cpu(qh->qh_overlay.qt_next);
td = (void *)swpl(qh->qh_overlay.qt_next);
if(td != (void *)QT_NEXT_TERMINATE)
td = (struct qTD *)(gehci.dma_offset + (uint32_t)td);
}
@@ -622,20 +623,20 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
int len, srclen;
uint32_t reg;
uint32_t *status_reg;
if(le16_to_cpu(req->index) > CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS)
if(swpw(req->index) > CONFIG_SYS_USB_EHCI_MAX_ROOT_PORTS)
{
err("The request port(%d) is not configured", le16_to_cpu(req->index) - 1);
err("The request port(%d) is not configured", swpw(req->index) - 1);
return -1;
}
status_reg = (uint32_t *)&gehci.hcor->or_portsc[le16_to_cpu(req->index) - 1];
status_reg = (uint32_t *)&gehci.hcor->or_portsc[swpw(req->index) - 1];
srclen = 0;
debug("ehci_submit_root req=%u (%#x), type=%u (%#x), value=%u, index=%u\r\n",
req->request, req->request, req->requesttype, req->requesttype, le16_to_cpu(req->value), le16_to_cpu(req->index));
req->request, req->request, req->requesttype, req->requesttype, swpw(req->value), swpw(req->index));
typeReq = req->request | req->requesttype << 8;
switch(typeReq)
{
case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
switch(le16_to_cpu(req->value) >> 8)
switch(swpw(req->value) >> 8)
{
case USB_DT_DEVICE:
debug("USB_DT_DEVICE request\r\n");
@@ -649,7 +650,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
break;
case USB_DT_STRING:
debug("USB_DT_STRING config\r\n");
switch(le16_to_cpu(req->value) & 0xff)
switch(swpw(req->value) & 0xff)
{
case 0: /* Language */
srcptr = "\4\3\1\0";
@@ -665,17 +666,17 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
break;
default:
debug("unknown value DT_STRING %x\r\n",
le16_to_cpu(req->value));
swpw(req->value));
goto unknown;
}
break;
default:
debug("unknown value %x\r\n", le16_to_cpu(req->value));
debug("unknown value %x\r\n", swpw(req->value));
goto unknown;
}
break;
case USB_REQ_GET_DESCRIPTOR | ((USB_DIR_IN | USB_RT_HUB) << 8):
switch(le16_to_cpu(req->value) >> 8)
switch(swpw(req->value) >> 8)
{
case USB_DT_HUB:
debug("USB_DT_HUB config\r\n");
@@ -683,13 +684,13 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
srclen = 0x8;
break;
default:
debug("unknown value %x\r\n", le16_to_cpu(req->value));
debug("unknown value %x\r\n", swpw(req->value));
goto unknown;
}
break;
case USB_REQ_SET_ADDRESS | (USB_RECIP_DEVICE << 8):
debug("USB_REQ_SET_ADDRESS\r\n");
rootdev = le16_to_cpu(req->value);
rootdev = swpw(req->value);
break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
debug("USB_REQ_SET_CONFIGURATION\r\n");
@@ -704,7 +705,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
case USB_REQ_GET_STATUS | ((USB_RT_PORT | USB_DIR_IN) << 8):
memset(tmpbuf, 0, 4);
reg = ehci_readl(status_reg);
if((reg & EHCI_PS_PR) && (portreset & (1 << le16_to_cpu(req->index))))
if((reg & EHCI_PS_PR) && (portreset & (1 << swpw(req->index))))
{
int ret;
/* force reset to complete */
@@ -717,7 +718,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
reg = ehci_readl(status_reg);
}
else
err("port(%d) reset error", le16_to_cpu(req->index) - 1);
err("port(%d) reset error", swpw(req->index) - 1);
}
if(reg & EHCI_PS_CS)
tmpbuf[0] |= USB_PORT_STAT_CONNECTION;
@@ -747,7 +748,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
tmpbuf[2] |= USB_PORT_STAT_C_ENABLE;
if(reg & EHCI_PS_OCC)
tmpbuf[2] |= USB_PORT_STAT_C_OVERCURRENT;
if(portreset & (1 << le16_to_cpu(req->index)))
if(portreset & (1 << swpw(req->index)))
tmpbuf[2] |= USB_PORT_STAT_C_RESET;
srcptr = tmpbuf;
srclen = 4;
@@ -755,7 +756,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
case USB_REQ_SET_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
reg = ehci_readl(status_reg);
reg &= ~EHCI_PS_CLEAR;
switch(le16_to_cpu(req->value))
switch(swpw(req->value))
{
case USB_PORT_FEAT_ENABLE:
reg |= EHCI_PS_PE;
@@ -772,10 +773,10 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
if((reg & (EHCI_PS_PE | EHCI_PS_CS)) == EHCI_PS_CS && !ehci_is_TDI() && EHCI_PS_IS_LOWSPEED(reg))
{
/* Low speed device, give up ownership. */
debug("port %d low speed --> companion\r\n", le16_to_cpu(req->index));
debug("port %d low speed --> companion\r\n", swpw(req->index));
reg |= EHCI_PS_PO;
ehci_writel(status_reg, reg);
companion |= (1 << le16_to_cpu(req->index));
companion |= (1 << swpw(req->index));
break;
}
else
@@ -787,12 +788,12 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
* caller must wait, then call GetPortStatus
* usb 2.0 specification say 50 ms resets on root
*/
wait_ms(50);
portreset |= (1 << le16_to_cpu(req->index));
wait(50 * 1000);
portreset |= (1 << swpw(req->index));
}
break;
default:
debug("unknown feature %x\r\n", le16_to_cpu(req->value));
debug("unknown feature %x\r\n", swpw(req->value));
goto unknown;
}
/* unblock posted writes */
@@ -800,7 +801,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
break;
case USB_REQ_CLEAR_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
reg = ehci_readl(status_reg);
switch(le16_to_cpu(req->value))
switch(swpw(req->value))
{
case USB_PORT_FEAT_ENABLE:
reg &= ~EHCI_PS_PE;
@@ -818,10 +819,10 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
reg = (reg & ~EHCI_PS_CLEAR) | EHCI_PS_OCC;
break;
case USB_PORT_FEAT_C_RESET:
portreset &= ~(1 << le16_to_cpu(req->index));
portreset &= ~(1 << swpw(req->index));
break;
default:
debug("unknown feature %x\r\n", le16_to_cpu(req->value));
debug("unknown feature %x\r\n", swpw(req->value));
goto unknown;
}
ehci_writel(status_reg, reg);
@@ -832,8 +833,8 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
debug("Unknown request\r\n");
goto unknown;
}
wait_ms(1);
len = min3(srclen, le16_to_cpu(req->length), length);
wait(1 * 1000);
len = min3(srclen, swpw(req->length), length);
if(srcptr != NULL && len > 0)
memcpy(buffer, srcptr, len);
else
@@ -843,7 +844,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
return 0;
unknown:
debug("requesttype=%x, request=%x, value=%x, index=%x, length=%x\r\n",
req->requesttype, req->request, le16_to_cpu(req->value), le16_to_cpu(req->index), le16_to_cpu(req->length));
req->requesttype, req->request, swpw(req->value), swpw(req->index), swpw(req->length));
dev->act_len = 0;
dev->status = USB_ST_STALLED;
return -1;
@@ -1056,12 +1057,12 @@ int ehci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
return(-1);
}
/* Set head of reclaim list */
gehci.qh_list->qh_link = cpu_to_hc32(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH);
gehci.qh_list->qh_endpt1 = cpu_to_hc32((1 << 15) | (USB_SPEED_HIGH << 12));
gehci.qh_list->qh_curtd = cpu_to_hc32(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_token = cpu_to_hc32(0x40);
gehci.qh_list->qh_link = swpl(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH);
gehci.qh_list->qh_endpt1 = swpl((1 << 15) | (USB_SPEED_HIGH << 12));
gehci.qh_list->qh_curtd = swpl(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_next = swpl(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_altnext = swpl(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_token = swpl(0x40);
/* Set async. queue head pointer. */
ehci_writel(&gehci.hcor->or_asynclistaddr, (uint32_t)gehci.qh_list - gehci.dma_offset);
reg = ehci_readl(&gehci.hccr->cr_hcsparams);
@@ -1086,7 +1087,7 @@ int ehci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
ehci_writel(&gehci.hcor->or_configflag, FLAG_CF);
/* unblock posted write */
cmd = ehci_readl(&gehci.hcor->or_usbcmd);
wait_ms(5);
wait(5 * 1000);
reg = HC_VERSION(ehci_readl(&gehci.hccr->cr_capbase));
info("USB EHCI %x.%02x", reg >> 8, reg & 0xff);
#ifndef CONFIG_USB_INTERRUPT_POLLING

116
sources/ohci-hcd.c
View File

@@ -45,7 +45,10 @@
#include "usb.h"
#include "ohci.h"
#include "util.h" /* for endian conversions */
#include "util.h" /* for endian conversions */
#include "wait.h" /* for wait routines */
#include "bas_printf.h"
#include "bas_string.h" /* for memset() */
//extern xQueueHandle queue_poll_hub;
@@ -88,16 +91,13 @@ struct pci_device_id ohci_usb_pci_table[] = {
#else
#define dbg(format, arg...) do {} while (0)
#endif /* DEBUG */
#define err usb_error_msg
#define err xprintf
#ifdef SHOW_INFO
#define info(format, arg...) do board_printf("INFO: " format "\r\n", ## arg)
#else
#define info(format, arg...) do {} while (0)
#endif
#define m16_swap(x) cpu_to_le16(x)
#define m32_swap(x) cpu_to_le32(x)
extern void udelay(long usec);
/* global ohci_t */
@@ -138,7 +138,7 @@ static void urb_free_priv(urb_priv_t *urb)
}
}
}
usb_free(urb);
/* FIXME: usb_free(urb); */
}
/*-------------------------------------------------------------------------*/
@@ -202,7 +202,7 @@ static void ep_print_int_eds(ohci_t *ohci, char *str)
board_printf(__FILE__ ": %s branch int %2d(%2x):", str, i, i);
while(*ed_p != 0 && j--)
{
ed_t *ed = (ed_t *)m32_swap((unsigned long)ed_p);
ed_t *ed = (ed_t *)swpl((unsigned long)ed_p);
board_printf(" ed: %4x;", ed->hwINFO);
ed_p = &ed->hwNextED;
}
@@ -484,7 +484,7 @@ static inline int sohci_return_job(ohci_t *ohci, urb_priv_t *urb)
static int sohci_get_current_frame_number(ohci_t *ohci, struct usb_device *usb_dev)
{
return m16_swap(ohci->hcca->frame_no);
return swpw(ohci->hcca->frame_no);
}
#endif
@@ -648,14 +648,14 @@ static int ep_unlink(ohci_t *ohci, ed_t *edi)
ohci->hc_control &= ~OHCI_CTRL_CLE;
writel(ohci->hc_control, &ohci->regs->control);
}
writel(m32_swap(*((uint32_t *)&ed->hwNextED)), &ohci->regs->ed_controlhead);
writel(swpl(*((uint32_t *)&ed->hwNextED)), &ohci->regs->ed_controlhead);
}
else
ed->ed_prev->hwNextED = ed->hwNextED;
if(ohci->ed_controltail == ed)
ohci->ed_controltail = ed->ed_prev;
else
((ed_t *)(m32_swap(*((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;
case PIPE_BULK:
if(ed->ed_prev == NULL)
@@ -665,14 +665,14 @@ static int ep_unlink(ohci_t *ohci, ed_t *edi)
ohci->hc_control &= ~OHCI_CTRL_BLE;
writel(ohci->hc_control, &ohci->regs->control);
}
writel(m32_swap(*((uint32_t *)&ed->hwNextED)), &ohci->regs->ed_bulkhead);
writel(swpl(*((uint32_t *)&ed->hwNextED)), &ohci->regs->ed_bulkhead);
}
else
ed->ed_prev->hwNextED = ed->hwNextED;
if(ohci->ed_bulktail == ed)
ohci->ed_bulktail = ed->ed_prev;
else
((ed_t *)(m32_swap(*((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;
case PIPE_INTERRUPT:
periodic_unlink(ohci, ed, 0, 1);
@@ -711,13 +711,13 @@ static ed_t *ep_add_ed(ohci_t *ohci, struct usb_device *usb_dev, unsigned long p
{
/* dummy td; end of td list for ed */
td = td_alloc(usb_dev);
ed->hwTailP = m32_swap((unsigned long)td - ohci->dma_offset);
ed->hwTailP = swpl((unsigned long)td - ohci->dma_offset);
ed->hwHeadP = ed->hwTailP;
ed->state = ED_UNLINK;
ed->type = usb_pipetype(pipe);
ohci_dev->ed_cnt++;
}
ed->hwINFO = m32_swap(usb_pipedevice(pipe)
ed->hwINFO = swpl(usb_pipedevice(pipe)
| usb_pipeendpoint(pipe) << 7
| (usb_pipeisoc(pipe)? 0x8000: 0)
| (usb_pipecontrol(pipe)? 0: (usb_pipeout(pipe)? 0x800: 0x1000))
@@ -753,7 +753,7 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
td_pt = urb_priv->td[index];
td_pt->hwNextTD = 0;
/* fill the old dummy TD */
td = urb_priv->td[index] = (td_t *)((m32_swap(urb_priv->ed->hwTailP) & ~0xf) + ohci->dma_offset);
td = urb_priv->td[index] = (td_t *)((swpl(urb_priv->ed->hwTailP) & ~0xf) + ohci->dma_offset);
td->ed = urb_priv->ed;
td->next_dl_td = NULL;
td->index = index;
@@ -768,18 +768,18 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
#endif
if(!len)
data = NULL;
td->hwINFO = m32_swap(info);
td->hwINFO = swpl(info);
if(data != NULL)
{
td->hwCBP = m32_swap((unsigned long)data - ohci->dma_offset);
td->hwBE = m32_swap((unsigned long)(data + len - 1 - ohci->dma_offset));
td->hwCBP = swpl((unsigned long)data - ohci->dma_offset);
td->hwBE = swpl((unsigned long)(data + len - 1 - ohci->dma_offset));
}
else
{
td->hwCBP = 0;
td->hwBE = 0;
}
td->hwNextTD = m32_swap((unsigned long)td_pt - ohci->dma_offset);
td->hwNextTD = swpl((unsigned long)td_pt - ohci->dma_offset);
/* append to queue */
td->ed->hwTailP = td->hwNextTD;
#if 0
@@ -787,14 +787,14 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
{
int i;
board_printf("td_fill: %08x %08x %08X %08X at 0x%08X\r\n",
m32_swap(td->hwINFO), m32_swap(td->hwCBP), m32_swap(td->hwNextTD), m32_swap(td->hwBE), td);
swpl(td->hwINFO), swpl(td->hwCBP), swpl(td->hwNextTD), swpl(td->hwBE), td);
for(i = 0; i < len; i++)
board_printf("%02X ", *(unsigned char *)(data + i) & 0xff);
board_printf("\r\n");
}
else
board_printf("td_fill: %08x %08x %08X %08X at 0x%08X\r\n",
m32_swap(td->hwINFO), m32_swap(td->hwCBP), m32_swap(td->hwNextTD), m32_swap(td->hwBE), td);
swpl(td->hwINFO), swpl(td->hwCBP), swpl(td->hwNextTD), swpl(td->hwBE), td);
#endif
}
@@ -875,9 +875,9 @@ static void dl_transfer_length(ohci_t *ohci, td_t *td)
{
uint32_t tdINFO, tdBE, tdCBP;
urb_priv_t *lurb_priv = td->ed->purb;
tdINFO = m32_swap(td->hwINFO);
tdBE = m32_swap(td->hwBE);
tdCBP = m32_swap(td->hwCBP);
tdINFO = swpl(td->hwINFO);
tdBE = swpl(td->hwBE);
tdCBP = swpl(td->hwCBP);
if(tdBE)
tdBE += ohci->dma_offset;
if(tdCBP)
@@ -900,19 +900,19 @@ static void check_status(ohci_t *ohci, td_t *td_list)
urb_priv_t *lurb_priv = td_list->ed->purb;
int urb_len = lurb_priv->length;
uint32_t *phwHeadP = &td_list->ed->hwHeadP;
int cc = TD_CC_GET(m32_swap(td_list->hwINFO));
int cc = TD_CC_GET(swpl(td_list->hwINFO));
if(cc)
{
err("OHCI usb-%s-%c error: %s (%x)", ohci->slot_name, (char)ohci->controller + '0', cc_to_string[cc], cc);
if(*phwHeadP & m32_swap(0x1))
if(*phwHeadP & swpl(0x1))
{
if(lurb_priv && ((td_list->index + 1) < urb_len))
{
*phwHeadP = (lurb_priv->td[urb_len - 1]->hwNextTD & m32_swap(0xfffffff0)) | (*phwHeadP & m32_swap(0x2));
*phwHeadP = (lurb_priv->td[urb_len - 1]->hwNextTD & swpl(0xfffffff0)) | (*phwHeadP & swpl(0x2));
lurb_priv->td_cnt += urb_len - td_list->index - 1;
}
else
*phwHeadP &= m32_swap(0xfffffff2);
*phwHeadP &= swpl(0xfffffff2);
}
#ifdef CONFIG_MPC5200
td_list->hwNextTD = 0;
@@ -927,7 +927,7 @@ static td_t *dl_reverse_done_list(ohci_t *ohci)
uint32_t td_list_hc;
td_t *td_rev = NULL;
td_t *td_list = NULL;
td_list_hc = m32_swap(ohci->hcca->done_head) & ~0xf;
td_list_hc = swpl(ohci->hcca->done_head) & ~0xf;
if(td_list_hc)
td_list_hc += ohci->dma_offset;
ohci->hcca->done_head = 0;
@@ -937,7 +937,7 @@ static td_t *dl_reverse_done_list(ohci_t *ohci)
check_status(ohci, td_list);
td_list->next_dl_td = td_rev;
td_rev = td_list;
td_list_hc = m32_swap(td_list->hwNextTD) & ~0xf;
td_list_hc = swpl(td_list->hwNextTD) & ~0xf;
if(td_list_hc)
td_list_hc += ohci->dma_offset;
}
@@ -969,7 +969,7 @@ static int takeback_td(ohci_t *ohci, td_t *td_list)
/* urb_t *urb; */
urb_priv_t *lurb_priv;
uint32_t tdINFO, edHeadP, edTailP;
tdINFO = m32_swap(td_list->hwINFO);
tdINFO = swpl(td_list->hwINFO);
ed = td_list->ed;
if(ed == NULL)
{
@@ -994,8 +994,8 @@ static int takeback_td(ohci_t *ohci, td_t *td_list)
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)))
{
edHeadP = m32_swap(ed->hwHeadP) & ~0xf;
edTailP = m32_swap(ed->hwTailP);
edHeadP = swpl(ed->hwHeadP) & ~0xf;
edTailP = swpl(ed->hwTailP);
/* unlink eds if they are not busy */
if((edHeadP == edTailP) && (ed->state == ED_OPER))
ep_unlink(ohci, ed);
@@ -1180,7 +1180,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, unsigned lon
pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, cmd, "SUB(rh)", usb_pipein(pipe));
#else
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
#endif
if(usb_pipeint(pipe))
{
@@ -1254,7 +1254,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, unsigned lon
OK(0);
case (RH_PORT_POWER):
WR_RH_PORTSTAT(RH_PS_PPS);
wait_ms(100);
wait(100 * 1000);
OK(0);
case (RH_PORT_ENABLE): /* BUG IN HUP CODE *********/
if(RD_RH_PORTSTAT & RH_PS_CCS)
@@ -1333,7 +1333,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, unsigned lon
ohci_dump_roothub(ohci, 1);
#else
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
#endif
len = min_t(int, len, leni);
if(data != data_buf)
@@ -1344,7 +1344,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, unsigned lon
pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, cmd, "RET(rh)", 0/*usb_pipein(pipe)*/);
#else
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
#endif
return stat;
}
@@ -1382,7 +1382,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, unsigned long
pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe));
#else
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
#endif
if(!maxsize)
{
@@ -1395,7 +1395,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, unsigned long
return -1;
}
#if 0
wait_ms(10);
wait(10 * 1000);
/* ohci_dump_status(ohci); */
#endif
/* allow more time for a BULK device to react - some are slow */
@@ -1436,7 +1436,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, unsigned long
}
if(--timeout)
{
wait_ms(1);
wait(1 * 1000);
// if(!urb->finished)
// dbg("*");
}
@@ -1455,7 +1455,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, unsigned long
pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "RET(ctlr)", usb_pipein(pipe));
#else
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
#endif
/* free TDs in urb_priv */
if(!usb_pipeint(pipe))
@@ -1479,7 +1479,7 @@ int ohci_submit_control_msg(struct usb_device *dev, unsigned long pipe, void *bu
pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe));
#else
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
#endif
if(!maxsize)
{
@@ -1553,7 +1553,7 @@ static int hc_reset(ohci_t *ohci)
err("USB RootHub reset timed out!\r\n");
break;
}
udelay(1);
wait(1 * 1000);
}
}
}
@@ -1574,12 +1574,12 @@ static int hc_reset(ohci_t *ohci)
{
dbg("USB OHCI set 48MHz clock\r\n");
pci_write_config_longword(ohci->handle, 0xE4, 0x21); // oscillator & disable ehci
wait_ms(10);
wait(10 * 1000);
}
else
{
pci_write_config_longword(ohci->handle, 0xE4, pci_read_config_longword(ohci->handle, 0xE4) | 0x01); // disable ehci
wait_ms(10);
wait(10 * 1000);
}
}
@@ -1590,7 +1590,7 @@ static int hc_reset(ohci_t *ohci)
info("USB HC TakeOver from SMM");
while(readl(&ohci->regs->control) & OHCI_CTRL_IR)
{
wait_ms(10);
wait(10 * 1000);
if(--smm_timeout == 0)
{
err("USB HC TakeOver failed!");
@@ -1604,7 +1604,7 @@ static int hc_reset(ohci_t *ohci)
/* Reset USB (needed by some controllers) */
ohci->hc_control = 0;
writel(ohci->hc_control, &ohci->regs->control);
wait_ms(50);
wait(50 * 1000);
/* HC Reset requires max 10 us delay */
writel(OHCI_HCR, &ohci->regs->cmdstatus);
while((readl(&ohci->regs->cmdstatus) & OHCI_HCR) != 0)
@@ -1614,7 +1614,7 @@ static int hc_reset(ohci_t *ohci)
err("USB HC reset timed out!");
return -1;
}
udelay(1);
wait(1 * 1000);
}
return 0;
}
@@ -1661,7 +1661,7 @@ static int hc_start(ohci_t *ohci)
writel(RH_HS_LPSC, &ohci->regs->roothub.status);
#endif /* OHCI_USE_NPS */
/* POTPGT delay is bits 24-31, in 2 ms units. */
wait_ms((ohci->ndp >> 23) & 0x1fe);
wait((ohci->ndp >> 23) & 0x1fe * 1000);
ohci->ndp &= RH_A_NDP;
/* connect the virtual root hub */
ohci->rh.devnum = 0;
@@ -1708,7 +1708,7 @@ static int hc_interrupt(ohci_t *ohci)
{
struct ohci_regs *regs = ohci->regs;
int ints, stat = -1;
if((ohci->hcca->done_head != 0) && !(m32_swap(ohci->hcca->done_head) & 0x01))
if((ohci->hcca->done_head != 0) && !(swpl(ohci->hcca->done_head) & 0x01))
ints = OHCI_INTR_WDH;
else
{
@@ -1759,7 +1759,7 @@ static int hc_interrupt(ohci_t *ohci)
ohci_dump(ohci, 1);
#else
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
#endif
/* HC Reset */
ohci->hc_control = 0;
@@ -1769,7 +1769,7 @@ static int hc_interrupt(ohci_t *ohci)
if(ints & OHCI_INTR_WDH)
{
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
writel(OHCI_INTR_WDH, &regs->intrdisable);
(void)readl(&regs->intrdisable); /* flush */
stat = dl_done_list(ohci);
@@ -1785,9 +1785,9 @@ static int hc_interrupt(ohci_t *ohci)
/* FIXME: this assumes SOF (1/ms) interrupts don't get lost... */
if(ints & OHCI_INTR_SF)
{
unsigned int frame = m16_swap(ohci->hcca->frame_no) & 1;
unsigned int frame = swpw(ohci->hcca->frame_no) & 1;
if(ohci->irq)
wait_ms(1);
wait(1 * 1000);
writel(OHCI_INTR_SF, &regs->intrdisable);
if(ohci->ed_rm_list[frame] != NULL)
writel(OHCI_INTR_SF, &regs->intrenable);
@@ -1846,17 +1846,17 @@ static void hc_free_buffers(ohci_t *ohci)
{
if(ohci->td_unaligned != NULL)
{
usb_free(ohci->td_unaligned);
/* FIXME: usb_free(ohci->td_unaligned); */
ohci->td_unaligned = NULL;
}
if(ohci->ohci_dev_unaligned != NULL)
{
usb_free(ohci->ohci_dev_unaligned);
/* FIXME: usb_free(ohci->ohci_dev_unaligned); */
ohci->ohci_dev_unaligned = NULL;
}
if(ohci->hcca_unaligned != NULL)
{
usb_free(ohci->hcca_unaligned);
/* FIXME: usb_free(ohci->hcca_unaligned); */
ohci->hcca_unaligned = NULL;
}
}
@@ -1963,7 +1963,7 @@ int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
default: ohci->slot_name = "generic"; break;
}
}
kprint("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)
{
err("Can't reset OHCI usb-%s-%c", ohci->slot_name, (char)ohci->controller + '0');

9
sources/pci.c
View File

@@ -59,6 +59,8 @@ static struct pci_class
};
static int num_classes = sizeof(pci_classes) / sizeof(struct pci_class);
static struct resource_descriptor resource_descriptors[16];
static char *device_class(int classcode)
{
int i;
@@ -155,6 +157,13 @@ void pci_write_config_longword(uint16_t handle, uint16_t offset, uint32_t value)
* (volatile uint32_t *) PCI_IO_OFFSET = swpl(value); /* access device */
}
struct resource_descriptor *pci_get_resource(uint16_t handle)
{
/* TODO: implement */
return (struct resource_descriptor *) 0L;
}
int pci_find_device(uint16_t device_id, uint16_t vendor_id, int index)
{
uint16_t bus;

1570
sources/usb.c Normal file
View File

File diff suppressed because it is too large Load Diff