void PRNT_Device_USBTask(USB_ClassInfo_PRNT_Device_t* const PRNTInterfaceInfo)
{
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
#if !defined(NO_CLASS_DRIVER_AUTOFLUSH)
Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
if (Endpoint_IsINReady())
PRNT_Device_Flush(PRNTInterfaceInfo);
#endif
if (PRNTInterfaceInfo->State.IsPrinterReset)
{
Endpoint_ResetEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
Endpoint_ResetEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataOUTEndpoint.Address);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
Endpoint_SelectEndpoint(PRNTInterfaceInfo->Config.DataINEndpoint.Address);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
PRNTInterfaceInfo->State.IsPrinterReset = false;
}
}
/** Task to manage the Mass Storage interface, reading in Command Block Wrappers from the host, processing the SCSI commands they
* contain, and returning Command Status Wrappers back to the host to indicate the success or failure of the last issued command.
*/
void MassStorage_Task(void)
{
/* Device must be connected and configured for the task to run */
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
/* Process sent command block from the host if one has been sent */
if (ReadInCommandBlock())
{
/* Indicate busy */
LEDs_SetAllLEDs(LEDMASK_USB_BUSY);
/* Check direction of command, select Data IN endpoint if data is from the device */
if (CommandBlock.Flags & COMMAND_DIRECTION_DATA_IN)
Endpoint_SelectEndpoint(MASS_STORAGE_IN_EPNUM);
/* Decode the received SCSI command, set returned status code */
CommandStatus.Status = SCSI_DecodeSCSICommand() ? Command_Pass : Command_Fail;
/* Load in the CBW tag into the CSW to link them together */
CommandStatus.Tag = CommandBlock.Tag;
/* Load in the data residue counter into the CSW */
CommandStatus.DataTransferResidue = CommandBlock.DataTransferLength;
/* Stall the selected data pipe if command failed (if data is still to be transferred) */
if ((CommandStatus.Status == Command_Fail) && (CommandStatus.DataTransferResidue))
Endpoint_StallTransaction();
/* Return command status block to the host */
ReturnCommandStatus();
/* Indicate ready */
LEDs_SetAllLEDs(LEDMASK_USB_READY);
}
/* Check if a Mass Storage Reset occurred */
if (IsMassStoreReset)
{
/* Reset the data endpoint banks */
Endpoint_ResetFIFO(MASS_STORAGE_OUT_EPNUM);
Endpoint_ResetFIFO(MASS_STORAGE_IN_EPNUM);
Endpoint_SelectEndpoint(MASS_STORAGE_OUT_EPNUM);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
Endpoint_SelectEndpoint(MASS_STORAGE_IN_EPNUM);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
/* Clear the abort transfer flag */
IsMassStoreReset = false;
}
}
int main (void)
{
uint32_t tmp_bulk_reset;
MCUSR &= ~(1u << WDRF);
wdt_disable();
clock_prescale_set(clock_div_1);
board_init();
USB_Init();
vue_write_address_full(VUE_CART_READER_nSTATUS | VUE_nROM_CE | VUE_nRAM_CS | VUE_nES);
sei();
while (true) {
USB_USBTask();
tmp_bulk_reset = bulk_reset;
VUE_Task();
if (tmp_bulk_reset) {
/* write default state */
VUE_CTRL->out |= VUE_nOE | VUE_nUWR | VUE_nLWR;
VUE_CTRL->out &= ~VUE_CART_READER_PL;
vue_write_address_full(VUE_CART_READER_nSTATUS | VUE_nROM_CE | VUE_nRAM_CS | VUE_nES);
/* Reset FSM */
cur_vue_state = IDLE;
/* Clear Endpoints */
Endpoint_ResetEndpoint(VUE_CART_READER_OUT_EP_ADDR);
Endpoint_ResetEndpoint(VUE_CART_READER_IN_EP_ADDR);
Endpoint_SelectEndpoint(VUE_CART_READER_OUT_EP_ADDR);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
Endpoint_SelectEndpoint(VUE_CART_READER_IN_EP_ADDR);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
Endpoint_AbortPendingIN();
bulk_reset = 0x00000000ul;
}
}
}
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{
if (USB_DeviceState[MSInterfaceInfo->Config.PortNumber] != DEVICE_STATE_Configured)
return;
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.PortNumber, MSInterfaceInfo->Config.DataOUTEndpointNumber);
if (Endpoint_IsReadWriteAllowed(MSInterfaceInfo->Config.PortNumber))
{
if (MS_Device_ReadInCommandBlock(MSInterfaceInfo))
{
if (MSInterfaceInfo->State.CommandBlock.Flags & MS_COMMAND_DIR_DATA_IN)
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.PortNumber, MSInterfaceInfo->Config.DataINEndpointNumber);
bool SCSICommandResult = CALLBACK_MS_Device_SCSICommandReceived(MSInterfaceInfo);
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.PortNumber, MSInterfaceInfo->Config.DataOUTEndpointNumber);// for streaming
Endpoint_ClearOUT(MSInterfaceInfo->Config.PortNumber);
if (MSInterfaceInfo->State.CommandBlock.Flags & MS_COMMAND_DIR_DATA_IN)
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.PortNumber, MSInterfaceInfo->Config.DataINEndpointNumber);
MSInterfaceInfo->State.CommandStatus.Status = (SCSICommandResult) ? MS_SCSI_COMMAND_Pass : MS_SCSI_COMMAND_Fail;
MSInterfaceInfo->State.CommandStatus.Signature = CPU_TO_LE32(MS_CSW_SIGNATURE);
MSInterfaceInfo->State.CommandStatus.Tag = MSInterfaceInfo->State.CommandBlock.Tag;
MSInterfaceInfo->State.CommandStatus.DataTransferResidue = MSInterfaceInfo->State.CommandBlock.DataTransferLength;
if (!(SCSICommandResult) && (le32_to_cpu(MSInterfaceInfo->State.CommandStatus.DataTransferResidue)))
Endpoint_StallTransaction(MSInterfaceInfo->Config.PortNumber);
MS_Device_ReturnCommandStatus(MSInterfaceInfo);
}
}
if (MSInterfaceInfo->State.IsMassStoreReset)
{
Endpoint_ResetEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
Endpoint_ResetEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.PortNumber, MSInterfaceInfo->Config.DataOUTEndpointNumber);
Endpoint_ClearStall(MSInterfaceInfo->Config.PortNumber);
Endpoint_ResetDataToggle(MSInterfaceInfo->Config.PortNumber);
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.PortNumber, MSInterfaceInfo->Config.DataINEndpointNumber);
Endpoint_ClearStall(MSInterfaceInfo->Config.PortNumber);
Endpoint_ResetDataToggle(MSInterfaceInfo->Config.PortNumber);
MSInterfaceInfo->State.IsMassStoreReset = false;
}
}
void MS_Device_USBTask(USB_ClassInfo_MS_Device_t* const MSInterfaceInfo)
{
if (USB_DeviceState != DEVICE_STATE_Configured)
return;
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
if (Endpoint_IsReadWriteAllowed())
{
if (MS_Device_ReadInCommandBlock(MSInterfaceInfo))
{
if (MSInterfaceInfo->State.CommandBlock.Flags & MS_COMMAND_DIR_DATA_IN)
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
MSInterfaceInfo->State.CommandStatus.Status = CALLBACK_MS_Device_SCSICommandReceived(MSInterfaceInfo) ?
MS_SCSI_COMMAND_Pass : MS_SCSI_COMMAND_Fail;
MSInterfaceInfo->State.CommandStatus.Signature = MS_CSW_SIGNATURE;
MSInterfaceInfo->State.CommandStatus.Tag = MSInterfaceInfo->State.CommandBlock.Tag;
MSInterfaceInfo->State.CommandStatus.DataTransferResidue = MSInterfaceInfo->State.CommandBlock.DataTransferLength;
if ((MSInterfaceInfo->State.CommandStatus.Status == MS_SCSI_COMMAND_Fail) &&
(MSInterfaceInfo->State.CommandStatus.DataTransferResidue))
{
Endpoint_StallTransaction();
}
MS_Device_ReturnCommandStatus(MSInterfaceInfo);
}
}
if (MSInterfaceInfo->State.IsMassStoreReset)
{
Endpoint_ResetFIFO(MSInterfaceInfo->Config.DataOUTEndpointNumber);
Endpoint_ResetFIFO(MSInterfaceInfo->Config.DataINEndpointNumber);
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataOUTEndpointNumber);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
Endpoint_SelectEndpoint(MSInterfaceInfo->Config.DataINEndpointNumber);
Endpoint_ClearStall();
Endpoint_ResetDataToggle();
MSInterfaceInfo->State.IsMassStoreReset = false;
}
}
static void USB_Device_ClearSetFeature(void)
{
switch (USB_ControlRequest.bmRequestType & CONTROL_REQTYPE_RECIPIENT)
{
#if !defined(NO_DEVICE_REMOTE_WAKEUP)
case REQREC_DEVICE:
if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_DeviceRemoteWakeup)
USB_Device_RemoteWakeupEnabled = (USB_ControlRequest.bRequest == REQ_SetFeature);
else
return;
break;
#endif
#if !defined(CONTROL_ONLY_DEVICE)
case REQREC_ENDPOINT:
if ((uint8_t)USB_ControlRequest.wValue == FEATURE_SEL_EndpointHalt)
{
uint8_t EndpointIndex = ((uint8_t)USB_ControlRequest.wIndex & ENDPOINT_EPNUM_MASK);
if (EndpointIndex == ENDPOINT_CONTROLEP)
return;
Endpoint_SelectEndpoint(EndpointIndex);
if (Endpoint_IsEnabled())
{
if (USB_ControlRequest.bRequest == REQ_SetFeature)
{
Endpoint_StallTransaction();
}
else
{
Endpoint_ClearStall();
Endpoint_ResetEndpoint(EndpointIndex);
Endpoint_ResetDataToggle();
}
}
}
break;
#endif
default:
return;
}
Endpoint_SelectEndpoint(ENDPOINT_CONTROLEP);
Endpoint_ClearSETUP();
Endpoint_ClearStatusStage();
}
void HUB_Task(void)
{
Endpoint_SelectEndpoint(1);
if (Endpoint_IsReadWriteAllowed())
{
if (hub_int_response) {
if (hub_int_force_data0) {
Endpoint_ResetDataToggle();
hub_int_force_data0 = 0;
}
Endpoint_Write_Byte(hub_int_response);
Endpoint_ClearIN();
hub_int_response = 0x00;
}
}
}
/*
* The Linux and OSX call the configuration changed entry each time
* a transaction is started (e.g., multiple runs of cbmctrl status).
* We need to reset the endpoints before reconfiguring them, otherwise
* we get a hang the second time through.
*
* We keep the original endpoint selected after returning.
*/
void
USB_ResetConfig()
{
static uint8_t endpoints[] = {
XUM_BULK_IN_ENDPOINT, XUM_BULK_OUT_ENDPOINT, 0,
};
uint8_t lastEndpoint, *endp;
lastEndpoint = Endpoint_GetCurrentEndpoint();
for (endp = endpoints; *endp != 0; endp++) {
Endpoint_SelectEndpoint(*endp);
Endpoint_ResetFIFO(*endp);
Endpoint_ResetDataToggle();
if (Endpoint_IsStalled())
Endpoint_ClearStall();
}
Endpoint_SelectEndpoint(lastEndpoint);
}
