/***************************************************************************
* Function Name : regTest
*
* This routine test the Read/Write functionality of SL811HS registers
*
* 1) Store original register value into a buffer
* 2) Write to registers with a RAMP pattern. (10, 11, 12, ..., 255)
* 3) Read from register
* 4) Compare the written value with the read value and make sure they are
* equivalent
* 5) Restore the original register value
*
* Input: hci = data structure for the host controller
*
*
* Return: TRUE = passed; FALSE = failed
**************************************************************************/
int regTest (hci_t * hci)
{
int i, data, result = TRUE;
char buf[256];
DBGFUNC ("Enter regTest\n");
for (i = 0x10; i < 256; i++) {
/* save the original buffer */
buf[i] = (char) SL811Read (hci, i);
/* Write the new data to the buffer */
SL811Write (hci, i, i);
}
/* compare the written data */
for (i = 0x10; i < 256; i++) {
data = SL811Read (hci, i);
if (data != i) {
DBGERR ("Pattern test failed!! value = 0x%x, s/b 0x%x\n",
data, i);
result = FALSE;
}
}
/* restore the data */
for (i = 0x10; i < 256; i++) {
SL811Write (hci, i, buf[i]);
}
return (result);
}
/***************************************************************************
* Function Name : regShow
*
* Display all SL811HS register values
*
* Input: hci = data structure for the host controller
*
* Return: none
**************************************************************************/
void regShow (hci_t * hci)
{
int i;
for (i = 0; i < 256; i++) {
printk ("offset %d: 0x%x\n", i, SL811Read (hci, i));
}
}
void USBReset(void)
{
u_int8 temp;
temp=SL811Read(CtrlReg);
SL811Write(CtrlReg,temp|0x08);
//task_time_sleep(25);
SL811Write(CtrlReg,temp);
}
/************************************************************************
* Function Name : hc_add_trans
*
* This function sets up the SL811HS register and transmit the USB packets.
*
* 1) Determine if enough time within the current frame to send the packet
* 2) Load the data into the SL811HS register
* 3) Set the appropriate command to the register and trigger the transmit
*
* Input: hci = data structure for the host controller
* len = data length
* data = transmitting data
* toggle = USB toggle bit, either 0 or 1
* maxps = maximum packet size for this endpoint
* slow = speed of the device
* endpoint = endpoint number
* address = USB address of the device
* pid = packet ID
* format =
* urb_state = the current stage of USB transaction
*
* Return: 0 = no time left to schedule the transfer
* 1 = success
*
***********************************************************************/
static inline int hc_add_trans (hci_t * hci, int len, void *data, int toggle,
int maxps, int slow, int endpoint, int address,
int pid, int format, int urb_state)
{
hcipriv_t *hp = &hci->hp;
__u16 speed;
int ii, jj, kk;
DBGFUNC ("enter hc_addr_trans: len =0x%x, toggle:0x%x, endpoing:0x%x,"
" addr:0x%x, pid:0x%x,format:0x%x\n", len, toggle, endpoint,
i address, pid, format);
if (len > maxps) {
len = maxps;
}
speed = hp->RHportStatus->portStatus;
if (speed & PORT_LOW_SPEED_DEV_ATTACH_STAT) {
// ii = (8*7*8 + 6*3) * len + 800;
ii = 8 * 8 * len + 1024;
} else {
if (slow) {
// ii = (8*7*8 + 6*3) * len + 800;
ii = 8 * 8 * len + 2048;
} else
// ii = (8*7 + 6*3)*len + 110;
ii = 8 * len + 256;
}
ii += 2 * 10 * len;
jj = SL811Read (hci, SL11H_SOFTMRREG);
kk = (jj & 0xFF) * 64 - ii;
if (kk < 0) {
DBGVERBOSE
("hc_add_trans: no bandwidth for schedule, ii = 0x%x,"
"jj = 0x%x, len =0x%x, active_trans = 0x%x\n", ii, jj, len,
hci->active_trans);
return (-1);
}
if (pid != PID_IN) {
/* Load data into hc */
SL811BufWrite (hci, SL11H_DATA_START, (__u8 *) data, len);
}
/* transmit */
SL11StartXaction (hci, (__u8) address, (__u8) endpoint, (__u8) pid, len,
toggle, slow, urb_state);
return len;
}
/************************************************************************
* Function Name : hc_parse_trans
*
* This function checks the status of the transmitted or received packet
* and copy the data from the SL811HS register into a buffer.
*
* 1) Check the status of the packet
* 2) If successful, and IN packet then copy the data from the SL811HS register
* into a buffer
*
* Input: hci = data structure for the host controller
* actbytes = pointer to actual number of bytes
* data = data buffer
* cc = packet status
* length = the urb transmit length
* pid = packet ID
* urb_state = the current stage of USB transaction
*
* Return: 0
***********************************************************************/
static inline int hc_parse_trans (hci_t * hci, int *actbytes, __u8 * data,
int *cc, int *toggle, int length, int pid,
int urb_state)
{
__u8 addr;
__u8 len;
DBGFUNC ("enter hc_parse_trans\n");
/* get packet status; convert ack rcvd to ack-not-rcvd */
*cc = (int) SL811Read (hci, SL11H_PKTSTATREG);
if (*cc &
(SL11H_STATMASK_ERROR | SL11H_STATMASK_TMOUT | SL11H_STATMASK_OVF |
SL11H_STATMASK_NAK | SL11H_STATMASK_STALL)) {
if (*cc & SL11H_STATMASK_OVF)
DBGERR ("parse trans: error recv ack, cc = 0x%x, TX_BASE_Len = "
"0x%x, TX_count=0x%x\n", *cc,
SL811Read (hci, SL11H_BUFLNTHREG),
SL811Read (hci, SL11H_XFERCNTREG));
} else {
DBGVERBOSE ("parse trans: recv ack, cc = 0x%x, len = 0x%x, \n",
*cc, length);
/* Successful data */
if ((pid == PID_IN) && (urb_state != US_CTRL_SETUP)) {
/* Find the base address */
addr = SL811Read (hci, SL11H_BUFADDRREG);
/* Find the Transmit Length */
len = SL811Read (hci, SL11H_BUFLNTHREG);
/* The actual data length = xmit length reg - xfer count reg */
*actbytes = len - SL811Read (hci, SL11H_XFERCNTREG);
if ((data != NULL) && (*actbytes > 0)) {
SL811BufRead (hci, addr, data, *actbytes);
} else if ((data == NULL) && (*actbytes <= 0)) {
DBGERR ("hc_parse_trans: data = NULL or actbyte = 0x%x\n",
*actbytes);
return 0;
}
} else if (pid == PID_OUT) {
*actbytes = length;
} else {
// printk ("ERR:parse_trans, pid != IN or OUT, pid = 0x%x\n", pid);
}
*toggle = !*toggle;
}
return 0;
}
void check_key_LED(void)
{
u_int8 intr;
intr=SL811Read(IntStatus);
if(intr & USB_DETECT)
{
if(bXXGFlags.SLAVE_ONLINE ==TRUE)
{bXXGFlags.SLAVE_REMOVED=TRUE;
bXXGFlags.SLAVE_ONLINE =FALSE;
}
}
else {
if(bXXGFlags.SLAVE_ONLINE == FALSE)
{bXXGFlags.SLAVE_DETECT=TRUE;
bXXGFlags.SLAVE_ONLINE =TRUE;
}
}
SL811Write(IntStatus,INT_CLEAR);
SL811Write(IntStatus,INSERT_REMOVE);
}
/*****************************************************************
*
* Function Name: hc_interrupt
*
* Interrupt service routine.
*
* 1) determine the causes of interrupt
* 2) clears all interrupts
* 3) calls appropriate function to service the interrupt
*
* Input: irq = interrupt line associated with the controller
* hci = data structure for the host controller
* r = holds the snapshot of the processor's context before
* the processor entered interrupt code. (not used here)
*
* Return value : None.
*
*****************************************************************/
static void hc_interrupt (int irq, void *__hci, struct pt_regs *r)
{
char ii;
hci_t *hci = __hci;
int isExcessNak = 0;
int urb_state = 0;
char tmpIrq = 0;
/* Get value from interrupt status register */
ii = SL811Read (hci, SL11H_INTSTATREG);
if (ii & SL11H_INTMASK_INSRMV) {
/* Device insertion or removal detected for the USB port */
SL811Write (hci, SL11H_INTENBLREG, 0);
SL811Write (hci, SL11H_CTLREG1, 0);
mdelay (100); // wait for device stable
handleInsRmvIntr (hci);
return;
}
/* Clear all interrupts */
SL811Write (hci, SL11H_INTSTATREG, 0xff);
if (ii & SL11H_INTMASK_XFERDONE) {
/* USB Done interrupt occurred */
urb_state = sh_done_list (hci, &isExcessNak);
#ifdef WARNING
if (hci->td_array->len > 0)
printk ("WARNING: IRQ, td_array->len = 0x%x, s/b:0\n",
hci->td_array->len);
#endif
if (hci->td_array->len == 0 && !isExcessNak
&& !(ii & SL11H_INTMASK_SOFINTR) && (urb_state == 0)) {
if (urb_state == 0) {
/* All urb_state has not been finished yet!
* continue with the current urb transaction
*/
if (hci->last_packet_nak == 0) {
if (!usb_pipecontrol
(hci->td_array->td[0].urb->pipe))
sh_add_packet (hci, hci->td_array-> td[0].urb);
}
} else {
/* The last transaction has completed:
* schedule the next transaction
*/
sh_schedule_trans (hci, 0);
}
}
SL811Write (hci, SL11H_INTSTATREG, 0xff);
return;
}
if (ii & SL11H_INTMASK_SOFINTR) {
hci->frame_number = (hci->frame_number + 1) % 2048;
if (hci->td_array->len == 0)
sh_schedule_trans (hci, 1);
else {
if (sofWaitCnt++ > 100) {
/* The last transaction has not completed.
* Need to retire the current td, and let
* it transmit again later on.
* (THIS NEEDS TO BE WORK ON MORE, IT SHOULD NEVER
* GET TO THIS POINT)
*/
DBGERR ("SOF interrupt: td_array->len = 0x%x, s/b: 0\n",
hci->td_array->len);
urb_print (hci->td_array->td[hci->td_array->len - 1].urb,
"INTERRUPT", 0);
sh_done_list (hci, &isExcessNak);
SL811Write (hci, SL11H_INTSTATREG, 0xff);
hci->td_array->len = 0;
sofWaitCnt = 0;
}
}
tmpIrq = SL811Read (hci, SL11H_INTSTATREG) & SL811Read (hci, SL11H_INTENBLREG);
if (tmpIrq) {
DBG ("IRQ occurred while service SOF: irq = 0x%x\n",
tmpIrq);
/* If we receive a DONE IRQ after schedule, need to
* handle DONE IRQ again
*/
if (tmpIrq & SL11H_INTMASK_XFERDONE) {
DBGERR ("IRQ occurred while service SOF: irq = 0x%x\n",
tmpIrq);
urb_state = sh_done_list (hci, &isExcessNak);
}
SL811Write (hci, SL11H_INTSTATREG, 0xff);
}
} else {
DBG ("SL811 ISR: unknown, int = 0x%x \n", ii);
}
SL811Write (hci, SL11H_INTSTATREG, 0xff);
return;
}
/************************************************************************
* Function Name : USBReset
*
* This function resets SL811HS controller and detects the speed of
* the connecting device
*
* Input: hci = data structure for the host controller
*
* Return: 0 = no device attached; 1 = USB device attached
*
***********************************************************************/
static int USBReset (hci_t * hci)
{
int status;
hcipriv_t *hp = &hci->hp;
DBGFUNC ("enter USBReset\n");
SL811Write (hci, SL11H_CTLREG2, 0xae);
// setup master and full speed
SL811Write (hci, SL11H_CTLREG1, 0x08); // reset USB
mdelay (20); // 20ms
SL811Write (hci, SL11H_CTLREG1, 0); // remove SE0
for (status = 0; status < 100; status++)
SL811Write (hci, SL11H_INTSTATREG, 0xff); // clear all interrupt bits
status = SL811Read (hci, SL11H_INTSTATREG);
if (status & 0x40) // Check if device is removed
{
DBG ("USBReset: Device removed\n");
SL811Write (hci, SL11H_INTENBLREG,
SL11H_INTMASK_XFERDONE | SL11H_INTMASK_SOFINTR |
SL11H_INTMASK_INSRMV);
hp->RHportStatus->portStatus &=
~(PORT_CONNECT_STAT | PORT_ENABLE_STAT);
return 0;
}
SL811Write (hci, SL11H_BUFLNTHREG_B, 0); //zero lenth
SL811Write (hci, SL11H_PIDEPREG_B, 0x50); //send SOF to EP0
SL811Write (hci, SL11H_DEVADDRREG_B, 0x01); //address0
SL811Write (hci, SL11H_SOFLOWREG, 0xe0);
if (!(status & 0x80)) {
/* slow speed device connect directly to root-hub */
DBG ("USBReset: low speed Device attached\n");
SL811Write (hci, SL11H_CTLREG1, 0x8);
mdelay (20);
SL811Write (hci, SL11H_SOFTMRREG, 0xee);
SL811Write (hci, SL11H_CTLREG1, 0x21);
/* start the SOF or EOP */
SL811Write (hci, SL11H_HOSTCTLREG_B, 0x01);
hp->RHportStatus->portStatus |=
(PORT_CONNECT_STAT | PORT_LOW_SPEED_DEV_ATTACH_STAT);
/* clear all interrupt bits */
for (status = 0; status < 20; status++)
SL811Write (hci, SL11H_INTSTATREG, 0xff);
} else {
/* full speed device connect directly to root hub */
DBG ("USBReset: full speed Device attached\n");
SL811Write (hci, SL11H_CTLREG1, 0x8);
mdelay (20);
SL811Write (hci, SL11H_SOFTMRREG, 0xae);
SL811Write (hci, SL11H_CTLREG1, 0x01);
/* start the SOF or EOP */
SL811Write (hci, SL11H_HOSTCTLREG_B, 0x01);
hp->RHportStatus->portStatus |= (PORT_CONNECT_STAT);
hp->RHportStatus->portStatus &= ~PORT_LOW_SPEED_DEV_ATTACH_STAT;
/* clear all interrupt bits */
SL811Write (hci, SL11H_INTSTATREG, 0xff);
}
/* enable all interrupts */
SL811Write (hci, SL11H_INTENBLREG,
SL11H_INTMASK_XFERDONE | SL11H_INTMASK_SOFINTR |
SL11H_INTMASK_INSRMV);
return 1;
}
//*****************************************************************************************
// usbXfer:
// successful transfer = return TRUE
// fail transfer = return FALSE
//*****************************************************************************************
u_int8 usbXfer(void)
{
u_int8 xferLen, data0, data1,cmd;
u_int8 intr,result,remainder,dataX,bufLen,addr,timeout;
//------------------------------------------------
// Default setting for usb trasnfer
//------------------------------------------------
dataX=timeout=0;
//result = SL811Read(EP0Status);
data0 = EP0_Buf; // DATA0 buffer address
data1 = data0 + ( u_int8)usbstack.wPayload; // DATA1 buffer address
bXXGFlags.DATA_STOP=FALSE;
bXXGFlags.TIMEOUT_ERR=FALSE;
//------------------------------------------------
// Define data transfer payload
//------------------------------------------------
if (usbstack.wLen >= usbstack.wPayload) // select proper data payload
xferLen = usbstack.wPayload; // limit to wPayload size
else // else take < payload len
xferLen = usbstack.wLen; //
// For IN token
if (usbstack.pid==PID_IN) // for current IN tokens
{ //
cmd = sDATA0_RD; // FS/FS on Hub, sync to sof
}
// For OUT token
else if(usbstack.pid==PID_OUT) // for OUT tokens
{
if(xferLen) // only when there are
{
//intr=usbstack.setup.wLength;
//usbstack.setup.wLength=WordSwap(usbstack.setup.wLength);
SL811BufWrite(data0,usbstack.buffer,xferLen); // data to transfer on USB
//usbstack.setup.wLength=intr;
}
cmd = sDATA0_WR; // FS/FS on Hub, sync to sof
// implement data toggle
bXXGFlags.bData1 = uDev.bData1[usbstack.endpoint];
uDev.bData1[usbstack.endpoint] = (uDev.bData1[usbstack.endpoint] ? 0 : 1); // DataToggle
if(bXXGFlags.bData1)
cmd |= 0x40; // Set Data1 bit in command
}
// For SETUP/OUT token
else // for current SETUP/OUT tokens
{
if(xferLen) // only when there are
{
intr=usbstack.setup.wLength;
usbstack.setup.wValue=usbstack.setup.wValue;
usbstack.setup.wIndex=usbstack.setup.wIndex;
usbstack.setup.wLength=usbstack.setup.wLength;
SL811BufWrite(data0,( u_int8 *)&usbstack.setup,xferLen); // data to transfer on USB
usbstack.setup.wLength=intr;
}
cmd = sDATA0_WR; // FS/FS on Hub, sync to sof
}
//------------------------------------------------
// For EP0's IN/OUT token data, start with DATA1
// Control Endpoint0's status stage.
// For data endpoint, IN/OUT data, start ????
//------------------------------------------------
if (usbstack.endpoint == 0 && usbstack.pid != PID_SETUP) // for Ep0's IN/OUT token
cmd |= 0x40; // always set DATA1
//------------------------------------------------
// Arming of USB data transfer for the first pkt
//------------------------------------------------
SL811Write(EP0Status,((usbstack.endpoint&0x0F)|usbstack.pid)); // PID + EP address
SL811Write(EP0Counter,usbstack.usbaddr); // USB address
SL811Write(EP0Address,data0); // buffer address, start with "data0"
SL811Write(EP0XferLen,xferLen); // data transfer length
SL811Write(IntStatus,INT_CLEAR); // clear interrupt status
SL811Write(EP0Control,cmd); // Enable ARM and USB transfer start here
//------------------------------------------------
// Main loop for completing a wLen data trasnfer
//------------------------------------------------
while(TRUE)
{
//---------------Wait for done interrupt------------------
while(TRUE) // always ensure requested device is
{ // inserted at all time, then you will
//intr=SL811Read(cSOFcnt);
//intr=SL811Read(IntEna);
intr = SL811Read(IntStatus);
// wait for interrupt to be done, and
if((intr & USB_DETECT) || (intr & INSERT_REMOVE)) // proceed to parse result from slave
{ // device.
bXXGFlags.DATA_STOP = TRUE; // if device is removed, set DATA_STOP
return FALSE; // flag true, so that main loop will
} // know this condition and exit gracefully
if(intr & USB_A_DONE)
break; // interrupt done !!!
}
SL811Write(IntStatus,INT_CLEAR); // clear interrupt status
result = SL811Read(EP0Status); // read EP0status register
remainder = SL811Read(EP0Counter); // remainder value in last pkt xfer
//-------------------------ACK----------------------------
if (result & EP0_ACK) // Transmission ACK
{
// SETUP TOKEN
if(usbstack.pid == PID_SETUP) // do nothing for SETUP/OUT token
break; // exit while(1) immediately
// OUT TOKEN
else if(usbstack.pid == PID_OUT)
break;
// IN TOKEN
else if(usbstack.pid == PID_IN)
{ // for IN token only
usbstack.wLen -= (WORD)xferLen; // update remainding wLen value
cmd ^= 0x40; // toggle DATA0/DATA1
dataX++; // point to next dataX
//------------------------------------------------
// If host requested for more data than the slave
// have, and if the slave's data len is a multiple
// of its endpoint payload size/last xferLen. Do
// not overwrite data in previous buffer.
//------------------------------------------------
if(remainder==xferLen) // empty data detected
bufLen = 0; // do not overwriten previous data
else // reset bufLen to zero
bufLen = xferLen; // update previous buffer length
//------------------------------------------------
// Arm for next data transfer when requested data
// length have not reach zero, i.e. wLen!=0, and
// last xferlen of data was completed, i.e.
// remainder is equal to zero, not a short pkt
//------------------------------------------------
if(!remainder && usbstack.wLen) // remainder==0 when last xferLen
{ // was all completed or wLen!=0
addr = (dataX & 1) ? data1:data0; // select next address for data
xferLen = (u_int8)(usbstack.wLen>=usbstack.wPayload) ? usbstack.wPayload:usbstack.wLen; // get data length required
//if (FULL_SPEED) // sync with SOF transfer
cmd |= 0x20; // always sync SOF when FS, regardless
SL811Write(EP0XferLen, xferLen); // select next xfer length
SL811Write(EP0Address, addr); // data buffer addr
SL811Write(IntStatus,INT_CLEAR); // is a LS is on Hub.
SL811Write(EP0Control,cmd); // Enable USB transfer and re-arm
}
//------------------------------------------------
// Copy last IN token data pkt from prev transfer
// Check if there was data available during the
// last data transfer
//------------------------------------------------
if(bufLen)
{
SL811BufRead(((dataX&1)?data0:data1), usbstack.buffer, bufLen);
usbstack.buffer += bufLen;
}
//------------------------------------------------
// Terminate on short packets, i.e. remainder!=0
// a short packet or empty data packet OR when
// requested data len have completed, i.e.wLen=0
// For a LOWSPEED device, the 1st device descp,
// wPayload is default to 64-u_int8, LS device will
// only send back a max of 8-u_int8 device descp,
// and host detect this as a short packet, and
// terminate with OUT status stage
//------------------------------------------------
if(remainder || !usbstack.wLen)
break;
}// PID IN
}
//-------------------------NAK----------------------------
if (result & EP0_NAK) // NAK Detected
{
if(usbstack.endpoint==0) // on ep0 during enumeration of LS device
{ // happen when slave is not fast enough,
SL811Write(IntStatus,INT_CLEAR); // clear interrupt status, need to
SL811Write(EP0Control,cmd); // re-arm and request for last cmd, IN token
result = 0; // respond to NAK status only
}
else // normal data endpoint, exit now !!! , non-zero ep
break; // main loop control the interval polling
}
//-----------------------TIMEOUT--------------------------
if (result & EP0_TIMEOUT) // TIMEOUT Detected
{
if(usbstack.endpoint==0) // happens when hub enumeration
{
if(++timeout >= TIMEOUT_RETRY)
{
timeout--;
break; // exit on the timeout detected
}
SL811Write(IntStatus,INT_CLEAR); // clear interrupt status, need to
SL811Write(EP0Control,cmd); // re-arm and request for last cmd again
}
else
{ // all other data endpoint, data transfer
bXXGFlags.TIMEOUT_ERR = TRUE; // failed, set flag to terminate transfer
break; // happens when data transfer on a device
} // through the hub
}
//-----------------------STALL----------------------------
if (result & EP0_STALL) // STALL detected
return TRUE; // for unsupported request.
//----------------------OVEFLOW---------------------------
if (result & EP0_OVERFLOW) // OVERFLOW detected
//result=result;
break;
//-----------------------ERROR----------------------------
if (result & EP0_ERROR) // ERROR detected
//result=result;
break;
} // end of While(1)
if (result & EP0_ACK) // on ACK transmission
return TRUE; // return OK
return FALSE; // fail transmission
}
//*****************************************************************************************
// SL811H variables initialization
//*****************************************************************************************
u_int8 SL811_GetRev(void)
{
return SL811Read(0x0e);
}
