Mirrors/u-boot
2
0
Fork 0
mirror of https://github.com/AsahiLinux/u-boot synced 2024-12-11 22:03:15 +00:00
Code Issues Projects Releases Packages Wiki Activity
u-boot/drivers/usb/host/isp116x-hcd.c
Ilya Yanok c60795f41d usb: use linux/usb/ch9.h instead of usbdescriptors.h 
Linux usb/ch9.h seems to have all the same information (and more)
as usbdescriptors.h so use the former instead of the later one.

As a consequense of this change USB_SPEED_* values don't correspond
directly to EHCI speed encoding anymore, I've added necessary
recoding in EHCI driver. Also there is no point to put speed into
pipe anymore so it's removed and a bunch of host drivers fixed to
look at usb_device->speed instead.

Old usbdescriptors.h included is not removed as it seems to be
used by old USB device code.

This makes usb.h and usbdevice.h incompatible. Fortunately the
only place that tries to include both are the old MUSB code and
it needs usb.h only for USB_DMA_MINALIGN used in aligned attribute
on musb_regs structure but this attribute seems to be unneeded
(old MUSB code doesn't support any DMA at all).

Signed-off-by: Ilya Yanok <ilya.yanok@cogentembedded.com>
2012-11-20 00:16:06 +01:00

1441 lines
36 KiB
C
Raw Blame History

/*
* ISP116x HCD (Host Controller Driver) for u-boot.
*
* Copyright (C) 2006-2007 Rodolfo Giometti <giometti@linux.it>
* Copyright (C) 2006-2007 Eurotech S.p.A. <info@eurotech.it>
*
* 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
*
*
* Derived in part from the SL811 HCD driver "u-boot/drivers/usb/sl811_usb.c"
* (original copyright message follows):
*
* (C) Copyright 2004
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* This code is based on linux driver for sl811hs chip, source at
* drivers/usb/host/sl811.c:
*
* SL811 Host Controller Interface driver for USB.
*
* Copyright (c) 2003/06, Courage Co., Ltd.
*
* Based on:
* 1.uhci.c by Linus Torvalds, Johannes Erdfelt, Randy Dunlap,
* Georg Acher, Deti Fliegl, Thomas Sailer, Roman Weissgaerber,
* Adam Richter, Gregory P. Smith;
* 2.Original SL811 driver (hc_sl811.o) by Pei Liu <pbl@cypress.com>
* 3.Rewrited as sl811.o by Yin Aihua <yinah:couragetech.com.cn>
*
* [[GNU/GPL disclaimer]]
*
* and in part from AU1x00 OHCI HCD driver "u-boot/arch/mips/cpu/au1x00_usb_ohci.c"
* (original copyright message follows):
*
* URB OHCI HCD (Host Controller Driver) for USB on the AU1x00.
*
* (C) Copyright 2003
* Gary Jennejohn, DENX Software Engineering <garyj@denx.de>
*
* [[GNU/GPL disclaimer]]
*
* Note: Part of this code has been derived from linux
*/
#include <common.h>
#include <asm/io.h>
#include <usb.h>
#include <malloc.h>
#include <linux/list.h>
/*
* ISP116x chips require certain delays between accesses to its
* registers. The following timing options exist.
*
* 1. Configure your memory controller (the best)
* 2. Use ndelay (easiest, poorest). For that, enable the following macro.
*
* Value is in microseconds.
*/
#ifdef ISP116X_HCD_USE_UDELAY
#define UDELAY 1
#endif
/*
* On some (slowly?) machines an extra delay after data packing into
* controller's FIFOs is required, * otherwise you may get the following
* error:
*
* uboot> usb start
* (Re)start USB...
* USB: scanning bus for devices... isp116x: isp116x_submit_job: CTL:TIMEOUT
* isp116x: isp116x_submit_job: ****** FIFO not ready! ******
*
* USB device not responding, giving up (status=4)
* isp116x: isp116x_submit_job: ****** FIFO not empty! ******
* isp116x: isp116x_submit_job: ****** FIFO not empty! ******
* isp116x: isp116x_submit_job: ****** FIFO not empty! ******
* 3 USB Device(s) found
* scanning bus for storage devices... 0 Storage Device(s) found
*
* Value is in milliseconds.
*/
#ifdef ISP116X_HCD_USE_EXTRA_DELAY
#define EXTRA_DELAY 2
#endif
/*
* Enable the following defines if you wish enable debugging messages.
*/
#undef DEBUG /* enable debugging messages */
#undef TRACE /* enable tracing code */
#undef VERBOSE /* verbose debugging messages */
#include "isp116x.h"
#define DRIVER_VERSION "08 Jan 2007"
static const char hcd_name[] = "isp116x-hcd";
struct isp116x isp116x_dev;
struct isp116x_platform_data isp116x_board;
static int got_rhsc; /* root hub status change */
struct usb_device *devgone; /* device which was disconnected */
static int rh_devnum; /* address of Root Hub endpoint */
/* ------------------------------------------------------------------------- */
#define ALIGN(x,a) (((x)+(a)-1UL)&~((a)-1UL))
#define min_t(type,x,y) \
({ type __x = (x); type __y = (y); __x < __y ? __x : __y; })
/* ------------------------------------------------------------------------- */
static int isp116x_reset(struct isp116x *isp116x);
/* --- Debugging functions ------------------------------------------------- */
#define isp116x_show_reg(d, r) { \
if ((r) < 0x20) { \
DBG("%-12s[%02x]: %08x", #r, \
r, isp116x_read_reg32(d, r)); \
} else { \
DBG("%-12s[%02x]: %04x", #r, \
r, isp116x_read_reg16(d, r)); \
} \
}
#define isp116x_show_regs(d) { \
isp116x_show_reg(d, HCREVISION); \
isp116x_show_reg(d, HCCONTROL); \
isp116x_show_reg(d, HCCMDSTAT); \
isp116x_show_reg(d, HCINTSTAT); \
isp116x_show_reg(d, HCINTENB); \
isp116x_show_reg(d, HCFMINTVL); \
isp116x_show_reg(d, HCFMREM); \
isp116x_show_reg(d, HCFMNUM); \
isp116x_show_reg(d, HCLSTHRESH); \
isp116x_show_reg(d, HCRHDESCA); \
isp116x_show_reg(d, HCRHDESCB); \
isp116x_show_reg(d, HCRHSTATUS); \
isp116x_show_reg(d, HCRHPORT1); \
isp116x_show_reg(d, HCRHPORT2); \
isp116x_show_reg(d, HCHWCFG); \
isp116x_show_reg(d, HCDMACFG); \
isp116x_show_reg(d, HCXFERCTR); \
isp116x_show_reg(d, HCuPINT); \
isp116x_show_reg(d, HCuPINTENB); \
isp116x_show_reg(d, HCCHIPID); \
isp116x_show_reg(d, HCSCRATCH); \
isp116x_show_reg(d, HCITLBUFLEN); \
isp116x_show_reg(d, HCATLBUFLEN); \
isp116x_show_reg(d, HCBUFSTAT); \
isp116x_show_reg(d, HCRDITL0LEN); \
isp116x_show_reg(d, HCRDITL1LEN); \
}
#if defined(TRACE)
static int isp116x_get_current_frame_number(struct usb_device *usb_dev)
{
struct isp116x *isp116x = &isp116x_dev;
return isp116x_read_reg32(isp116x, HCFMNUM);
}
static void dump_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
int len, char *str)
{
#if defined(VERBOSE)
int i;
#endif
DBG("%s URB:[%4x] dev:%2d,ep:%2d-%c,type:%s,len:%d stat:%#lx",
str,
isp116x_get_current_frame_number(dev),
usb_pipedevice(pipe),
usb_pipeendpoint(pipe),
usb_pipeout(pipe) ? 'O' : 'I',
usb_pipetype(pipe) < 2 ?
(usb_pipeint(pipe) ?
"INTR" : "ISOC") :
(usb_pipecontrol(pipe) ? "CTRL" : "BULK"), len, dev->status);
#if defined(VERBOSE)
if (len > 0 && buffer) {
printf(__FILE__ ": data(%d):", len);
for (i = 0; i < 16 && i < len; i++)
printf(" %02x", ((__u8 *) buffer)[i]);
printf("%s\n", i < len ? "..." : "");
}
#endif
}
#define PTD_DIR_STR(ptd) ({char __c; \
switch(PTD_GET_DIR(ptd)){ \
case 0: __c = 's'; break; \
case 1: __c = 'o'; break; \
default: __c = 'i'; break; \
}; __c;})
/*
Dump PTD info. The code documents the format
perfectly, right :)
*/
static inline void dump_ptd(struct ptd *ptd)
{
#if defined(VERBOSE)
int k;
#endif
DBG("PTD(ext) : cc:%x %d%c%d %d,%d,%d t:%x %x%x%x",
PTD_GET_CC(ptd),
PTD_GET_FA(ptd), PTD_DIR_STR(ptd), PTD_GET_EP(ptd),
PTD_GET_COUNT(ptd), PTD_GET_LEN(ptd), PTD_GET_MPS(ptd),
PTD_GET_TOGGLE(ptd),
PTD_GET_ACTIVE(ptd), PTD_GET_SPD(ptd), PTD_GET_LAST(ptd));
#if defined(VERBOSE)
printf("isp116x: %s: PTD(byte): ", __FUNCTION__);
for (k = 0; k < sizeof(struct ptd); ++k)
printf("%02x ", ((u8 *) ptd)[k]);
printf("\n");
#endif
}
static inline void dump_ptd_data(struct ptd *ptd, u8 * buf, int type)
{
#if defined(VERBOSE)
int k;
if (type == 0 /* 0ut data */ ) {
printf("isp116x: %s: out data: ", __FUNCTION__);
for (k = 0; k < PTD_GET_LEN(ptd); ++k)
printf("%02x ", ((u8 *) buf)[k]);
printf("\n");
}
if (type == 1 /* 1n data */ ) {
printf("isp116x: %s: in data: ", __FUNCTION__);
for (k = 0; k < PTD_GET_COUNT(ptd); ++k)
printf("%02x ", ((u8 *) buf)[k]);
printf("\n");
}
if (PTD_GET_LAST(ptd))
DBG("--- last PTD ---");
#endif
}
#else
#define dump_msg(dev, pipe, buffer, len, str) do { } while (0)
#define dump_pkt(dev, pipe, buffer, len, setup, str, small) do {} while (0)
#define dump_ptd(ptd) do {} while (0)
#define dump_ptd_data(ptd, buf, type) do {} while (0)
#endif
/* --- Virtual Root Hub ---------------------------------------------------- */
/* Device descriptor */
static __u8 root_hub_dev_des[] = {
0x12, /* __u8 bLength; */
0x01, /* __u8 bDescriptorType; Device */
0x10, /* __u16 bcdUSB; v1.1 */
0x01,
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 __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 unsigned char root_hub_str_index0[] = {
0x04, /* __u8 bLength; */
0x03, /* __u8 bDescriptorType; String-descriptor */
0x09, /* __u8 lang ID */
0x04, /* __u8 lang ID */
};
static unsigned char root_hub_str_index1[] = {
0x22, /* __u8 bLength; */
0x03, /* __u8 bDescriptorType; String-descriptor */
'I', /* __u8 Unicode */
0, /* __u8 Unicode */
'S', /* __u8 Unicode */
0, /* __u8 Unicode */
'P', /* __u8 Unicode */
0, /* __u8 Unicode */
'1', /* __u8 Unicode */
0, /* __u8 Unicode */
'1', /* __u8 Unicode */
0, /* __u8 Unicode */
'6', /* __u8 Unicode */
0, /* __u8 Unicode */
'x', /* __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 */
};
/*
* Hub class-specific descriptor is constructed dynamically
*/
/* --- Virtual root hub management functions ------------------------------- */
static int rh_check_port_status(struct isp116x *isp116x)
{
u32 temp, ndp, i;
int res;
res = -1;
temp = isp116x_read_reg32(isp116x, HCRHSTATUS);
ndp = (temp & RH_A_NDP);
for (i = 0; i < ndp; i++) {
temp = isp116x_read_reg32(isp116x, HCRHPORT1 + i);
/* check for a device disconnect */
if (((temp & (RH_PS_PESC | RH_PS_CSC)) ==
(RH_PS_PESC | RH_PS_CSC)) && ((temp & RH_PS_CCS) == 0)) {
res = i;
break;
}
}
return res;
}
/* --- HC management functions --------------------------------------------- */
/* Write len bytes to fifo, pad till 32-bit boundary
*/
static void write_ptddata_to_fifo(struct isp116x *isp116x, void *buf, int len)
{
u8 *dp = (u8 *) buf;
u16 *dp2 = (u16 *) buf;
u16 w;
int quot = len % 4;
if ((unsigned long)dp2 & 1) {
/* not aligned */
for (; len > 1; len -= 2) {
w = *dp++;
w |= *dp++ << 8;
isp116x_raw_write_data16(isp116x, w);
}
if (len)
isp116x_write_data16(isp116x, (u16) * dp);
} else {
/* aligned */
for (; len > 1; len -= 2)
isp116x_raw_write_data16(isp116x, *dp2++);
if (len)
isp116x_write_data16(isp116x, 0xff & *((u8 *) dp2));
}
if (quot == 1 || quot == 2)
isp116x_raw_write_data16(isp116x, 0);
}
/* Read len bytes from fifo and then read till 32-bit boundary
*/
static void read_ptddata_from_fifo(struct isp116x *isp116x, void *buf, int len)
{
u8 *dp = (u8 *) buf;
u16 *dp2 = (u16 *) buf;
u16 w;
int quot = len % 4;
if ((unsigned long)dp2 & 1) {
/* not aligned */
for (; len > 1; len -= 2) {
w = isp116x_raw_read_data16(isp116x);
*dp++ = w & 0xff;
*dp++ = (w >> 8) & 0xff;
}
if (len)
*dp = 0xff & isp116x_read_data16(isp116x);
} else {
/* aligned */
for (; len > 1; len -= 2)
*dp2++ = isp116x_raw_read_data16(isp116x);
if (len)
*(u8 *) dp2 = 0xff & isp116x_read_data16(isp116x);
}
if (quot == 1 || quot == 2)
isp116x_raw_read_data16(isp116x);
}
/* Write PTD's and data for scheduled transfers into the fifo ram.
* Fifo must be empty and ready */
static void pack_fifo(struct isp116x *isp116x, struct usb_device *dev,
unsigned long pipe, struct ptd *ptd, int n, void *data,
int len)
{
int buflen = n * sizeof(struct ptd) + len;
int i, done;
DBG("--- pack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
isp116x_write_addr(isp116x, HCATLPORT | ISP116x_WRITE_OFFSET);
done = 0;
for (i = 0; i < n; i++) {
DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
dump_ptd(&ptd[i]);
isp116x_write_data16(isp116x, ptd[i].count);
isp116x_write_data16(isp116x, ptd[i].mps);
isp116x_write_data16(isp116x, ptd[i].len);
isp116x_write_data16(isp116x, ptd[i].faddr);
dump_ptd_data(&ptd[i], (__u8 *) data + done, 0);
write_ptddata_to_fifo(isp116x,
(__u8 *) data + done,
PTD_GET_LEN(&ptd[i]));
done += PTD_GET_LEN(&ptd[i]);
}
}
/* Read the processed PTD's and data from fifo ram back to URBs' buffers.
* Fifo must be full and done */
static int unpack_fifo(struct isp116x *isp116x, struct usb_device *dev,
unsigned long pipe, struct ptd *ptd, int n, void *data,
int len)
{
int buflen = n * sizeof(struct ptd) + len;
int i, done, cc, ret;
isp116x_write_reg16(isp116x, HCuPINT, HCuPINT_AIIEOT);
isp116x_write_reg16(isp116x, HCXFERCTR, buflen);
isp116x_write_addr(isp116x, HCATLPORT);
ret = TD_CC_NOERROR;
done = 0;
for (i = 0; i < n; i++) {
DBG("i=%d - done=%d - len=%d", i, done, PTD_GET_LEN(&ptd[i]));
ptd[i].count = isp116x_read_data16(isp116x);
ptd[i].mps = isp116x_read_data16(isp116x);
ptd[i].len = isp116x_read_data16(isp116x);
ptd[i].faddr = isp116x_read_data16(isp116x);
dump_ptd(&ptd[i]);
read_ptddata_from_fifo(isp116x,
(__u8 *) data + done,
PTD_GET_LEN(&ptd[i]));
dump_ptd_data(&ptd[i], (__u8 *) data + done, 1);
done += PTD_GET_LEN(&ptd[i]);
cc = PTD_GET_CC(&ptd[i]);
/* Data underrun means basically that we had more buffer space than
* the function had data. It is perfectly normal but upper levels have
* to know how much we actually transferred.
*/
if (cc == TD_NOTACCESSED ||
(cc != TD_CC_NOERROR && (ret == TD_CC_NOERROR || ret == TD_DATAUNDERRUN)))
ret = cc;
}
DBG("--- unpack buffer %p - %d bytes (fifo %d) ---", data, len, buflen);
return ret;
}
/* Interrupt handling
*/
static int isp116x_interrupt(struct isp116x *isp116x)
{
u16 irqstat;
u32 intstat;
int ret = 0;
isp116x_write_reg16(isp116x, HCuPINTENB, 0);
irqstat = isp116x_read_reg16(isp116x, HCuPINT);
isp116x_write_reg16(isp116x, HCuPINT, irqstat);
DBG(">>>>>> irqstat %x <<<<<<", irqstat);
if (irqstat & HCuPINT_ATL) {
DBG(">>>>>> HCuPINT_ATL <<<<<<");
udelay(500);
ret = 1;
}
if (irqstat & HCuPINT_OPR) {
intstat = isp116x_read_reg32(isp116x, HCINTSTAT);
isp116x_write_reg32(isp116x, HCINTSTAT, intstat);
DBG(">>>>>> HCuPINT_OPR %x <<<<<<", intstat);
if (intstat & HCINT_UE) {
ERR("unrecoverable error, controller disabled");
/* FIXME: be optimistic, hope that bug won't repeat
* often. Make some non-interrupt context restart the
* controller. Count and limit the retries though;
* either hardware or software errors can go forever...
*/
isp116x_reset(isp116x);
ret = -1;
return -1;
}
if (intstat & HCINT_RHSC) {
got_rhsc = 1;
ret = 1;
/* When root hub or any of its ports is going
to come out of suspend, it may take more
than 10ms for status bits to stabilize. */
mdelay(20);
}
if (intstat & HCINT_SO) {
ERR("schedule overrun");
ret = -1;
}
irqstat &= ~HCuPINT_OPR;
}
return ret;
}
/* With one PTD we can transfer almost 1K in one go;
* HC does the splitting into endpoint digestible transactions
*/
struct ptd ptd[1];
static inline int max_transfer_len(struct usb_device *dev, unsigned long pipe)
{
unsigned mpck = usb_maxpacket(dev, pipe);
/* One PTD can transfer 1023 bytes but try to always
* transfer multiples of endpoint buffer size
*/
return 1023 / mpck * mpck;
}
/* Do an USB transfer
*/
static int isp116x_submit_job(struct usb_device *dev, unsigned long pipe,
int dir, void *buffer, int len)
{
struct isp116x *isp116x = &isp116x_dev;
int type = usb_pipetype(pipe);
int epnum = usb_pipeendpoint(pipe);
int max = usb_maxpacket(dev, pipe);
int dir_out = usb_pipeout(pipe);
int speed_low = (dev->speed == USB_SPEED_LOW);
int i, done = 0, stat, timeout, cc;
/* 500 frames or 0.5s timeout when function is busy and NAKs transactions for a while */
int retries = 500;
DBG("------------------------------------------------");
dump_msg(dev, pipe, buffer, len, "SUBMIT");
DBG("------------------------------------------------");
if (len >= 1024) {
ERR("Too big job");
dev->status = USB_ST_CRC_ERR;
return -1;
}
if (isp116x->disabled) {
ERR("EPIPE");
dev->status = USB_ST_CRC_ERR;
return -1;
}
/* device pulled? Shortcut the action. */
if (devgone == dev) {
ERR("ENODEV");
dev->status = USB_ST_CRC_ERR;
return USB_ST_CRC_ERR;
}
if (!max) {
ERR("pipesize for pipe %lx is zero", pipe);
dev->status = USB_ST_CRC_ERR;
return -1;
}
if (type == PIPE_ISOCHRONOUS) {
ERR("isochronous transfers not supported");
dev->status = USB_ST_CRC_ERR;
return -1;
}
/* FIFO not empty? */
if (isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_FULL) {
ERR("****** FIFO not empty! ******");
dev->status = USB_ST_BUF_ERR;
return -1;
}
retry:
isp116x_write_reg32(isp116x, HCINTSTAT, 0xff);
/* Prepare the PTD data */
ptd->count = PTD_CC_MSK | PTD_ACTIVE_MSK |
PTD_TOGGLE(usb_gettoggle(dev, epnum, dir_out));
ptd->mps = PTD_MPS(max) | PTD_SPD(speed_low) | PTD_EP(epnum) | PTD_LAST_MSK;
ptd->len = PTD_LEN(len) | PTD_DIR(dir);
ptd->faddr = PTD_FA(usb_pipedevice(pipe));
retry_same:
/* Pack data into FIFO ram */
pack_fifo(isp116x, dev, pipe, ptd, 1, buffer, len);
#ifdef EXTRA_DELAY
mdelay(EXTRA_DELAY);
#endif
/* Start the data transfer */
/* Allow more time for a BULK device to react - some are slow */
if (usb_pipebulk(pipe))
timeout = 5000;
else
timeout = 100;
/* Wait for it to complete */
for (;;) {
/* Check whether the controller is done */
stat = isp116x_interrupt(isp116x);
if (stat < 0) {
dev->status = USB_ST_CRC_ERR;
break;
}
if (stat > 0)
break;
/* Check the timeout */
if (--timeout)
udelay(1);
else {
ERR("CTL:TIMEOUT ");
stat = USB_ST_CRC_ERR;
break;
}
}
/* We got an Root Hub Status Change interrupt */
if (got_rhsc) {
isp116x_show_regs(isp116x);
got_rhsc = 0;
/* Abuse timeout */
timeout = rh_check_port_status(isp116x);
if (timeout >= 0) {
/*
* FIXME! NOTE! AAAARGH!
* This is potentially dangerous because it assumes
* that only one device is ever plugged in!
*/
devgone = dev;
}
}
/* Ok, now we can read transfer status */
/* FIFO not ready? */
if (!(isp116x_read_reg16(isp116x, HCBUFSTAT) & HCBUFSTAT_ATL_DONE)) {
ERR("****** FIFO not ready! ******");
dev->status = USB_ST_BUF_ERR;
return -1;
}
/* Unpack data from FIFO ram */
cc = unpack_fifo(isp116x, dev, pipe, ptd, 1, buffer, len);
i = PTD_GET_COUNT(ptd);
done += i;
buffer += i;
len -= i;
/* There was some kind of real problem; Prepare the PTD again
* and retry from the failed transaction on
*/
if (cc && cc != TD_NOTACCESSED && cc != TD_DATAUNDERRUN) {
if (retries >= 100) {
retries -= 100;
/* The chip will have toggled the toggle bit for the failed
* transaction too. We have to toggle it back.
*/
usb_settoggle(dev, epnum, dir_out, !PTD_GET_TOGGLE(ptd));
goto retry;
}
}
/* "Normal" errors; TD_NOTACCESSED would mean in effect that the function have NAKed
* the transactions from the first on for the whole frame. It may be busy and we retry
* with the same PTD. PTD_ACTIVE (and not TD_NOTACCESSED) would mean that some of the
* PTD didn't make it because the function was busy or the frame ended before the PTD
* finished. We prepare the rest of the data and try again.
*/
else if (cc == TD_NOTACCESSED || PTD_GET_ACTIVE(ptd) || (cc != TD_DATAUNDERRUN && PTD_GET_COUNT(ptd) < PTD_GET_LEN(ptd))) {
if (retries) {
--retries;
if (cc == TD_NOTACCESSED && PTD_GET_ACTIVE(ptd) && !PTD_GET_COUNT(ptd)) goto retry_same;
usb_settoggle(dev, epnum, dir_out, PTD_GET_TOGGLE(ptd));
goto retry;
}
}
if (cc != TD_CC_NOERROR && cc != TD_DATAUNDERRUN) {
DBG("****** completition code error %x ******", cc);
switch (cc) {
case TD_CC_BITSTUFFING:
dev->status = USB_ST_BIT_ERR;
break;
case TD_CC_STALL:
dev->status = USB_ST_STALLED;
break;
case TD_BUFFEROVERRUN:
case TD_BUFFERUNDERRUN:
dev->status = USB_ST_BUF_ERR;
break;
default:
dev->status = USB_ST_CRC_ERR;
}
return -cc;
}
else usb_settoggle(dev, epnum, dir_out, PTD_GET_TOGGLE(ptd));
dump_msg(dev, pipe, buffer, len, "SUBMIT(ret)");
dev->status = 0;
return done;
}
/* Adapted from au1x00_usb_ohci.c
*/
static int isp116x_submit_rh_msg(struct usb_device *dev, unsigned long pipe,
void *buffer, int transfer_len,
struct devrequest *cmd)
{
struct isp116x *isp116x = &isp116x_dev;
u32 tmp = 0;
int leni = transfer_len;
int len = 0;
int stat = 0;
u32 datab[4];
u8 *data_buf = (u8 *) datab;
u16 bmRType_bReq;
u16 wValue;
u16 wIndex;
u16 wLength;
if (usb_pipeint(pipe)) {
INFO("Root-Hub submit IRQ: NOT implemented");
return 0;
}
bmRType_bReq = cmd->requesttype | (cmd->request << 8);
wValue = swap_16(cmd->value);
wIndex = swap_16(cmd->index);
wLength = swap_16(cmd->length);
DBG("--- HUB ----------------------------------------");
DBG("submit rh urb, req=%x val=%#x index=%#x len=%d",
bmRType_bReq, wValue, wIndex, wLength);
dump_msg(dev, pipe, buffer, transfer_len, "RH");
DBG("------------------------------------------------");
switch (bmRType_bReq) {
case RH_GET_STATUS:
DBG("RH_GET_STATUS");
*(__u16 *) data_buf = swap_16(1);
len = 2;
break;
case RH_GET_STATUS | RH_INTERFACE:
DBG("RH_GET_STATUS | RH_INTERFACE");
*(__u16 *) data_buf = swap_16(0);
len = 2;
break;
case RH_GET_STATUS | RH_ENDPOINT:
DBG("RH_GET_STATUS | RH_ENDPOINT");
*(__u16 *) data_buf = swap_16(0);
len = 2;
break;
case RH_GET_STATUS | RH_CLASS:
DBG("RH_GET_STATUS | RH_CLASS");
tmp = isp116x_read_reg32(isp116x, HCRHSTATUS);
*(__u32 *) data_buf = swap_32(tmp & ~(RH_HS_CRWE | RH_HS_DRWE));
len = 4;
break;
case RH_GET_STATUS | RH_OTHER | RH_CLASS:
DBG("RH_GET_STATUS | RH_OTHER | RH_CLASS");
tmp = isp116x_read_reg32(isp116x, HCRHPORT1 + wIndex - 1);
*(__u32 *) data_buf = swap_32(tmp);
isp116x_show_regs(isp116x);
len = 4;
break;
case RH_CLEAR_FEATURE | RH_ENDPOINT:
DBG("RH_CLEAR_FEATURE | RH_ENDPOINT");
switch (wValue) {
case RH_ENDPOINT_STALL:
DBG("C_HUB_ENDPOINT_STALL");
len = 0;
break;
}
break;
case RH_CLEAR_FEATURE | RH_CLASS:
DBG("RH_CLEAR_FEATURE | RH_CLASS");
switch (wValue) {
case RH_C_HUB_LOCAL_POWER:
DBG("C_HUB_LOCAL_POWER");
len = 0;
break;
case RH_C_HUB_OVER_CURRENT:
DBG("C_HUB_OVER_CURRENT");
isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_OCIC);
len = 0;
break;
}
break;
case RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS:
DBG("RH_CLEAR_FEATURE | RH_OTHER | RH_CLASS");
switch (wValue) {
case RH_PORT_ENABLE:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_CCS);
len = 0;
break;
case RH_PORT_SUSPEND:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_POCI);
len = 0;
break;
case RH_PORT_POWER:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_LSDA);
len = 0;
break;
case RH_C_PORT_CONNECTION:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_CSC);
len = 0;
break;
case RH_C_PORT_ENABLE:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_PESC);
len = 0;
break;
case RH_C_PORT_SUSPEND:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_PSSC);
len = 0;
break;
case RH_C_PORT_OVER_CURRENT:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_POCI);
len = 0;
break;
case RH_C_PORT_RESET:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_PRSC);
len = 0;
break;
default:
ERR("invalid wValue");
stat = USB_ST_STALLED;
}
isp116x_show_regs(isp116x);
break;
case RH_SET_FEATURE | RH_OTHER | RH_CLASS:
DBG("RH_SET_FEATURE | RH_OTHER | RH_CLASS");
switch (wValue) {
case RH_PORT_SUSPEND:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_PSS);
len = 0;
break;
case RH_PORT_RESET:
/* Spin until any current reset finishes */
while (1) {
tmp =
isp116x_read_reg32(isp116x,
HCRHPORT1 + wIndex - 1);
if (!(tmp & RH_PS_PRS))
break;
mdelay(1);
}
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_PRS);
mdelay(10);
len = 0;
break;
case RH_PORT_POWER:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_PPS);
len = 0;
break;
case RH_PORT_ENABLE:
isp116x_write_reg32(isp116x, HCRHPORT1 + wIndex - 1,
RH_PS_PES);
len = 0;
break;
default:
ERR("invalid wValue");
stat = USB_ST_STALLED;
}
isp116x_show_regs(isp116x);
break;
case RH_SET_ADDRESS:
DBG("RH_SET_ADDRESS");
rh_devnum = wValue;
len = 0;
break;
case RH_GET_DESCRIPTOR:
DBG("RH_GET_DESCRIPTOR: %x, %d", 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:
ERR("invalid wValue");
stat = USB_ST_STALLED;
}
break;
case RH_GET_DESCRIPTOR | RH_CLASS:
DBG("RH_GET_DESCRIPTOR | RH_CLASS");
tmp = isp116x_read_reg32(isp116x, HCRHDESCA);
data_buf[0] = 0x09; /* min length; */
data_buf[1] = 0x29;
data_buf[2] = tmp & RH_A_NDP;
data_buf[3] = 0;
if (tmp & RH_A_PSM) /* per-port power switching? */
data_buf[3] |= 0x01;
if (tmp & RH_A_NOCP) /* no overcurrent reporting? */
data_buf[3] |= 0x10;
else if (tmp & RH_A_OCPM) /* per-port overcurrent rep? */
data_buf[3] |= 0x08;
/* Corresponds to data_buf[4-7] */
datab[1] = 0;
data_buf[5] = (tmp & RH_A_POTPGT) >> 24;
tmp = isp116x_read_reg32(isp116x, HCRHDESCB);
data_buf[7] = tmp & RH_B_DR;
if (data_buf[2] < 7)
data_buf[8] = 0xff;
else {
data_buf[0] += 2;
data_buf[8] = (tmp & RH_B_DR) >> 8;
data_buf[10] = data_buf[9] = 0xff;
}
len = min_t(unsigned int, leni,
min_t(unsigned int, data_buf[0], wLength));
break;
case RH_GET_CONFIGURATION:
DBG("RH_GET_CONFIGURATION");
*(__u8 *) data_buf = 0x01;
len = 1;
break;
case RH_SET_CONFIGURATION:
DBG("RH_SET_CONFIGURATION");
isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPSC);
len = 0;
break;
default:
ERR("*** *** *** unsupported root hub command *** *** ***");
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;
DBG("dev act_len %d, status %d", dev->act_len, dev->status);
dump_msg(dev, pipe, buffer, transfer_len, "RH(ret)");
return stat;
}
/* --- Transfer functions -------------------------------------------------- */
int submit_int_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
int len, int interval)
{
DBG("dev=%p pipe=%#lx buf=%p size=%d int=%d",
dev, pipe, buffer, len, interval);
return -1;
}
int submit_control_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
int len, struct devrequest *setup)
{
int devnum = usb_pipedevice(pipe);
int epnum = usb_pipeendpoint(pipe);
int max = max_transfer_len(dev, pipe);
int dir_in = usb_pipein(pipe);
int done, ret;
/* Control message is for the HUB? */
if (devnum == rh_devnum)
return isp116x_submit_rh_msg(dev, pipe, buffer, len, setup);
/* Ok, no HUB message so send the message to the device */
/* Setup phase */
DBG("--- SETUP PHASE --------------------------------");
usb_settoggle(dev, epnum, 1, 0);
ret = isp116x_submit_job(dev, pipe,
PTD_DIR_SETUP,
setup, sizeof(struct devrequest));
if (ret < 0) {
DBG("control setup phase error (ret = %d", ret);
return -1;
}
/* Data phase */
DBG("--- DATA PHASE ---------------------------------");
done = 0;
usb_settoggle(dev, epnum, !dir_in, 1);
while (done < len) {
ret = isp116x_submit_job(dev, pipe,
dir_in ? PTD_DIR_IN : PTD_DIR_OUT,
(__u8 *) buffer + done,
max > len - done ? len - done : max);
if (ret < 0) {
DBG("control data phase error (ret = %d)", ret);
return -1;
}
done += ret;
if (dir_in && ret < max) /* short packet */
break;
}
/* Status phase */
DBG("--- STATUS PHASE -------------------------------");
usb_settoggle(dev, epnum, !dir_in, 1);
ret = isp116x_submit_job(dev, pipe,
!dir_in ? PTD_DIR_IN : PTD_DIR_OUT, NULL, 0);
if (ret < 0) {
DBG("control status phase error (ret = %d", ret);
return -1;
}
dev->act_len = done;
dump_msg(dev, pipe, buffer, len, "DEV(ret)");
return done;
}
int submit_bulk_msg(struct usb_device *dev, unsigned long pipe, void *buffer,
int len)
{
int dir_out = usb_pipeout(pipe);
int max = max_transfer_len(dev, pipe);
int done, ret;
DBG("--- BULK ---------------------------------------");
DBG("dev=%ld pipe=%ld buf=%p size=%d dir_out=%d",
usb_pipedevice(pipe), usb_pipeendpoint(pipe), buffer, len, dir_out);
done = 0;
while (done < len) {
ret = isp116x_submit_job(dev, pipe,
!dir_out ? PTD_DIR_IN : PTD_DIR_OUT,
(__u8 *) buffer + done,
max > len - done ? len - done : max);
if (ret < 0) {
DBG("error on bulk message (ret = %d)", ret);
return -1;
}
done += ret;
if (!dir_out && ret < max) /* short packet */
break;
}
dev->act_len = done;
return 0;
}
/* --- Basic functions ----------------------------------------------------- */
static int isp116x_sw_reset(struct isp116x *isp116x)
{
int retries = 15;
int ret = 0;
DBG("");
isp116x->disabled = 1;
isp116x_write_reg16(isp116x, HCSWRES, HCSWRES_MAGIC);
isp116x_write_reg32(isp116x, HCCMDSTAT, HCCMDSTAT_HCR);
while (--retries) {
/* It usually resets within 1 ms */
mdelay(1);
if (!(isp116x_read_reg32(isp116x, HCCMDSTAT) & HCCMDSTAT_HCR))
break;
}
if (!retries) {
ERR("software reset timeout");
ret = -1;
}
return ret;
}
static int isp116x_reset(struct isp116x *isp116x)
{
unsigned long t;
u16 clkrdy = 0;
int ret, timeout = 15 /* ms */ ;
DBG("");
ret = isp116x_sw_reset(isp116x);
if (ret)
return ret;
for (t = 0; t < timeout; t++) {
clkrdy = isp116x_read_reg16(isp116x, HCuPINT) & HCuPINT_CLKRDY;
if (clkrdy)
break;
mdelay(1);
}
if (!clkrdy) {
ERR("clock not ready after %dms", timeout);
/* After sw_reset the clock won't report to be ready, if
H_WAKEUP pin is high. */
ERR("please make sure that the H_WAKEUP pin is pulled low!");
ret = -1;
}
return ret;
}
static void isp116x_stop(struct isp116x *isp116x)
{
u32 val;
DBG("");
isp116x_write_reg16(isp116x, HCuPINTENB, 0);
/* Switch off ports' power, some devices don't come up
after next 'start' without this */
val = isp116x_read_reg32(isp116x, HCRHDESCA);
val &= ~(RH_A_NPS | RH_A_PSM);
isp116x_write_reg32(isp116x, HCRHDESCA, val);
isp116x_write_reg32(isp116x, HCRHSTATUS, RH_HS_LPS);
isp116x_sw_reset(isp116x);
}
/*
* Configure the chip. The chip must be successfully reset by now.
*/
static int isp116x_start(struct isp116x *isp116x)
{
struct isp116x_platform_data *board = isp116x->board;
u32 val;
DBG("");
/* Clear interrupt status and disable all interrupt sources */
isp116x_write_reg16(isp116x, HCuPINT, 0xff);
isp116x_write_reg16(isp116x, HCuPINTENB, 0);
isp116x_write_reg16(isp116x, HCITLBUFLEN, ISP116x_ITL_BUFSIZE);
isp116x_write_reg16(isp116x, HCATLBUFLEN, ISP116x_ATL_BUFSIZE);
/* Hardware configuration */
val = HCHWCFG_DBWIDTH(1);
if (board->sel15Kres)
val |= HCHWCFG_15KRSEL;
/* Remote wakeup won't work without working clock */
if (board->remote_wakeup_enable)
val |= HCHWCFG_CLKNOTSTOP;
if (board->oc_enable)
val |= HCHWCFG_ANALOG_OC;
isp116x_write_reg16(isp116x, HCHWCFG, val);
/* --- Root hub configuration */
val = (25 << 24) & RH_A_POTPGT;
/* AN10003_1.pdf recommends RH_A_NPS (no power switching) to
be always set. Yet, instead, we request individual port
power switching. */
val |= RH_A_PSM;
/* Report overcurrent per port */
val |= RH_A_OCPM;
isp116x_write_reg32(isp116x, HCRHDESCA, val);
isp116x->rhdesca = isp116x_read_reg32(isp116x, HCRHDESCA);
val = RH_B_PPCM;
isp116x_write_reg32(isp116x, HCRHDESCB, val);
isp116x->rhdescb = isp116x_read_reg32(isp116x, HCRHDESCB);
val = 0;
if (board->remote_wakeup_enable)
val |= RH_HS_DRWE;
isp116x_write_reg32(isp116x, HCRHSTATUS, val);
isp116x->rhstatus = isp116x_read_reg32(isp116x, HCRHSTATUS);
isp116x_write_reg32(isp116x, HCFMINTVL, 0x27782edf);
/* Go operational */
val = HCCONTROL_USB_OPER;
if (board->remote_wakeup_enable)
val |= HCCONTROL_RWE;
isp116x_write_reg32(isp116x, HCCONTROL, val);
/* Disable ports to avoid race in device enumeration */
isp116x_write_reg32(isp116x, HCRHPORT1, RH_PS_CCS);
isp116x_write_reg32(isp116x, HCRHPORT2, RH_PS_CCS);
isp116x_show_regs(isp116x);
isp116x->disabled = 0;
return 0;
}
/* --- Init functions ------------------------------------------------------ */
int isp116x_check_id(struct isp116x *isp116x)
{
int val;
val = isp116x_read_reg16(isp116x, HCCHIPID);
if ((val & HCCHIPID_MASK) != HCCHIPID_MAGIC) {
ERR("invalid chip ID %04x", val);
return -1;
}
return 0;
}
int usb_lowlevel_init(int index, void **controller))
{
struct isp116x *isp116x = &isp116x_dev;
DBG("");
got_rhsc = rh_devnum = 0;
/* Init device registers addr */
isp116x->addr_reg = (u16 *) ISP116X_HCD_ADDR;
isp116x->data_reg = (u16 *) ISP116X_HCD_DATA;
/* Setup specific board settings */
#ifdef ISP116X_HCD_SEL15kRES
isp116x_board.sel15Kres = 1;
#endif
#ifdef ISP116X_HCD_OC_ENABLE
isp116x_board.oc_enable = 1;
#endif
#ifdef ISP116X_HCD_REMOTE_WAKEUP_ENABLE
isp116x_board.remote_wakeup_enable = 1;
#endif
isp116x->board = &isp116x_board;
/* Try to get ISP116x silicon chip ID */
if (isp116x_check_id(isp116x) < 0)
return -1;
isp116x->disabled = 1;
isp116x->sleeping = 0;
isp116x_reset(isp116x);
isp116x_start(isp116x);
return 0;
}
int usb_lowlevel_stop(int index)
{
struct isp116x *isp116x = &isp116x_dev;
DBG("");
if (!isp116x->disabled)
isp116x_stop(isp116x);
return 0;
}
Reference in a new issue View git blame Copy permalink