#include <stdio.h>
#include <string.h>
#include "BasicTyp.h"
#include "common.h"
#include "usb.h"
#include "chap_9.h"
#include "Hal4D13.h"
#include "ISO.H"

// *************************************************************************
// Public Data
// *************************************************************************

extern D13FLAGS bD13flags;
extern USBCHECK_DEVICE_STATES bUSBCheck_Device_State;
extern CONTROL_XFER ControlData;

UCHAR ALTERNATIVE_SETTING = 0;

// *************************************************************************
// USB Device Descriptor
// *************************************************************************

#define NUM_ENDPOINTS	4

#define NUM_INTERFACE	2
#define NUM_ALTINTERFACE	2

#define USB_CLASS_CODE_TEST_CLASS_DEVICE                    0xdc
#define USB_SUBCLASS_CODE_TEST_CLASS_D12                    0xA0
#define USB_PROTOCOL_CODE_TEST_CLASS_D12                    0xB0

#define EP0_TX_FIFO_SIZE   64//16
#define EP0_RX_FIFO_SIZE   64//16
#define EP0_PACKET_SIZE    64//16

#define EP1_TX_FIFO_SIZE   16
#define EP1_RX_FIFO_SIZE   16
#define EP1_PACKET_SIZE    16

#define EP2_TX_FIFO_SIZE   64
#define EP2_RX_FIFO_SIZE   64
#define EP2_PACKET_SIZE    64

//#define CONFIG_DESCRIPTOR_LENGTH    NUM_ALTINTERFACE * sizeof(USB_CONFIGURATION_DESCRIPTOR) + NUM_ALTINTERFACE * sizeof(USB_INTERFACE_DESCRIPTOR) + NUM_ENDPOINTS * sizeof(USB_ENDPOINT_DESCRIPTOR)

//#define CONFIG_DESCRIPTOR_LENGTH    sizeof( USB_CONFIGURATION_DESCRIPTOR)//NUM_ALTINTERFACE * sizeof(USB_CONFIGURATION_DESCRIPTOR) +NUM_ALTINTERFACE * sizeof(USB_INTERFACE_DESCRIPTOR) +4 * NUM_ALTINTERFACE * sizeof(USB_ENDPOINT_DESCRIPTOR) 

#define CONFIG_DESCRIPTOR_LENGTH    0x2e //sizeof( USB_CONFIGURATION_DESCRIPTOR)//NUM_ALTINTERFACE * sizeof(USB_CONFIGURATION_DESCRIPTOR) +NUM_ALTINTERFACE * sizeof(USB_INTERFACE_DESCRIPTOR) +4 * NUM_ALTINTERFACE * sizeof(USB_ENDPOINT_DESCRIPTOR) 

struct DEVICE { BYTE bLength;
		 BYTE bDescriptorType;
		 WORD bcdUSB;
		 BYTE bDeviceClass;
		 BYTE bDeviceSubClass;
		 BYTE bDeviceProtocol;
		 BYTE bMaxPacketSize;
		 WORD idVendor;
		 WORD idProduct;
		 WORD bcdDevice;
		 BYTE iManufacturer;
		 BYTE iProduct;
		 BYTE iSerialNumber;
		 BYTE bNumConfigurations;
	       };

struct CONFIGURATION { BYTE bLength;
		 BYTE bDescriptorType;
		 BYTE wTotalLength;
		 BYTE wZero;
		 BYTE bNumInterfaces;
		 BYTE bConfigurationValue;
		 BYTE iConfiguration;
		 BYTE bmAttributes;
		 BYTE MaxPower;
	       };

struct INTERFACE { BYTE bLength;
		 BYTE bDescriptionType;
		 BYTE bInterfaceNumber;
		 BYTE bAlternateSetting;
		 BYTE bNumEndpoints;
		 BYTE bInterfaceClass;
		 BYTE bInterfaceSubClass;
		 BYTE bInterfaceProtocol;
		 BYTE iInterface;
	       };

struct ENDPOINT { BYTE bLength;
		 BYTE bDescriptorType;
		 BYTE bEndpointAddress;
		 BYTE bmAttributes;
		 WORD wMaxPacketSize;
		 BYTE bInterval;
    	       };

struct HIDDESC {
             BYTE bLength;
             BYTE bDescriptorType;
             WORD bcdHID;
             BYTE bCountryCode;
             BYTE bNumDescriptors;
		 BYTE bReportDescriptorType;
             WORD wItemLength;
             };
 
struct CONFIG { struct CONFIGURATION sConfig;
                struct INTERFACE sInterface;
                struct HIDDESC sHIDDesc;
                struct ENDPOINT sEndpoint1;
              };
//sDevice sConfiguration
//sizeof(struct CONFIGURATION)
//sizeof( struct DEVICE)
struct DEVICE code sDevice= { sizeof( struct DEVICE),//BYTE bLength
                     0x01,  //BYTE bDescriptorType
                     0x0a01,//WORD bcdUSB
                     0xff,  //Byte bDeviceClass
                     0xff,  //BYTE bDeviceSubClass
                     0xff,  //BYTE bDeviceProtocol
                     0x08,  //BYTE bMaxPacketSize of 8
                     0x7104,//WORD idVendor
                     0x0211,//WORD idProduct, For Philips Hub mouse
                     0x0a01,//WORD bcdDevice
                     0x01,  //BYTE iManufacturer
                     0x02,  //BYTE iProduct
                     0x00,  //BYTE iSerialNumber
                     0x01 };//BYTE bNumConfigurations


struct CONFIG code sConfiguration= {sizeof(struct CONFIGURATION), //BYTE bLength
                    0x02, //BYTE bDescriptorType //Assigned by USB
                   sizeof( struct CONFIG), //BYTE wTotalLength
                    0x00, //BYTE wZero, always 00
                    0x01, //BYTE bNumInterfaces
                    0x01, //BYTE bConfigurationValue
                    0x00, //BYTE iConfiguration
                    0x0a0, //BYTE bmAttributes, Bus powered and remote wakeup
                    0x05, //BYTE MaxPower
                   sizeof(struct INTERFACE), //BYTE bLength
                    0x04, //BYTE bDescriptionType, assigned by USB
                    0x00, //BYTE bInterfaceNumber
                    0x00, //BYTE bAlternateSetting
                    0x01, //BYTE bNumEndpoints, uses 1 endpoints
                    0x03, //BYTE bInterfaceClass, HID Class - 0x03
                    0x01, //BYTE bInterfaceSubClass
                    0x01, //BYTE bInterfaceProtocol
                    0x00 ,//BYTE iInterface
			 sizeof(struct HIDDESC),//BYTE bLength;
                    0x21, //BYTE bDescriptorType;
                    0x0001,//WORD bcdHID;
                    0x00,//BYTE bCountryCode;
                    0x01,//BYTE bNumDescriptors;
		        0x22,//BYTE bReportDescriptorType;
                    0x3200,//WORD wItemLength;
                   sizeof(struct ENDPOINT), //BYTE bLength
                    0x05, //BYTE bDescriptorType, assigned by USB
                    0x81, //BYTE bEndpointAddress, IN endpoint, endpoint 1
                    0x03, //BYTE bmAttributes, Interrupt endpoint
                    0x0800, //WORD wMaxPacketSize
                    0x0A, //Polling Time

                    }; //Interval

unsigned char code REPORT_DESCRIPTOR[50] = {0x05,
                         	0x01,
					0x09,
	                        0x02,
					0xA1,
					0x01,
					0x09,
					0x01,

					0xA1,
					0x00,
					0x05,
					0x09,
					0x19,
					0x01,
					0x29,
					0x03,

					0x15,
					0x00,
					0x25,7
					0x01,
					0x95,
					0x03,
					0x75,
					0x01,

					0x81,
					0x02,
					0x95,
					0x01,
					0x75,
					0x05,
					0x81,
					0x01,

					0x05,
					0x01,
					0x09,
					0x30,
					0x09,
					0x31,
					0x15,
					0x81,

					0x25,
					0x7F,
					0x75,
					0x08,
					0x95,
					0x02,
					0x81,
					0x06,

					0xC0,
					0xC0,
      };

unsigned char code LANG_ID[4] = {0x04,  //4 bytes
				 0x03,  //bDescriptorType = String Desc
				 0x09,  //Lang ID for English = 0x0409
				 0x04,};



USB_STRING_INTERFACE_DESCRIPTOR  strInterface =
{
	sizeof(USB_STRING_INTERFACE_DESCRIPTOR),
	USB_STRING_DESCRIPTOR_TYPE,
	{'I',0,'n',0,'t',0,'e',0,'r',0,'f',0,'a',0,'c',0,'e',0,'0',0,'0',0}
};

USB_STRING_CONFIGURATION_DESCRIPTOR  strConfiguration =
{
	sizeof(USB_STRING_CONFIGURATION_DESCRIPTOR),
	USB_STRING_DESCRIPTOR_TYPE,
	{
	'C',0,
	'o',0,
	'n',0,
	'f',0,
	'i',0,
	'g',0,
	'0',0,
	'0',0
    }
};

USB_STRING_SERIALNUMBER_DESCRIPTOR  strSerialNum =
{
	sizeof(strSerialNum),
	USB_STRING_DESCRIPTOR_TYPE,
   {
	'0',0,
	'0',0,
	'0',0,
	'0',0,

	'0',0,
	'0',0,
	'0',0,
	'0',0,

	'0',0,
	'0',0,
	'0',0,
	'0',0
   }
};
USB_STRING_PRODUCT_DESCRIPTOR  strProduct =
{
	sizeof(USB_STRING_PRODUCT_DESCRIPTOR),
	USB_STRING_DESCRIPTOR_TYPE,
	{
	'P', 0,
	'H', 0,
	'I', 0,
	'L', 0,
	'I', 0,
	'P', 0,
	'S', 0,
	' ', 0,
	'I', 0,
	'S', 0,
	'P', 0,
	'1', 0,
	'1', 0,
	'8', 0,
	'1', 0,
	' ', 0,
	'T', 0,
	'e', 0,
	's', 0,
	't', 0,
	' ', 0,
	' ', 0,
	' ', 0
	}
};

USB_STRING_MANUFACTURER_DESCRIPTOR  strManufacturer =
{
	sizeof(USB_STRING_MANUFACTURER_DESCRIPTOR),
	USB_STRING_DESCRIPTOR_TYPE,
	{
	'P', 0,
	'H', 0,
	'I', 0,
	'L', 0,
	'I', 0,
	'P', 0,
	'S', 0,
	' ', 0,
	'S', 0,
	'e', 0,
	'm', 0,
	'i', 0,
	'c', 0,
	'o', 0,
	'n', 0,
	'd', 0,
	'u', 0,
	'c', 0,
	't', 0,
	'o', 0,
	'r', 0,
	's', 0,
	' ', 0,
	'A', 0,
	'P', 0,
	'I', 0,
	'C', 0}
};

// *************************************************************************
// USB Protocol Layer
// ************************************************************************



// *************************************************************************
// USB standard device requests
// *************************************************************************

void Chap9_GetStatus(void)
{
	UCHAR   endp, txdat[2];
	UCHAR   c;
	UCHAR   bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;


	if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
	{
	switch(bRecipient)
			{
			case USB_RECIPIENT_DEVICE:
					if(bD13flags.bits.remote_wakeup == 1)
						txdat[0] = DEVSTS_SELFPOWERED|DEVSTS_REMOTEWAKEUP;   /* remote wakeup and Self-powered */
					else
						txdat[0] = DEVSTS_SELFPOWERED;   /* Self-powered*/
					txdat[1]=0;

					Chap9_SingleTransmitEP0(txdat, 2);
					break;

			case USB_RECIPIENT_INTERFACE:

					Chap9_StallEP0InControlRead();
					break;

			case USB_RECIPIENT_ENDPOINT:

					if( ControlData.DeviceRequest.wIndex == 0x00 )
					{
						endp = -1;
						c = Hal4D13_GetEndpointStatusWOInteruptClear(endp + 1);
						if(c & D13REG_EPSTS_STALL)
							txdat[0] = ENDPSTS_HALT;   /* Halt */
						else
							txdat[0] = 0;

						txdat[1] = 0;

						Chap9_SingleTransmitEP0(txdat, 2);
					}
					else
						Chap9_StallEP0InControlRead();

					break;

			default:
					Chap9_StallEP0InControlRead();
					break;
			}
	}


	else
	{
		if(ControlData.DeviceRequest.wValue == 0 && ControlData.DeviceRequest.wLength == 2 )
		{
			switch(bRecipient)
			{
			case USB_RECIPIENT_DEVICE:
					if(bD13flags.bits.remote_wakeup == 1)
						txdat[0] = DEVSTS_SELFPOWERED|DEVSTS_REMOTEWAKEUP;   /* remote wakeup and Self-powered */
					else
						txdat[0] = DEVSTS_SELFPOWERED;   /* Self-powered*/
					txdat[1]=0;

					Chap9_SingleTransmitEP0(txdat, 2);
					break;

			case USB_RECIPIENT_INTERFACE:
					txdat[0]=0;
					txdat[1]=0;

					Chap9_SingleTransmitEP0(txdat, 2);
					break;

			case USB_RECIPIENT_ENDPOINT:

					if( ControlData.DeviceRequest.wIndex == 0x00 )
						endp = -1;
					else
						endp = (UCHAR)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);

					c = Hal4D13_GetEndpointStatusWOInteruptClear(endp + 1);
					if(c & D13REG_EPSTS_STALL)
						txdat[0] = ENDPSTS_HALT;   /* Halt */
					else
						txdat[0] = 0;

					txdat[1] = 0;

					Chap9_SingleTransmitEP0(txdat, 2);
					break;

			default:
					Chap9_StallEP0InControlRead();
					break;
			}
		}
	}

}

void Chap9_ClearFeature(void)
{
	UCHAR   endp;
	UCHAR   bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;
	USHORT  wFeature = ControlData.DeviceRequest.wValue;

	if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
	{
		if( ControlData.DeviceRequest.wLength == 0 )
		{
			switch(bRecipient)
			{
			case USB_RECIPIENT_DEVICE:
						if(wFeature == USB_FEATURE_REMOTE_WAKEUP)
						{
						bD13flags.bits.remote_wakeup = 0;
						Chap9_SingleTransmitEP0(0, 0);
						}
						else
							Chap9_StallEP0InControlWrite();

						break;



			case USB_RECIPIENT_ENDPOINT:

						if(wFeature == USB_FEATURE_ENDPOINT_STALL)
						{
							if( ControlData.DeviceRequest.wIndex == 0x00 )
							{
								endp = 0;
								Hal4D13_SetEndpointStatus(endp, 0);

								Chap9_SingleTransmitEP0(0, 0);
							}
							else
							{
								Chap9_StallEP0InControlWrite();
								break;
							}

						}

						else
							Chap9_StallEP0InControlWrite();

						break;


			default:
						Chap9_StallEP0InControlWrite();
						break;
			}
	  }
	}

	else
	{

		if( ControlData.DeviceRequest.wLength == 0 )
		{
			switch(bRecipient)
			{
			case USB_RECIPIENT_DEVICE:
				if(wFeature == USB_FEATURE_REMOTE_WAKEUP)
				{
					bD13flags.bits.remote_wakeup = 0;
					Chap9_SingleTransmitEP0(0, 0);
				}
				else
				{
					Chap9_StallEP0InControlWrite();
				}

				break;

				case USB_RECIPIENT_ENDPOINT:

				if(wFeature == USB_FEATURE_ENDPOINT_STALL)
				{
					if( ControlData.DeviceRequest.wIndex == 0x00 )
							endp = -1;
					else
						endp = (UCHAR)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);

					Hal4D13_SetEndpointStatus(endp+1, 0);
					Hal4D13_SetEndpointStatus(endp+1, 0);

					Chap9_SingleTransmitEP0(0, 0);
				}
				else
				{
					Chap9_StallEP0InControlWrite();
				}
				break;

			default:
					Chap9_StallEP0InControlWrite();
					break;
			}
	  }
	}

}

void Chap9_SetFeature(void)
{
  UCHAR   endp = 0;
	UCHAR   bRecipient = ControlData.DeviceRequest.bmRequestType & USB_RECIPIENT;
	USHORT  wFeature = ControlData.DeviceRequest.wValue;
  

	if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
	{
		switch(bRecipient)
		{
		case USB_RECIPIENT_DEVICE:
			if(wFeature == USB_FEATURE_REMOTE_WAKEUP)
			{
				bD13flags.bits.remote_wakeup = 1;
				Chap9_SingleTransmitEP0(0, 0);
			}
			else
			{
				Chap9_StallEP0InControlWrite();
			}
			break;

		case USB_RECIPIENT_ENDPOINT:
			if( wFeature == USB_FEATURE_ENDPOINT_STALL)
			{
				if( ControlData.DeviceRequest.wIndex == 0x00 )
					endp = -1;

				Hal4D13_SetEndpointStatus(endp+1, D13REG_EPSTS_STALL);
				Chap9_SingleTransmitEP0(0, 0);

			}
			else
				Chap9_StallEP0InControlWrite();

			break;
		default:
			Chap9_StallEP0InControlWrite();
			break;
		}
	}


	else
	{
		if( ControlData.DeviceRequest.wLength == 0 )
		{
			switch(bRecipient)
			{
			case USB_RECIPIENT_DEVICE:
				if(wFeature == USB_FEATURE_REMOTE_WAKEUP)
				{
					bD13flags.bits.remote_wakeup = 1;
					Chap9_SingleTransmitEP0(0, 0);
				}
				else
				{
					Chap9_StallEP0InControlWrite();
				}
				break;
			case USB_RECIPIENT_ENDPOINT:
				if( wFeature == USB_FEATURE_ENDPOINT_STALL)
				{
					if( ControlData.DeviceRequest.wIndex == 0x00 )
						endp = -1;
					else
						endp = (UCHAR)(ControlData.DeviceRequest.wIndex & MAX_ENDPOINTS);

					Hal4D13_SetEndpointStatus(endp+1, D13REG_EPSTS_STALL);

					Chap9_SingleTransmitEP0(0, 0);

				}
				else
				{
					Hal4D13_SetEndpointStatus(endp+1, 0);
					Chap9_SingleTransmitEP0(0, 0);
				}
				break;
			default:
				Chap9_StallEP0InControlWrite();
				break;
			}
		}
	}



}

void Chap9_SetAddress(void)
{

	UCHAR   j;

	{
		RaiseIRQL();
		disable();
		if(!ControlData.Abort)
		{
			if(bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE)
			{
				if((ControlData.DeviceRequest.wValue & DEVICE_ADDRESS_MASK) != 0 )
				{
					bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE = 0;
					Hal4D13_SetAddressEnable((UCHAR)(ControlData.DeviceRequest.wValue &
											DEVICE_ADDRESS_MASK), 1);
					bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 1;
					Chap9_SingleTransmitEP0(0, 0);

				}

				else
					bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE = 1;
			}

			else if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
			{
				if((ControlData.DeviceRequest.wValue & DEVICE_ADDRESS_MASK) == 0 )
				{
					Hal4D13_SetAddressEnable((UCHAR)(ControlData.DeviceRequest.wValue &
											DEVICE_ADDRESS_MASK), 1);
					bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE = 1;
					bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 0;
					Chap9_SingleTransmitEP0(0, 0);

				}

				else
				{
					bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE = 0;
					Hal4D13_SetAddressEnable((UCHAR)(ControlData.DeviceRequest.wValue &
											DEVICE_ADDRESS_MASK), 1);
					bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 1;
					Chap9_SingleTransmitEP0(0, 0);

				}

			}

			else
			{

				bUSBCheck_Device_State.State_bits.DEVICE_CONFIGURATION_STATE = 0;
				bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 0;
				bUSBCheck_Device_State.State_bits.DEVICE_DEFAULT_STATE = 1;
				j = DEV_BEHAVIOUR_NOT_SPECIFIED;
				Chap9_SingleTransmitEP0(&j, 0);
			}

		}
		LowerIRQL();
		enable();

	}
  printf("Hal4D13_GetAddress %04x\n",Hal4D13_GetAddress());
}


void Chap9_GetDescriptor(void)
{
	UCHAR   bDescriptor =      MSB(ControlData.DeviceRequest.wValue);
	UCHAR   bDescriptorIndex = LSB(ControlData.DeviceRequest.wValue);
  printf("bDescriptor %d\n",bDescriptor);
  printf("bDescriptorIndex %d\n",bDescriptorIndex);
  printf("size %d\n",sizeof(struct CONFIGURATION));
  printf("sizeof(USB_DEVICE_DESCRIPTOR) %d\n",sizeof( struct DEVICE));
	switch(bDescriptor)
	{
	//sDevice sConfiguration
	//sizeof(struct CONFIGURATION)
//sizeof( struct DEVICE)

	case USB_DEVICE_DESCRIPTOR_TYPE:{//1
	//	Chap9_BurstTransmitEP0( sDevice , sizeof(USB_DEVICE_DESCRIPTOR));
	    Chap9_BurstTransmitEP0( &sDevice,sizeof( struct DEVICE));
		break;}
	case USB_CONFIGURATION_DESCRIPTOR_TYPE:{//2
//		Chap9_BurstTransmitEP0((PUCHAR)&ConfigDescr, CONFIG_DESCRIPTOR_LENGTH);
   
		    printf("\nConfigDescr     \n");    Chap9_BurstTransmitEP0(&sConfiguration, sizeof(struct CONFIGURATION));//sizeof(USB_CONFIGURATION_DESCRIPTOR));
   //       printf("\nInterfaceDescr0  ");    Chap9_BurstTransmitEP0((PUCHAR)&InterfaceDescr0, sizeof(USB_INTERFACE_DESCRIPTOR));
//          printf("\nEP1_TXDesc       ");     Chap9_BurstTransmitEP0((PUCHAR)&EP1_TXDescr, 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)&ConfigDescr, sizeof(CONFIG_DESCRIPTOR_LENGTH));
			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;
		}
	case USB_INTERFACE_DESCRIPTOR_TYPE:
	case USB_ENDPOINT_DESCRIPTOR_TYPE:
	case USB_POWER_DESCRIPTOR_TYPE:
	default:
		Chap9_StallEP0InControlRead();
		break;
	}
}

void Chap9_GetConfiguration(void)
{
	UCHAR   c = bD13flags.bits.configuration;
	UCHAR   j;

	if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
	{
		j = 0;
		Chap9_SingleTransmitEP0(&j, 1);
	}

	else
	{
		if (ControlData.DeviceRequest.wValue == 0 && ControlData.DeviceRequest.wIndex == 0 && ControlData.DeviceRequest.wLength == 1)
		{

		Chap9_SingleTransmitEP0(&c, 1);
		}
	}

}

void Chap9_SetConfiguration(void)
{
  
	if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
	{
		if(ControlData.DeviceRequest.wIndex == 0 && ControlData.DeviceRequest.wLength == 0)
		{
			if (ControlData.DeviceRequest.wValue == 0)
			{
				/* put device in unconfigured state */
				bD13flags.bits.configuration = 0;
				bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 1;
				Chap9_SingleTransmitEP0(0, 0);
			}
			else if (ControlData.DeviceRequest.wValue == 1)
			{
				/* Configure device */
				bD13flags.bits.configuration = 1;
				bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 0;
				bUSBCheck_Device_State.State_bits.DEVICE_CONFIGURATION_STATE = 1;
				Chap9_SingleTransmitEP0(0, 0);
			}

			else
				Chap9_StallEP0InControlWrite();
		}
	}

	else
	{
		if (ControlData.DeviceRequest.wValue == 0)
		{
			/* put device in unconfigured state */
			bD13flags.bits.configuration = 0;
			bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 1;
			bUSBCheck_Device_State.State_bits.DEVICE_CONFIGURATION_STATE = 0;
			Chap9_SingleTransmitEP0(0, 0);

		}

		else if (ControlData.DeviceRequest.wValue == 1)
		{
			/* Configure device */
			bD13flags.bits.configuration = 1;
			bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE = 0;
			bUSBCheck_Device_State.State_bits.DEVICE_CONFIGURATION_STATE = 1;
			Chap9_SingleTransmitEP0(0, 0);
		}
		else
			Chap9_StallEP0InControlWrite();
	}

}

void Chap9_GetInterface(void)
{

	if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
		Chap9_StallEP0InControlRead();


	else
	{

		if ((ControlData.DeviceRequest.wValue == 0 && ControlData.DeviceRequest.wIndex == 0 && ControlData.DeviceRequest.wLength == 1))
			Chap9_SingleTransmitEP0(&ALTERNATIVE_SETTING, 1);      //txdat
		else
			Chap9_StallEP0InControlRead();
	}

}

void Chap9_SetInterface(void)
{
	UCHAR   dir = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_DIR_MASK;

	if(dir)
		Chap9_StallEP0InControlRead();


	if(bUSBCheck_Device_State.State_bits.DEVICE_ADDRESS_STATE)
		Chap9_StallEP0InControlRead();



	else
	{

		if (ControlData.DeviceRequest.wValue == 0 && ControlData.DeviceRequest.wIndex == 0)
		{
			ALTERNATIVE_SETTING = 0;
			Chap9_SingleTransmitEP0(0,0);
		}

		else if (ControlData.DeviceRequest.wValue == 1 && ControlData.DeviceRequest.wIndex == 0)
		{
			ALTERNATIVE_SETTING = 1;
			Chap9_SingleTransmitEP0(0,0);
		}
		else
		{
			Chap9_StallEP0InControlWrite();
		}
	}

}

// *************************************************************************
// Chap9 support functions
// *************************************************************************

void Chap9_StallEP0(void)
{
	UCHAR dir;
	dir = ControlData.DeviceRequest.bmRequestType & USB_REQUEST_DIR_MASK;
	if(dir)
	{
		Hal4D13_StallEP0InControlRead();
	}
	else
	{
		Hal4D13_StallEP0InControlWrite();
	}

	RaiseIRQL();
	if(!ControlData.Abort)
	{
		bD13flags.bits.DCP_state = USBFSM4DCP_STALL;

	}
	LowerIRQL();
}
void Chap9_StallEP0InControlWrite(void)
{
	Hal4D13_StallEP0InControlWrite();

	RaiseIRQL();
	if(!ControlData.Abort)
	{
		bD13flags.bits.DCP_state = USBFSM4DCP_STALL;

	}
	LowerIRQL();
}

void Chap9_StallEP0InControlRead(void)
{
	Hal4D13_StallEP0InControlRead();
	RaiseIRQL();
	if(!ControlData.Abort)
	{
		bD13flags.bits.DCP_state = USBFSM4DCP_STALL;

	}
	LowerIRQL();
}

void Chap9_SingleTransmitEP0(PUCHAR buf, USHORT len)
{

	Hal4D13_SingleTransmitEP0(buf, len);

	RaiseIRQL();
	if(!ControlData.Abort)
	{
		ControlData.wLength = ControlData.wCount = len;
		bD13flags.bits.DCP_state = USBFSM4DCP_HANDSHAKE;

	}
	LowerIRQL();
}

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();
		}
}