/**************************************************************************//**
|
* @file endpoint0.c
|
* @version V1.00
|
* $Revision: 2 $
|
* $Date: 20/08/04 14:25 $
|
* @brief Endpoint 0 interrupt routine for MUSBFSFC firmware
|
*
|
* @note
|
* Copyright (C) 2020 Panchip Technology Corp. All rights reserved.
|
*****************************************************************************/
|
#include "endpoint0.h"
|
#include "descript.h"
|
#include "PanSeries.h"
|
#include "endpoint.h"
|
#include "usb.h"
|
//#define SYS_TEST /*.....*/
|
|
/* Pointer to current configuration descriptor */
|
void * gpCurCfg = NULL;
|
/* Current device state */
|
uint32_t gnDevState = DEVSTATE_DEFAULT;
|
|
/* Pointer to current interface descriptors */
|
USB_InterfaceDscrDef *gpCurIf[M_MAXIFS];
|
|
/* Current alternate interface values */
|
uint8_t gbyCurIfVal[M_MAXIFS];
|
|
/****************************************
|
Standard Device Request
|
This routine is called when a standard device request has been received.
|
The bRequest field of the received command is decoded.
|
****************************************/
|
void StdDevReq (USB_EndPointStatusDef *pep0state, USB_CommandDef *pcmd)
|
{
|
uint32_t bError = FALSE, bNoData = FALSE, n;
|
uint8_t by;
|
uint8_t byConfig;
|
USB_CfgDscrDef * pcfg;
|
uint8_t * *ppby;
|
|
// SYS_TEST("pcmd->bRequest:%d,pcmd->wValue:%x\r\n",pcmd->bRequest,pcmd->wValue);
|
switch (pcmd->bRequest) {
|
case SET_ADDRESS:
|
SYS_TEST("S_ADDR\r\n");
|
/* Store device function address until status stage of request */
|
if (pcmd->bmRequestType != M_CMD_STDDEVOUT)
|
bError = TRUE;
|
else if (gnDevState <= DEVSTATE_ADDRESS) {
|
pep0state->byFAddr = (uint8_t)pcmd->wValue;
|
bNoData = TRUE;
|
}
|
else
|
bError = TRUE;
|
break;
|
case GET_DESCRIPTOR:
|
/* Decode the required descriptor from the command */
|
if (pcmd->bmRequestType == M_CMD_STDIFIN)
|
{
|
pep0state->nBytesLeft = sizeof(report);
|
pep0state->pData = (void*)report;
|
pep0state->nState = M_EP0_TX;
|
}
|
else if(pcmd->bmRequestType == M_CMD_STDDEVIN){
|
switch (pcmd->wValue & M_CMD_DESCMASK) {
|
case M_CMD_DEVICE:
|
SYS_TEST("DEVICE\r\n");
|
/* Prepare to return Standard Device Descriptor */
|
pep0state->nBytesLeft = sizeof(USB_DeviceDscrDef);
|
/* Check host is allowing a descriptor this long */
|
if (pcmd->wLength < pep0state->nBytesLeft)
|
pep0state->nBytesLeft = pcmd->wLength;
|
pep0state->pData = (void*)&stddevdsc;
|
pep0state->nState = M_EP0_TX;
|
break;
|
case M_CMD_DEVQUAL:
|
SYS_TEST("DEVQUAL\r\n");
|
/* No alternate speed supported */
|
bError = TRUE;
|
break;
|
case M_CMD_CONFIG:
|
SYS_TEST("CFG\r\n");
|
byConfig = (uint8_t)(pcmd->wValue & 0x00FF);
|
// SYS_TEST("byConfig:%d\r\n",byConfig);
|
if (byConfig >= stddevdsc.bNumConfigurations)
|
bError = TRUE;
|
else {
|
/* Get pointer to requested configuration descriptor */
|
ppby = (uint8_t**)&cfg;
|
ppby += byConfig;
|
pcfg = (USB_CfgDscrDef *)*ppby;
|
/* Prepare to return Configuration Descriptors */
|
pep0state->nBytesLeft = (int)pcfg->wTotalLength;
|
pep0state->pData = (void*)pcfg;
|
pep0state->nState = M_EP0_TX;
|
/* Check host is allowing a descriptor this long */
|
if (pcmd->wLength < pep0state->nBytesLeft)
|
pep0state->nBytesLeft = pcmd->wLength;
|
}
|
break;
|
case M_CMD_OTHERSPEED:
|
/* No alternate speed supported */
|
bError = TRUE;
|
break;
|
case M_CMD_REPORT:
|
SYS_TEST("report\r\n");
|
break;
|
default: bError = TRUE;
|
}
|
}
|
else{
|
bError = TRUE;
|
}
|
break;
|
case SET_CONFIGURATION:
|
SYS_TEST("S_CFG\r\n");
|
byConfig = (uint8_t)(pcmd->wValue & 0x00FF);
|
// SYS_TEST("set_config : %x %x %x %x %x \r\n",pcmd->bmRequestType,pcmd->bRequest,pcmd->wValue,pcmd->wIndex,pcmd->wLength);
|
if (gnDevState == DEVSTATE_DEFAULT)
|
bError = TRUE;
|
/* Assumes configurations are numbered 1 to NumConfigurations */
|
else if (byConfig > stddevdsc.bNumConfigurations)
|
bError = TRUE;
|
else if (!byConfig)
|
gnDevState = DEVSTATE_ADDRESS;
|
else {
|
/* Get pointer to requested configuration descriptor */
|
ppby = (uint8_t**)&cfg;
|
ppby += byConfig-1;
|
gpCurCfg = (void *)*ppby;
|
/* Set all alternate settings to zero */
|
for (n=0; n<M_MAXIFS; n++)
|
gbyCurIfVal[n] = 0;
|
/* Configure endpoints */
|
ConfigureIfs();
|
gnDevState = DEVSTATE_CONFIG;
|
WRITE_REG(USB->INDEX, 0);
|
bNoData = TRUE;
|
}
|
break;
|
case SET_INTERFACE:
|
SYS_TEST("S_INF\r\n");
|
if (gnDevState > DEVSTATE_ADDRESS) {
|
n = (int)pcmd->wIndex;
|
pcfg = (USB_CfgDscrDef *)gpCurCfg;
|
if ((uint8_t)n >= pcfg->bNumInterfaces)
|
bError = TRUE;
|
else {
|
gbyCurIfVal[n] = (uint8_t)pcmd->wValue;
|
if (ConfigureIfs() == FALSE)
|
bError = TRUE;
|
WRITE_REG(USB->INDEX, 0);
|
bNoData = TRUE;
|
}
|
}
|
else
|
bError = TRUE;
|
break;
|
|
case GET_CONFIGURATION:
|
SYS_TEST("G_CFG\r\n");
|
if ((gnDevState == DEVSTATE_ADDRESS) && (!pcmd->wValue)) {
|
/* Prepare to return zero */
|
pep0state->nBytesLeft = 1;
|
pep0state->pData = (void*)&pcmd->wValue;
|
pep0state->nState = M_EP0_TX;
|
}
|
else if (gnDevState > DEVSTATE_ADDRESS) {
|
/* Prepare to return configuration value */
|
pcfg = (USB_CfgDscrDef *)gpCurCfg;
|
pep0state->nBytesLeft = 1;
|
pep0state->pData = (void*)&pcfg->bConfigurationValue;
|
pep0state->nState = M_EP0_TX;
|
}
|
else
|
bError = TRUE;
|
break;
|
|
case GET_INTERFACE:
|
SYS_TEST("G_INTF\r\n");
|
if (gnDevState > DEVSTATE_ADDRESS) {
|
n = (int)pcmd->wIndex;
|
pcfg = (USB_CfgDscrDef *)gpCurCfg;
|
if ((uint8_t)n >= pcfg->bNumInterfaces)
|
bError = TRUE;
|
else {
|
/* Prepare to return interface value */
|
pep0state->nBytesLeft = 1;
|
pep0state->pData = (void*)&gpCurIf[n]->bInterfaceNumber;
|
pep0state->nState = M_EP0_TX;
|
}
|
}
|
else
|
bError = TRUE;
|
break;
|
|
case SET_FEATURE:
|
SYS_TEST("S_FT\r\n");
|
switch (pcmd->bmRequestType) {
|
case M_CMD_STDDEVOUT:
|
switch (pcmd->wValue) {
|
case M_FTR_DEVREMWAKE:
|
default:
|
bError = TRUE;
|
break;
|
}
|
break;
|
case M_CMD_STDIFIN:
|
/* Add interface features here */
|
case M_CMD_STDEPIN:
|
/* Add endpoint features here */
|
default:bError = TRUE;break;
|
}
|
break;
|
|
case CLEAR_FEATURE:
|
SYS_TEST("C_FT\r\n");
|
break;
|
default:
|
SYS_TEST("bError\r\n");
|
/* Stall the command if an unrecognized request is received */
|
bError = TRUE;
|
break;
|
}
|
|
/* Stall command if an error occurred */
|
if (bError)
|
by = M_CSR0_SVDOUTPKTRDY | M_CSR0_SENDSTALL;
|
else if (bNoData)
|
by = M_CSR0_SVDOUTPKTRDY | M_CSR0_DATAEND;
|
else
|
by = M_CSR0_SVDOUTPKTRDY;
|
WRITE_REG(USB->CSR0_INCSR1, by);
|
}
|
|
|
#define GET_REPORT (0X1)
|
#define GET_IDLE (0X2)
|
#define GET_PROTOCOL (0X3)
|
#define SET_REPORT (0X9)
|
#define SET_IDLE (0XA)
|
#define SET_PROTOCOL (0XB)
|
|
void StdClassReq(USB_CommandDef *pcmd)
|
{
|
// uint8_t reqType;
|
|
switch(pcmd->bRequest){
|
case GET_REPORT:
|
break;
|
case SET_IDLE:
|
break;
|
default:break;
|
}
|
}
|
|
/****************************************
|
Endpoint 0 command
|
This routine is called when a command has been received in the SETUP phase.
|
****************************************/
|
void Endpoint0_Command (USB_EndPointStatusDef *pep0state, USB_CommandDef *pcmd)
|
{
|
// uint8_t byType;
|
|
/* Check request type */
|
switch (pcmd->bmRequestType & M_CMD_TYPEMASK) {
|
case M_CMD_STDREQ:
|
StdDevReq (pep0state, pcmd);break;
|
case M_CMD_CLASSREQ:
|
// SYS_TEST("class req \r\n");
|
// break;
|
/* Add call to external routine for handling class requests */
|
case M_CMD_VENDREQ:
|
/* Add call to external routine for handling vendor requests */
|
default:
|
/* Stall the command if a reserved request is received */
|
WRITE_REG(USB->CSR0_INCSR1, M_CSR0_SVDOUTPKTRDY | M_CSR0_SENDSTALL);
|
break;
|
}
|
}
|
|
/****************************************
|
Endpoint 0 interrupt service routine
|
****************************************/
|
void Endpoint0(int32_t nCallState)
|
{
|
static USB_EndPointStatusDef ep0state;
|
static USB_CommandDef cmd;
|
uint8_t byCSR0;
|
|
/* Check for USB reset of endpoint 0 */
|
if (nCallState == M_EP_RESET) {
|
ep0state.nState = M_EP0_IDLE;
|
ep0state.byFAddr = 0xFF;
|
/* Clear current configuration pointer */
|
gpCurCfg = NULL;
|
return;
|
}
|
|
/* Read CSR0 */
|
WRITE_REG(USB->INDEX, 0);
|
byCSR0 = READ_REG(USB->CSR0_INCSR1);
|
|
/* Check for status stage of a request */
|
if (!(byCSR0 & M_CSR0_OUTPKTRDY)) {
|
/* Complete SET_ADDRESS command */
|
if (ep0state.byFAddr != 0xFF) {
|
WRITE_REG(USB->FADDR,ep0state.byFAddr);
|
SYS_TEST("addr : %x\r\n",ep0state.byFAddr);
|
if ((gnDevState == DEVSTATE_DEFAULT) && ep0state.byFAddr)
|
gnDevState = DEVSTATE_ADDRESS;
|
else if ((gnDevState == DEVSTATE_ADDRESS) && !ep0state.byFAddr) //out of range ,add by zf
|
gnDevState = DEVSTATE_DEFAULT;
|
}
|
}
|
/* Clear pending commands */
|
ep0state.byFAddr = 0xFF;
|
|
|
/* Check for SentStall */
|
if (byCSR0 & M_CSR0_SENTSTALL) {
|
WRITE_REG(USB->CSR0_INCSR1, (byCSR0 & ~M_CSR0_SENDSTALL));
|
ep0state.nState = M_EP0_IDLE;
|
}
|
|
/* Check for SetupEnd */
|
if (byCSR0 & M_CSR0_SETUPEND) {
|
WRITE_REG(USB->CSR0_INCSR1, (byCSR0 | M_CSR0_SVDSETUPEND));
|
ep0state.nState = M_EP0_IDLE;
|
}
|
|
/* Call relevant routines for endpoint 0 state */
|
|
if (ep0state.nState == M_EP0_IDLE) {
|
/* If no packet has been received, */
|
/* assume that this was a STATUS phase complete. */
|
/* Otherwise load new command */
|
if (byCSR0 & M_CSR0_OUTPKTRDY) {
|
/* Read the 8-uint8_t command from the FIFO */
|
/* There is no need to check that OutCount is set to 8 */
|
/* as the MUSBFSFC will reject SETUP packets that are not 8 bytes long. */
|
USB_Read (0, 8, &cmd); //add zf
|
Endpoint0_Command (&ep0state, &cmd);
|
}
|
}
|
if (ep0state.nState == M_EP0_TX){
|
Endpoint0_Tx(&ep0state);
|
}
|
}
|
|
|
/****************************************
|
Endpoint 0 Tx
|
This routine is called when data is to be sent to the host.
|
****************************************/
|
void Endpoint0_Tx (USB_EndPointStatusDef *pep0state)
|
{
|
uint32_t nBytes;
|
uint8_t by;
|
|
/* Determine number of bytes to send */
|
if (pep0state->nBytesLeft <= M_EP0_MAXP) {
|
nBytes = pep0state->nBytesLeft;
|
pep0state->nBytesLeft = 0;
|
}
|
else {
|
nBytes = M_EP0_MAXP;
|
pep0state->nBytesLeft -= M_EP0_MAXP;
|
}
|
|
USB_Write (0, nBytes, pep0state->pData); //add zf
|
pep0state->pData = (uint8_t *)pep0state->pData + nBytes;
|
if (nBytes < M_EP0_MAXP) {
|
by = M_CSR0_INPKTRDY | M_CSR0_DATAEND;
|
pep0state->nState = M_EP0_IDLE;
|
}
|
else
|
by = M_CSR0_INPKTRDY;
|
WRITE_REG(USB->CSR0_INCSR1, by);
|
}
|
|
/****************************************
|
ConfigureIfs
|
This routine is called when a SET_CONFIGURATION or SET_INTERFACE
|
command is received and will set the gpCurIF pointers
|
to the selected interface descriptors and will set the
|
maximum packet size and operating mode for the endpoints in
|
the selected interfaces
|
****************************************/
|
uint32_t ConfigureIfs(void)
|
{
|
USB_CfgDscrDef * pcfg;
|
uint8_t byIf, byAltIf, byEP, byNumEPs, by;
|
uint8_t *pby;
|
uint8_t *pbyIfVal;
|
USB_InterfaceDscrDef * pif;
|
USB_EndPointDscrDef * pep;
|
|
/* Set pointer to first interface descriptor in current configuration */
|
pby = (uint8_t *)gpCurCfg;
|
pby += sizeof(USB_CfgDscrDef);
|
pif = (USB_InterfaceDscrDef *)pby;
|
|
/* Loop through all interfaces in the current configuration */
|
pcfg = (USB_CfgDscrDef *)gpCurCfg;
|
pbyIfVal = (uint8_t*)&gbyCurIfVal;
|
for (byIf=0; byIf<pcfg->bNumInterfaces; byIf++, pbyIfVal++) {
|
/* Advance pointer to selected alternate interface descriptor */
|
if (*pbyIfVal) {
|
for (byAltIf=0; byAltIf<*pbyIfVal; byAltIf++) {
|
byNumEPs = pif->bNumEndpoints;
|
pby += sizeof(USB_InterfaceDscrDef) + byNumEPs * sizeof(USB_EndPointDscrDef);
|
pif = (USB_InterfaceDscrDef *)pby;
|
/* Check an alternate setting > number of alternates not specified */
|
if (!pif->bAlternateSetting)
|
return FALSE;
|
}
|
}
|
|
/* Store pointer to interface in global array */
|
gpCurIf[byIf] = pif;
|
/* Loop through all endpoints in interface */
|
byNumEPs = pif->bNumEndpoints;
|
pby += sizeof(USB_InterfaceDscrDef);
|
#ifdef HAS_REPORT_DESC
|
pby += sizeof(USB_HidDscrDef); //zf add
|
#endif
|
for (byEP=0; byEP<byNumEPs; byEP++) {
|
pep = (USB_EndPointDscrDef *)pby;
|
/* Configure the endpoint */
|
WRITE_REG(USB->INDEX, (pep->bEndpointAddress & 0x0F));
|
/* Round up max packet size to a multiple of 8 for writing to MaxP registers */
|
by = (uint8_t)((pep->wMaxPacketSize+7)>>3);
|
if (pep->bEndpointAddress & 0x80) {
|
WRITE_REG(USB->MAX_PKT_IN, by);
|
by = READ_REG(USB->IN_CSR2);
|
switch (pep->bmAttributes & M_EP_TFMASK) {
|
case M_EP_ISO:
|
by |= M_INCSR2_ISO;
|
break;
|
case M_EP_BULK:
|
case M_EP_INTR:
|
default:
|
by &= ~M_INCSR2_ISO;
|
break;
|
}
|
/* Set mode bit high (only strictly necessary if sharing a FIFO) */
|
by |= M_INCSR2_MODE;
|
WRITE_REG(USB->IN_CSR2, by);
|
/* Other configuration for an IN endpoint */
|
/* e.g. AutoClr, DMA */
|
/* should be added here */
|
}
|
else {
|
WRITE_REG(USB->MAX_PKT_OUT, by);
|
by = READ_REG(USB->OUT_CSR2);
|
switch (pep->bmAttributes & M_EP_TFMASK) {
|
case M_EP_ISO:
|
by |= M_OUTCSR2_ISO;
|
break;
|
case M_EP_BULK:
|
case M_EP_INTR:
|
default:
|
by &= ~M_OUTCSR2_ISO;
|
break;
|
}
|
WRITE_REG(USB->OUT_CSR2, by);
|
/* Other configuration for an OUT endpoint */
|
/* e.g. AutoSet, DMA */
|
/* should be added here */
|
}
|
pby += sizeof(USB_EndPointDscrDef);
|
}
|
|
/* Skip any alternate setting interfaces */
|
pif = (USB_InterfaceDscrDef *)pby;
|
while (pif->bAlternateSetting) {
|
byNumEPs = pif->bNumEndpoints;
|
pby += sizeof(USB_InterfaceDscrDef) + byNumEPs * sizeof(USB_EndPointDscrDef);
|
pif = (USB_InterfaceDscrDef *)pby;
|
}
|
}
|
|
return TRUE;
|
}
|
