mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
958 lines
21 KiB
958 lines
21 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* Copyright (c) 2009 Wind River Systems, Inc. |
|
* Tom Rix <[email protected]> |
|
* |
|
* This file is a rewrite of the usb device part of |
|
* repository git.omapzoom.org/repo/u-boot.git, branch master, |
|
* file cpu/omap3/fastboot.c |
|
* |
|
* This is the unique part of its copyright : |
|
* |
|
* ------------------------------------------------------------------------- |
|
* |
|
* (C) Copyright 2008 - 2009 |
|
* Windriver, <www.windriver.com> |
|
* Tom Rix <[email protected]> |
|
* |
|
* ------------------------------------------------------------------------- |
|
* |
|
* The details of connecting the device to the uboot usb device subsystem |
|
* came from the old omap3 repository www.sakoman.net/u-boot-omap3.git, |
|
* branch omap3-dev-usb, file drivers/usb/usbdcore_musb.c |
|
* |
|
* This is the unique part of its copyright : |
|
* |
|
* ------------------------------------------------------------------------- |
|
* |
|
* (C) Copyright 2008 Texas Instruments Incorporated. |
|
* |
|
* Based on |
|
* u-boot OMAP1510 USB drivers (drivers/usbdcore_omap1510.c) |
|
* twl4030 init based on linux (drivers/i2c/chips/twl4030_usb.c) |
|
* |
|
* Author: Diego Dompe ([email protected]) |
|
* Atin Malaviya ([email protected]) |
|
* |
|
* ------------------------------------------------------------------------- |
|
*/ |
|
|
|
#include <common.h> |
|
#include <usbdevice.h> |
|
#include <usb/udc.h> |
|
#include "../gadget/ep0.h" |
|
#include "musb_core.h" |
|
#if defined(CONFIG_USB_OMAP3) |
|
#include "omap3.h" |
|
#elif defined(CONFIG_USB_AM35X) |
|
#include "am35x.h" |
|
#elif defined(CONFIG_USB_DAVINCI) |
|
#include "davinci.h" |
|
#endif |
|
|
|
/* Define MUSB_DEBUG for debugging */ |
|
/* #define MUSB_DEBUG */ |
|
#include "musb_debug.h" |
|
|
|
#define MAX_ENDPOINT 15 |
|
|
|
#define GET_ENDPOINT(dev,ep) \ |
|
(((struct usb_device_instance *)(dev))->bus->endpoint_array + ep) |
|
|
|
#define SET_EP0_STATE(s) \ |
|
do { \ |
|
if ((0 <= (s)) && (SET_ADDRESS >= (s))) { \ |
|
if ((s) != ep0_state) { \ |
|
if ((debug_setup) && (debug_level > 1)) \ |
|
serial_printf("INFO : Changing state " \ |
|
"from %s to %s in %s at " \ |
|
"line %d\n", \ |
|
ep0_state_strings[ep0_state],\ |
|
ep0_state_strings[s], \ |
|
__PRETTY_FUNCTION__, \ |
|
__LINE__); \ |
|
ep0_state = s; \ |
|
} \ |
|
} else { \ |
|
if (debug_level > 0) \ |
|
serial_printf("Error at %s %d with setting " \ |
|
"state %d is invalid\n", \ |
|
__PRETTY_FUNCTION__, __LINE__, s); \ |
|
} \ |
|
} while (0) |
|
|
|
/* static implies these initialized to 0 or NULL */ |
|
static int debug_setup; |
|
static int debug_level; |
|
static struct musb_epinfo epinfo[MAX_ENDPOINT * 2 + 2]; |
|
static enum ep0_state_enum { |
|
IDLE = 0, |
|
TX, |
|
RX, |
|
SET_ADDRESS |
|
} ep0_state = IDLE; |
|
static char *ep0_state_strings[4] = { |
|
"IDLE", |
|
"TX", |
|
"RX", |
|
"SET_ADDRESS", |
|
}; |
|
|
|
static struct urb *ep0_urb; |
|
struct usb_endpoint_instance *ep0_endpoint; |
|
static struct usb_device_instance *udc_device; |
|
static int enabled; |
|
|
|
#ifdef MUSB_DEBUG |
|
static void musb_db_regs(void) |
|
{ |
|
u8 b; |
|
u16 w; |
|
|
|
b = readb(&musbr->faddr); |
|
serial_printf("\tfaddr 0x%2.2x\n", b); |
|
|
|
b = readb(&musbr->power); |
|
musb_print_pwr(b); |
|
|
|
w = readw(&musbr->ep[0].ep0.csr0); |
|
musb_print_csr0(w); |
|
|
|
b = readb(&musbr->devctl); |
|
musb_print_devctl(b); |
|
|
|
b = readb(&musbr->ep[0].ep0.configdata); |
|
musb_print_config(b); |
|
|
|
w = readw(&musbr->frame); |
|
serial_printf("\tframe 0x%4.4x\n", w); |
|
|
|
b = readb(&musbr->index); |
|
serial_printf("\tindex 0x%2.2x\n", b); |
|
|
|
w = readw(&musbr->ep[1].epN.rxmaxp); |
|
musb_print_rxmaxp(w); |
|
|
|
w = readw(&musbr->ep[1].epN.rxcsr); |
|
musb_print_rxcsr(w); |
|
|
|
w = readw(&musbr->ep[1].epN.txmaxp); |
|
musb_print_txmaxp(w); |
|
|
|
w = readw(&musbr->ep[1].epN.txcsr); |
|
musb_print_txcsr(w); |
|
} |
|
#else |
|
#define musb_db_regs() |
|
#endif /* DEBUG_MUSB */ |
|
|
|
static void musb_peri_softconnect(void) |
|
{ |
|
u8 power, devctl; |
|
|
|
/* Power off MUSB */ |
|
power = readb(&musbr->power); |
|
power &= ~MUSB_POWER_SOFTCONN; |
|
writeb(power, &musbr->power); |
|
|
|
/* Read intr to clear */ |
|
readb(&musbr->intrusb); |
|
readw(&musbr->intrrx); |
|
readw(&musbr->intrtx); |
|
|
|
udelay(1000 * 1000); /* 1 sec */ |
|
|
|
/* Power on MUSB */ |
|
power = readb(&musbr->power); |
|
power |= MUSB_POWER_SOFTCONN; |
|
/* |
|
* The usb device interface is usb 1.1 |
|
* Disable 2.0 high speed by clearring the hsenable bit. |
|
*/ |
|
power &= ~MUSB_POWER_HSENAB; |
|
writeb(power, &musbr->power); |
|
|
|
/* Check if device is in b-peripheral mode */ |
|
devctl = readb(&musbr->devctl); |
|
if (!(devctl & MUSB_DEVCTL_BDEVICE) || |
|
(devctl & MUSB_DEVCTL_HM)) { |
|
serial_printf("ERROR : Unsupport USB mode\n"); |
|
serial_printf("Check that mini-B USB cable is attached " |
|
"to the device\n"); |
|
} |
|
|
|
if (debug_setup && (debug_level > 1)) |
|
musb_db_regs(); |
|
} |
|
|
|
static void musb_peri_reset(void) |
|
{ |
|
if ((debug_setup) && (debug_level > 1)) |
|
serial_printf("INFO : %s reset\n", __PRETTY_FUNCTION__); |
|
|
|
if (ep0_endpoint) |
|
ep0_endpoint->endpoint_address = 0xff; |
|
|
|
/* Sync sw and hw addresses */ |
|
writeb(udc_device->address, &musbr->faddr); |
|
|
|
SET_EP0_STATE(IDLE); |
|
} |
|
|
|
static void musb_peri_resume(void) |
|
{ |
|
/* noop */ |
|
} |
|
|
|
static void musb_peri_ep0_stall(void) |
|
{ |
|
u16 csr0; |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
csr0 |= MUSB_CSR0_P_SENDSTALL; |
|
writew(csr0, &musbr->ep[0].ep0.csr0); |
|
if ((debug_setup) && (debug_level > 1)) |
|
serial_printf("INFO : %s stall\n", __PRETTY_FUNCTION__); |
|
} |
|
|
|
static void musb_peri_ep0_ack_req(void) |
|
{ |
|
u16 csr0; |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
csr0 |= MUSB_CSR0_P_SVDRXPKTRDY; |
|
writew(csr0, &musbr->ep[0].ep0.csr0); |
|
} |
|
|
|
static void musb_ep0_tx_ready(void) |
|
{ |
|
u16 csr0; |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
csr0 |= MUSB_CSR0_TXPKTRDY; |
|
writew(csr0, &musbr->ep[0].ep0.csr0); |
|
} |
|
|
|
static void musb_ep0_tx_ready_and_last(void) |
|
{ |
|
u16 csr0; |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
csr0 |= (MUSB_CSR0_TXPKTRDY | MUSB_CSR0_P_DATAEND); |
|
writew(csr0, &musbr->ep[0].ep0.csr0); |
|
} |
|
|
|
static void musb_peri_ep0_last(void) |
|
{ |
|
u16 csr0; |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
csr0 |= MUSB_CSR0_P_DATAEND; |
|
writew(csr0, &musbr->ep[0].ep0.csr0); |
|
} |
|
|
|
static void musb_peri_ep0_set_address(void) |
|
{ |
|
u8 faddr; |
|
writeb(udc_device->address, &musbr->faddr); |
|
|
|
/* Verify */ |
|
faddr = readb(&musbr->faddr); |
|
if (udc_device->address == faddr) { |
|
SET_EP0_STATE(IDLE); |
|
usbd_device_event_irq(udc_device, DEVICE_ADDRESS_ASSIGNED, 0); |
|
if ((debug_setup) && (debug_level > 1)) |
|
serial_printf("INFO : %s Address set to %d\n", |
|
__PRETTY_FUNCTION__, udc_device->address); |
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s Address missmatch " |
|
"sw %d vs hw %d\n", |
|
__PRETTY_FUNCTION__, |
|
udc_device->address, faddr); |
|
} |
|
} |
|
|
|
static void musb_peri_rx_ack(unsigned int ep) |
|
{ |
|
u16 peri_rxcsr; |
|
|
|
peri_rxcsr = readw(&musbr->ep[ep].epN.rxcsr); |
|
peri_rxcsr &= ~MUSB_RXCSR_RXPKTRDY; |
|
writew(peri_rxcsr, &musbr->ep[ep].epN.rxcsr); |
|
} |
|
|
|
static void musb_peri_tx_ready(unsigned int ep) |
|
{ |
|
u16 peri_txcsr; |
|
|
|
peri_txcsr = readw(&musbr->ep[ep].epN.txcsr); |
|
peri_txcsr |= MUSB_TXCSR_TXPKTRDY; |
|
writew(peri_txcsr, &musbr->ep[ep].epN.txcsr); |
|
} |
|
|
|
static void musb_peri_ep0_zero_data_request(int err) |
|
{ |
|
musb_peri_ep0_ack_req(); |
|
|
|
if (err) { |
|
musb_peri_ep0_stall(); |
|
SET_EP0_STATE(IDLE); |
|
} else { |
|
|
|
musb_peri_ep0_last(); |
|
|
|
/* USBD state */ |
|
switch (ep0_urb->device_request.bRequest) { |
|
case USB_REQ_SET_ADDRESS: |
|
if ((debug_setup) && (debug_level > 1)) |
|
serial_printf("INFO : %s received set " |
|
"address\n", __PRETTY_FUNCTION__); |
|
break; |
|
|
|
case USB_REQ_SET_CONFIGURATION: |
|
if ((debug_setup) && (debug_level > 1)) |
|
serial_printf("INFO : %s Configured\n", |
|
__PRETTY_FUNCTION__); |
|
usbd_device_event_irq(udc_device, DEVICE_CONFIGURED, 0); |
|
break; |
|
} |
|
|
|
/* EP0 state */ |
|
if (USB_REQ_SET_ADDRESS == ep0_urb->device_request.bRequest) { |
|
SET_EP0_STATE(SET_ADDRESS); |
|
} else { |
|
SET_EP0_STATE(IDLE); |
|
} |
|
} |
|
} |
|
|
|
static void musb_peri_ep0_rx_data_request(void) |
|
{ |
|
/* |
|
* This is the completion of the data OUT / RX |
|
* |
|
* Host is sending data to ep0 that is not |
|
* part of setup. This comes from the cdc_recv_setup |
|
* op that is device specific. |
|
* |
|
*/ |
|
musb_peri_ep0_ack_req(); |
|
|
|
ep0_endpoint->rcv_urb = ep0_urb; |
|
ep0_urb->actual_length = 0; |
|
SET_EP0_STATE(RX); |
|
} |
|
|
|
static void musb_peri_ep0_tx_data_request(int err) |
|
{ |
|
if (err) { |
|
musb_peri_ep0_stall(); |
|
SET_EP0_STATE(IDLE); |
|
} else { |
|
musb_peri_ep0_ack_req(); |
|
|
|
ep0_endpoint->tx_urb = ep0_urb; |
|
ep0_endpoint->sent = 0; |
|
SET_EP0_STATE(TX); |
|
} |
|
} |
|
|
|
static void musb_peri_ep0_idle(void) |
|
{ |
|
u16 count0; |
|
int err; |
|
u16 csr0; |
|
|
|
/* |
|
* Verify addresses |
|
* A lot of confusion can be caused if the address |
|
* in software, udc layer, does not agree with the |
|
* hardware. Since the setting of the hardware address |
|
* must be set after the set address request, the |
|
* usb state machine is out of sync for a few frame. |
|
* It is a good idea to run this check when changes |
|
* are made to the state machine. |
|
*/ |
|
if ((debug_level > 0) && |
|
(ep0_state != SET_ADDRESS)) { |
|
u8 faddr; |
|
|
|
faddr = readb(&musbr->faddr); |
|
if (udc_device->address != faddr) { |
|
serial_printf("ERROR : %s addresses do not" |
|
"match sw %d vs hw %d\n", |
|
__PRETTY_FUNCTION__, |
|
udc_device->address, faddr); |
|
udelay(1000 * 1000); |
|
hang(); |
|
} |
|
} |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
|
|
if (!(MUSB_CSR0_RXPKTRDY & csr0)) |
|
goto end; |
|
|
|
count0 = readw(&musbr->ep[0].ep0.count0); |
|
if (count0 == 0) |
|
goto end; |
|
|
|
if (count0 != 8) { |
|
if ((debug_setup) && (debug_level > 1)) |
|
serial_printf("WARN : %s SETUP incorrect size %d\n", |
|
__PRETTY_FUNCTION__, count0); |
|
musb_peri_ep0_stall(); |
|
goto end; |
|
} |
|
|
|
read_fifo(0, count0, &ep0_urb->device_request); |
|
|
|
if (debug_level > 2) |
|
print_usb_device_request(&ep0_urb->device_request); |
|
|
|
if (ep0_urb->device_request.wLength == 0) { |
|
err = ep0_recv_setup(ep0_urb); |
|
|
|
/* Zero data request */ |
|
musb_peri_ep0_zero_data_request(err); |
|
} else { |
|
/* Is data coming or going ? */ |
|
u8 reqType = ep0_urb->device_request.bmRequestType; |
|
|
|
if (USB_REQ_DEVICE2HOST == (reqType & USB_REQ_DIRECTION_MASK)) { |
|
err = ep0_recv_setup(ep0_urb); |
|
/* Device to host */ |
|
musb_peri_ep0_tx_data_request(err); |
|
} else { |
|
/* |
|
* Host to device |
|
* |
|
* The RX routine will call ep0_recv_setup |
|
* when the data packet has arrived. |
|
*/ |
|
musb_peri_ep0_rx_data_request(); |
|
} |
|
} |
|
|
|
end: |
|
return; |
|
} |
|
|
|
static void musb_peri_ep0_rx(void) |
|
{ |
|
/* |
|
* This is the completion of the data OUT / RX |
|
* |
|
* Host is sending data to ep0 that is not |
|
* part of setup. This comes from the cdc_recv_setup |
|
* op that is device specific. |
|
* |
|
* Pass the data back to driver ep0_recv_setup which |
|
* should give the cdc_recv_setup the chance to handle |
|
* the rx |
|
*/ |
|
u16 csr0; |
|
u16 count0; |
|
|
|
if (debug_level > 3) { |
|
if (0 != ep0_urb->actual_length) { |
|
serial_printf("%s finished ? %d of %d\n", |
|
__PRETTY_FUNCTION__, |
|
ep0_urb->actual_length, |
|
ep0_urb->device_request.wLength); |
|
} |
|
} |
|
|
|
if (ep0_urb->device_request.wLength == ep0_urb->actual_length) { |
|
musb_peri_ep0_last(); |
|
SET_EP0_STATE(IDLE); |
|
ep0_recv_setup(ep0_urb); |
|
return; |
|
} |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
if (!(MUSB_CSR0_RXPKTRDY & csr0)) |
|
return; |
|
|
|
count0 = readw(&musbr->ep[0].ep0.count0); |
|
|
|
if (count0) { |
|
struct usb_endpoint_instance *endpoint; |
|
u32 length; |
|
u8 *data; |
|
|
|
endpoint = ep0_endpoint; |
|
if (endpoint && endpoint->rcv_urb) { |
|
struct urb *urb = endpoint->rcv_urb; |
|
unsigned int remaining_space = urb->buffer_length - |
|
urb->actual_length; |
|
|
|
if (remaining_space) { |
|
int urb_bad = 0; /* urb is good */ |
|
|
|
if (count0 > remaining_space) |
|
length = remaining_space; |
|
else |
|
length = count0; |
|
|
|
data = (u8 *) urb->buffer_data; |
|
data += urb->actual_length; |
|
|
|
/* The common musb fifo reader */ |
|
read_fifo(0, length, data); |
|
|
|
musb_peri_ep0_ack_req(); |
|
|
|
/* |
|
* urb's actual_length is updated in |
|
* usbd_rcv_complete |
|
*/ |
|
usbd_rcv_complete(endpoint, length, urb_bad); |
|
|
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s no space in " |
|
"rcv buffer\n", |
|
__PRETTY_FUNCTION__); |
|
} |
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s problem with " |
|
"endpoint\n", |
|
__PRETTY_FUNCTION__); |
|
} |
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s with nothing to do\n", |
|
__PRETTY_FUNCTION__); |
|
} |
|
} |
|
|
|
static void musb_peri_ep0_tx(void) |
|
{ |
|
u16 csr0; |
|
int transfer_size = 0; |
|
unsigned int p, pm; |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
|
|
/* Check for pending tx */ |
|
if (csr0 & MUSB_CSR0_TXPKTRDY) |
|
goto end; |
|
|
|
/* Check if this is the last packet sent */ |
|
if (ep0_endpoint->sent >= ep0_urb->actual_length) { |
|
SET_EP0_STATE(IDLE); |
|
goto end; |
|
} |
|
|
|
transfer_size = ep0_urb->actual_length - ep0_endpoint->sent; |
|
/* Is the transfer size negative ? */ |
|
if (transfer_size <= 0) { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s problem with the" |
|
" transfer size %d\n", |
|
__PRETTY_FUNCTION__, |
|
transfer_size); |
|
SET_EP0_STATE(IDLE); |
|
goto end; |
|
} |
|
|
|
/* Truncate large transfers to the fifo size */ |
|
if (transfer_size > ep0_endpoint->tx_packetSize) |
|
transfer_size = ep0_endpoint->tx_packetSize; |
|
|
|
write_fifo(0, transfer_size, &ep0_urb->buffer[ep0_endpoint->sent]); |
|
ep0_endpoint->sent += transfer_size; |
|
|
|
/* Done or more to send ? */ |
|
if (ep0_endpoint->sent >= ep0_urb->actual_length) |
|
musb_ep0_tx_ready_and_last(); |
|
else |
|
musb_ep0_tx_ready(); |
|
|
|
/* Wait a bit */ |
|
pm = 10; |
|
for (p = 0; p < pm; p++) { |
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
if (!(csr0 & MUSB_CSR0_TXPKTRDY)) |
|
break; |
|
|
|
/* Double the delay. */ |
|
udelay(1 << pm); |
|
} |
|
|
|
if ((ep0_endpoint->sent >= ep0_urb->actual_length) && (p < pm)) |
|
SET_EP0_STATE(IDLE); |
|
|
|
end: |
|
return; |
|
} |
|
|
|
static void musb_peri_ep0(void) |
|
{ |
|
u16 csr0; |
|
|
|
if (SET_ADDRESS == ep0_state) |
|
return; |
|
|
|
csr0 = readw(&musbr->ep[0].ep0.csr0); |
|
|
|
/* Error conditions */ |
|
if (MUSB_CSR0_P_SENTSTALL & csr0) { |
|
csr0 &= ~MUSB_CSR0_P_SENTSTALL; |
|
writew(csr0, &musbr->ep[0].ep0.csr0); |
|
SET_EP0_STATE(IDLE); |
|
} |
|
if (MUSB_CSR0_P_SETUPEND & csr0) { |
|
csr0 |= MUSB_CSR0_P_SVDSETUPEND; |
|
writew(csr0, &musbr->ep[0].ep0.csr0); |
|
SET_EP0_STATE(IDLE); |
|
if ((debug_setup) && (debug_level > 1)) |
|
serial_printf("WARN: %s SETUPEND\n", |
|
__PRETTY_FUNCTION__); |
|
} |
|
|
|
/* Normal states */ |
|
if (IDLE == ep0_state) |
|
musb_peri_ep0_idle(); |
|
|
|
if (TX == ep0_state) |
|
musb_peri_ep0_tx(); |
|
|
|
if (RX == ep0_state) |
|
musb_peri_ep0_rx(); |
|
} |
|
|
|
static void musb_peri_rx_ep(unsigned int ep) |
|
{ |
|
u16 peri_rxcount; |
|
u8 peri_rxcsr = readw(&musbr->ep[ep].epN.rxcsr); |
|
|
|
if (!(peri_rxcsr & MUSB_RXCSR_RXPKTRDY)) { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s %d without MUSB_RXCSR_RXPKTRDY set\n", |
|
__PRETTY_FUNCTION__, ep); |
|
return; |
|
} |
|
|
|
peri_rxcount = readw(&musbr->ep[ep].epN.rxcount); |
|
if (peri_rxcount) { |
|
struct usb_endpoint_instance *endpoint; |
|
u32 length; |
|
u8 *data; |
|
|
|
endpoint = GET_ENDPOINT(udc_device, ep); |
|
if (endpoint && endpoint->rcv_urb) { |
|
struct urb *urb = endpoint->rcv_urb; |
|
unsigned int remaining_space = urb->buffer_length - |
|
urb->actual_length; |
|
|
|
if (remaining_space) { |
|
int urb_bad = 0; /* urb is good */ |
|
|
|
if (peri_rxcount > remaining_space) |
|
length = remaining_space; |
|
else |
|
length = peri_rxcount; |
|
|
|
data = (u8 *) urb->buffer_data; |
|
data += urb->actual_length; |
|
|
|
/* The common musb fifo reader */ |
|
read_fifo(ep, length, data); |
|
|
|
musb_peri_rx_ack(ep); |
|
|
|
/* |
|
* urb's actual_length is updated in |
|
* usbd_rcv_complete |
|
*/ |
|
usbd_rcv_complete(endpoint, length, urb_bad); |
|
|
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s %d no space " |
|
"in rcv buffer\n", |
|
__PRETTY_FUNCTION__, ep); |
|
} |
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s %d problem with " |
|
"endpoint\n", |
|
__PRETTY_FUNCTION__, ep); |
|
} |
|
|
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s %d with nothing to do\n", |
|
__PRETTY_FUNCTION__, ep); |
|
} |
|
} |
|
|
|
static void musb_peri_rx(u16 intr) |
|
{ |
|
unsigned int ep; |
|
|
|
/* Check for EP0 */ |
|
if (0x01 & intr) |
|
musb_peri_ep0(); |
|
|
|
for (ep = 1; ep < 16; ep++) { |
|
if ((1 << ep) & intr) |
|
musb_peri_rx_ep(ep); |
|
} |
|
} |
|
|
|
static void musb_peri_tx(u16 intr) |
|
{ |
|
/* Check for EP0 */ |
|
if (0x01 & intr) |
|
musb_peri_ep0_tx(); |
|
|
|
/* |
|
* Use this in the future when handling epN tx |
|
* |
|
* u8 ep; |
|
* |
|
* for (ep = 1; ep < 16; ep++) { |
|
* if ((1 << ep) & intr) { |
|
* / * handle tx for this endpoint * / |
|
* } |
|
* } |
|
*/ |
|
} |
|
|
|
void udc_irq(void) |
|
{ |
|
/* This is a high freq called function */ |
|
if (enabled) { |
|
u8 intrusb; |
|
|
|
intrusb = readb(&musbr->intrusb); |
|
|
|
/* |
|
* See drivers/usb/gadget/mpc8xx_udc.c for |
|
* state diagram going from detached through |
|
* configuration. |
|
*/ |
|
if (MUSB_INTR_RESUME & intrusb) { |
|
usbd_device_event_irq(udc_device, |
|
DEVICE_BUS_ACTIVITY, 0); |
|
musb_peri_resume(); |
|
} |
|
|
|
musb_peri_ep0(); |
|
|
|
if (MUSB_INTR_RESET & intrusb) { |
|
usbd_device_event_irq(udc_device, DEVICE_RESET, 0); |
|
musb_peri_reset(); |
|
} |
|
|
|
if (MUSB_INTR_DISCONNECT & intrusb) { |
|
/* cable unplugged from hub/host */ |
|
usbd_device_event_irq(udc_device, DEVICE_RESET, 0); |
|
musb_peri_reset(); |
|
usbd_device_event_irq(udc_device, DEVICE_HUB_RESET, 0); |
|
} |
|
|
|
if (MUSB_INTR_SOF & intrusb) { |
|
usbd_device_event_irq(udc_device, |
|
DEVICE_BUS_ACTIVITY, 0); |
|
musb_peri_resume(); |
|
} |
|
|
|
if (MUSB_INTR_SUSPEND & intrusb) { |
|
usbd_device_event_irq(udc_device, |
|
DEVICE_BUS_INACTIVE, 0); |
|
} |
|
|
|
if (ep0_state != SET_ADDRESS) { |
|
u16 intrrx, intrtx; |
|
|
|
intrrx = readw(&musbr->intrrx); |
|
intrtx = readw(&musbr->intrtx); |
|
|
|
if (intrrx) |
|
musb_peri_rx(intrrx); |
|
|
|
if (intrtx) |
|
musb_peri_tx(intrtx); |
|
} else { |
|
if (MUSB_INTR_SOF & intrusb) { |
|
u8 faddr; |
|
faddr = readb(&musbr->faddr); |
|
/* |
|
* Setting of the address can fail. |
|
* Normally it succeeds the second time. |
|
*/ |
|
if (udc_device->address != faddr) |
|
musb_peri_ep0_set_address(); |
|
} |
|
} |
|
} |
|
} |
|
|
|
void udc_set_nak(int ep_num) |
|
{ |
|
/* noop */ |
|
} |
|
|
|
void udc_unset_nak(int ep_num) |
|
{ |
|
/* noop */ |
|
} |
|
|
|
int udc_endpoint_write(struct usb_endpoint_instance *endpoint) |
|
{ |
|
int ret = 0; |
|
|
|
/* Transmit only if the hardware is available */ |
|
if (endpoint->tx_urb && endpoint->state == 0) { |
|
unsigned int ep = endpoint->endpoint_address & |
|
USB_ENDPOINT_NUMBER_MASK; |
|
|
|
u16 peri_txcsr = readw(&musbr->ep[ep].epN.txcsr); |
|
|
|
/* Error conditions */ |
|
if (peri_txcsr & MUSB_TXCSR_P_UNDERRUN) { |
|
peri_txcsr &= ~MUSB_TXCSR_P_UNDERRUN; |
|
writew(peri_txcsr, &musbr->ep[ep].epN.txcsr); |
|
} |
|
|
|
if (debug_level > 1) |
|
musb_print_txcsr(peri_txcsr); |
|
|
|
/* Check if a packet is waiting to be sent */ |
|
if (!(peri_txcsr & MUSB_TXCSR_TXPKTRDY)) { |
|
u32 length; |
|
u8 *data; |
|
struct urb *urb = endpoint->tx_urb; |
|
unsigned int remaining_packet = urb->actual_length - |
|
endpoint->sent; |
|
|
|
if (endpoint->tx_packetSize < remaining_packet) |
|
length = endpoint->tx_packetSize; |
|
else |
|
length = remaining_packet; |
|
|
|
data = (u8 *) urb->buffer; |
|
data += endpoint->sent; |
|
|
|
/* common musb fifo function */ |
|
write_fifo(ep, length, data); |
|
|
|
musb_peri_tx_ready(ep); |
|
|
|
endpoint->last = length; |
|
/* usbd_tx_complete will take care of updating 'sent' */ |
|
usbd_tx_complete(endpoint); |
|
} |
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s Problem with urb %p " |
|
"or ep state %d\n", |
|
__PRETTY_FUNCTION__, |
|
endpoint->tx_urb, endpoint->state); |
|
} |
|
|
|
return ret; |
|
} |
|
|
|
void udc_setup_ep(struct usb_device_instance *device, unsigned int id, |
|
struct usb_endpoint_instance *endpoint) |
|
{ |
|
if (0 == id) { |
|
/* EP0 */ |
|
ep0_endpoint = endpoint; |
|
ep0_endpoint->endpoint_address = 0xff; |
|
ep0_urb = usbd_alloc_urb(device, endpoint); |
|
} else if (MAX_ENDPOINT >= id) { |
|
int ep_addr; |
|
|
|
/* Check the direction */ |
|
ep_addr = endpoint->endpoint_address; |
|
if (USB_DIR_IN == (ep_addr & USB_ENDPOINT_DIR_MASK)) { |
|
/* IN */ |
|
epinfo[(id * 2) + 1].epsize = endpoint->tx_packetSize; |
|
} else { |
|
/* OUT */ |
|
epinfo[id * 2].epsize = endpoint->rcv_packetSize; |
|
} |
|
|
|
musb_configure_ep(&epinfo[0], ARRAY_SIZE(epinfo)); |
|
} else { |
|
if (debug_level > 0) |
|
serial_printf("ERROR : %s endpoint request %d " |
|
"exceeds maximum %d\n", |
|
__PRETTY_FUNCTION__, id, MAX_ENDPOINT); |
|
} |
|
} |
|
|
|
void udc_connect(void) |
|
{ |
|
/* noop */ |
|
} |
|
|
|
void udc_disconnect(void) |
|
{ |
|
/* noop */ |
|
} |
|
|
|
void udc_enable(struct usb_device_instance *device) |
|
{ |
|
/* Save the device structure pointer */ |
|
udc_device = device; |
|
|
|
enabled = 1; |
|
} |
|
|
|
void udc_disable(void) |
|
{ |
|
enabled = 0; |
|
} |
|
|
|
void udc_startup_events(struct usb_device_instance *device) |
|
{ |
|
/* The DEVICE_INIT event puts the USB device in the state STATE_INIT. */ |
|
usbd_device_event_irq(device, DEVICE_INIT, 0); |
|
|
|
/* |
|
* The DEVICE_CREATE event puts the USB device in the state |
|
* STATE_ATTACHED. |
|
*/ |
|
usbd_device_event_irq(device, DEVICE_CREATE, 0); |
|
|
|
/* Resets the address to 0 */ |
|
usbd_device_event_irq(device, DEVICE_RESET, 0); |
|
|
|
udc_enable(device); |
|
} |
|
|
|
int udc_init(void) |
|
{ |
|
int ret; |
|
int ep_loop; |
|
|
|
ret = musb_platform_init(); |
|
if (ret < 0) |
|
goto end; |
|
|
|
/* Configure all the endpoint FIFO's and start usb controller */ |
|
musbr = musb_cfg.regs; |
|
|
|
/* Initialize the endpoints */ |
|
for (ep_loop = 0; ep_loop <= MAX_ENDPOINT * 2; ep_loop++) { |
|
epinfo[ep_loop].epnum = (ep_loop / 2) + 1; |
|
epinfo[ep_loop].epdir = ep_loop % 2; /* OUT, IN */ |
|
epinfo[ep_loop].epsize = 0; |
|
} |
|
|
|
musb_peri_softconnect(); |
|
|
|
ret = 0; |
|
end: |
|
|
|
return ret; |
|
}
|
|
|