void Chap9_BurstTransmitEP0(PUCHAR pData, USHORT len)
{
ControlData.wCount = 0;
if(ControlData.wLength > len)
ControlData.wLength = len;
ControlData.Addr.pData = pData;
if( ControlData.wLength >= EP0_PACKET_SIZE)
{
Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN, pData, EP0_PACKET_SIZE);
RaiseIRQL();
if(!ControlData.Abort)
{
ControlData.wCount += EP0_PACKET_SIZE;
bD13flags.bits.DCP_state = USBFSM4DCP_DATAIN;
}
LowerIRQL();
}
else
{
Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN, pData, ControlData.wLength);
RaiseIRQL();
if(!ControlData.Abort)
{
ControlData.wCount += ControlData.wLength;
bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
}
LowerIRQL();
}
}
void Isr_Ep00TxDone(void)
{
short i = ControlData.wLength - ControlData.wCount;
UCHAR ep_last;
Hal4D13_ReadInterruptRegister();
ep_last = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP0_CONTROL_IN); /* Clear interrupt flag */
switch (bD13flags.bits.DCP_state)
{
case USBFSM4DCP_HANDSHAKE:
break;
case USBFSM4DCP_DATAIN:
if( i >= EP0_PACKET_SIZE)
{
Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN,ControlData.Addr.pData + ControlData.wCount, EP0_PACKET_SIZE);
ControlData.wCount += EP0_PACKET_SIZE;
// State remains at USBFSM4DCP_DATAIN
}
else if( i != 0)
{
Hal4D13_WriteEndpoint(1, ControlData.Addr.pData + ControlData.wCount, i);
ControlData.wCount += i;
bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
}
else if (i == 0)
{
bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
Hal4D13_SingleTransmitEP0(0, 0);
}
break;
case USBFSM4DCP_REQUESTPROC: break;
case USBFSM4DCP_IDLE: break;
case USBFSM4DCP_SETUPPROC: break;
case USBFSM4DCP_STALL: break;
case USBFSM4DCP_DATAOUT: break;
default:
USB_ISR_DEBUG(("Fatal Error: Isr_Ep0TxDone Unexpected FSMState=%x\r\n",bD13flags.bits.DCP_state));
bD13flags.bits.DCP_state = USBFSM4DCP_STALL;
Hal4D13_StallEP0InControlRead();
break;
}
}
void Chap9_BurstTransmitEP0(PUCHAR pData, USHORT len)
{
ControlData.wCount = 0;
//printf("wCount = %d \n",ControlData.wCount);
if(ControlData.wLength > len)
ControlData.wLength = len;
printf("wLength = %d \n",ControlData.wLength);
ControlData.Addr.pData = pData;
if( ControlData.wLength >= EP0_PACKET_SIZE)
{
Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN, pData, EP0_PACKET_SIZE);
RaiseIRQL();
if(!ControlData.Abort)
{
ControlData.wCount += EP0_PACKET_SIZE;
bD13flags.bits.DCP_state = USBFSM4DCP_DATAIN;
}
LowerIRQL();
}
else
{
USHORT i = Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN, pData, ControlData.wLength);
//printf("Descriptor size after writing to Ep0 is %d \n ",i);
RaiseIRQL();
if(!ControlData.Abort)
{
ControlData.wCount += ControlData.wLength;
bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;
}
LowerIRQL();
}
}
void Isr_Ep01Done(void)
{
unsigned char bbuf[8];
UCHAR c;
c = Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP01);
//Richard Hal4D13_ReadEndpoint(EPINDEX4EP01, &bbuf, 8);
//Richard Hal4D13_ReadBulkEndpoint(EPINDEX4EP01,&bbuf, 1);
Hal4D13_ReadEndpoint(EPINDEX4EP01, bbuf, 8);
Hal4D13_ReadBulkEndpoint(EPINDEX4EP01,bbuf, 1);
USB_ISR_DEBUG(("Received From Endpoint 1\r\n"));
if (bbuf[0]==0xaa) bbuf[0]=bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS++;
else if (bbuf[0]==0x55) bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS = 0;
else if (bbuf[0]==0x99) bUSBCheck_Device_State.State_bits.RESET_BITS = 1;
else bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS=0xcc;
bbuf[0]=bUSBCheck_Device_State.State_bits.FOUR_RESERVED_BITS;
IOWR(LEDG_BASE,0,bbuf[0]);
IOWR(LEDR_BASE,0,bbuf[0]);
SEG7_Hex(bbuf[0], 0);
//IOWR(SEG7_DISPLAY_BASE,0,bbuf[0]);
// richard Hal4D13_WriteEndpoint(EPINDEX4EP02,&bbuf, 8);
Hal4D13_WriteEndpoint(EPINDEX4EP02,bbuf, 8);
Hal4D13_GetEndpointStatusWInteruptClear(EPINDEX4EP01); /* Clear interrupt flag*/
}
void Hal4D13_SingleTransmitEP0(UCHAR * buf, USHORT len)
{
if( len <= EP0_PACKET_SIZE) {
Hal4D13_WriteEndpoint(EPINDEX4EP0_CONTROL_IN, buf, len);
}
}
int main() {
/* Local variables */
HID_KEYS_REPORT old_report;
BOOL bufferAvailable, readyToSend, watchdog_required;
UCHAR gesture;
UCHAR send_buffer[8];
int i;
/* Configure ISP1362 chip */
disable_irq();
disconnect_USB_controller();
usleep(1000000);
Hal4D13_ResetDevice(); //This is good because its a legit ISP1362 call
//changed state settings to reset values -- If possible I would like to remove these.
hid_settings.state = reset;
watchdog_required = FALSE;
bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE = 1;
bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 0;
bUSBCheck_Device_State.State_bits.DEVICE_CONFIGURATION_STATE = 0;
bUSBCheck_Device_State.State_bits.RESET_BITS = 0;
usleep(1000000);
reconnect_USB_controller();
CHECK_CHIP_ID(); //Checks chip ID and prints it to console. Is not actually required
Hal4D13_AcquireD13(USB_0_BASE,(void*)usb_isr); //Registers main ISR. very important.
enable_irq();
/* Initialise HID report structures to zero */
new_report.modifier = 0x00;
new_report.reserved = 0x00;
for(i=0; i<6; i++){
new_report.keycode[i] = 0x00;
}
old_report.modifier = 0x00;
old_report.reserved = 0x00;
for(i=0; i<6; i++){
old_report.keycode[i] = 0x00;
}
while(1) {
/* Interrupt service routines modify state bits, calls handler based on state */
if (bUSBCheck_Device_State.State_bits.RESET_BITS == 1) {
disable_irq();
break;
}
if (bD13flags.bits.suspend) {
disable_irq();
bD13flags.bits.suspend= 0;
enable_irq();
change_suspend_state();
} // Suspend Change Handler
if (bD13flags.bits.DCP_state == USBFSM4DCP_SETUPPROC) {
disable_irq();
SetupToken_Handler();
enable_irq();
} // Setup Token Handler
if ((bD13flags.bits.DCP_state == USBFSM4DCP_REQUESTPROC) && !ControlData.Abort) {
disable_irq();
bD13flags.bits.DCP_state = 0x00;
DeviceRequest_Handler();
enable_irq();
} // Device Request Handler
//TODO: Revisit how toSend is decided. Now bufferAvailable
if(bD13flags.bits.DCP_state == USBFSM4DCP_INTR1DONE) {
bD13flags.bits.DCP_state = 0x00;
if(Hal4D13_GetErrorCode(EPINDEX4EP01) & 0x01) {
//I feel like I need to do something in here. We get interrupts from the other side when packet is received.
}
}
UCHAR status = Hal4D13_GetEndpointStatusWOInteruptClear(EPINDEX4EP01);
if(!(status & 0x60)) {
bufferAvailable = TRUE;
}
printf("Status bits are = %x\n", status);
if(hid_settings.state == connected) {
/* Check for gesture */
disable_irq();
gesture = readGesture();
mapGestureToKeycodes(&new_report, gesture);
enable_irq();
/* See if we should send the next report */
disable_irq();
readyToSend = reportChanged(old_report, new_report) && bufferAvailable;
if(readyToSend || watchdog_required) {
send_buffer[0] = new_report.modifier;
send_buffer[1] = new_report.reserved;
send_buffer[2] = new_report.keycode[0];
send_buffer[3] = new_report.keycode[1];
send_buffer[4] = new_report.keycode[2];
send_buffer[5] = new_report.keycode[3];
send_buffer[6] = new_report.keycode[4];
send_buffer[7] = new_report.keycode[5];
Hal4D13_LockDevice(0);
Hal4D13_WriteEndpoint(EPINDEX4EP01, send_buffer, 8);
bufferAvailable = FALSE;
readyToSend = FALSE;
watchdog_required = FALSE;
}
enable_irq();
/* Update old report */
old_report.keycode[0] = new_report.keycode[0]; //We only use one key slot so only need to to update one
old_report.modifier = new_report.modifier;
if(new_report.keycode[0] != 0)
IOWR(GREEN_LEDS_BASE, 0, new_report.keycode[0]);
}
} //End While(1)
return 0;
}//End Main
void Chap9_GetDescriptor(void)
{
UCHAR bDescriptor = MSB(ControlData.DeviceRequest.wValue);
UCHAR bDescriptorIndex = LSB(ControlData.DeviceRequest.wValue);
//printf("bDescri %d\n",bDescriptor);
//printf("Index %d\n",bDescriptorIndex);
////printf("USB_DEVICE_DESCRIPTORsize %d\n",sizeof(USB_DEVICE_DESCRIPTOR));
// //printf("CONFIGURATIONsize %d\n",sizeof(USB_CONFIGURATION_DESCRIPTOR_a));
switch(bDescriptor)
{
//sDevice sConfiguration
//sizeof(struct CONFIGURATION)
//sizeof( struct DEVICE)
case USB_DEVICE_DESCRIPTOR_TYPE://1
{
//printf("entering device descriptor");
Chap9_BurstTransmitEP0( (PUCHAR)&DeviceDescr , sizeof(USB_DEVICE_DESCRIPTOR));
//Chap9_BurstTransmitEP0((PUCHAR)&sDevice,sizeof(struct DEVICE));
//printf("exiting device descriptor");
break;
}
case USB_CONFIGURATION_DESCRIPTOR_TYPE://2
{
// Chap9_BurstTransmitEP0((PUCHAR)&ConfigDescr, CONFIG_DESCRIPTOR_LENGTH);
printf("\nConfigDescr ");
Chap9_BurstTransmitEP0((PUCHAR)&ConfigDescr, sizeof(USB_CONFIGURATION_DESCRIPTOR));//sizeof(USB_CONFIGURATION_DESCRIPTOR));
//Chap9_SetConfiguration();
//config_endpoint();
//printf("\nInterfaceDescr0 ");
//Chap9_BurstTransmitEP0((PUCHAR)&InterfaceDescr, sizeof(USB_INTERFACE_DESCRIPTOR));
//printf("\nHID_TXDesc ");
//Chap9_BurstTransmitEP0( (PUCHAR)&hidDescr , sizeof(USB_HID_DESCRIPTOR));
//printf("\nEP1_TXDesc ");
//Chap9_BurstTransmitEP0((PUCHAR)&EP_Descr, sizeof(USB_ENDPOINT_DESCRIPTOR));
////printf("\nEP1_RXDescr "); Chap9_BurstTransmitEP0((PUCHAR)&EP1_RXDescr, sizeof(USB_ENDPOINT_DESCRIPTOR));
////printf("\nEP2_TXDescr "); Chap9_BurstTransmitEP0((PUCHAR)&EP2_TXDescr, sizeof(USB_ENDPOINT_DESCRIPTOR));
////printf("\nEP2_RXDescr "); Chap9_BurstTransmitEP0((PUCHAR)&EP2_RXDescr, sizeof(USB_ENDPOINT_DESCRIPTOR));
break;
}
case USB_STRING_DESCRIPTOR_TYPE://3
switch(bDescriptorIndex)
{
case STR_INDEX_LANGUAGE:
//printf("\n str1 \n");
Chap9_BurstTransmitEP0((PUCHAR)&strLanguage, sizeof(USB_STRING_LANGUAGE_DESCRIPTOR));
break;
case STR_INDEX_MANUFACTURER:
//printf("\n str2 \n");Chap9_BurstTransmitEP0((PUCHAR)&strManufacturer, sizeof(USB_STRING_MANUFACTURER_DESCRIPTOR));
break;
case STR_INDEX_PRODUCT:
//printf("\n str3 \n");Chap9_BurstTransmitEP0((PUCHAR)&strProduct, sizeof(USB_STRING_PRODUCT_DESCRIPTOR));
break;
case STR_INDEX_SERIALNUMBER:
//printf("\n str4 \n");Chap9_BurstTransmitEP0((PUCHAR)&strSerialNum, sizeof(USB_STRING_SERIALNUMBER_DESCRIPTOR));
break;
case STR_INDEX_CONFIGURATION:
//printf("\n str5 \n");Chap9_BurstTransmitEP0((PUCHAR)&strConfiguration, sizeof(USB_STRING_CONFIGURATION_DESCRIPTOR) );
break;
case STR_INDEX_INTERFACE:
//printf("\n str6 \n");Chap9_BurstTransmitEP0((PUCHAR)&strInterface, sizeof(USB_STRING_INTERFACE_DESCRIPTOR) );
break;
default:
//printf("\n str7 \n");Chap9_StallEP0InControlRead();
break;
}
//Mohamed Maged's code starts
case USB_HID_DESCRIPTOR_TYPE://0x21
{
//printf("entering hid descriptor");
Chap9_BurstTransmitEP0( (PUCHAR)&hidDescr , sizeof(USB_HID_DESCRIPTOR));
//printf("exiting hid descriptor");
break;
}
case USB_Report_DESCRIPTOR_TYPE://0x21
{
printf("sending Report descriptor \n");
Chap9_BurstTransmitEP0( (PUCHAR)&REPORT_DESCRIPTOR , sizeof(REPORT_DESCRIPTOR));
//filling Ep01 buffer to generate an EP01 done interrupt
UCHAR rbuff[4]={0x00,0x0a,0x0b,0x0c};
Hal4D13_WriteEndpoint(EPINDEX4EP01,(PUCHAR)&rbuff,8);
//Hal4D13_WriteEndpoint(EPINDEX4EP01,(PUCHAR)&report1,4);
//printf("exiting report descriptor");
break;
}
case USB_INTERFACE_DESCRIPTOR_TYPE:
{
//printf("entering interface descriptor");
Chap9_BurstTransmitEP0( (PUCHAR)&InterfaceDescr , sizeof(USB_INTERFACE_DESCRIPTOR));
//printf("exiting interface descriptor");
break;
}
case USB_ENDPOINT_DESCRIPTOR_TYPE:
{
//printf("entering EP descriptor");
Chap9_BurstTransmitEP0( (PUCHAR)&EP_Descr , sizeof(USB_ENDPOINT_DESCRIPTOR));
//printf("exiting Ep descriptor");
break;
}
//end
case USB_POWER_DESCRIPTOR_TYPE:
default:
Chap9_StallEP0InControlRead();
break;
}
}
