Firebee/FireBee_SVN
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 3689373d8d
commit 8039abec46
13 changed files with 1829 additions and 220 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
BaS_gcc/Makefile
View File

@@ -83,6 +83,7 @@ CSRCS= \
$(SRCDIR)/MCD_tasks.c \ $(SRCDIR)/MCD_tasks.c \
$(SRCDIR)/MCD_tasksInit.c \ $(SRCDIR)/MCD_tasksInit.c \
\ \
$(SRCDIR)/usb.c \
$(SRCDIR)/ohci-hcd.c \ $(SRCDIR)/ohci-hcd.c \
$(SRCDIR)/ehci-hcd.c \ $(SRCDIR)/ehci-hcd.c \
\ \

3
BaS_gcc/bas.lk.in
View File

@@ -34,6 +34,9 @@ SECTIONS
OBJDIR/supervisor.o(.text) OBJDIR/supervisor.o(.text)
OBJDIR/mmu.o(.text) OBJDIR/mmu.o(.text)
OBJDIR/pci.o(.text) OBJDIR/pci.o(.text)
OBJDIR/usb.o(.text)
OBJDIR/ohci-hcd.o(.text)
OBJDIR/ehci-hcd.o(.text)
OBJDIR/BaS.o(.text) OBJDIR/BaS.o(.text)
OBJDIR/wait.o(.text) OBJDIR/wait.o(.text)

1
BaS_gcc/include/bas_string.h
View File

@@ -33,6 +33,7 @@ extern char *strcat(char *dst, const char *src);
extern char *strncat(char *dst, const char *src, int max); extern char *strncat(char *dst, const char *src, int max);
extern int atoi(const char *c); extern int atoi(const char *c);
extern void *memcpy(void *dst, const void *src, size_t n); extern void *memcpy(void *dst, const void *src, size_t n);
extern void *memset(void *s, int c, size_t n);
extern void bzero(void *s, size_t n); extern void bzero(void *s, size_t n);
#define isdigit(c) (((c) >= '0') && ((c) <= '9')) #define isdigit(c) (((c) >= '0') && ((c) <= '9'))

8
BaS_gcc/include/ehci.h
View File

@@ -131,16 +131,16 @@ struct usb_linux_config_descriptor {
#define ehci_readl(x) (*((volatile u32 *)(x))) #define ehci_readl(x) (*((volatile u32 *)(x)))
#define ehci_writel(a, b) (*((volatile u32 *)(a)) = ((volatile u32)b)) #define ehci_writel(a, b) (*((volatile u32 *)(a)) = ((volatile u32)b))
#else #else
#define ehci_readl(x) cpu_to_le32((*((volatile u32 *)(x)))) #define ehci_readl(x) swpl((*((volatile u32 *)(x))))
#define ehci_writel(a, b) (*((volatile u32 *)(a)) = cpu_to_le32(((volatile u32)b))) #define ehci_writel(a, b) (*((volatile u32 *)(a)) = swpl(((volatile u32)b)))
#endif #endif
#if defined CONFIG_EHCI_MMIO_BIG_ENDIAN #if defined CONFIG_EHCI_MMIO_BIG_ENDIAN
#define hc32_to_cpu(x) be32_to_cpu((x)) #define hc32_to_cpu(x) be32_to_cpu((x))
#define cpu_to_hc32(x) cpu_to_be32((x)) #define cpu_to_hc32(x) cpu_to_be32((x))
#else #else
#define hc32_to_cpu(x) le32_to_cpu((x)) #define hc32_to_cpu(x) swpl((x))
#define cpu_to_hc32(x) cpu_to_le32((x)) #define cpu_to_hc32(x) swpl((x))
#endif #endif
#define EHCI_PS_WKOC_E (1 << 22) /* RW wake on over current */ #define EHCI_PS_WKOC_E (1 << 22) /* RW wake on over current */

14
BaS_gcc/include/pci.h
View File

@@ -199,8 +199,18 @@ extern void init_eport(void);
extern void init_xlbus_arbiter(void); extern void init_xlbus_arbiter(void);
extern void init_pci(void); extern void init_pci(void);
struct resource_descriptor
{
uint16_t next;
uint16_t flags;
uint32_t start;
uint32_t length;
uint32_t offset;
uint32_t dma_offset;
uint8_t private;
} __attribute__ ((packed));
extern int pci_find_device(uint16_t device_id, uint16_t vendor_id, int index); extern int pci_find_device(uint16_t device_id, uint16_t vendor_id, int index);
/* FIXME: parameters missing */
extern uint32_t pci_read_config_longword(uint16_t handle, uint16_t offset); extern uint32_t pci_read_config_longword(uint16_t handle, uint16_t offset);
extern uint16_t pci_read_config_word(uint16_t handle, uint16_t offset); extern uint16_t pci_read_config_word(uint16_t handle, uint16_t offset);
@@ -210,7 +220,7 @@ extern void pci_write_config_longword(uint16_t handle, uint16_t offset, uint32_t
extern void pci_write_config_word(uint16_t handle, uint16_t offset, uint16_t value); extern void pci_write_config_word(uint16_t handle, uint16_t offset, uint16_t value);
extern void pci_write_config_byte(uint16_t handle, uint16_t offset, uint8_t value); extern void pci_write_config_byte(uint16_t handle, uint16_t offset, uint8_t value);
extern void *pci_get_resource(); extern struct resource_descriptor *pci_get_resource(uint16_t handle);
extern void pci_hook_interrupt(); extern void pci_hook_interrupt();
extern void pci_unhook_interrupt(); extern void pci_unhook_interrupt();

184
BaS_gcc/include/usb.h
View File

@@ -26,8 +26,8 @@
#ifndef _USB_H_ #ifndef _USB_H_
#define _USB_H_ #define _USB_H_
#include <stdlib.h> //#include <stdlib.h>
#include <string.h> #include <bas_string.h>
#include "pci.h" #include "pci.h"
#include "mod_devicetable.h" #include "mod_devicetable.h"
#include "pci_ids.h" #include "pci_ids.h"
@@ -44,15 +44,15 @@ extern long *tab_funcs_pci;
#define out32r(addr,val) Write_mem_longword(usb_handle,addr,val) #define out32r(addr,val) Write_mem_longword(usb_handle,addr,val)
#define __u8 unsigned char #define __u8 uint8_t
#define __u16 unsigned short #define __u16 uint16_t
#define __u32 unsigned long #define __u32 uint32_t
#define u8 unsigned char #define u8 uint8_t
#define u16 unsigned short #define u16 uint16_t
#define u32 unsigned long #define u32 uint32_t
#define uint8_t unsigned char #define uint8_t uint8_t
#define uint32_t unsigned long #define uint32_t uint32_t
#define uint16_t unsigned short #define uint16_t uint16_t
extern void kprint(const char *fmt, ...); extern void kprint(const char *fmt, ...);
extern int sprintD(char *s, const char *fmt, ...); extern int sprintD(char *s, const char *fmt, ...);
@@ -75,71 +75,71 @@ extern int sprintD(char *s, const char *fmt, ...);
/* String descriptor */ /* String descriptor */
struct usb_string_descriptor { struct usb_string_descriptor {
unsigned char bLength; uint8_t bLength;
unsigned char bDescriptorType; uint8_t bDescriptorType;
unsigned short wData[1]; uint16_t wData[1];
} __attribute__ ((packed)); } __attribute__ ((packed));
/* device request (setup) */ /* device request (setup) */
struct devrequest { struct devrequest {
unsigned char requesttype; uint8_t requesttype;
unsigned char request; uint8_t request;
unsigned short value; uint16_t value;
unsigned short index; uint16_t index;
unsigned short length; uint16_t length;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* All standard descriptors have these 2 fields in common */ /* All standard descriptors have these 2 fields in common */
struct usb_descriptor_header { struct usb_descriptor_header {
unsigned char bLength; uint8_t bLength;
unsigned char bDescriptorType; uint8_t bDescriptorType;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Device descriptor */ /* Device descriptor */
struct usb_device_descriptor { struct usb_device_descriptor {
unsigned char bLength; uint8_t bLength;
unsigned char bDescriptorType; uint8_t bDescriptorType;
unsigned short bcdUSB; uint16_t bcdUSB;
unsigned char bDeviceClass; uint8_t bDeviceClass;
unsigned char bDeviceSubClass; uint8_t bDeviceSubClass;
unsigned char bDeviceProtocol; uint8_t bDeviceProtocol;
unsigned char bMaxPacketSize0; uint8_t bMaxPacketSize0;
unsigned short idVendor; uint16_t idVendor;
unsigned short idProduct; uint16_t idProduct;
unsigned short bcdDevice; uint16_t bcdDevice;
unsigned char iManufacturer; uint8_t iManufacturer;
unsigned char iProduct; uint8_t iProduct;
unsigned char iSerialNumber; uint8_t iSerialNumber;
unsigned char bNumConfigurations; uint8_t bNumConfigurations;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Endpoint descriptor */ /* Endpoint descriptor */
struct usb_endpoint_descriptor { struct usb_endpoint_descriptor {
unsigned char bLength; uint8_t bLength;
unsigned char bDescriptorType; uint8_t bDescriptorType;
unsigned char bEndpointAddress; uint8_t bEndpointAddress;
unsigned char bmAttributes; uint8_t bmAttributes;
unsigned short wMaxPacketSize; uint16_t wMaxPacketSize;
unsigned char bInterval; uint8_t bInterval;
unsigned char bRefresh; uint8_t bRefresh;
unsigned char bSynchAddress; uint8_t bSynchAddress;
} __attribute__ ((packed)) __attribute__ ((aligned(2))); } __attribute__ ((packed)) __attribute__ ((aligned(2)));
/* Interface descriptor */ /* Interface descriptor */
struct usb_interface_descriptor { struct usb_interface_descriptor {
unsigned char bLength; uint8_t bLength;
unsigned char bDescriptorType; uint8_t bDescriptorType;
unsigned char bInterfaceNumber; uint8_t bInterfaceNumber;
unsigned char bAlternateSetting; uint8_t bAlternateSetting;
unsigned char bNumEndpoints; uint8_t bNumEndpoints;
unsigned char bInterfaceClass; uint8_t bInterfaceClass;
unsigned char bInterfaceSubClass; uint8_t bInterfaceSubClass;
unsigned char bInterfaceProtocol; uint8_t bInterfaceProtocol;
unsigned char iInterface; uint8_t iInterface;
unsigned char no_of_ep; uint8_t no_of_ep;
unsigned char num_altsetting; uint8_t num_altsetting;
unsigned char act_altsetting; uint8_t act_altsetting;
struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS]; struct usb_endpoint_descriptor ep_desc[USB_MAXENDPOINTS];
} __attribute__ ((packed)); } __attribute__ ((packed));
@@ -147,16 +147,16 @@ struct usb_interface_descriptor {
/* Configuration descriptor information.. */ /* Configuration descriptor information.. */
struct usb_config_descriptor { struct usb_config_descriptor {
unsigned char bLength; uint8_t bLength;
unsigned char bDescriptorType; uint8_t bDescriptorType;
unsigned short wTotalLength; uint16_t wTotalLength;
unsigned char bNumInterfaces; uint8_t bNumInterfaces;
unsigned char bConfigurationValue; uint8_t bConfigurationValue;
unsigned char iConfiguration; uint8_t iConfiguration;
unsigned char bmAttributes; uint8_t bmAttributes;
unsigned char MaxPower; uint8_t MaxPower;
unsigned char no_of_if; /* number of interfaces */ uint8_t no_of_if; /* number of interfaces */
struct usb_interface_descriptor if_desc[USB_MAXINTERFACES]; struct usb_interface_descriptor if_desc[USB_MAXINTERFACES];
} __attribute__ ((packed)); } __attribute__ ((packed));
@@ -193,14 +193,14 @@ struct usb_device {
int have_langid; /* whether string_langid is valid yet */ int have_langid; /* whether string_langid is valid yet */
int string_langid; /* language ID for strings */ int string_langid; /* language ID for strings */
int (*irq_handle)(struct usb_device *dev); int (*irq_handle)(struct usb_device *dev);
unsigned long irq_status; uint32_t irq_status;
int irq_act_len; /* transfered bytes */ int irq_act_len; /* transfered bytes */
void *privptr; void *privptr;
/* /*
* Child devices - if this is a hub device * Child devices - if this is a hub device
* Each instance needs its own set of data structures. * Each instance needs its own set of data structures.
*/ */
unsigned long status; uint32_t status;
int act_len; /* transfered bytes */ int act_len; /* transfered bytes */
int maxchild; /* Number of ports if hub */ int maxchild; /* Number of ports if hub */
int portnr; int portnr;
@@ -230,16 +230,16 @@ typedef struct
int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **priv); int ohci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **priv);
int ohci_usb_lowlevel_stop(void *priv); int ohci_usb_lowlevel_stop(void *priv);
int ohci_submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len); int ohci_submit_bulk_msg(struct usb_device *dev, uint32_t pipe, void *buffer, int transfer_len);
int ohci_submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len, struct devrequest *setup); int ohci_submit_control_msg(struct usb_device *dev, uint32_t pipe, void *buffer, int transfer_len, struct devrequest *setup);
int ohci_submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len, int interval); int ohci_submit_int_msg(struct usb_device *dev, uint32_t pipe, void *buffer, int transfer_len, int interval);
void ohci_usb_enable_interrupt(int enable); void ohci_usb_enable_interrupt(int enable);
int ehci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **priv); int ehci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **priv);
int ehci_usb_lowlevel_stop(void *priv); int ehci_usb_lowlevel_stop(void *priv);
int ehci_submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len); int ehci_submit_bulk_msg(struct usb_device *dev, uint32_t pipe, void *buffer, int transfer_len);
int ehci_submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len, struct devrequest *setup); int ehci_submit_control_msg(struct usb_device *dev, uint32_t pipe, void *buffer, int transfer_len, struct devrequest *setup);
int ehci_submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len, int interval); int ehci_submit_int_msg(struct usb_device *dev, uint32_t pipe, void *buffer, int transfer_len, int interval);
void ehci_usb_enable_interrupt(int enable); void ehci_usb_enable_interrupt(int enable);
void usb_enable_interrupt(int enable); void usb_enable_interrupt(int enable);
@@ -276,16 +276,16 @@ int usb_stop(void); /* stop the USB Controller */
int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol); int usb_set_protocol(struct usb_device *dev, int ifnum, int protocol);
int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id); int usb_set_idle(struct usb_device *dev, int ifnum, int duration, int report_id);
struct usb_device *usb_get_dev_index(int index, int bus); struct usb_device *usb_get_dev_index(int index, int bus);
int usb_control_msg(struct usb_device *dev, unsigned int pipe, unsigned char request, unsigned char requesttype, unsigned short value, int usb_control_msg(struct usb_device *dev, unsigned int pipe, uint8_t request, uint8_t requesttype, uint16_t value,
unsigned short index, void *data, unsigned short size, int timeout); uint16_t index, void *data, uint16_t size, int timeout);
int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, void *data, int len, int *actual_length, int timeout); int usb_bulk_msg(struct usb_device *dev, unsigned int pipe, void *data, int len, int *actual_length, int timeout);
int usb_submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer, int transfer_len, int interval); int usb_submit_int_msg(struct usb_device *dev, uint32_t pipe, void *buffer, int transfer_len, int interval);
void usb_disable_asynch(int disable); void usb_disable_asynch(int disable);
int usb_maxpacket(struct usb_device *dev, unsigned long pipe); int usb_maxpacket(struct usb_device *dev, uint32_t pipe);
void wait_ms(unsigned long ms); void wait_ms(uint32_t ms);
int usb_get_configuration_no(struct usb_device *dev, unsigned char *buffer, int cfgno); int usb_get_configuration_no(struct usb_device *dev, uint8_t *buffer, int cfgno);
int usb_get_report(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size); int usb_get_report(struct usb_device *dev, int ifnum, uint8_t type, uint8_t id, void *buf, int size);
int usb_get_class_descriptor(struct usb_device *dev, int ifnum, unsigned char type, unsigned char id, void *buf, int size); int usb_get_class_descriptor(struct usb_device *dev, int ifnum, uint8_t type, uint8_t id, void *buf, int size);
int usb_clear_halt(struct usb_device *dev, int pipe); int usb_clear_halt(struct usb_device *dev, int pipe);
int usb_string(struct usb_device *dev, int index, char *buf, size_t size); int usb_string(struct usb_device *dev, int index, char *buf, size_t size);
int usb_set_interface(struct usb_device *dev, int interface, int alternate); int usb_set_interface(struct usb_device *dev, int interface, int alternate);
@@ -391,26 +391,26 @@ int usb_set_interface(struct usb_device *dev, int interface, int alternate);
* Hub Stuff * Hub Stuff
*/ */
struct usb_port_status { struct usb_port_status {
unsigned short wPortStatus; uint16_t wPortStatus;
unsigned short wPortChange; uint16_t wPortChange;
} __attribute__ ((packed)); } __attribute__ ((packed));
struct usb_hub_status { struct usb_hub_status {
unsigned short wHubStatus; uint16_t wHubStatus;
unsigned short wHubChange; uint16_t wHubChange;
} __attribute__ ((packed)); } __attribute__ ((packed));
/* Hub descriptor */ /* Hub descriptor */
struct usb_hub_descriptor { struct usb_hub_descriptor {
unsigned char bLength; uint8_t bLength;
unsigned char bDescriptorType; uint8_t bDescriptorType;
unsigned char bNbrPorts; uint8_t bNbrPorts;
unsigned short wHubCharacteristics; uint16_t wHubCharacteristics;
unsigned char bPwrOn2PwrGood; uint8_t bPwrOn2PwrGood;
unsigned char bHubContrCurrent; uint8_t bHubContrCurrent;
unsigned char DeviceRemovable[(USB_MAXCHILDREN+1+7)/8]; uint8_t DeviceRemovable[(USB_MAXCHILDREN+1+7)/8];
unsigned char PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8]; uint8_t PortPowerCtrlMask[(USB_MAXCHILDREN+1+7)/8];
/* DeviceRemovable and PortPwrCtrlMask want to be variable-length /* DeviceRemovable and PortPwrCtrlMask want to be variable-length
bitmaps that hold max 255 entries. (bit0 is ignored) */ bitmaps that hold max 255 entries. (bit0 is ignored) */
} __attribute__ ((packed)); } __attribute__ ((packed));

4
BaS_gcc/include/util.h
View File

@@ -31,7 +31,7 @@
* uint16_t swpw(uint16_t val); * uint16_t swpw(uint16_t val);
* swap endianess of val, 16 bits only. * swap endianess of val, 16 bits only.
*/ */
inline uint16_t swpw(uint16_t w) static inline uint16_t swpw(uint16_t w)
{ {
register uint32_t result asm("d0"); register uint32_t result asm("d0");
__asm__ __volatile__ __asm__ __volatile__
@@ -52,7 +52,7 @@ inline uint16_t swpw(uint16_t w)
* swap endianess of val, 32 bits only. * swap endianess of val, 32 bits only.
* e.g. ABCD => DCBA * e.g. ABCD => DCBA
*/ */
inline uint32_t swpl(uint32_t l) static inline uint32_t swpl(uint32_t l)
{ {
register uint32_t result asm("d0"); register uint32_t result asm("d0");

2
BaS_gcc/include/wait.h
View File

@@ -36,6 +36,8 @@
//#error unknown machine //#error unknown machine
#endif /* MACHINE_FIREBEE */ #endif /* MACHINE_FIREBEE */
#include "MCF5475.h"
typedef bool (*checker_func)(void); typedef bool (*checker_func)(void);
extern __inline__ void wait(uint32_t) __attribute__((always_inline)); extern __inline__ void wait(uint32_t) __attribute__((always_inline));

12
BaS_gcc/sources/bas_string.c
View File

@@ -42,6 +42,18 @@ void bzero(void *s, size_t n)
((unsigned char *) s)[i] = '\0'; ((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) int strncmp(const char *s1, const char *s2, int max)
{ {

125
BaS_gcc/sources/ehci-hcd.c
View File

@@ -23,6 +23,7 @@
#include "util.h" /* for endian conversions */ #include "util.h" /* for endian conversions */
#include "wait.h"
#include "usb.h" #include "usb.h"
#include "ehci.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) if((uint32_t)qh & QH_LINK_TYPE_QH)
break; break;
qh = qh_addr(qh); 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); qh = qh_addr(qh);
/* Save first qTD pointer, needed for invalidating pass on this QH */ /* Save first qTD pointer, needed for invalidating pass on this QH */
if(flush) 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) if(qtd != NULL)
qtd = (struct qTD *)(gehci.dma_offset + (uint32_t)qtd); qtd = (struct qTD *)(gehci.dma_offset + (uint32_t)qtd);
first_qtd = qtd; first_qtd = qtd;
@@ -223,7 +224,7 @@ static void cache_qh(struct QH *qh, int flush)
if(qtd == NULL) if(qtd == NULL)
break; break;
cache_qtd(qtd, flush); 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) if(next != NULL)
next = (struct qTD *)(gehci.dma_offset + (uint32_t)next); next = (struct qTD *)(gehci.dma_offset + (uint32_t)next);
if(next == qtd) if(next == qtd)
@@ -396,7 +397,7 @@ static int ehci_td_buffer(struct qTD *td, void *buf, size_t sz)
idx = 0; idx = 0;
while(idx < 5) 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; next = (addr + 4096) & ~4095;
delta = next - addr; delta = next - addr;
if(delta >= sz) 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); debug("dev=%p, pipe=%lx, buffer=%p, length=%d, req=%p\r\n", dev, pipe, buffer, length, req);
if(req != NULL) if(req != NULL)
debug("ehci_submit_async req=%u (%#x), type=%u (%#x), value=%u (%#x), index=%u\r\n", 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); qh = ehci_alloc(sizeof(struct QH), 32);
if(qh == NULL) if(qh == NULL)
{ {
debug("unable to allocate QH\r\n"); debug("unable to allocate QH\r\n");
return -1; 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; 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); 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); endpt = (1 << 30) | (dev->portnr << 23) | (dev->parent->devnum << 16) | (0 << 8) | (0 << 0);
qh->qh_endpt2 = cpu_to_hc32(endpt); qh->qh_endpt2 = swpl(endpt);
qh->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE); qh->qh_overlay.qt_next = swpl(QT_NEXT_TERMINATE);
qh->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE); qh->qh_overlay.qt_altnext = swpl(QT_NEXT_TERMINATE);
td = NULL; td = NULL;
tdp = &qh->qh_overlay.qt_next; tdp = &qh->qh_overlay.qt_next;
toggle = usb_gettoggle(dev, usb_pipeendpoint(pipe), usb_pipeout(pipe)); 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"); debug("unable to allocate SETUP td\r\n");
goto fail; goto fail;
} }
td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE); td->qt_next = swpl(QT_NEXT_TERMINATE);
td->qt_altnext = cpu_to_hc32(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); 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) if(ehci_td_buffer(td, req, sizeof(*req)) != 0)
{ {
debug("unable construct SETUP td\r\n"); debug("unable construct SETUP td\r\n");
ehci_free(td, sizeof(*td)); ehci_free(td, sizeof(*td));
goto fail; goto fail;
} }
*tdp = cpu_to_hc32((uint32_t)td - gehci.dma_offset); *tdp = swpl((uint32_t)td - gehci.dma_offset);
tdp = &td->qt_next; tdp = &td->qt_next;
toggle = 1; 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"); debug("unable to allocate DATA td\r\n");
goto fail; goto fail;
} }
td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE); td->qt_next = swpl(QT_NEXT_TERMINATE);
td->qt_altnext = cpu_to_hc32(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); 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) if(ehci_td_buffer(td, buffer, length) != 0)
{ {
debug("unable construct DATA td\r\n"); debug("unable construct DATA td\r\n");
ehci_free(td, sizeof(*td)); ehci_free(td, sizeof(*td));
goto fail; goto fail;
} }
*tdp = cpu_to_hc32((uint32_t)td - gehci.dma_offset); *tdp = swpl((uint32_t)td - gehci.dma_offset);
tdp = &td->qt_next; tdp = &td->qt_next;
} }
if(req != NULL) 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"); debug("unable to allocate ACK td\r\n");
goto fail; goto fail;
} }
td->qt_next = cpu_to_hc32(QT_NEXT_TERMINATE); td->qt_next = swpl(QT_NEXT_TERMINATE);
td->qt_altnext = cpu_to_hc32(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); 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); td->qt_token = swpl(token);
*tdp = cpu_to_hc32((uint32_t)td - gehci.dma_offset); *tdp = swpl((uint32_t)td - gehci.dma_offset);
tdp = &td->qt_next; 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 */ /* Flush dcache */
ehci_flush_dcache(gehci.qh_list); ehci_flush_dcache(gehci.qh_list);
usbsts = ehci_readl(&gehci.hcor->or_usbsts); 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 */ /* Invalidate dcache */
ehci_invalidate_dcache(gehci.qh_list); ehci_invalidate_dcache(gehci.qh_list);
token = hc32_to_cpu(vtd->qt_token); token = swpl(vtd->qt_token);
if(!(token & 0x80)) if(!(token & 0x80))
break; break;
wait_ms(1); wait(1 * 1000);
ts++; ts++;
} }
while(ts < 1000); 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)); err("EHCI fail timeout STD_ASS reset (usbsts=%#x)", ehci_readl(&gehci.hcor->or_usbsts));
goto fail; goto fail;
} }
gehci.qh_list->qh_link = cpu_to_hc32(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH); gehci.qh_list->qh_link = swpl(((uint32_t)gehci.qh_list - gehci.dma_offset) | QH_LINK_TYPE_QH);
token = hc32_to_cpu(qh->qh_overlay.qt_token); token = swpl(qh->qh_overlay.qt_token);
if(!(token & 0x80)) if(!(token & 0x80))
{ {
debug("TOKEN=%#x\r\n", token); 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; return (dev->status != USB_ST_NOT_PROC) ? 0 : -1;
fail: 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) if(td != (void *)QT_NEXT_TERMINATE)
td = (struct qTD *)(gehci.dma_offset + (uint32_t)td); td = (struct qTD *)(gehci.dma_offset + (uint32_t)td);
while(td != (void *)QT_NEXT_TERMINATE) while(td != (void *)QT_NEXT_TERMINATE)
{ {
qh->qh_overlay.qt_next = td->qt_next; qh->qh_overlay.qt_next = td->qt_next;
ehci_free(td, sizeof(*td)); 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) if(td != (void *)QT_NEXT_TERMINATE)
td = (struct qTD *)(gehci.dma_offset + (uint32_t)td); 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; int len, srclen;
uint32_t reg; uint32_t reg;
uint32_t *status_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; 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; srclen = 0;
debug("ehci_submit_root req=%u (%#x), type=%u (%#x), value=%u, index=%u\r\n", 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; typeReq = req->request | req->requesttype << 8;
switch(typeReq) switch(typeReq)
{ {
case DeviceRequest | USB_REQ_GET_DESCRIPTOR: case DeviceRequest | USB_REQ_GET_DESCRIPTOR:
switch(le16_to_cpu(req->value) >> 8) switch(swpw(req->value) >> 8)
{ {
case USB_DT_DEVICE: case USB_DT_DEVICE:
debug("USB_DT_DEVICE request\r\n"); 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; break;
case USB_DT_STRING: case USB_DT_STRING:
debug("USB_DT_STRING config\r\n"); debug("USB_DT_STRING config\r\n");
switch(le16_to_cpu(req->value) & 0xff) switch(swpw(req->value) & 0xff)
{ {
case 0: /* Language */ case 0: /* Language */
srcptr = "\4\3\1\0"; srcptr = "\4\3\1\0";
@@ -665,17 +666,17 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
break; break;
default: default:
debug("unknown value DT_STRING %x\r\n", debug("unknown value DT_STRING %x\r\n",
le16_to_cpu(req->value)); swpw(req->value));
goto unknown; goto unknown;
} }
break; break;
default: default:
debug("unknown value %x\r\n", le16_to_cpu(req->value)); debug("unknown value %x\r\n", swpw(req->value));
goto unknown; goto unknown;
} }
break; break;
case USB_REQ_GET_DESCRIPTOR | ((USB_DIR_IN | USB_RT_HUB) << 8): 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: case USB_DT_HUB:
debug("USB_DT_HUB config\r\n"); 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; srclen = 0x8;
break; break;
default: default:
debug("unknown value %x\r\n", le16_to_cpu(req->value)); debug("unknown value %x\r\n", swpw(req->value));
goto unknown; goto unknown;
} }
break; break;
case USB_REQ_SET_ADDRESS | (USB_RECIP_DEVICE << 8): case USB_REQ_SET_ADDRESS | (USB_RECIP_DEVICE << 8):
debug("USB_REQ_SET_ADDRESS\r\n"); debug("USB_REQ_SET_ADDRESS\r\n");
rootdev = le16_to_cpu(req->value); rootdev = swpw(req->value);
break; break;
case DeviceOutRequest | USB_REQ_SET_CONFIGURATION: case DeviceOutRequest | USB_REQ_SET_CONFIGURATION:
debug("USB_REQ_SET_CONFIGURATION\r\n"); 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): case USB_REQ_GET_STATUS | ((USB_RT_PORT | USB_DIR_IN) << 8):
memset(tmpbuf, 0, 4); memset(tmpbuf, 0, 4);
reg = ehci_readl(status_reg); 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; int ret;
/* force reset to complete */ /* 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); reg = ehci_readl(status_reg);
} }
else 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) if(reg & EHCI_PS_CS)
tmpbuf[0] |= USB_PORT_STAT_CONNECTION; 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; tmpbuf[2] |= USB_PORT_STAT_C_ENABLE;
if(reg & EHCI_PS_OCC) if(reg & EHCI_PS_OCC)
tmpbuf[2] |= USB_PORT_STAT_C_OVERCURRENT; 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; tmpbuf[2] |= USB_PORT_STAT_C_RESET;
srcptr = tmpbuf; srcptr = tmpbuf;
srclen = 4; 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): case USB_REQ_SET_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
reg = ehci_readl(status_reg); reg = ehci_readl(status_reg);
reg &= ~EHCI_PS_CLEAR; reg &= ~EHCI_PS_CLEAR;
switch(le16_to_cpu(req->value)) switch(swpw(req->value))
{ {
case USB_PORT_FEAT_ENABLE: case USB_PORT_FEAT_ENABLE:
reg |= EHCI_PS_PE; 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)) 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. */ /* 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; reg |= EHCI_PS_PO;
ehci_writel(status_reg, reg); ehci_writel(status_reg, reg);
companion |= (1 << le16_to_cpu(req->index)); companion |= (1 << swpw(req->index));
break; break;
} }
else 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 * caller must wait, then call GetPortStatus
* usb 2.0 specification say 50 ms resets on root * usb 2.0 specification say 50 ms resets on root
*/ */
wait_ms(50); wait(50 * 1000);
portreset |= (1 << le16_to_cpu(req->index)); portreset |= (1 << swpw(req->index));
} }
break; break;
default: default:
debug("unknown feature %x\r\n", le16_to_cpu(req->value)); debug("unknown feature %x\r\n", swpw(req->value));
goto unknown; goto unknown;
} }
/* unblock posted writes */ /* unblock posted writes */
@@ -800,7 +801,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
break; break;
case USB_REQ_CLEAR_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8): case USB_REQ_CLEAR_FEATURE | ((USB_DIR_OUT | USB_RT_PORT) << 8):
reg = ehci_readl(status_reg); reg = ehci_readl(status_reg);
switch(le16_to_cpu(req->value)) switch(swpw(req->value))
{ {
case USB_PORT_FEAT_ENABLE: case USB_PORT_FEAT_ENABLE:
reg &= ~EHCI_PS_PE; 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; reg = (reg & ~EHCI_PS_CLEAR) | EHCI_PS_OCC;
break; break;
case USB_PORT_FEAT_C_RESET: case USB_PORT_FEAT_C_RESET:
portreset &= ~(1 << le16_to_cpu(req->index)); portreset &= ~(1 << swpw(req->index));
break; break;
default: default:
debug("unknown feature %x\r\n", le16_to_cpu(req->value)); debug("unknown feature %x\r\n", swpw(req->value));
goto unknown; goto unknown;
} }
ehci_writel(status_reg, reg); 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"); debug("Unknown request\r\n");
goto unknown; goto unknown;
} }
wait_ms(1); wait(1 * 1000);
len = min3(srclen, le16_to_cpu(req->length), length); len = min3(srclen, swpw(req->length), length);
if(srcptr != NULL && len > 0) if(srcptr != NULL && len > 0)
memcpy(buffer, srcptr, len); memcpy(buffer, srcptr, len);
else else
@@ -843,7 +844,7 @@ static int ehci_submit_root(struct usb_device *dev, unsigned long pipe, void *bu
return 0; return 0;
unknown: unknown:
debug("requesttype=%x, request=%x, value=%x, index=%x, length=%x\r\n", 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->act_len = 0;
dev->status = USB_ST_STALLED; dev->status = USB_ST_STALLED;
return -1; return -1;
@@ -1056,12 +1057,12 @@ int ehci_usb_lowlevel_init(long handle, const struct pci_device_id *ent, void **
return(-1); return(-1);
} }
/* Set head of reclaim list */ /* 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_link = swpl(((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_endpt1 = swpl((1 << 15) | (USB_SPEED_HIGH << 12));
gehci.qh_list->qh_curtd = cpu_to_hc32(QT_NEXT_TERMINATE); gehci.qh_list->qh_curtd = swpl(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_next = cpu_to_hc32(QT_NEXT_TERMINATE); gehci.qh_list->qh_overlay.qt_next = swpl(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_altnext = cpu_to_hc32(QT_NEXT_TERMINATE); gehci.qh_list->qh_overlay.qt_altnext = swpl(QT_NEXT_TERMINATE);
gehci.qh_list->qh_overlay.qt_token = cpu_to_hc32(0x40); gehci.qh_list->qh_overlay.qt_token = swpl(0x40);
/* Set async. queue head pointer. */ /* Set async. queue head pointer. */
ehci_writel(&gehci.hcor->or_asynclistaddr, (uint32_t)gehci.qh_list - gehci.dma_offset); ehci_writel(&gehci.hcor->or_asynclistaddr, (uint32_t)gehci.qh_list - gehci.dma_offset);
reg = ehci_readl(&gehci.hccr->cr_hcsparams); 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); ehci_writel(&gehci.hcor->or_configflag, FLAG_CF);
/* unblock posted write */ /* unblock posted write */
cmd = ehci_readl(&gehci.hcor->or_usbcmd); cmd = ehci_readl(&gehci.hcor->or_usbcmd);
wait_ms(5); wait(5 * 1000);
reg = HC_VERSION(ehci_readl(&gehci.hccr->cr_capbase)); reg = HC_VERSION(ehci_readl(&gehci.hccr->cr_capbase));
info("USB EHCI %x.%02x", reg >> 8, reg & 0xff); info("USB EHCI %x.%02x", reg >> 8, reg & 0xff);
#ifndef CONFIG_USB_INTERRUPT_POLLING #ifndef CONFIG_USB_INTERRUPT_POLLING

114
BaS_gcc/sources/ohci-hcd.c
View File

@@ -46,6 +46,9 @@
#include "usb.h" #include "usb.h"
#include "ohci.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; //extern xQueueHandle queue_poll_hub;
@@ -88,16 +91,13 @@ struct pci_device_id ohci_usb_pci_table[] = {
#else #else
#define dbg(format, arg...) do {} while (0) #define dbg(format, arg...) do {} while (0)
#endif /* DEBUG */ #endif /* DEBUG */
#define err usb_error_msg #define err xprintf
#ifdef SHOW_INFO #ifdef SHOW_INFO
#define info(format, arg...) do board_printf("INFO: " format "\r\n", ## arg) #define info(format, arg...) do board_printf("INFO: " format "\r\n", ## arg)
#else #else
#define info(format, arg...) do {} while (0) #define info(format, arg...) do {} while (0)
#endif #endif
#define m16_swap(x) cpu_to_le16(x)
#define m32_swap(x) cpu_to_le32(x)
extern void udelay(long usec); extern void udelay(long usec);
/* global ohci_t */ /* 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); board_printf(__FILE__ ": %s branch int %2d(%2x):", str, i, i);
while(*ed_p != 0 && j--) 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); board_printf(" ed: %4x;", ed->hwINFO);
ed_p = &ed->hwNextED; 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) 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 #endif
@@ -648,14 +648,14 @@ static int ep_unlink(ohci_t *ohci, ed_t *edi)
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);
} }
writel(m32_swap(*((uint32_t *)&ed->hwNextED)), &ohci->regs->ed_controlhead); writel(swpl(*((uint32_t *)&ed->hwNextED)), &ohci->regs->ed_controlhead);
} }
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 *)(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; break;
case PIPE_BULK: case PIPE_BULK:
if(ed->ed_prev == NULL) 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; ohci->hc_control &= ~OHCI_CTRL_BLE;
writel(ohci->hc_control, &ohci->regs->control); 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 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 *)(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; break;
case PIPE_INTERRUPT: case PIPE_INTERRUPT:
periodic_unlink(ohci, ed, 0, 1); 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 */ /* dummy td; end of td list for ed */
td = td_alloc(usb_dev); 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->hwHeadP = ed->hwTailP;
ed->state = ED_UNLINK; ed->state = ED_UNLINK;
ed->type = usb_pipetype(pipe); ed->type = usb_pipetype(pipe);
ohci_dev->ed_cnt++; ohci_dev->ed_cnt++;
} }
ed->hwINFO = m32_swap(usb_pipedevice(pipe) ed->hwINFO = swpl(usb_pipedevice(pipe)
| usb_pipeendpoint(pipe) << 7 | usb_pipeendpoint(pipe) << 7
| (usb_pipeisoc(pipe)? 0x8000: 0) | (usb_pipeisoc(pipe)? 0x8000: 0)
| (usb_pipecontrol(pipe)? 0: (usb_pipeout(pipe)? 0x800: 0x1000)) | (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 = urb_priv->td[index];
td_pt->hwNextTD = 0; td_pt->hwNextTD = 0;
/* fill the old dummy TD */ /* 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->ed = urb_priv->ed;
td->next_dl_td = NULL; td->next_dl_td = NULL;
td->index = index; td->index = index;
@@ -768,18 +768,18 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
#endif #endif
if(!len) if(!len)
data = NULL; data = NULL;
td->hwINFO = m32_swap(info); td->hwINFO = swpl(info);
if(data != NULL) if(data != NULL)
{ {
td->hwCBP = m32_swap((unsigned long)data - ohci->dma_offset); td->hwCBP = swpl((unsigned long)data - ohci->dma_offset);
td->hwBE = m32_swap((unsigned long)(data + len - 1 - ohci->dma_offset)); td->hwBE = swpl((unsigned long)(data + len - 1 - ohci->dma_offset));
} }
else else
{ {
td->hwCBP = 0; td->hwCBP = 0;
td->hwBE = 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 */ /* append to queue */
td->ed->hwTailP = td->hwNextTD; td->ed->hwTailP = td->hwNextTD;
#if 0 #if 0
@@ -787,14 +787,14 @@ static void td_fill(ohci_t *ohci, unsigned int info, void *data, int len,
{ {
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",
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++) for(i = 0; i < len; i++)
board_printf("%02X ", *(unsigned char *)(data + i) & 0xff); board_printf("%02X ", *(unsigned char *)(data + i) & 0xff);
board_printf("\r\n"); board_printf("\r\n");
} }
else else
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",
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 #endif
} }
@@ -875,9 +875,9 @@ static void dl_transfer_length(ohci_t *ohci, td_t *td)
{ {
uint32_t tdINFO, tdBE, tdCBP; uint32_t tdINFO, tdBE, tdCBP;
urb_priv_t *lurb_priv = td->ed->purb; urb_priv_t *lurb_priv = td->ed->purb;
tdINFO = m32_swap(td->hwINFO); tdINFO = swpl(td->hwINFO);
tdBE = m32_swap(td->hwBE); tdBE = swpl(td->hwBE);
tdCBP = m32_swap(td->hwCBP); tdCBP = swpl(td->hwCBP);
if(tdBE) if(tdBE)
tdBE += ohci->dma_offset; tdBE += ohci->dma_offset;
if(tdCBP) 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; urb_priv_t *lurb_priv = td_list->ed->purb;
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(m32_swap(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 & m32_swap(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 & 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; lurb_priv->td_cnt += urb_len - td_list->index - 1;
} }
else else
*phwHeadP &= m32_swap(0xfffffff2); *phwHeadP &= swpl(0xfffffff2);
} }
#ifdef CONFIG_MPC5200 #ifdef CONFIG_MPC5200
td_list->hwNextTD = 0; td_list->hwNextTD = 0;
@@ -927,7 +927,7 @@ static td_t *dl_reverse_done_list(ohci_t *ohci)
uint32_t td_list_hc; uint32_t td_list_hc;
td_t *td_rev = NULL; td_t *td_rev = NULL;
td_t *td_list = 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) 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;
@@ -937,7 +937,7 @@ static td_t *dl_reverse_done_list(ohci_t *ohci)
check_status(ohci, td_list); check_status(ohci, td_list);
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 = m32_swap(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;
} }
@@ -969,7 +969,7 @@ static int takeback_td(ohci_t *ohci, td_t *td_list)
/* urb_t *urb; */ /* urb_t *urb; */
urb_priv_t *lurb_priv; urb_priv_t *lurb_priv;
uint32_t tdINFO, edHeadP, edTailP; uint32_t tdINFO, edHeadP, edTailP;
tdINFO = m32_swap(td_list->hwINFO); tdINFO = swpl(td_list->hwINFO);
ed = td_list->ed; ed = td_list->ed;
if(ed == NULL) 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); 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 = m32_swap(ed->hwHeadP) & ~0xf; edHeadP = swpl(ed->hwHeadP) & ~0xf;
edTailP = m32_swap(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);
@@ -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)); pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, cmd, "SUB(rh)", usb_pipein(pipe));
#else #else
if(ohci->irq) if(ohci->irq)
wait_ms(1); wait(1 * 1000);
#endif #endif
if(usb_pipeint(pipe)) 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); OK(0);
case (RH_PORT_POWER): case (RH_PORT_POWER):
WR_RH_PORTSTAT(RH_PS_PPS); WR_RH_PORTSTAT(RH_PS_PPS);
wait_ms(100); 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)
@@ -1333,7 +1333,7 @@ static int ohci_submit_rh_msg(ohci_t *ohci, struct usb_device *dev, unsigned lon
ohci_dump_roothub(ohci, 1); ohci_dump_roothub(ohci, 1);
#else #else
if(ohci->irq) if(ohci->irq)
wait_ms(1); 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)
@@ -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)*/); 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_ms(1); wait(1 * 1000);
#endif #endif
return stat; 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)); pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe));
#else #else
if(ohci->irq) if(ohci->irq)
wait_ms(1); wait(1 * 1000);
#endif #endif
if(!maxsize) if(!maxsize)
{ {
@@ -1395,7 +1395,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, unsigned long
return -1; return -1;
} }
#if 0 #if 0
wait_ms(10); wait(10 * 1000);
/* ohci_dump_status(ohci); */ /* ohci_dump_status(ohci); */
#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 */
@@ -1436,7 +1436,7 @@ static int submit_common_msg(ohci_t *ohci, struct usb_device *dev, unsigned long
} }
if(--timeout) if(--timeout)
{ {
wait_ms(1); wait(1 * 1000);
// if(!urb->finished) // if(!urb->finished)
// dbg("*"); // 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)); pkt_print(ohci, urb, dev, pipe, buffer, transfer_len, setup, "RET(ctlr)", usb_pipein(pipe));
#else #else
if(ohci->irq) if(ohci->irq)
wait_ms(1); wait(1 * 1000);
#endif #endif
/* free TDs in urb_priv */ /* free TDs in urb_priv */
if(!usb_pipeint(pipe)) 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)); pkt_print(ohci, NULL, dev, pipe, buffer, transfer_len, setup, "SUB", usb_pipein(pipe));
#else #else
if(ohci->irq) if(ohci->irq)
wait_ms(1); wait(1 * 1000);
#endif #endif
if(!maxsize) if(!maxsize)
{ {
@@ -1553,7 +1553,7 @@ static int hc_reset(ohci_t *ohci)
err("USB RootHub reset timed out!\r\n"); err("USB RootHub reset timed out!\r\n");
break; 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"); 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
wait_ms(10); wait(10 * 1000);
} }
else else
{ {
pci_write_config_longword(ohci->handle, 0xE4, pci_read_config_longword(ohci->handle, 0xE4) | 0x01); // disable ehci 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"); info("USB HC TakeOver from SMM");
while(readl(&ohci->regs->control) & OHCI_CTRL_IR) while(readl(&ohci->regs->control) & OHCI_CTRL_IR)
{ {
wait_ms(10); wait(10 * 1000);
if(--smm_timeout == 0) if(--smm_timeout == 0)
{ {
err("USB HC TakeOver failed!"); err("USB HC TakeOver failed!");
@@ -1604,7 +1604,7 @@ static int hc_reset(ohci_t *ohci)
/* Reset USB (needed by some controllers) */ /* Reset USB (needed by some controllers) */
ohci->hc_control = 0; ohci->hc_control = 0;
writel(ohci->hc_control, &ohci->regs->control); writel(ohci->hc_control, &ohci->regs->control);
wait_ms(50); wait(50 * 1000);
/* HC Reset requires max 10 us delay */ /* HC Reset requires max 10 us delay */
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)
@@ -1614,7 +1614,7 @@ static int hc_reset(ohci_t *ohci)
err("USB HC reset timed out!"); err("USB HC reset timed out!");
return -1; return -1;
} }
udelay(1); wait(1 * 1000);
} }
return 0; return 0;
} }
@@ -1661,7 +1661,7 @@ static int hc_start(ohci_t *ohci)
writel(RH_HS_LPSC, &ohci->regs->roothub.status); writel(RH_HS_LPSC, &ohci->regs->roothub.status);
#endif /* OHCI_USE_NPS */ #endif /* OHCI_USE_NPS */
/* POTPGT delay is bits 24-31, in 2 ms units. */ /* 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; ohci->ndp &= RH_A_NDP;
/* connect the virtual root hub */ /* connect the virtual root hub */
ohci->rh.devnum = 0; ohci->rh.devnum = 0;
@@ -1708,7 +1708,7 @@ 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) && !(m32_swap(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
{ {
@@ -1759,7 +1759,7 @@ static int hc_interrupt(ohci_t *ohci)
ohci_dump(ohci, 1); ohci_dump(ohci, 1);
#else #else
if(ohci->irq) if(ohci->irq)
wait_ms(1); wait(1 * 1000);
#endif #endif
/* HC Reset */ /* HC Reset */
ohci->hc_control = 0; ohci->hc_control = 0;
@@ -1769,7 +1769,7 @@ static int hc_interrupt(ohci_t *ohci)
if(ints & OHCI_INTR_WDH) if(ints & OHCI_INTR_WDH)
{ {
if(ohci->irq) if(ohci->irq)
wait_ms(1); 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 */
stat = dl_done_list(ohci); 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... */ /* FIXME: this assumes SOF (1/ms) interrupts don't get lost... */
if(ints & OHCI_INTR_SF) 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) if(ohci->irq)
wait_ms(1); 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);
@@ -1846,17 +1846,17 @@ static void hc_free_buffers(ohci_t *ohci)
{ {
if(ohci->td_unaligned != NULL) if(ohci->td_unaligned != NULL)
{ {
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)
{ {
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)
{ {
usb_free(ohci->hcca_unaligned); /* FIXME: usb_free(ohci->hcca_unaligned); */
ohci->hcca_unaligned = NULL; 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; 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) 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');

9
BaS_gcc/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 int num_classes = sizeof(pci_classes) / sizeof(struct pci_class);
static struct resource_descriptor resource_descriptors[16];
static char *device_class(int classcode) static char *device_class(int classcode)
{ {
int i; 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 */ * (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) int pci_find_device(uint16_t device_id, uint16_t vendor_id, int index)
{ {
uint16_t bus; uint16_t bus;

1570
BaS_gcc/sources/usb.c Normal file
View File

File diff suppressed because it is too large Load Diff