📄 host_811.c.bak
字号:
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(pid == PID_SETUP) // do nothing for SETUP/OUT token
break; // exit while(1) immediately
// OUT TOKEN
else if(pid == PID_OUT)
break;
// IN TOKEN
else if(pid == PID_IN)
{ // for IN token only
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 && wLen) // remainder==0 when last xferLen
{ // was all completed or wLen!=0
addr = (dataX & 1) ? data1:data0; // select next address for data
xferLen = (BYTE)(wLen>=wPayload) ? wPayload: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), buffer, bufLen);
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-byte, LS device will
// only send back a max of 8-byte device descp,
// and host detect this as a short packet, and
// terminate with OUT status stage
//------------------------------------------------
if(remainder || !wLen)
break;
}
}
//-------------------------NAK----------------------------
if (result & EP0_NAK) // NAK Detected
{
if(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(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
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
break;
//-----------------------ERROR----------------------------
if (result & EP0_ERROR) // ERROR detected
break;
} // end of While(1)
if (result & EP0_ACK) // on ACK transmission
return TRUE; // return OK
return FALSE; // fail transmission
}
//*****************************************************************************************
// Control Endpoint 0's USB Data Xfer
// ep0Xfer, endpoint 0 data transfer
//*****************************************************************************************
int ep0Xfer(BYTE usbaddr, WORD payload, pSetupPKG setup, BYTE *pData)
{
xdata BYTE pid = PID_IN;
xdata WORD wLen = WordSwap(setup->wLength); // swap back for correct length
xdata BYTE ep0 = 0; // always endpoint zero
//----------------------------------------------------
// SETUP token with 8-byte request on endpoint 0
//----------------------------------------------------
if (!usbXfer(usbaddr, ep0, PID_SETUP, 0, payload, 8, (BYTE*)setup))
return FALSE;
//----------------------------------------------------
// IN or OUT data stage on endpoint 0
//----------------------------------------------------
if (wLen) // if there are data for transfer
{
if (setup->bmRequest & 0x80) // host-to-device : IN token
{
pid = PID_OUT;
if(!usbXfer(usbaddr, ep0, PID_IN, 0, payload, wLen, pData))
return FALSE;
payload = 0;
}
else // device-to-host : OUT token
{
if(!usbXfer(usbaddr, ep0, PID_OUT, 0, payload, wLen, pData))
return FALSE;
}
}
//----------------------------------------------------
// Status stage IN or OUT zero-length data packet
//----------------------------------------------------
if(!usbXfer(usbaddr, ep0, pid, 0, payload, 0, NULL))
return FALSE;
return TRUE;
}
//*****************************************************************************************
// Control endpoint
//*****************************************************************************************
int VendorCmd(BYTE usbaddr,BYTE bReq,BYTE bCmd,WORD wValue,WORD wIndex,WORD wLen,BYTE *pData)
{
xdata SetupPKG setup;
setup.bmRequest = bReq;
setup.bRequest = bCmd;
setup.wValue = wValue;
setup.wIndex = wIndex;
setup.wLength = WordSwap(wLen);
return ep0Xfer(usbaddr, uDev[usbaddr].wPayLoad[0], &setup, pData);
}
//*****************************************************************************************
// Set Device Address :
//*****************************************************************************************
int SetAddress(WORD addr)
{
return VendorCmd(0,0,SET_ADDRESS, WordSwap(addr), 0, 0, NULL);
}
//*****************************************************************************************
// Set Device Configuration :
//*****************************************************************************************
int Set_Configuration(BYTE usbaddr, WORD wVal)
{
return VendorCmd(usbaddr, 0, SET_CONFIG, WordSwap(wVal), 0, 0, NULL);
}
//*****************************************************************************************
// Get Device Descriptor : Device, Configuration, String
//*****************************************************************************************
int GetDesc(BYTE usbaddr, WORD wValue, WORD wIndex, WORD wLen, BYTE *desc)
{
return VendorCmd(usbaddr, 0x80, GET_DESCRIPTOR, wValue, wIndex, wLen, desc);
}
//*****************************************************************************************
// HID Get_Desc :
//*****************************************************************************************
int GetHid_Desc(BYTE usbaddr, WORD wValue, WORD wLen, BYTE *desc)
{
return VendorCmd(usbaddr, 0x81, GET_DESCRIPTOR, wValue, 0, wLen, desc);
}
//*****************************************************************************************
// GetHUBDesc :
//*****************************************************************************************
int GetHubDesc(BYTE usbaddr, WORD wValue, WORD wLen, BYTE *desc)
{
return VendorCmd(usbaddr, 0xA0, GET_DESCRIPTOR, wValue, 0, wLen, desc);
}
//*****************************************************************************************
// Get Status : (HUB)
//*****************************************************************************************
int GetStatus(BYTE usbaddr, BYTE *desc)
{
return VendorCmd(usbaddr, 0x80, GET_STATUS, 0, 0, 2, desc);
}
//*****************************************************************************************
// PortFeature : (SET_FEATURE, CLEAR_FEATURE)
//*****************************************************************************************
int PortFeature(BYTE usbaddr, BYTE bReq, WORD wValue, BYTE cPort)
{
return VendorCmd(usbaddr, 0x23, bReq, WordSwap(wValue), WordSwap((WORD)cPort), 0, NULL);
}
//*****************************************************************************************
// GetPortStatus :
//*****************************************************************************************
int GetPortStatus(BYTE usbaddr, BYTE cPort, BYTE *desc)
{
return VendorCmd(usbaddr, 0xA3, GET_STATUS, 0, WordSwap((WORD)cPort), 0x04, desc);
}
//*****************************************************************************************
// GetDevInfo :
//*****************************************************************************************
WORD GetDevInfo(BYTE *DevInfo)
{
BYTE EpAddr;
int i;
BYTE DescBufLen = 0;
for(EpAddr = 1; (EpAddr < MAX_DEV); EpAddr++)
{
if(uHub.bPortPresent[EpAddr])
{
DevInfo[DescBufLen++] = EpAddr; // USB Address
DevInfo[DescBufLen++] = uHub.bPortNumber[EpAddr]; // Port Number
DevInfo[DescBufLen++] = uHub.bPortSpeed[EpAddr]; // Device Speed (from enum)
DevInfo[DescBufLen++] = uDev[EpAddr].bClass; // Class Type (from enum)
(WORD)DevInfo[DescBufLen++] = uDev[EpAddr].wVID; // VID
DescBufLen++;
(WORD)DevInfo[DescBufLen++] = uDev[EpAddr].wPID; // PID
DescBufLen++;
DevInfo[DescBufLen++] = (BYTE)uDev[EpAddr].wPayLoad[0]; // Ep0 MaxPktSize (max 64 bytes)
DevInfo[DescBufLen++] = uDev[EpAddr].bNumOfEPs; // Number of data endpoints
for(i=0;i<uDev[EpAddr].bNumOfEPs;i++) // save all data endpoints info
{
DevInfo[DescBufLen++] = uDev[EpAddr].bEPAddr[i+1]; // ep address/direction
DevInfo[DescBufLen++] = uDev[EpAddr].bAttr[i+1]; // transfer type
(WORD)DevInfo[DescBufLen++] = uDev[EpAddr].wPayLoad[i+1]; // max data payload
DescBufLen++; // 2 byte payload
DevInfo[DescBufLen++] = uDev[EpAddr].bInterval[i+1]; // polling interval
}
}
}
return(DescBufLen);
}
//*****************************************************************************************
// USB Data Endpoint Read/Write
// wLen is in low byte first format
//*****************************************************************************************
int DataRW(BYTE usbaddr, BYTE epaddr, WORD wPayload, WORD wLen, BYTE *pData)
{
xdata BYTE pid = PID_OUT;
if(epaddr & 0x80) // get direction of transfer
pid = PID_IN;
if(usbXfer(usbaddr,epaddr&0x0F,pid,0,wPayload,wLen,pData))
return TRUE;
return FALSE;
}
//*****************************************************************************************
// USB Device Enumeration Process
// Support 1 confguration and interface #0 and alternate setting #0 only
// Support up to 1 control endpoint + 4 data endpoint only
//*****************************************************************************************
int EnumUsbDev(BYTE usbaddr)
{
int i; // always reset USB transfer address
xdata BYTE uAddr = 0; // for enumeration to Address #0
xdata BYTE epLen;
xdata WORD strLang;
//------------------------------------------------
// Reset only Slave device attached directly
//------------------------------------------------
uDev[0].wPayLoad[0] = 64; // default 64-byte payload of Endpoint 0, address #0
if(usbaddr == 1) // bus reset for the device attached to SL811HS only
USBReset(); // that will always have the USB address = 0x01 (for a hub)
EZUSB_Delay(25);
//------------------------------------------------
// Get USB Device Descriptors on EP0 & Addr 0
// with default 64-byte payload
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -