/*******************************************************************************
* Function Name : Set_CSW
* Description : Set the SCW with the needed fields.
* Input : u8 CSW_Status this filed can be CSW_CMD_PASSED,CSW_CMD_FAILED,
* or CSW_PHASE_ERROR.
* Output : None.
* Return : None.
*******************************************************************************/
void Set_CSW (u8 CSW_Status, u8 Send_Permission)
{
CSW.dSignature = BOT_CSW_SIGNATURE;
CSW.bStatus = CSW_Status;
UserToPMABufferCopy(((u8 *)& CSW), ENDP3_TXADDR, CSW_DATA_LENGTH);
SetEPTxCount(ENDP3, CSW_DATA_LENGTH);
Bot_State = BOT_ERROR;
if (Send_Permission)
{
Bot_State = BOT_CSW_Send;
SetEPTxStatus(ENDP3, EP_TX_VALID);
}
}
/*******************************************************************************
* Function Name : Set_CSW
* Description : Set the SCW with the needed fields.
* Input : uint8_t CSW_Status this filed can be CSW_CMD_PASSED,CSW_CMD_FAILED,
* or CSW_PHASE_ERROR.
* Output : None.
* Return : None.
*******************************************************************************/
void Set_CSW (uint8_t CSW_Status, uint8_t Send_Permission)
{
CSW.dSignature = BOT_CSW_SIGNATURE;
CSW.bStatus = CSW_Status;
USB_SIL_Write(EP1_IN, ((uint8_t *)& CSW), CSW_DATA_LENGTH);
Bot_State = BOT_ERROR;
if (Send_Permission)
{
Bot_State = BOT_CSW_Send;
#ifndef USE_STM3210C_EVAL
SetEPTxStatus(ENDP1, EP_TX_VALID);
#endif
}
}
/*******************************************************************************
* Function Name : Standard_SetEndPointFeature
* Description : Set or enable a specific feature of EndPoint
* Input : None.
* Output : None.
* Return : - Return USB_SUCCESS, if the request is performed.
* - Return USB_UNSUPPORT, if the request is invalid.
*******************************************************************************/
RESULT Standard_SetEndPointFeature(void)
{
uint32_t wIndex0;
uint32_t Related_Endpoint;
uint32_t rEP;
uint32_t Status;
wIndex0 = pInformation->USBwIndex0;
rEP = wIndex0 & ~0x80;
Related_Endpoint = ENDP0 + rEP;
if (ValBit(pInformation->USBwIndex0, 7))
{
/* get Status of endpoint & stall the request if the related_ENdpoint
is Disabled*/
Status = GetEPTxStatus(Related_Endpoint);
}
else
{
Status = GetEPRxStatus(Related_Endpoint);
}
if (Related_Endpoint >= Device_Table.Total_Endpoint
|| pInformation->USBwValue != 0 || Status == 0
|| pInformation->Current_Configuration == 0)
{
return USB_UNSUPPORT;
}
else
{
if (wIndex0 & 0x80)
{
/* IN endpoint */
SetEPTxStatus(Related_Endpoint, EP_TX_STALL);
}
else
{
/* OUT endpoint */
SetEPRxStatus(Related_Endpoint, EP_RX_STALL);
}
}
pUser_Standard_Requests->User_SetEndPointFeature();
return USB_SUCCESS;
}
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the microSD card.
*******************************************************************************/
void Read_Memory(u32 Memory_Offset, u32 Transfer_Length)
{
static u32 Offset, Length;
if (TransferState == TXFR_IDLE )
{
Offset = Memory_Offset * Mass_Block_Size;
Length = Transfer_Length * Mass_Block_Size;
TransferState = TXFR_ONGOING;
}
if (TransferState == TXFR_ONGOING )
{
if (!Block_Read_count)
{
Clash = 1;
__ExtFlash_PageRD(Data_Buffer, Offset, Mass_Block_Size);
UserToPMABufferCopy((u8 *)Data_Buffer, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
Block_Read_count = Mass_Block_Size - BULK_MAX_PACKET_SIZE;
Block_offset = BULK_MAX_PACKET_SIZE;
}
else
{
UserToPMABufferCopy((u8 *)Data_Buffer + Block_offset, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
Block_Read_count -= BULK_MAX_PACKET_SIZE;
Block_offset += BULK_MAX_PACKET_SIZE;
}
SetEPTxCount(ENDP1, BULK_MAX_PACKET_SIZE);
SetEPTxStatus(ENDP1, EP_TX_VALID);
Offset += BULK_MAX_PACKET_SIZE;
Length -= BULK_MAX_PACKET_SIZE;
CSW.dDataResidue -= BULK_MAX_PACKET_SIZE;
}
if (Length == 0)
{
Block_Read_count = 0;
Block_offset = 0;
Offset = 0;
Bot_State = BOT_DATA_IN_LAST;
TransferState = TXFR_IDLE;
}
}
void monkey_ep_reset(void) {
int i;
/* Set Joystick_DEVICE as not configured */
pInformation->Current_Configuration = 0;
pInformation->Current_Interface = 0;/*the default Interface*/
/* Current Feature initialization */
pInformation->Current_Feature = config1_descriptor[7];
for(i=0; i<8; ++i) {
if(ep_conf_list[i].direct==0) continue;
switch(ep_conf_list[i].attr) {
case 0x00:
SetEPType(i, EP_BULK);
ClearEPDoubleBuff(i);
break;
case 0x01:
SetEPType(i, EP_CONTROL);
Clear_Status_Out(i);
break;
case 0x02:
SetEPType(i, EP_ISOCHRONOUS);
break;
case 0x03:
SetEPType(i, EP_INTERRUPT);
break;
}
if(ep_conf_list[i].direct & EP_IN) {
SetEPTxStatus(i, ep_conf_list[i].tx_status);
SetEPTxAddr(i, ep_conf_list[i].tx_addr);
SetEPTxCount(i, ep_conf_list[i].tx_max);
}
if(ep_conf_list[i].direct & EP_OUT) {
SetEPRxAddr(i, ep_conf_list[i].rx_addr);
SetEPRxCount(i, ep_conf_list[i].rx_max);
SetEPRxStatus(i, ep_conf_list[i].rx_status);
}
}
}
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the microSD card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void Read_Memory(void)
{ //unsigned int a=0,b=0;
NAND_ADDRESS Nand_Addr;
// GPIO_SetBits(GPIOB, GPIO_Pin_5);
if (!Block_Read_count)
{
//NAND_ConvertOffsetToAddress(Memory_Offset, 64, &Nand_Addr);
NAND_ConvertOffsetToAddress(Memory_Offset, 2048, &Nand_Addr);
NAND_ReadSmallPage(Data1_Buffer, Nand_Addr, 1);
//NAND_ReadSpareArea(Data1_Buffer, Nand_Addr, 1);
UserToPMABufferCopy(Data1_Buffer, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
Block_Read_count = 2048 - BULK_MAX_PACKET_SIZE;
//Block_Read_count = 64 - BULK_MAX_PACKET_SIZE;
Block_offset = BULK_MAX_PACKET_SIZE;
}
else
{
UserToPMABufferCopy(Data1_Buffer + Block_offset, ENDP1_TXADDR, BULK_MAX_PACKET_SIZE);
Block_Read_count -= BULK_MAX_PACKET_SIZE;
Block_offset += BULK_MAX_PACKET_SIZE;
}
SetEPTxCount(ENDP1, BULK_MAX_PACKET_SIZE);
SetEPTxStatus(ENDP1, EP_TX_VALID);
Memory_Offset += BULK_MAX_PACKET_SIZE;
Transfer_Length -= BULK_MAX_PACKET_SIZE;
CSW.dDataResidue -= BULK_MAX_PACKET_SIZE;
//Led_RW_ON();
if (Transfer_Length == 0)
{
Block_Read_count = 0;
Block_offset = 0;
Memory_Offset = 0;
Bot_State = BOT_DATA_IN_LAST;
//Led_RW_OFF();
}
}
/*******************************************************************************
* Function Name : Read_Memory
* Description : Handle the Read operation from the microSD card.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void Read_Memory(uint8_t lun, uint32_t Memory_Offset, uint32_t Transfer_Length)
{
static uint32_t Offset, Length;
if (TransferState == TXFR_IDLE) {
Offset = Memory_Offset * Mass_Block_Size[lun];
Length = Transfer_Length * Mass_Block_Size[lun];
TransferState = TXFR_ONGOING;
}
if (TransferState == TXFR_ONGOING) {
// 缓冲区空时从存储设备读取数据
if (0 == Block_Read_count) {
MAL_Read(lun, Offset, Data_Buffer, Mass_Block_Size[lun]);
Block_Read_count = Mass_Block_Size[lun];
Block_offset = 0;
}
USB_SIL_Write(EP1_IN, (uint8_t *)Data_Buffer + Block_offset, BULK_MAX_PACKET_SIZE);
Block_Read_count -= BULK_MAX_PACKET_SIZE;
Block_offset += BULK_MAX_PACKET_SIZE;
SetEPTxCount(ENDP1, BULK_MAX_PACKET_SIZE);
SetEPTxStatus(ENDP1, EP_TX_VALID);
Offset += BULK_MAX_PACKET_SIZE;
Length -= BULK_MAX_PACKET_SIZE;
CSW.dDataResidue -= BULK_MAX_PACKET_SIZE;
USB_Led_RW_ON();
}
if (Length == 0) {
Block_Read_count = 0;
Block_offset = 0;
Offset = 0;
Bot_State = BOT_DATA_IN_LAST;
TransferState = TXFR_IDLE;
USB_Led_RW_OFF();
}
}
vsf_err_t stm32_usbd_ep_set_IN_epsize(uint8_t idx, uint16_t epsize)
{
int8_t index;
index = stm32_usbd_get_ep(idx);
if (index < 0)
{
return VSFERR_FAIL;
}
idx = (uint8_t)index;
if ((EP_Cfg_Ptr - epsize) < STM32_USBD_EP_NUM * 8)
{
return VSFERR_NOT_ENOUGH_RESOURCES;
}
stm32_usbd_IN_epsize[idx] = epsize;
SetEPTxCount(idx, epsize);
// fix for 16-bit aligned memory
EP_Cfg_Ptr -= epsize & 1 ? epsize + 1 : epsize;
SetEPTxAddr(idx, EP_Cfg_Ptr);
SetEPTxStatus(idx, EP_TX_NAK);
return VSFERR_NONE;
}
/**
* @brief Stall an endpoint.
* @param pdev: device instance
* @param epnum: endpoint address
* @retval : status
*/
uint32_t DCD_EP_Stall (USB_CORE_HANDLE *pdev, uint8_t epnum)
{
USB_EP *ep;
if ((0x80 & epnum) == 0x80)
{
ep = &pdev->dev.in_ep[epnum & 0x7F];
}
else
{
ep = &pdev->dev.out_ep[epnum];
}
if (ep->num ==0)
{
/* This macro sets STALL status for RX & TX*/
_SetEPRxTxStatus(ep->num,EP_RX_STALL,EP_TX_STALL);
/*Endpoint is stalled */
ep->is_stall = 1;
return USB_OK;
}
if (ep->is_in)
{
/* IN endpoint */
ep->is_stall = 1;
/* IN Endpoint stalled */
SetEPTxStatus(ep->num , EP_TX_STALL);
}
else
{
ep->is_stall = 1;
/* OUT Endpoint stalled */
SetEPRxStatus(ep->num , EP_RX_STALL);
}
return USB_OK;
}
/*******************************************************************************
* Function Name : EP1_Send_Callback.
* Description : EP1 Sending data Callback Routine.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void EP1_Send_Callback(void)
{
UserToPMABufferCopy((u8 *)USB_S_Buffer, ENDP1_TXADDR, USB_S_Size);
SetEPTxCount(ENDP1, USB_S_Size);
SetEPTxStatus(ENDP1, EP_TX_VALID);
}
/**
* @brief Configure an EP
* @param pdev : Device instance
* @param ep_addr: endpoint address
* @param ep_mps: endpoint max packet size
* @param ep_type: endpoint Type
*/
uint32_t DCD_EP_Open(USB_CORE_HANDLE *pdev ,
uint16_t ep_addr,
uint16_t ep_mps,
uint8_t ep_type)
{
USB_EP *ep;
/* initialize ep structure*/
if ((ep_addr & 0x80) == 0x80)
{
ep = &pdev->dev.in_ep[ep_addr & 0x7F];
ep->is_in = 1;
}
else
{
ep = &pdev->dev.out_ep[ep_addr & 0x7F];
ep->is_in = 0;
}
ep->maxpacket = ep_mps;
ep->type = ep_type;
ep->num = ep_addr & 0x7F;
if (ep->num == 0)
{
/* Initialize the control transfer variables*/
ep->ctl_data_len =0;
ep->rem_data_len = 0;
ep->total_data_len = 0;
}
/* Initialize the transaction level variables */
ep->xfer_buff = 0;
ep->xfer_len = 0;
ep->xfer_count = 0;
ep->is_stall = 0;
/* initialize HW */
switch (ep->type)
{
case USB_EP_CONTROL:
SetEPType(ep->num, EP_CONTROL);
break;
case USB_EP_BULK:
SetEPType(ep->num, EP_BULK);
break;
case USB_EP_INT:
SetEPType(ep->num, EP_INTERRUPT);
break;
case USB_EP_ISOC:
SetEPType(ep->num, EP_ISOCHRONOUS);
break;
}
if (ep->doublebuffer == 0)
{
if (ep->is_in)
{
/*Set the endpoint Transmit buffer address */
SetEPTxAddr(ep->num, ep->pmaadress);
ClearDTOG_TX(ep->num);
/* Configure NAK status for the Endpoint*/
SetEPTxStatus(ep->num, EP_TX_NAK);
}
else
{
/*Set the endpoint Receive buffer address */
SetEPRxAddr(ep->num, ep->pmaadress);
/*Set the endpoint Receive buffer counter*/
SetEPRxCount(ep->num, ep->maxpacket);
ClearDTOG_RX(ep->num);
/* Configure VALID status for the Endpoint*/
SetEPRxStatus(ep->num, EP_RX_VALID);
}
}
/*Double Buffer*/
else
{
/*Set the endpoint as double buffered*/
SetEPDoubleBuff(ep->num);
/*Set buffer address for double buffered mode*/
SetEPDblBuffAddr(ep->num,ep->pmaaddr0, ep->pmaaddr1);
if (ep->is_in==0)
{
/* Clear the data toggle bits for the endpoint IN/OUT*/
ClearDTOG_RX(ep->num);
ClearDTOG_TX(ep->num);
/* Reset value of the data toggle bits for the endpoint out*/
ToggleDTOG_TX(ep->num);
SetEPRxStatus(ep->num, EP_RX_VALID);
SetEPTxStatus(ep->num, EP_TX_DIS);
}
else
{
/* Clear the data toggle bits for the endpoint IN/OUT*/
ClearDTOG_RX(ep->num);
ClearDTOG_TX(ep->num);
ToggleDTOG_RX(ep->num);
/* Configure DISABLE status for the Endpoint*/
SetEPTxStatus(ep->num, EP_TX_DIS);
SetEPRxStatus(ep->num, EP_RX_DIS);
}
}
return USB_OK;
}
/*******************************************************************************
* Function Name : USB_Reset
* Description : USB reset routine
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void USB_Reset(void)
{
/* Set USB DEVICE as not configured */
pInformation->Current_Configuration = 0;
/* Set USB DEVICE with the default Interface*/
pInformation->Current_Interface = 0;
#ifdef USB_CDC_ENABLE
/* Current Feature initialization */
pInformation->Current_Feature = CDC_ConfigDescriptor[7];
#endif
#ifdef USB_HID_ENABLE
/* Current Feature initialization */
pInformation->Current_Feature = HID_ConfigDescriptor[7];
#endif
SetBTABLE(BTABLE_ADDRESS);
/* Initialize Endpoint 0 */
SetEPType(ENDP0, EP_CONTROL);
SetEPTxStatus(ENDP0, EP_TX_STALL);
SetEPRxAddr(ENDP0, ENDP0_RXADDR);
SetEPTxAddr(ENDP0, ENDP0_TXADDR);
Clear_Status_Out(ENDP0);
SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
SetEPRxValid(ENDP0);
#ifdef USB_CDC_ENABLE
/* Initialize Endpoint 1 */
SetEPType(ENDP1, EP_BULK);
SetEPTxAddr(ENDP1, ENDP1_TXADDR);
SetEPTxStatus(ENDP1, EP_TX_NAK);
SetEPRxStatus(ENDP1, EP_RX_DIS);
/* Initialize Endpoint 2 */
SetEPType(ENDP2, EP_INTERRUPT);
SetEPTxAddr(ENDP2, ENDP2_TXADDR);
SetEPRxStatus(ENDP2, EP_RX_DIS);
SetEPTxStatus(ENDP2, EP_TX_NAK);
/* Initialize Endpoint 3 */
SetEPType(ENDP3, EP_BULK);
SetEPRxAddr(ENDP3, ENDP3_RXADDR);
SetEPRxCount(ENDP3, CDC_DATA_SIZE);
SetEPRxStatus(ENDP3, EP_RX_VALID);
SetEPTxStatus(ENDP3, EP_TX_DIS);
#endif
#ifdef USB_HID_ENABLE
/* Initialize Endpoint 1 */
SetEPType(ENDP1, EP_INTERRUPT);
SetEPTxAddr(ENDP1, ENDP1_TXADDR);
#if defined (SPARK_USB_MOUSE)
SetEPTxCount(ENDP1, 4);
#elif defined (SPARK_USB_KEYBOARD)
SetEPTxCount(ENDP1, 8);
#endif
SetEPRxStatus(ENDP1, EP_RX_DIS);
SetEPTxStatus(ENDP1, EP_TX_NAK);
#endif
/* Set this device to response on default address */
SetDeviceAddress(0);
bDeviceState = ATTACHED;
}
/*******************************************************************************
* Function Name : Virtual_Com_Port_Reset
* Description : Virtual_Com_Port Mouse reset routine
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void Virtual_Com_Port_Reset(void)
{
/* Set Virtual_Com_Port_DEVICE as not configured */
pInformation->Current_Configuration = 0;
pInformation->Current_Interface = 0;/*the default Interface*/
SetBTABLE(BTABLE_ADDRESS);
/* Initialize Endpoint 0 */
SetEPType(ENDP0, EP_CONTROL);
SetEPTxStatus(ENDP0, EP_TX_STALL);
SetEPRxAddr(ENDP0, ENDP0_RXADDR); //GS 0x40 64
SetEPTxAddr(ENDP0, ENDP0_TXADDR); //GS 0x80 128
Clear_Status_Out(ENDP0);
SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
SetEPRxValid(ENDP0);
/*-------------------------------------------------------------*/
/* -------------- Buffer Description Table -----------------*/
/*-------------------------------------------------------------*/
//#define VIRTUAL_COM_PORT_DATA_SIZE 64
/* EP0 */
/* rx/tx buffer base address */
//#define ENDP0_RXADDR (0x40)
//#define ENDP0_TXADDR (0x80)
/* EP1 */
/* tx buffer base address */
//#define ENDP1_BUFF0_ADDR (0xC0)
//#define ENDP1_BUFF1_ADDR (0x100)
//#define ENDP2_BUFF0_ADDR (0x1C0)
//#define ENDP2_BUFF1_ADDR (0x1D0)
// Initialize Endpoint 1
SetEPType(ENDP1, EP_BULK);
SetEPTxAddr(ENDP1, ENDP1_BUFF_ADDR);
SetEPRxCount(ENDP1,64);
SetEPTxStatus(ENDP1, EP_TX_NAK);
SetEPRxStatus(ENDP1, EP_RX_DIS);
// Initialize Endpoint 2
SetEPType(ENDP2, EP_BULK);
SetEPRxAddr(ENDP2, ENDP2_BUFF_ADDR);
SetEPRxCount(ENDP2, 64);
SetEPRxStatus(ENDP2, EP_RX_VALID);
SetEPTxStatus(ENDP2, EP_TX_DIS);
// Initialize Endpoint 3 // IN cmd
SetEPType(ENDP3, EP_BULK);
SetEPTxAddr(ENDP3, ENDP3_BUFF_ADDR);
SetEPRxCount(ENDP3, 64);
SetEPTxStatus(ENDP3, EP_TX_NAK);
SetEPRxStatus(ENDP3, EP_RX_DIS);
// Initialize Endpoint 4 // OUT cmd
SetEPType(ENDP4, EP_BULK);
SetEPRxAddr(ENDP4, ENDP4_BUFF_ADDR);
SetEPRxCount(ENDP4, 64);
SetEPRxStatus(ENDP4, EP_RX_VALID);
SetEPTxStatus(ENDP4, EP_TX_DIS);
/* Set this device to respsonse on default address */
SetDeviceAddress(0);
}
/*******************************************************************************
* Function Name : Joystick_Reset.
* Description : Joystick Mouse reset routine.
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void USB_APP_Reset(void)
{
/* Set Joystick_DEVICE as not configured */
pInformation->Current_Configuration = 0;
/* Current Feature initialization */
#if(USB_DEVICE_CONFIG & _USE_USB_VIRTUAL_COMM_DEVICE)
if (g_usb_type == USB_VIRTUAL_PORT)
{
pInformation->Current_Interface = 0;
pInformation->Current_Feature = Virtual_Com_Port_ConfigDescriptor[7];
}
else
#endif
#if(USB_DEVICE_CONFIG & _USE_USB_KEYBOARD_DEVICE)
if(g_usb_type == USB_KEYBOARD)
{
pInformation->Current_Interface = 0;
pInformation->Current_Feature = Keyboard_ConfigDescriptor[7];
}
else
#endif
#if(USB_DEVICE_CONFIG & _USE_USB_MASS_STOARGE_DEVICE)
{
pInformation->Current_Feature = MASS_ConfigDescriptor[7];
}
#endif
#if(USB_DEVICE_CONFIG & _USE_USB_PRINTER_DEVICE)
{
pInformation->Current_Interface = 0;
pInformation->Current_Feature = Printer_ConfigDescriptor[7];
}
#endif
SetBTABLE(BTABLE_ADDRESS);
/* Initialize Endpoint 0 */
SetEPType(ENDP0, EP_CONTROL);
SetEPTxStatus(ENDP0, EP_TX_STALL);
SetEPRxAddr(ENDP0, ENDP0_RXADDR);
SetEPTxAddr(ENDP0, ENDP0_TXADDR);
Clear_Status_Out(ENDP0);
SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
SetEPRxValid(ENDP0);
#if(USB_DEVICE_CONFIG & _USE_USB_VIRTUAL_COMM_DEVICE)
if (g_usb_type == USB_VIRTUAL_PORT)
{
/* Initialize Endpoint 1 */
SetEPType(ENDP1, EP_BULK);
SetEPTxAddr(ENDP1, ENDP1_TXADDR);
SetEPTxStatus(ENDP1, EP_TX_NAK);
SetEPRxStatus(ENDP1, EP_RX_DIS);
/* Initialize Endpoint 2 */
SetEPType(ENDP2, EP_INTERRUPT);
SetEPTxAddr(ENDP2, ENDP2_TXADDR);
SetEPRxStatus(ENDP2, EP_RX_DIS);
SetEPTxStatus(ENDP2, EP_TX_NAK);
/* Initialize Endpoint 3 */
SetEPType(ENDP3, EP_BULK);
SetEPRxAddr(ENDP3, ENDP3_RXADDR);
SetEPRxCount(ENDP3, VIRTUAL_COM_PORT_DATA_SIZE);
SetEPRxStatus(ENDP3, EP_RX_VALID);
SetEPTxStatus(ENDP3, EP_TX_DIS);
}
else
#endif
#if(USB_DEVICE_CONFIG & _USE_USB_KEYBOARD_DEVICE)
if(g_usb_type == USB_KEYBOARD)
{
/* Initialize Endpoint 1 */
SetEPType(ENDP1, EP_INTERRUPT);
SetEPTxAddr(ENDP1, ENDP1_TXADDR);
SetEPTxCount(ENDP1, 1);
SetEPRxStatus(ENDP1, EP_RX_DIS);
SetEPTxStatus(ENDP1, EP_TX_NAK);
}
else
#endif
#if(USB_DEVICE_CONFIG & _USE_USB_MASS_STOARGE_DEVICE)
{
/* Initialize Endpoint 1 */
SetEPType(ENDP1, EP_BULK);
SetEPTxAddr(ENDP1, ENDP1_TXADDR);
SetEPTxStatus(ENDP1, EP_TX_NAK);
SetEPRxStatus(ENDP1, EP_RX_DIS);
/* Initialize Endpoint 2 */
SetEPType(ENDP2, EP_BULK);
SetEPRxAddr(ENDP2, ENDP2_RXADDR);
SetEPRxCount(ENDP2, Device_Property.MaxPacketSize);
//SetEPRxCount(ENDP2, 0x40); //joe ÐÞ¸Ä
SetEPRxStatus(ENDP2, EP_RX_VALID);
SetEPTxStatus(ENDP2, EP_TX_DIS);
SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
SetEPRxValid(ENDP0);
CBW.dSignature = BOT_CBW_SIGNATURE;
Bot_State = BOT_IDLE;
}
#endif
#if(USB_DEVICE_CONFIG & _USE_USB_PRINTER_DEVICE)
{
/* Initialize Endpoint 1 */
SetEPType(ENDP1, EP_BULK);
SetEPTxAddr(ENDP1, ENDP1_TXADDR);
SetEPTxStatus(ENDP1, EP_TX_NAK);
SetEPRxStatus(ENDP1, EP_RX_DIS);
/* Initialize Endpoint 2 */
SetEPType(ENDP2, EP_BULK);
SetEPRxAddr(ENDP2, ENDP2_RXADDR);
SetEPRxCount(ENDP2, Device_Property.MaxPacketSize);
//SetEPRxCount(ENDP2, 0x40); //joe ÐÞ¸Ä
SetEPRxStatus(ENDP2, EP_RX_VALID);
SetEPTxStatus(ENDP2, EP_TX_DIS);
}
#endif
bDeviceState = ATTACHED;
/* Set this device to response on default address */
SetDeviceAddress(0);
}
/*******************************************************************************
* Function Name : SetEPTxValid
* Description : Valid the endpoint Tx Status.
* Input : bEpNum: Endpoint Number.
* Output : None.
* Return : None.
*******************************************************************************/
void SetEPTxValid(uint8_t bEpNum) {
SetEPTxStatus(bEpNum,EP_TX_VALID);
}
/*******************************************************************************
* Function Name : Standard_ClearFeature.
* Description : Clear or disable a specific feature.
* Input : None.
* Output : None.
* Return : - Return USB_SUCCESS, if the request is performed.
* - Return USB_UNSUPPORT, if the request is invalid.
*******************************************************************************/
RESULT Standard_ClearFeature(void) {
uint32_t Type_Rec = Type_Recipient;
uint32_t Status;
if(Type_Rec == (STANDARD_REQUEST | DEVICE_RECIPIENT)) { /*Device Clear Feature*/
ClrBit(pInformation->Current_Feature, 5);
return USB_SUCCESS;
} else if(Type_Rec == (STANDARD_REQUEST | ENDPOINT_RECIPIENT)) { /*EndPoint Clear Feature*/
DEVICE* pDev;
uint32_t Related_Endpoint;
uint32_t wIndex0;
uint32_t rEP;
if((pInformation->USBwValue != ENDPOINT_STALL) || (pInformation->USBwIndex1 != 0)) {
return USB_UNSUPPORT;
}
pDev = &Device_Table;
wIndex0 = pInformation->USBwIndex0;
rEP = wIndex0 & ~0x80;
Related_Endpoint = ENDP0 + rEP;
if(ValBit(pInformation->USBwIndex0, 7)) {
/*Get Status of endpoint & stall the request if the related_ENdpoint
is Disabled*/
Status = _GetEPTxStatus(Related_Endpoint);
} else {
Status = _GetEPRxStatus(Related_Endpoint);
}
if((rEP >= pDev->Total_Endpoint) || (Status == 0) || (pInformation->Current_Configuration == 0)) {
return USB_UNSUPPORT;
}
if(wIndex0 & 0x80) {
/* IN endpoint */
if(_GetTxStallStatus(Related_Endpoint)) {
#ifndef STM32F10X_CL
ClearDTOG_TX(Related_Endpoint);
#endif /* STM32F10X_CL */
SetEPTxStatus(Related_Endpoint, EP_TX_VALID);
}
} else {
/* OUT endpoint */
if(_GetRxStallStatus(Related_Endpoint)) {
if(Related_Endpoint == ENDP0) {
/* After clear the STALL, enable the default endpoint receiver */
SetEPRxCount(Related_Endpoint, Device_Property.MaxPacketSize);
_SetEPRxStatus(Related_Endpoint, EP_RX_VALID);
} else {
#ifndef STM32F10X_CL
ClearDTOG_RX(Related_Endpoint);
#endif /* STM32F10X_CL */
_SetEPRxStatus(Related_Endpoint, EP_RX_VALID);
}
}
}
pUser_Standard_Requests->User_ClearFeature();
return USB_SUCCESS;
}
return USB_UNSUPPORT;
}
/*******************************************************************************
* Function Name : Virtual_Com_Port_Reset
* Description : Virtual_Com_Port Mouse reset routine
* Input : None.
* Output : None.
* Return : None.
*******************************************************************************/
void Virtual_Com_Port_Reset(void)
{
/* Set Virtual_Com_Port DEVICE as not configured */
pInformation->Current_Configuration = 0;
/* Current Feature initialization */
pInformation->Current_Feature = Virtual_Com_Port_ConfigDescriptor[7];
/* Set Virtual_Com_Port DEVICE with the default Interface*/
pInformation->Current_Interface = 0;
#ifdef STM32F10X_CL
/* EP0 is already configured by USB_SIL_Init() function */
/* Init EP1 IN as Bulk endpoint */
OTG_DEV_EP_Init(EP1_IN, OTG_DEV_EP_TYPE_BULK, VIRTUAL_COM_PORT_DATA_SIZE);
/* Init EP2 IN as Interrupt endpoint */
OTG_DEV_EP_Init(EP2_IN, OTG_DEV_EP_TYPE_INT, VIRTUAL_COM_PORT_INT_SIZE);
/* Init EP3 OUT as Bulk endpoint */
OTG_DEV_EP_Init(EP3_OUT, OTG_DEV_EP_TYPE_BULK, VIRTUAL_COM_PORT_DATA_SIZE);
#else
SetBTABLE(BTABLE_ADDRESS);
/* Initialize Endpoint 0 */
SetEPType(ENDP0, EP_CONTROL);
SetEPTxStatus(ENDP0, EP_TX_STALL);
SetEPRxAddr(ENDP0, ENDP0_RXADDR);
SetEPTxAddr(ENDP0, ENDP0_TXADDR);
Clear_Status_Out(ENDP0);
SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
SetEPRxValid(ENDP0);
/* Initialize Endpoint 1 */
SetEPType(ENDP1, EP_BULK);
SetEPTxAddr(ENDP1, ENDP1_TXADDR);
SetEPTxStatus(ENDP1, EP_TX_NAK);
SetEPRxStatus(ENDP1, EP_RX_DIS);
/* Initialize Endpoint 2 */
SetEPType(ENDP2, EP_INTERRUPT);
SetEPTxAddr(ENDP2, ENDP2_TXADDR);
SetEPRxStatus(ENDP2, EP_RX_DIS);
SetEPTxStatus(ENDP2, EP_TX_NAK);
/* Initialize Endpoint 3 */
SetEPType(ENDP3, EP_BULK);
SetEPRxAddr(ENDP3, ENDP3_RXADDR);
SetEPRxCount(ENDP3, VIRTUAL_COM_PORT_DATA_SIZE);
SetEPRxStatus(ENDP3, EP_RX_VALID);
SetEPTxStatus(ENDP3, EP_TX_DIS);
/* Initialize Endpoint 4 */
SetEPType(ENDP4, EP_BULK);
SetEPTxAddr(ENDP4, ENDP4_TXADDR);
SetEPTxStatus(ENDP4, EP_TX_NAK);
SetEPRxStatus(ENDP4, EP_RX_DIS);
/* Initialize Endpoint 5 */
SetEPType(ENDP5, EP_INTERRUPT);
SetEPTxAddr(ENDP5, ENDP5_TXADDR);
SetEPRxStatus(ENDP5, EP_RX_DIS);
SetEPTxStatus(ENDP5, EP_TX_NAK);
/* Initialize Endpoint 6 */
SetEPType(ENDP6, EP_BULK);
SetEPRxAddr(ENDP6, ENDP6_RXADDR);
SetEPRxCount(ENDP6, VIRTUAL_COM_PORT_DATA_SIZE);
SetEPRxStatus(ENDP6, EP_RX_VALID);
SetEPTxStatus(ENDP6, EP_TX_DIS);
/* Set this device to response on default address */
SetDeviceAddress(0);
#endif /* STM32F10X_CL */
bDeviceState = ATTACHED;
}
