upstream u-boot with additional patches for our devices/boards:
https://lists.denx.de/pipermail/u-boot/2017-March/282789.html (AXP crashes) ;
Gbit ethernet patch for some LIME2 revisions ;
with SPI flash support
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.
1295 lines
31 KiB
1295 lines
31 KiB
/*
|
|
* Mentor USB OTG Core host controller driver.
|
|
*
|
|
* Copyright (c) 2008 Texas Instruments
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
* Author: Thomas Abraham t-abraham@ti.com, Texas Instruments
|
|
*/
|
|
|
|
#include <common.h>
|
|
#include "musb_hcd.h"
|
|
|
|
/* MSC control transfers */
|
|
#define USB_MSC_BBB_RESET 0xFF
|
|
#define USB_MSC_BBB_GET_MAX_LUN 0xFE
|
|
|
|
/* Endpoint configuration information */
|
|
static const struct musb_epinfo epinfo[3] = {
|
|
{MUSB_BULK_EP, 1, 512}, /* EP1 - Bluk Out - 512 Bytes */
|
|
{MUSB_BULK_EP, 0, 512}, /* EP1 - Bluk In - 512 Bytes */
|
|
{MUSB_INTR_EP, 0, 64} /* EP2 - Interrupt IN - 64 Bytes */
|
|
};
|
|
|
|
/* --- Virtual Root Hub ---------------------------------------------------- */
|
|
#ifdef MUSB_NO_MULTIPOINT
|
|
static int rh_devnum;
|
|
static u32 port_status;
|
|
|
|
/* Device descriptor */
|
|
static const u8 root_hub_dev_des[] = {
|
|
0x12, /* __u8 bLength; */
|
|
0x01, /* __u8 bDescriptorType; Device */
|
|
0x00, /* __u16 bcdUSB; v1.1 */
|
|
0x02,
|
|
0x09, /* __u8 bDeviceClass; HUB_CLASSCODE */
|
|
0x00, /* __u8 bDeviceSubClass; */
|
|
0x00, /* __u8 bDeviceProtocol; */
|
|
0x08, /* __u8 bMaxPacketSize0; 8 Bytes */
|
|
0x00, /* __u16 idVendor; */
|
|
0x00,
|
|
0x00, /* __u16 idProduct; */
|
|
0x00,
|
|
0x00, /* __u16 bcdDevice; */
|
|
0x00,
|
|
0x00, /* __u8 iManufacturer; */
|
|
0x01, /* __u8 iProduct; */
|
|
0x00, /* __u8 iSerialNumber; */
|
|
0x01 /* __u8 bNumConfigurations; */
|
|
};
|
|
|
|
/* Configuration descriptor */
|
|
static const u8 root_hub_config_des[] = {
|
|
0x09, /* __u8 bLength; */
|
|
0x02, /* __u8 bDescriptorType; Configuration */
|
|
0x19, /* __u16 wTotalLength; */
|
|
0x00,
|
|
0x01, /* __u8 bNumInterfaces; */
|
|
0x01, /* __u8 bConfigurationValue; */
|
|
0x00, /* __u8 iConfiguration; */
|
|
0x40, /* __u8 bmAttributes;
|
|
Bit 7: Bus-powered, 6: Self-powered, 5 Remote-wakwup, 4..0: resvd */
|
|
0x00, /* __u8 MaxPower; */
|
|
|
|
/* interface */
|
|
0x09, /* __u8 if_bLength; */
|
|
0x04, /* __u8 if_bDescriptorType; Interface */
|
|
0x00, /* __u8 if_bInterfaceNumber; */
|
|
0x00, /* __u8 if_bAlternateSetting; */
|
|
0x01, /* __u8 if_bNumEndpoints; */
|
|
0x09, /* __u8 if_bInterfaceClass; HUB_CLASSCODE */
|
|
0x00, /* __u8 if_bInterfaceSubClass; */
|
|
0x00, /* __u8 if_bInterfaceProtocol; */
|
|
0x00, /* __u8 if_iInterface; */
|
|
|
|
/* endpoint */
|
|
0x07, /* __u8 ep_bLength; */
|
|
0x05, /* __u8 ep_bDescriptorType; Endpoint */
|
|
0x81, /* __u8 ep_bEndpointAddress; IN Endpoint 1 */
|
|
0x03, /* __u8 ep_bmAttributes; Interrupt */
|
|
0x00, /* __u16 ep_wMaxPacketSize; ((MAX_ROOT_PORTS + 1) / 8 */
|
|
0x02,
|
|
0xff /* __u8 ep_bInterval; 255 ms */
|
|
};
|
|
|
|
static const unsigned char root_hub_str_index0[] = {
|
|
0x04, /* __u8 bLength; */
|
|
0x03, /* __u8 bDescriptorType; String-descriptor */
|
|
0x09, /* __u8 lang ID */
|
|
0x04, /* __u8 lang ID */
|
|
};
|
|
|
|
static const unsigned char root_hub_str_index1[] = {
|
|
0x1c, /* __u8 bLength; */
|
|
0x03, /* __u8 bDescriptorType; String-descriptor */
|
|
'M', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'U', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'S', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'B', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
' ', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'R', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'o', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'o', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
't', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
' ', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'H', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'u', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
'b', /* __u8 Unicode */
|
|
0, /* __u8 Unicode */
|
|
};
|
|
#endif
|
|
|
|
/*
|
|
* This function writes the data toggle value.
|
|
*/
|
|
static void write_toggle(struct usb_device *dev, u8 ep, u8 dir_out)
|
|
{
|
|
u16 toggle = usb_gettoggle(dev, ep, dir_out);
|
|
u16 csr;
|
|
|
|
if (dir_out) {
|
|
csr = readw(&musbr->txcsr);
|
|
if (!toggle) {
|
|
if (csr & MUSB_TXCSR_MODE)
|
|
csr = MUSB_TXCSR_CLRDATATOG;
|
|
else
|
|
csr = 0;
|
|
writew(csr, &musbr->txcsr);
|
|
} else {
|
|
csr |= MUSB_TXCSR_H_WR_DATATOGGLE;
|
|
writew(csr, &musbr->txcsr);
|
|
csr |= (toggle << MUSB_TXCSR_H_DATATOGGLE_SHIFT);
|
|
writew(csr, &musbr->txcsr);
|
|
}
|
|
} else {
|
|
if (!toggle) {
|
|
csr = readw(&musbr->txcsr);
|
|
if (csr & MUSB_TXCSR_MODE)
|
|
csr = MUSB_RXCSR_CLRDATATOG;
|
|
else
|
|
csr = 0;
|
|
writew(csr, &musbr->rxcsr);
|
|
} else {
|
|
csr = readw(&musbr->rxcsr);
|
|
csr |= MUSB_RXCSR_H_WR_DATATOGGLE;
|
|
writew(csr, &musbr->rxcsr);
|
|
csr |= (toggle << MUSB_S_RXCSR_H_DATATOGGLE);
|
|
writew(csr, &musbr->rxcsr);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This function checks if RxStall has occured on the endpoint. If a RxStall
|
|
* has occured, the RxStall is cleared and 1 is returned. If RxStall has
|
|
* not occured, 0 is returned.
|
|
*/
|
|
static u8 check_stall(u8 ep, u8 dir_out)
|
|
{
|
|
u16 csr;
|
|
|
|
/* For endpoint 0 */
|
|
if (!ep) {
|
|
csr = readw(&musbr->txcsr);
|
|
if (csr & MUSB_CSR0_H_RXSTALL) {
|
|
csr &= ~MUSB_CSR0_H_RXSTALL;
|
|
writew(csr, &musbr->txcsr);
|
|
return 1;
|
|
}
|
|
} else { /* For non-ep0 */
|
|
if (dir_out) { /* is it tx ep */
|
|
csr = readw(&musbr->txcsr);
|
|
if (csr & MUSB_TXCSR_H_RXSTALL) {
|
|
csr &= ~MUSB_TXCSR_H_RXSTALL;
|
|
writew(csr, &musbr->txcsr);
|
|
return 1;
|
|
}
|
|
} else { /* is it rx ep */
|
|
csr = readw(&musbr->rxcsr);
|
|
if (csr & MUSB_RXCSR_H_RXSTALL) {
|
|
csr &= ~MUSB_RXCSR_H_RXSTALL;
|
|
writew(csr, &musbr->rxcsr);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* waits until ep0 is ready. Returns 0 if ep is ready, -1 for timeout
|
|
* error and -2 for stall.
|
|
*/
|
|
static int wait_until_ep0_ready(struct usb_device *dev, u32 bit_mask)
|
|
{
|
|
u16 csr;
|
|
int result = 1;
|
|
int timeout = CONFIG_MUSB_TIMEOUT;
|
|
|
|
while (result > 0) {
|
|
csr = readw(&musbr->txcsr);
|
|
if (csr & MUSB_CSR0_H_ERROR) {
|
|
csr &= ~MUSB_CSR0_H_ERROR;
|
|
writew(csr, &musbr->txcsr);
|
|
dev->status = USB_ST_CRC_ERR;
|
|
result = -1;
|
|
break;
|
|
}
|
|
|
|
switch (bit_mask) {
|
|
case MUSB_CSR0_TXPKTRDY:
|
|
if (!(csr & MUSB_CSR0_TXPKTRDY)) {
|
|
if (check_stall(MUSB_CONTROL_EP, 0)) {
|
|
dev->status = USB_ST_STALLED;
|
|
result = -2;
|
|
} else
|
|
result = 0;
|
|
}
|
|
break;
|
|
|
|
case MUSB_CSR0_RXPKTRDY:
|
|
if (check_stall(MUSB_CONTROL_EP, 0)) {
|
|
dev->status = USB_ST_STALLED;
|
|
result = -2;
|
|
} else
|
|
if (csr & MUSB_CSR0_RXPKTRDY)
|
|
result = 0;
|
|
break;
|
|
|
|
case MUSB_CSR0_H_REQPKT:
|
|
if (!(csr & MUSB_CSR0_H_REQPKT)) {
|
|
if (check_stall(MUSB_CONTROL_EP, 0)) {
|
|
dev->status = USB_ST_STALLED;
|
|
result = -2;
|
|
} else
|
|
result = 0;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* Check the timeout */
|
|
if (--timeout)
|
|
udelay(1);
|
|
else {
|
|
dev->status = USB_ST_CRC_ERR;
|
|
result = -1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* waits until tx ep is ready. Returns 1 when ep is ready and 0 on error.
|
|
*/
|
|
static u8 wait_until_txep_ready(struct usb_device *dev, u8 ep)
|
|
{
|
|
u16 csr;
|
|
int timeout = CONFIG_MUSB_TIMEOUT;
|
|
|
|
do {
|
|
if (check_stall(ep, 1)) {
|
|
dev->status = USB_ST_STALLED;
|
|
return 0;
|
|
}
|
|
|
|
csr = readw(&musbr->txcsr);
|
|
if (csr & MUSB_TXCSR_H_ERROR) {
|
|
dev->status = USB_ST_CRC_ERR;
|
|
return 0;
|
|
}
|
|
|
|
/* Check the timeout */
|
|
if (--timeout)
|
|
udelay(1);
|
|
else {
|
|
dev->status = USB_ST_CRC_ERR;
|
|
return -1;
|
|
}
|
|
|
|
} while (csr & MUSB_TXCSR_TXPKTRDY);
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* waits until rx ep is ready. Returns 1 when ep is ready and 0 on error.
|
|
*/
|
|
static u8 wait_until_rxep_ready(struct usb_device *dev, u8 ep)
|
|
{
|
|
u16 csr;
|
|
int timeout = CONFIG_MUSB_TIMEOUT;
|
|
|
|
do {
|
|
if (check_stall(ep, 0)) {
|
|
dev->status = USB_ST_STALLED;
|
|
return 0;
|
|
}
|
|
|
|
csr = readw(&musbr->rxcsr);
|
|
if (csr & MUSB_RXCSR_H_ERROR) {
|
|
dev->status = USB_ST_CRC_ERR;
|
|
return 0;
|
|
}
|
|
|
|
/* Check the timeout */
|
|
if (--timeout)
|
|
udelay(1);
|
|
else {
|
|
dev->status = USB_ST_CRC_ERR;
|
|
return -1;
|
|
}
|
|
|
|
} while (!(csr & MUSB_RXCSR_RXPKTRDY));
|
|
return 1;
|
|
}
|
|
|
|
/*
|
|
* This function performs the setup phase of the control transfer
|
|
*/
|
|
static int ctrlreq_setup_phase(struct usb_device *dev, struct devrequest *setup)
|
|
{
|
|
int result;
|
|
u16 csr;
|
|
|
|
/* write the control request to ep0 fifo */
|
|
write_fifo(MUSB_CONTROL_EP, sizeof(struct devrequest), (void *)setup);
|
|
|
|
/* enable transfer of setup packet */
|
|
csr = readw(&musbr->txcsr);
|
|
csr |= (MUSB_CSR0_TXPKTRDY|MUSB_CSR0_H_SETUPPKT);
|
|
writew(csr, &musbr->txcsr);
|
|
|
|
/* wait until the setup packet is transmitted */
|
|
result = wait_until_ep0_ready(dev, MUSB_CSR0_TXPKTRDY);
|
|
dev->act_len = 0;
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* This function handles the control transfer in data phase
|
|
*/
|
|
static int ctrlreq_in_data_phase(struct usb_device *dev, u32 len, void *buffer)
|
|
{
|
|
u16 csr;
|
|
u32 rxlen = 0;
|
|
u32 nextlen = 0;
|
|
u8 maxpktsize = (1 << dev->maxpacketsize) * 8;
|
|
u8 *rxbuff = (u8 *)buffer;
|
|
u8 rxedlength;
|
|
int result;
|
|
|
|
while (rxlen < len) {
|
|
/* Determine the next read length */
|
|
nextlen = ((len-rxlen) > maxpktsize) ? maxpktsize : (len-rxlen);
|
|
|
|
/* Set the ReqPkt bit */
|
|
csr = readw(&musbr->txcsr);
|
|
writew(csr | MUSB_CSR0_H_REQPKT, &musbr->txcsr);
|
|
result = wait_until_ep0_ready(dev, MUSB_CSR0_RXPKTRDY);
|
|
if (result < 0)
|
|
return result;
|
|
|
|
/* Actual number of bytes received by usb */
|
|
rxedlength = readb(&musbr->rxcount);
|
|
|
|
/* Read the data from the RxFIFO */
|
|
read_fifo(MUSB_CONTROL_EP, rxedlength, &rxbuff[rxlen]);
|
|
|
|
/* Clear the RxPktRdy Bit */
|
|
csr = readw(&musbr->txcsr);
|
|
csr &= ~MUSB_CSR0_RXPKTRDY;
|
|
writew(csr, &musbr->txcsr);
|
|
|
|
/* short packet? */
|
|
if (rxedlength != nextlen) {
|
|
dev->act_len += rxedlength;
|
|
break;
|
|
}
|
|
rxlen += nextlen;
|
|
dev->act_len = rxlen;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This function handles the control transfer out data phase
|
|
*/
|
|
static int ctrlreq_out_data_phase(struct usb_device *dev, u32 len, void *buffer)
|
|
{
|
|
u16 csr;
|
|
u32 txlen = 0;
|
|
u32 nextlen = 0;
|
|
u8 maxpktsize = (1 << dev->maxpacketsize) * 8;
|
|
u8 *txbuff = (u8 *)buffer;
|
|
int result = 0;
|
|
|
|
while (txlen < len) {
|
|
/* Determine the next write length */
|
|
nextlen = ((len-txlen) > maxpktsize) ? maxpktsize : (len-txlen);
|
|
|
|
/* Load the data to send in FIFO */
|
|
write_fifo(MUSB_CONTROL_EP, txlen, &txbuff[txlen]);
|
|
|
|
/* Set TXPKTRDY bit */
|
|
csr = readw(&musbr->txcsr);
|
|
writew(csr | MUSB_CSR0_H_DIS_PING | MUSB_CSR0_TXPKTRDY,
|
|
&musbr->txcsr);
|
|
result = wait_until_ep0_ready(dev, MUSB_CSR0_TXPKTRDY);
|
|
if (result < 0)
|
|
break;
|
|
|
|
txlen += nextlen;
|
|
dev->act_len = txlen;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* This function handles the control transfer out status phase
|
|
*/
|
|
static int ctrlreq_out_status_phase(struct usb_device *dev)
|
|
{
|
|
u16 csr;
|
|
int result;
|
|
|
|
/* Set the StatusPkt bit */
|
|
csr = readw(&musbr->txcsr);
|
|
csr |= (MUSB_CSR0_H_DIS_PING | MUSB_CSR0_TXPKTRDY |
|
|
MUSB_CSR0_H_STATUSPKT);
|
|
writew(csr, &musbr->txcsr);
|
|
|
|
/* Wait until TXPKTRDY bit is cleared */
|
|
result = wait_until_ep0_ready(dev, MUSB_CSR0_TXPKTRDY);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* This function handles the control transfer in status phase
|
|
*/
|
|
static int ctrlreq_in_status_phase(struct usb_device *dev)
|
|
{
|
|
u16 csr;
|
|
int result;
|
|
|
|
/* Set the StatusPkt bit and ReqPkt bit */
|
|
csr = MUSB_CSR0_H_DIS_PING | MUSB_CSR0_H_REQPKT | MUSB_CSR0_H_STATUSPKT;
|
|
writew(csr, &musbr->txcsr);
|
|
result = wait_until_ep0_ready(dev, MUSB_CSR0_H_REQPKT);
|
|
|
|
/* clear StatusPkt bit and RxPktRdy bit */
|
|
csr = readw(&musbr->txcsr);
|
|
csr &= ~(MUSB_CSR0_RXPKTRDY | MUSB_CSR0_H_STATUSPKT);
|
|
writew(csr, &musbr->txcsr);
|
|
return result;
|
|
}
|
|
|
|
/*
|
|
* determines the speed of the device (High/Full/Slow)
|
|
*/
|
|
static u8 get_dev_speed(struct usb_device *dev)
|
|
{
|
|
return (dev->speed & USB_SPEED_HIGH) ? MUSB_TYPE_SPEED_HIGH :
|
|
((dev->speed & USB_SPEED_LOW) ? MUSB_TYPE_SPEED_LOW :
|
|
MUSB_TYPE_SPEED_FULL);
|
|
}
|
|
|
|
/*
|
|
* configure the hub address and the port address.
|
|
*/
|
|
static void config_hub_port(struct usb_device *dev, u8 ep)
|
|
{
|
|
u8 chid;
|
|
u8 hub;
|
|
|
|
/* Find out the nearest parent which is high speed */
|
|
while (dev->parent->parent != NULL)
|
|
if (get_dev_speed(dev->parent) != MUSB_TYPE_SPEED_HIGH)
|
|
dev = dev->parent;
|
|
else
|
|
break;
|
|
|
|
/* determine the port address at that hub */
|
|
hub = dev->parent->devnum;
|
|
for (chid = 0; chid < USB_MAXCHILDREN; chid++)
|
|
if (dev->parent->children[chid] == dev)
|
|
break;
|
|
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
/* configure the hub address and the port address */
|
|
writeb(hub, &musbr->tar[ep].txhubaddr);
|
|
writeb((chid + 1), &musbr->tar[ep].txhubport);
|
|
writeb(hub, &musbr->tar[ep].rxhubaddr);
|
|
writeb((chid + 1), &musbr->tar[ep].rxhubport);
|
|
#endif
|
|
}
|
|
|
|
#ifdef MUSB_NO_MULTIPOINT
|
|
|
|
static void musb_port_reset(int do_reset)
|
|
{
|
|
u8 power = readb(&musbr->power);
|
|
|
|
if (do_reset) {
|
|
power &= 0xf0;
|
|
writeb(power | MUSB_POWER_RESET, &musbr->power);
|
|
port_status |= USB_PORT_STAT_RESET;
|
|
port_status &= ~USB_PORT_STAT_ENABLE;
|
|
udelay(30000);
|
|
} else {
|
|
writeb(power & ~MUSB_POWER_RESET, &musbr->power);
|
|
|
|
power = readb(&musbr->power);
|
|
if (power & MUSB_POWER_HSMODE)
|
|
port_status |= USB_PORT_STAT_HIGH_SPEED;
|
|
|
|
port_status &= ~(USB_PORT_STAT_RESET | (USB_PORT_STAT_C_CONNECTION << 16));
|
|
port_status |= USB_PORT_STAT_ENABLE
|
|
| (USB_PORT_STAT_C_RESET << 16)
|
|
| (USB_PORT_STAT_C_ENABLE << 16);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* root hub control
|
|
*/
|
|
static int musb_submit_rh_msg(struct usb_device *dev, unsigned long pipe,
|
|
void *buffer, int transfer_len,
|
|
struct devrequest *cmd)
|
|
{
|
|
int leni = transfer_len;
|
|
int len = 0;
|
|
int stat = 0;
|
|
u32 datab[4];
|
|
const u8 *data_buf = (u8 *) datab;
|
|
u16 bmRType_bReq;
|
|
u16 wValue;
|
|
u16 wIndex;
|
|
u16 wLength;
|
|
u16 int_usb;
|
|
|
|
if ((pipe & PIPE_INTERRUPT) == PIPE_INTERRUPT) {
|
|
debug("Root-Hub submit IRQ: NOT implemented\n");
|
|
return 0;
|
|
}
|
|
|
|
bmRType_bReq = cmd->requesttype | (cmd->request << 8);
|
|
wValue = swap_16(cmd->value);
|
|
wIndex = swap_16(cmd->index);
|
|
wLength = swap_16(cmd->length);
|
|
|
|
debug("--- HUB ----------------------------------------\n");
|
|
debug("submit rh urb, req=%x val=%#x index=%#x len=%d\n",
|
|
bmRType_bReq, wValue, wIndex, wLength);
|
|
debug("------------------------------------------------\n");
|
|
|
|
switch (bmRType_bReq) {
|
|
case RH_GET_STATUS:
|
|
debug("RH_GET_STATUS\n");
|
|
|
|
*(__u16 *) data_buf = swap_16(1);
|
|
len = 2;
|
|
break;
|
|
|
|
case RH_GET_STATUS | RH_INTERFACE:
|
|
debug("RH_GET_STATUS | RH_INTERFACE\n");
|
|
|
|
*(__u16 *) data_buf = swap_16(0);
|
|
len = 2;
|
|
break;
|
|
|
|
case RH_GET_STATUS | RH_ENDPOINT:
|
|
debug("RH_GET_STATUS | RH_ENDPOINT\n");
|
|
|
|
*(__u16 *) data_buf = swap_16(0);
|
|
len = 2;
|
|
break;
|
|
|
|
case RH_GET_STATUS | RH_CLASS:
|
|
debug("RH_GET_STATUS | RH_CLASS\n");
|
|
|
|
*(__u32 *) data_buf = swap_32(0);
|
|
len = 4;
|
|
break;
|
|
|
|
case RH_GET_STATUS | RH_OTHER | RH_CLASS:
|
|
debug("RH_GET_STATUS | RH_OTHER | RH_CLASS\n");
|
|
|
|
int_usb = readw(&musbr->intrusb);
|
|
if (int_usb & MUSB_INTR_CONNECT) {
|
|
port_status |= USB_PORT_STAT_CONNECTION
|
|
| (USB_PORT_STAT_C_CONNECTION << 16);
|
|
port_status |= USB_PORT_STAT_HIGH_SPEED
|
|
| USB_PORT_STAT_ENABLE;
|
|
}
|
|
|
|
if (port_status & USB_PORT_STAT_RESET)
|
|
musb_port_reset(0);
|
|
|
|
*(__u32 *) data_buf = swap_32(port_status);
|
|
len = 4;
|
|
break;
|
|
|
|
case RH_CLEAR_FEATURE | RH_ENDPOINT:
|
|
debug("RH_CLEAR_FEATURE | RH_ENDPOINT\n");
|
|
|
|
switch (wValue) {
|
|
case RH_ENDPOINT_STALL:
|
|
debug("C_HUB_ENDPOINT_STALL\n");
|
|
len = 0;
|
|
break;
|
|
}
|
|
port_status &= ~(1 << wValue);
|
|
break;
|
|
|
|
case RH_CLEAR_FEATURE | RH_CLASS:
|
|
debug("RH_CLEAR_FEATURE | RH_CLASS\n");
|
|
|
|
switch (wValue) {
|
|
case RH_C_HUB_LOCAL_POWER:
|
|
debug("C_HUB_LOCAL_POWER\n");
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_C_HUB_OVER_CURRENT:
|
|
debug("C_HUB_OVER_CURRENT\n");
|
|
len = 0;
|
|
break;
|
|
}
|
|
port_status &= ~(1 << wValue);
|
|
break;
|
|
|
|
case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
|
|
debug("RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS\n");
|
|
|
|
switch (wValue) {
|
|
case RH_PORT_ENABLE:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_PORT_SUSPEND:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_PORT_POWER:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_C_PORT_CONNECTION:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_C_PORT_ENABLE:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_C_PORT_SUSPEND:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_C_PORT_OVER_CURRENT:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_C_PORT_RESET:
|
|
len = 0;
|
|
break;
|
|
|
|
default:
|
|
debug("invalid wValue\n");
|
|
stat = USB_ST_STALLED;
|
|
}
|
|
|
|
port_status &= ~(1 << wValue);
|
|
break;
|
|
|
|
case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
|
|
debug("RH_SET_FEATURE | RH_OTHER | RH_CLASS\n");
|
|
|
|
switch (wValue) {
|
|
case RH_PORT_SUSPEND:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_PORT_RESET:
|
|
musb_port_reset(1);
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_PORT_POWER:
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_PORT_ENABLE:
|
|
len = 0;
|
|
break;
|
|
|
|
default:
|
|
debug("invalid wValue\n");
|
|
stat = USB_ST_STALLED;
|
|
}
|
|
|
|
port_status |= 1 << wValue;
|
|
break;
|
|
|
|
case RH_SET_ADDRESS:
|
|
debug("RH_SET_ADDRESS\n");
|
|
|
|
rh_devnum = wValue;
|
|
len = 0;
|
|
break;
|
|
|
|
case RH_GET_DESCRIPTOR:
|
|
debug("RH_GET_DESCRIPTOR: %x, %d\n", wValue, wLength);
|
|
|
|
switch (wValue) {
|
|
case (USB_DT_DEVICE << 8): /* device descriptor */
|
|
len = min_t(unsigned int,
|
|
leni, min_t(unsigned int,
|
|
sizeof(root_hub_dev_des),
|
|
wLength));
|
|
data_buf = root_hub_dev_des;
|
|
break;
|
|
|
|
case (USB_DT_CONFIG << 8): /* configuration descriptor */
|
|
len = min_t(unsigned int,
|
|
leni, min_t(unsigned int,
|
|
sizeof(root_hub_config_des),
|
|
wLength));
|
|
data_buf = root_hub_config_des;
|
|
break;
|
|
|
|
case ((USB_DT_STRING << 8) | 0x00): /* string 0 descriptors */
|
|
len = min_t(unsigned int,
|
|
leni, min_t(unsigned int,
|
|
sizeof(root_hub_str_index0),
|
|
wLength));
|
|
data_buf = root_hub_str_index0;
|
|
break;
|
|
|
|
case ((USB_DT_STRING << 8) | 0x01): /* string 1 descriptors */
|
|
len = min_t(unsigned int,
|
|
leni, min_t(unsigned int,
|
|
sizeof(root_hub_str_index1),
|
|
wLength));
|
|
data_buf = root_hub_str_index1;
|
|
break;
|
|
|
|
default:
|
|
debug("invalid wValue\n");
|
|
stat = USB_ST_STALLED;
|
|
}
|
|
|
|
break;
|
|
|
|
case RH_GET_DESCRIPTOR | RH_CLASS: {
|
|
u8 *_data_buf = (u8 *) datab;
|
|
debug("RH_GET_DESCRIPTOR | RH_CLASS\n");
|
|
|
|
_data_buf[0] = 0x09; /* min length; */
|
|
_data_buf[1] = 0x29;
|
|
_data_buf[2] = 0x1; /* 1 port */
|
|
_data_buf[3] = 0x01; /* per-port power switching */
|
|
_data_buf[3] |= 0x10; /* no overcurrent reporting */
|
|
|
|
/* Corresponds to data_buf[4-7] */
|
|
_data_buf[4] = 0;
|
|
_data_buf[5] = 5;
|
|
_data_buf[6] = 0;
|
|
_data_buf[7] = 0x02;
|
|
_data_buf[8] = 0xff;
|
|
|
|
len = min_t(unsigned int, leni,
|
|
min_t(unsigned int, data_buf[0], wLength));
|
|
break;
|
|
}
|
|
|
|
case RH_GET_CONFIGURATION:
|
|
debug("RH_GET_CONFIGURATION\n");
|
|
|
|
*(__u8 *) data_buf = 0x01;
|
|
len = 1;
|
|
break;
|
|
|
|
case RH_SET_CONFIGURATION:
|
|
debug("RH_SET_CONFIGURATION\n");
|
|
|
|
len = 0;
|
|
break;
|
|
|
|
default:
|
|
debug("*** *** *** unsupported root hub command *** *** ***\n");
|
|
stat = USB_ST_STALLED;
|
|
}
|
|
|
|
len = min_t(int, len, leni);
|
|
if (buffer != data_buf)
|
|
memcpy(buffer, data_buf, len);
|
|
|
|
dev->act_len = len;
|
|
dev->status = stat;
|
|
debug("dev act_len %d, status %d\n", dev->act_len, dev->status);
|
|
|
|
return stat;
|
|
}
|
|
|
|
static void musb_rh_init(void)
|
|
{
|
|
rh_devnum = 0;
|
|
port_status = 0;
|
|
}
|
|
|
|
#else
|
|
|
|
static void musb_rh_init(void) {}
|
|
|
|
#endif
|
|
|
|
/*
|
|
* do a control transfer
|
|
*/
|
|
int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
|
|
int len, struct devrequest *setup)
|
|
{
|
|
int devnum = usb_pipedevice(pipe);
|
|
u8 devspeed;
|
|
|
|
#ifdef MUSB_NO_MULTIPOINT
|
|
/* Control message is for the HUB? */
|
|
if (devnum == rh_devnum) {
|
|
int stat = musb_submit_rh_msg(dev, pipe, buffer, len, setup);
|
|
if (stat)
|
|
return stat;
|
|
}
|
|
#endif
|
|
|
|
/* select control endpoint */
|
|
writeb(MUSB_CONTROL_EP, &musbr->index);
|
|
readw(&musbr->txcsr);
|
|
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
/* target addr and (for multipoint) hub addr/port */
|
|
writeb(devnum, &musbr->tar[MUSB_CONTROL_EP].txfuncaddr);
|
|
writeb(devnum, &musbr->tar[MUSB_CONTROL_EP].rxfuncaddr);
|
|
#endif
|
|
|
|
/* configure the hub address and the port number as required */
|
|
devspeed = get_dev_speed(dev);
|
|
if ((musb_ishighspeed()) && (dev->parent != NULL) &&
|
|
(devspeed != MUSB_TYPE_SPEED_HIGH)) {
|
|
config_hub_port(dev, MUSB_CONTROL_EP);
|
|
writeb(devspeed << 6, &musbr->txtype);
|
|
} else {
|
|
writeb(musb_cfg.musb_speed << 6, &musbr->txtype);
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
writeb(0, &musbr->tar[MUSB_CONTROL_EP].txhubaddr);
|
|
writeb(0, &musbr->tar[MUSB_CONTROL_EP].txhubport);
|
|
writeb(0, &musbr->tar[MUSB_CONTROL_EP].rxhubaddr);
|
|
writeb(0, &musbr->tar[MUSB_CONTROL_EP].rxhubport);
|
|
#endif
|
|
}
|
|
|
|
/* Control transfer setup phase */
|
|
if (ctrlreq_setup_phase(dev, setup) < 0)
|
|
return 0;
|
|
|
|
switch (setup->request) {
|
|
case USB_REQ_GET_DESCRIPTOR:
|
|
case USB_REQ_GET_CONFIGURATION:
|
|
case USB_REQ_GET_INTERFACE:
|
|
case USB_REQ_GET_STATUS:
|
|
case USB_MSC_BBB_GET_MAX_LUN:
|
|
/* control transfer in-data-phase */
|
|
if (ctrlreq_in_data_phase(dev, len, buffer) < 0)
|
|
return 0;
|
|
/* control transfer out-status-phase */
|
|
if (ctrlreq_out_status_phase(dev) < 0)
|
|
return 0;
|
|
break;
|
|
|
|
case USB_REQ_SET_ADDRESS:
|
|
case USB_REQ_SET_CONFIGURATION:
|
|
case USB_REQ_SET_FEATURE:
|
|
case USB_REQ_SET_INTERFACE:
|
|
case USB_REQ_CLEAR_FEATURE:
|
|
case USB_MSC_BBB_RESET:
|
|
/* control transfer in status phase */
|
|
if (ctrlreq_in_status_phase(dev) < 0)
|
|
return 0;
|
|
break;
|
|
|
|
case USB_REQ_SET_DESCRIPTOR:
|
|
/* control transfer out data phase */
|
|
if (ctrlreq_out_data_phase(dev, len, buffer) < 0)
|
|
return 0;
|
|
/* control transfer in status phase */
|
|
if (ctrlreq_in_status_phase(dev) < 0)
|
|
return 0;
|
|
break;
|
|
|
|
default:
|
|
/* unhandled control transfer */
|
|
return -1;
|
|
}
|
|
|
|
dev->status = 0;
|
|
dev->act_len = len;
|
|
|
|
#ifdef MUSB_NO_MULTIPOINT
|
|
/* Set device address to USB_FADDR register */
|
|
if (setup->request == USB_REQ_SET_ADDRESS)
|
|
writeb(dev->devnum, &musbr->faddr);
|
|
#endif
|
|
|
|
return len;
|
|
}
|
|
|
|
/*
|
|
* do a bulk transfer
|
|
*/
|
|
int submit_bulk_msg(struct usb_device *dev, unsigned long pipe,
|
|
void *buffer, int len)
|
|
{
|
|
int dir_out = usb_pipeout(pipe);
|
|
int ep = usb_pipeendpoint(pipe);
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
int devnum = usb_pipedevice(pipe);
|
|
#endif
|
|
u8 type;
|
|
u16 csr;
|
|
u32 txlen = 0;
|
|
u32 nextlen = 0;
|
|
u8 devspeed;
|
|
|
|
/* select bulk endpoint */
|
|
writeb(MUSB_BULK_EP, &musbr->index);
|
|
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
/* write the address of the device */
|
|
if (dir_out)
|
|
writeb(devnum, &musbr->tar[MUSB_BULK_EP].txfuncaddr);
|
|
else
|
|
writeb(devnum, &musbr->tar[MUSB_BULK_EP].rxfuncaddr);
|
|
#endif
|
|
|
|
/* configure the hub address and the port number as required */
|
|
devspeed = get_dev_speed(dev);
|
|
if ((musb_ishighspeed()) && (dev->parent != NULL) &&
|
|
(devspeed != MUSB_TYPE_SPEED_HIGH)) {
|
|
/*
|
|
* MUSB is in high speed and the destination device is full
|
|
* speed device. So configure the hub address and port
|
|
* address registers.
|
|
*/
|
|
config_hub_port(dev, MUSB_BULK_EP);
|
|
} else {
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
if (dir_out) {
|
|
writeb(0, &musbr->tar[MUSB_BULK_EP].txhubaddr);
|
|
writeb(0, &musbr->tar[MUSB_BULK_EP].txhubport);
|
|
} else {
|
|
writeb(0, &musbr->tar[MUSB_BULK_EP].rxhubaddr);
|
|
writeb(0, &musbr->tar[MUSB_BULK_EP].rxhubport);
|
|
}
|
|
#endif
|
|
devspeed = musb_cfg.musb_speed;
|
|
}
|
|
|
|
/* Write the saved toggle bit value */
|
|
write_toggle(dev, ep, dir_out);
|
|
|
|
if (dir_out) { /* bulk-out transfer */
|
|
/* Program the TxType register */
|
|
type = (devspeed << MUSB_TYPE_SPEED_SHIFT) |
|
|
(MUSB_TYPE_PROTO_BULK << MUSB_TYPE_PROTO_SHIFT) |
|
|
(ep & MUSB_TYPE_REMOTE_END);
|
|
writeb(type, &musbr->txtype);
|
|
|
|
/* Write maximum packet size to the TxMaxp register */
|
|
writew(dev->epmaxpacketout[ep], &musbr->txmaxp);
|
|
while (txlen < len) {
|
|
nextlen = ((len-txlen) < dev->epmaxpacketout[ep]) ?
|
|
(len-txlen) : dev->epmaxpacketout[ep];
|
|
|
|
#ifdef CONFIG_USB_BLACKFIN
|
|
/* Set the transfer data size */
|
|
writew(nextlen, &musbr->txcount);
|
|
#endif
|
|
|
|
/* Write the data to the FIFO */
|
|
write_fifo(MUSB_BULK_EP, nextlen,
|
|
(void *)(((u8 *)buffer) + txlen));
|
|
|
|
/* Set the TxPktRdy bit */
|
|
csr = readw(&musbr->txcsr);
|
|
writew(csr | MUSB_TXCSR_TXPKTRDY, &musbr->txcsr);
|
|
|
|
/* Wait until the TxPktRdy bit is cleared */
|
|
if (!wait_until_txep_ready(dev, MUSB_BULK_EP)) {
|
|
readw(&musbr->txcsr);
|
|
usb_settoggle(dev, ep, dir_out,
|
|
(csr >> MUSB_TXCSR_H_DATATOGGLE_SHIFT) & 1);
|
|
dev->act_len = txlen;
|
|
return 0;
|
|
}
|
|
txlen += nextlen;
|
|
}
|
|
|
|
/* Keep a copy of the data toggle bit */
|
|
csr = readw(&musbr->txcsr);
|
|
usb_settoggle(dev, ep, dir_out,
|
|
(csr >> MUSB_TXCSR_H_DATATOGGLE_SHIFT) & 1);
|
|
} else { /* bulk-in transfer */
|
|
/* Write the saved toggle bit value */
|
|
write_toggle(dev, ep, dir_out);
|
|
|
|
/* Program the RxType register */
|
|
type = (devspeed << MUSB_TYPE_SPEED_SHIFT) |
|
|
(MUSB_TYPE_PROTO_BULK << MUSB_TYPE_PROTO_SHIFT) |
|
|
(ep & MUSB_TYPE_REMOTE_END);
|
|
writeb(type, &musbr->rxtype);
|
|
|
|
/* Write the maximum packet size to the RxMaxp register */
|
|
writew(dev->epmaxpacketin[ep], &musbr->rxmaxp);
|
|
while (txlen < len) {
|
|
nextlen = ((len-txlen) < dev->epmaxpacketin[ep]) ?
|
|
(len-txlen) : dev->epmaxpacketin[ep];
|
|
|
|
/* Set the ReqPkt bit */
|
|
csr = readw(&musbr->rxcsr);
|
|
writew(csr | MUSB_RXCSR_H_REQPKT, &musbr->rxcsr);
|
|
|
|
/* Wait until the RxPktRdy bit is set */
|
|
if (!wait_until_rxep_ready(dev, MUSB_BULK_EP)) {
|
|
csr = readw(&musbr->rxcsr);
|
|
usb_settoggle(dev, ep, dir_out,
|
|
(csr >> MUSB_S_RXCSR_H_DATATOGGLE) & 1);
|
|
csr &= ~MUSB_RXCSR_RXPKTRDY;
|
|
writew(csr, &musbr->rxcsr);
|
|
dev->act_len = txlen;
|
|
return 0;
|
|
}
|
|
|
|
/* Read the data from the FIFO */
|
|
read_fifo(MUSB_BULK_EP, nextlen,
|
|
(void *)(((u8 *)buffer) + txlen));
|
|
|
|
/* Clear the RxPktRdy bit */
|
|
csr = readw(&musbr->rxcsr);
|
|
csr &= ~MUSB_RXCSR_RXPKTRDY;
|
|
writew(csr, &musbr->rxcsr);
|
|
txlen += nextlen;
|
|
}
|
|
|
|
/* Keep a copy of the data toggle bit */
|
|
csr = readw(&musbr->rxcsr);
|
|
usb_settoggle(dev, ep, dir_out,
|
|
(csr >> MUSB_S_RXCSR_H_DATATOGGLE) & 1);
|
|
}
|
|
|
|
/* bulk transfer is complete */
|
|
dev->status = 0;
|
|
dev->act_len = len;
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This function initializes the usb controller module.
|
|
*/
|
|
int usb_lowlevel_init(void)
|
|
{
|
|
u8 power;
|
|
u32 timeout;
|
|
|
|
musb_rh_init();
|
|
|
|
if (musb_platform_init() == -1)
|
|
return -1;
|
|
|
|
/* Configure all the endpoint FIFO's and start usb controller */
|
|
musbr = musb_cfg.regs;
|
|
musb_configure_ep(&epinfo[0],
|
|
sizeof(epinfo) / sizeof(struct musb_epinfo));
|
|
musb_start();
|
|
|
|
/*
|
|
* Wait until musb is enabled in host mode with a timeout. There
|
|
* should be a usb device connected.
|
|
*/
|
|
timeout = musb_cfg.timeout;
|
|
while (timeout--)
|
|
if (readb(&musbr->devctl) & MUSB_DEVCTL_HM)
|
|
break;
|
|
|
|
/* if musb core is not in host mode, then return */
|
|
if (!timeout)
|
|
return -1;
|
|
|
|
/* start usb bus reset */
|
|
power = readb(&musbr->power);
|
|
writeb(power | MUSB_POWER_RESET, &musbr->power);
|
|
|
|
/* After initiating a usb reset, wait for about 20ms to 30ms */
|
|
udelay(30000);
|
|
|
|
/* stop usb bus reset */
|
|
power = readb(&musbr->power);
|
|
power &= ~MUSB_POWER_RESET;
|
|
writeb(power, &musbr->power);
|
|
|
|
/* Determine if the connected device is a high/full/low speed device */
|
|
musb_cfg.musb_speed = (readb(&musbr->power) & MUSB_POWER_HSMODE) ?
|
|
MUSB_TYPE_SPEED_HIGH :
|
|
((readb(&musbr->devctl) & MUSB_DEVCTL_FSDEV) ?
|
|
MUSB_TYPE_SPEED_FULL : MUSB_TYPE_SPEED_LOW);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This function stops the operation of the davinci usb module.
|
|
*/
|
|
int usb_lowlevel_stop(void)
|
|
{
|
|
/* Reset the USB module */
|
|
musb_platform_deinit();
|
|
writeb(0, &musbr->devctl);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* This function supports usb interrupt transfers. Currently, usb interrupt
|
|
* transfers are not supported.
|
|
*/
|
|
int submit_int_msg(struct usb_device *dev, unsigned long pipe,
|
|
void *buffer, int len, int interval)
|
|
{
|
|
int dir_out = usb_pipeout(pipe);
|
|
int ep = usb_pipeendpoint(pipe);
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
int devnum = usb_pipedevice(pipe);
|
|
#endif
|
|
u8 type;
|
|
u16 csr;
|
|
u32 txlen = 0;
|
|
u32 nextlen = 0;
|
|
u8 devspeed;
|
|
|
|
/* select interrupt endpoint */
|
|
writeb(MUSB_INTR_EP, &musbr->index);
|
|
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
/* write the address of the device */
|
|
if (dir_out)
|
|
writeb(devnum, &musbr->tar[MUSB_INTR_EP].txfuncaddr);
|
|
else
|
|
writeb(devnum, &musbr->tar[MUSB_INTR_EP].rxfuncaddr);
|
|
#endif
|
|
|
|
/* configure the hub address and the port number as required */
|
|
devspeed = get_dev_speed(dev);
|
|
if ((musb_ishighspeed()) && (dev->parent != NULL) &&
|
|
(devspeed != MUSB_TYPE_SPEED_HIGH)) {
|
|
/*
|
|
* MUSB is in high speed and the destination device is full
|
|
* speed device. So configure the hub address and port
|
|
* address registers.
|
|
*/
|
|
config_hub_port(dev, MUSB_INTR_EP);
|
|
} else {
|
|
#ifndef MUSB_NO_MULTIPOINT
|
|
if (dir_out) {
|
|
writeb(0, &musbr->tar[MUSB_INTR_EP].txhubaddr);
|
|
writeb(0, &musbr->tar[MUSB_INTR_EP].txhubport);
|
|
} else {
|
|
writeb(0, &musbr->tar[MUSB_INTR_EP].rxhubaddr);
|
|
writeb(0, &musbr->tar[MUSB_INTR_EP].rxhubport);
|
|
}
|
|
#endif
|
|
devspeed = musb_cfg.musb_speed;
|
|
}
|
|
|
|
/* Write the saved toggle bit value */
|
|
write_toggle(dev, ep, dir_out);
|
|
|
|
if (!dir_out) { /* intrrupt-in transfer */
|
|
/* Write the saved toggle bit value */
|
|
write_toggle(dev, ep, dir_out);
|
|
writeb(interval, &musbr->rxinterval);
|
|
|
|
/* Program the RxType register */
|
|
type = (devspeed << MUSB_TYPE_SPEED_SHIFT) |
|
|
(MUSB_TYPE_PROTO_INTR << MUSB_TYPE_PROTO_SHIFT) |
|
|
(ep & MUSB_TYPE_REMOTE_END);
|
|
writeb(type, &musbr->rxtype);
|
|
|
|
/* Write the maximum packet size to the RxMaxp register */
|
|
writew(dev->epmaxpacketin[ep], &musbr->rxmaxp);
|
|
|
|
while (txlen < len) {
|
|
nextlen = ((len-txlen) < dev->epmaxpacketin[ep]) ?
|
|
(len-txlen) : dev->epmaxpacketin[ep];
|
|
|
|
/* Set the ReqPkt bit */
|
|
csr = readw(&musbr->rxcsr);
|
|
writew(csr | MUSB_RXCSR_H_REQPKT, &musbr->rxcsr);
|
|
|
|
/* Wait until the RxPktRdy bit is set */
|
|
if (!wait_until_rxep_ready(dev, MUSB_INTR_EP)) {
|
|
csr = readw(&musbr->rxcsr);
|
|
usb_settoggle(dev, ep, dir_out,
|
|
(csr >> MUSB_S_RXCSR_H_DATATOGGLE) & 1);
|
|
csr &= ~MUSB_RXCSR_RXPKTRDY;
|
|
writew(csr, &musbr->rxcsr);
|
|
dev->act_len = txlen;
|
|
return 0;
|
|
}
|
|
|
|
/* Read the data from the FIFO */
|
|
read_fifo(MUSB_INTR_EP, nextlen,
|
|
(void *)(((u8 *)buffer) + txlen));
|
|
|
|
/* Clear the RxPktRdy bit */
|
|
csr = readw(&musbr->rxcsr);
|
|
csr &= ~MUSB_RXCSR_RXPKTRDY;
|
|
writew(csr, &musbr->rxcsr);
|
|
txlen += nextlen;
|
|
}
|
|
|
|
/* Keep a copy of the data toggle bit */
|
|
csr = readw(&musbr->rxcsr);
|
|
usb_settoggle(dev, ep, dir_out,
|
|
(csr >> MUSB_S_RXCSR_H_DATATOGGLE) & 1);
|
|
}
|
|
|
|
/* interrupt transfer is complete */
|
|
dev->irq_status = 0;
|
|
dev->irq_act_len = len;
|
|
dev->irq_handle(dev);
|
|
dev->status = 0;
|
|
dev->act_len = len;
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef CONFIG_SYS_USB_EVENT_POLL
|
|
/*
|
|
* This function polls for USB keyboard data.
|
|
*/
|
|
void usb_event_poll()
|
|
{
|
|
struct stdio_dev *dev;
|
|
struct usb_device *usb_kbd_dev;
|
|
struct usb_interface *iface;
|
|
struct usb_endpoint_descriptor *ep;
|
|
int pipe;
|
|
int maxp;
|
|
|
|
/* Get the pointer to USB Keyboard device pointer */
|
|
dev = stdio_get_by_name("usbkbd");
|
|
usb_kbd_dev = (struct usb_device *)dev->priv;
|
|
iface = &usb_kbd_dev->config.if_desc[0];
|
|
ep = &iface->ep_desc[0];
|
|
pipe = usb_rcvintpipe(usb_kbd_dev, ep->bEndpointAddress);
|
|
|
|
/* Submit a interrupt transfer request */
|
|
maxp = usb_maxpacket(usb_kbd_dev, pipe);
|
|
usb_submit_int_msg(usb_kbd_dev, pipe, &new[0],
|
|
maxp > 8 ? 8 : maxp, ep->bInterval);
|
|
}
|
|
#endif /* CONFIG_SYS_USB_EVENT_POLL */
|
|
|