BOOL ValidateAndDisplayDeviceFwVersion ( void )
{
if ( USBHostGenericGetRxLength(deviceAddress) == 4 &&
DataPacket.CMD == READ_VERSION &&
DataPacket._byte[3] >= DEMO_FW_MAJOR_VERSION )
{
// Display Device FW version on LCD
LcdData[0][13] = '0' + DataPacket._byte[3];
LcdData[0][15] = '0' + DataPacket._byte[4];
LCDWriteLine(1, (char *)&LcdData[0][0] );
// Display device FW version on terminal
UART2PrintString( "Device firmware version " );
UART2PutDec( DataPacket._byte[3] );
UART2PrintString( "." );
UART2PutDec( DataPacket._byte[4] );
UART2PrintString( "\r\n" );
return TRUE;
}
else
{
UART2PrintString( "Device Firmware Version Error!\r\n" );
LCDWriteLine( 2, "Dev FW Ver Error" );
return FALSE;
}
} // ValidateAndDisplayDeviceFwVersion
BOOL USBHostChargerEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size )
{
// Make sure the event is for a connected device
if (!_USBHostCharger_FindDevice( address ))
{
return FALSE;
}
// Handle specific events.
switch (event)
{
case EVENT_DETACH:
// Notify that application that the device has been detached.
USB_HOST_APP_EVENT_HANDLER(usbChargingDevices[currentChargingRecord].ID.deviceAddress, EVENT_CHARGER_DETACH, &usbChargingDevices[currentChargingRecord].ID.deviceAddress, sizeof(BYTE) );
usbChargingDevices[currentChargingRecord].flags.val = 0;
usbChargingDevices[currentChargingRecord].ID.deviceAddress = 0;
#ifdef DEBUG_MODE
UART2PrintString( "USB Charging Client Device Detached: address=" );
UART2PutDec( address );
UART2PrintString( "\r\n" );
#endif
return TRUE;
break;
case EVENT_SUSPEND:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
default:
break;
}
return FALSE;
} // USBHostChargerEventHandler
BOOL CheckForNewAttach ( void )
{
// Try to get the device address, if we don't have one.
if (deviceAddress == 0)
{
GENERIC_DEVICE_ID DevID;
/*DevID.vid = 0x046D;
DevID.pid = 0xC526;*/
DevID.vid = gc_DevData.ID.vid;
DevID.pid = gc_DevData.ID.pid;
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
DevID.serialNumberLength = 0;
DevID.serialNumber = NULL;
#endif
if (USBHostGenericGetDeviceAddress(&DevID))
{
deviceAddress = DevID.deviceAddress;
UART2PrintString( "Generic demo device attached - polled, deviceAddress=" );
UART2PutDec( deviceAddress );
UART2PrintString( "\r\n" );
UART2PrintString( "VID=" );
UART2PutHexWord(DevID.vid);
UART2PrintString( "\r\n" );
UART2PrintString( "PID=" );
UART2PutHexWord(DevID.pid);
UART2PrintString( "\r\n" );
return TRUE;
}
}
return FALSE;
} // CheckForNewAttach
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
static int aaa = 0;
static long data_cnt = 0;
static long data_cnt_bak = 0;
static long jpeg_cnt = 0;
static long jpeg_size = 0;
static long jpeg_size_bak = 0;
static long jpeg_ptr = 0;
static long jpeg_start = 0;
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
BYTE i;
#endif
int j;
// Handle specific events.
switch ( (INT)event )
{
case EVENT_TRANSFER: // A USB transfer has completed
case EVENT_DATA_ISOC_READ:
for(j = 0;j < size-1;j++){
if(((BYTE*)data)[j] == 0xFF){
if(((BYTE*)data)[j+1] == 0xD8){
if(((BYTE*)data)[j+2] == 0xFF){
if(((BYTE*)data)[j+3] == 0xE0){
jpeg_size = data_cnt -jpeg_size_bak;
jpeg_size_bak = data_cnt;
/*UART2PrintString( "JPEG-SIZE=" );
UART2PutDec((jpeg_size/100000) % 10);
UART2PutDec((jpeg_size/10000) % 10);
UART2PutDec((jpeg_size/1000) % 10);
UART2PutDec((jpeg_size/100) % 10);
UART2PutDec((jpeg_size/10) % 10);
UART2PutDec(jpeg_size % 10);
UART2PrintString( "JPEG-CNT=" );
UART2PutDec((jpeg_cnt/1000) % 10);
UART2PutDec((jpeg_cnt/100) % 10);
UART2PutDec((jpeg_cnt/10) % 10);
UART2PutDec(jpeg_cnt % 10);
UART2PrintString( "\r\n" );*/
if(jpeg_cnt == 1){
UART2PrintString( "JPEG-SIZE=" );
UART2PutDec((jpeg_ptr/100000) % 10);
UART2PutDec((jpeg_ptr/10000) % 10);
UART2PutDec((jpeg_ptr/1000) % 10);
UART2PutDec((jpeg_ptr/100) % 10);
UART2PutDec((jpeg_ptr/10) % 10);
UART2PutDec(jpeg_ptr % 10);
UART2PrintString( "\r\n" );
packet_dump(jpeg,jpeg_ptr);
}
jpeg_cnt++;
jpeg_start = j;
//packet_dump((data + j),4);
}
}
}
}
}
if((size != 0x0C) && jpeg_cnt == 1){
int i;
for(i = 0x0C;i < size;i++){
if(jpeg_ptr == 0){
UART2PrintString( "jpeg_start=" );
i = jpeg_start;
UART2PutDec(jpeg_cnt % 10);
UART2PrintString( "\r\n" );
}
jpeg[jpeg_ptr++] = ((BYTE*)data)[i];
}
}
if(size != 0x0C){
/*if(aaa >= 0 && aaa <= 0){
UART2PrintString( "DATA=" );
packet_dump(data,size);
UART2PrintString( "\r\n ");
aaa++;
}*/
}
data_cnt += size;
/*if(data_cnt > data_cnt_bak + 1024 * 10){
//data_cnt = 1024 * 100;
UART2PrintString( "a" );
UART2PutDec((data_cnt/1000000) % 10);
UART2PutDec((data_cnt/100000) % 10);
UART2PutDec((data_cnt/10000) % 10);
UART2PutDec((data_cnt/1000) % 10);
UART2PutDec((data_cnt/100) % 10);
UART2PutDec((data_cnt/10) % 10);
UART2PutDec(data_cnt % 10);
UART2PrintString( "\r\n" );
data_cnt_bak = data_cnt;
}*/
return TRUE;
break;
UART2PrintString( "a" );
case EVENT_GENERIC_ATTACH:
return TRUE;
break;
case EVENT_GENERIC_DETACH:
deviceAddress = 0;
DemoState = DEMO_INITIALIZE;
UART2PrintString( "Generic demo device detached - event\r\n" );
return TRUE;
case EVENT_GENERIC_TX_DONE: // The main state machine will poll the driver.
case EVENT_GENERIC_RX_DONE:
return TRUE;
case EVENT_VBUS_REQUEST_POWER:
// We'll let anything attach.
return TRUE;
case EVENT_VBUS_RELEASE_POWER:
// We aren't keeping track of power.
return TRUE;
case EVENT_HUB_ATTACH:
UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
return TRUE;
break;
case EVENT_UNSUPPORTED_DEVICE:
UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
return TRUE;
break;
case EVENT_CANNOT_ENUMERATE:
UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
return TRUE;
break;
case EVENT_CLIENT_INIT_ERROR:
UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
return TRUE;
break;
case EVENT_OUT_OF_MEMORY:
UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
return TRUE;
break;
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
return TRUE;
break;
case EVENT_SUSPEND:
case EVENT_DETACH:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
UART2PrintString( "a" );
return TRUE;
break;
default:
break;
}
return FALSE;
}
void ManageDemoState ( void )
{
int j;
DWORD byteCount;
BYTE errorCode;
BYTE RetVal;
//接続されていなかったら初期化
if (USBHostGenericDeviceDetached(deviceAddress) && deviceAddress != 0)
{
long i;
for(i = 0;i < sizeof(jpeg);i++){
jpeg[i] = 0;
}
UART2PrintString( "Generic demo device detached - polled\r\n" );
DemoState = DEMO_INITIALIZE;
deviceAddress = 0;
}
switch (DemoState)
{
case DEMO_INITIALIZE:
DemoState = DEMO_STATE_IDLE;
break;
case DEMO_STATE_IDLE:
//接続されたら、読み出し処理に移行
if (CheckForNewAttach())
{
DemoState = DEMO_STATE_GET_INFO;
UART2PrintString( "USB_Ver=" );
UART2PutDec(((USB_DEVICE_DESCRIPTOR *)pDeviceDescriptor)->bcdUSB >> 8);
UART2PrintString( "-" );
UART2PutDec(((USB_DEVICE_DESCRIPTOR *)pDeviceDescriptor)->bcdUSB);
UART2PrintString( "\r\n" );
}
break;
case DEMO_STATE_GET_INFO:
if(control(GET_INFO, VS_PROBE_CONTROL, 1, param, 1) == USB_SUCCESS){
UART2PrintString( "GET_INFO, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_INFO;
}
break;
case DEMO_STATE_WAIT_GET_INFO:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_INFO, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(param,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_DEF;
}
break;
case DEMO_STATE_GET_DEF:
if(control(GET_DEF, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_DEF, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_DEF;
}
break;
case DEMO_STATE_WAIT_GET_DEF:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_DEF, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_MIN;
}
break;
case DEMO_STATE_GET_MIN:
if(control(GET_MIN, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_MIN, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_MIN;
}
break;
case DEMO_STATE_WAIT_GET_MIN:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_MIN, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_MAX;
}
break;
case DEMO_STATE_GET_MAX:
if(control(GET_MAX, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_MAX, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_MAX;
}
break;
case DEMO_STATE_WAIT_GET_MAX:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_MAX, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_CUR;
}
break;
case DEMO_STATE_GET_CUR:
if(control(GET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_CUR, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_CUR;
}
break;
case DEMO_STATE_WAIT_GET_CUR:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_CUR, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_SET_CUR ;
}
break;
case DEMO_STATE_SET_CUR:
for(j = 0;j < param_len;j++){
temp[j] = 0;
}
temp[2] = 2;//フォーマットインデックス
temp[3] = 1;//フレームインデックス
/*temp[4] = 0x80;
temp[5] = 0x84;
temp[6] = 0x1E;
temp[7] = 0x00;*/
temp[4] = 0x15;//30Hz
temp[5] = 0x16;
temp[6] = 0x05;
temp[7] = 0x00;
if(control(SET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "SET_CUR, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_SET_CUR;
}
break;
case DEMO_STATE_WAIT_SET_CUR:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=SET_CUR, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_GET_CUR2 ;
}
break;
case DEMO_STATE_GET_CUR2:
if(control(GET_CUR, VS_PROBE_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_CUR2, VS_PROBE_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_CUR2;
}
break;
case DEMO_STATE_WAIT_GET_CUR2:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_CUR2, VS_PROBE_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_GET_INFO2 ;
}
break;
case DEMO_STATE_GET_INFO2:
if(control(GET_INFO, VS_COMMIT_CONTROL, 1, param, 1) == USB_SUCCESS){
UART2PrintString( "GET_INFO, VS_COMMIT_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_INFO2;
}
break;
case DEMO_STATE_WAIT_GET_INFO2:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_INFO, VS_COMMIT_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(param,byteCount);
UART2PrintString( "\r\n" );
DemoState = DEMO_STATE_GET_CUR3;
}
break;
case DEMO_STATE_GET_CUR3:
if(control(GET_CUR, VS_COMMIT_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "GET_CUR2, VS_COMMIT_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_GET_CUR3;
}
break;
case DEMO_STATE_WAIT_GET_CUR3:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=GET_CUR2, VS_COMMIT_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_SET_CUR2 ;
}
break;
case DEMO_STATE_SET_CUR2:
for(j = 0;j < param_len;j++){
temp[j] = 0;
}
temp[2] = 2;
temp[3] = 0x01;//640x480 30Hz
//temp[3] = 0x02;//160x120 30Hz
//temp[3] = 0x0C;//800x600
temp[4] = 0x80;//5Hz
temp[5] = 0x84;
temp[6] = 0x1E;
temp[7] = 0x00;
/*temp[4] = 0x15;//30Hz
temp[5] = 0x16;
temp[6] = 0x05;
temp[7] = 0x00;*/
if(control(SET_CUR, VS_COMMIT_CONTROL, 1, temp, param_len) == USB_SUCCESS){
UART2PrintString( "SET_CUR, VS_COMMIT_CONTROL\r\n" );
DemoState = DEMO_STATE_WAIT_SET_CUR2;
}
break;
case DEMO_STATE_WAIT_SET_CUR2:
if (USBHostTransferIsComplete( deviceAddress, 0, &errorCode, &byteCount )){
UART2PrintString( "OK=SET_CUR, VS_COMMIT_CONTROL\r\n" );
UART2PrintString( "Byte Count=" );
UART2PutDec(byteCount);
UART2PrintString( "\r\n" );
packet_dump(temp,byteCount);
UART2PrintString( "\r\n" );
DemoState =DEMO_STATE_SET_ISOCHRONOUS ;
}
break;
case DEMO_STATE_SET_ISOCHRONOUS:
if(USBHostIssueDeviceRequest( deviceAddress, 0x01, USB_REQUEST_SET_INTERFACE,
0x06/*Alternate Setting:0x1*/, 0x01/*interface:0x03*/, 0, NULL, USB_DEVICE_REQUEST_SET,
0x00 )== USB_SUCCESS){
UART2PrintString( "USB_REQUEST_SET_INTERFACE=OK!\r\n" );
DemoState =DEMO_STATE_WAIT_SET_ISOCHRONOUS ;
}
break;
case DEMO_STATE_WAIT_SET_ISOCHRONOUS:
if(USBHostReadIsochronous(deviceAddress,0x81,&isocData) == USB_SUCCESS){
//UART2PrintString( "USBHostReadIsochronous=OK!\r\n" );
DemoState = DEMO_STATE_ERROR;
}
break;
case DEMO_STATE_ERROR:
break;
default:
DemoState = DEMO_INITIALIZE;
break;
}
//DelayMs(1); // 1ms delay
} // ManageDemoState
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
BYTE i;
#endif
// Handle specific events.
switch ( (INT)event )
{
case EVENT_GENERIC_ATTACH:
if (size == sizeof(GENERIC_DEVICE_ID))
{
deviceAddress = ((GENERIC_DEVICE_ID *)data)->deviceAddress;
DemoState = DEMO_STATE_GET_DEV_VERSION;
UART2PrintString( "Generic demo device attached - event, deviceAddress=" );
UART2PutDec( deviceAddress );
UART2PrintString( "\r\n" );
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
for (i=1; i<((GENERIC_DEVICE_ID *)data)->serialNumberLength; i++)
{
UART2PutChar( ((GENERIC_DEVICE_ID *)data)->serialNumber[i] );
}
#endif
UART2PrintString( "\r\n" );
return TRUE;
}
break;
case EVENT_GENERIC_DETACH:
deviceAddress = 0;
DemoState = DEMO_INITIALIZE;
UART2PrintString( "Generic demo device detached - event\r\n" );
return TRUE;
case EVENT_GENERIC_TX_DONE: // The main state machine will poll the driver.
case EVENT_GENERIC_RX_DONE:
return TRUE;
case EVENT_VBUS_REQUEST_POWER:
// We'll let anything attach.
return TRUE;
case EVENT_VBUS_RELEASE_POWER:
// We aren't keeping track of power.
return TRUE;
case EVENT_HUB_ATTACH:
UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
return TRUE;
break;
case EVENT_UNSUPPORTED_DEVICE:
UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
return TRUE;
break;
case EVENT_CANNOT_ENUMERATE:
UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
return TRUE;
break;
case EVENT_CLIENT_INIT_ERROR:
UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
return TRUE;
break;
case EVENT_OUT_OF_MEMORY:
UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
return TRUE;
break;
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
return TRUE;
break;
case EVENT_SUSPEND:
case EVENT_DETACH:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
return TRUE;
break;
default:
break;
}
return FALSE;
} // USB_ApplicationEventHandler
BOOL USB_ApplicationEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
BYTE i;
#endif
#ifdef DEBUG_MODE
int data_num;
#endif
// Handle specific events.
switch (event)
{
case EVENT_GENERIC_ATTACH:
if (size == sizeof(GENERIC_DEVICE_ID))
{
deviceAddress = ((GENERIC_DEVICE_ID *)data)->deviceAddress;
UART2PrintString( "Generic demo device attached - event, deviceAddress=" );
UART2PutDec( deviceAddress );
UART2PrintString( "\r\n" );
#ifdef USB_GENERIC_SUPPORT_SERIAL_NUMBERS
for (i=1; i<((GENERIC_DEVICE_ID *)data)->serialNumberLength; i++)
{
UART2PutChar( ((GENERIC_DEVICE_ID *)data)->serialNumber[i] );
}
#endif
UART2PrintString( "\r\n" );
btClientData.Initialized = TRUE;
btClientData.State = BT_INITIALIZE;
return TRUE;
}
break;
case EVENT_GENERIC_DETACH:
deviceAddress = 0;
UART2PrintString( "Generic demo device detached - event\r\n" );
return TRUE;
case EVENT_GENERIC_TX2_DONE: // The main state machine will poll the driver.
// UART2PrintString( "TX2_DONE\r\n" );
return TRUE;
case EVENT_GENERIC_RX2_DONE:
if(*(DWORD*)data != 0)
{
#ifdef DEBUG_MODE
UART2PrintString( "HCI:R2: " );
for(data_num=0;data_num<*(DWORD*)data;data_num++)
{UART2PutHex(buf2[data_num]);UART2PutChar(' ');}
UART2PrintString( "\r\n" );
#endif
phybusif_input_acl(cb,buf2,*(DWORD*)data);
}
btClientData.State = BT_STATE_IDLE;
return TRUE;
case EVENT_GENERIC_RX1_DONE:
if(*(DWORD*)data != 0)
{
#ifdef DEBUG_MODE
UART2PrintString( "HCI:R1: " );
for(data_num=0;data_num<*(DWORD*)data;data_num++)
{UART2PutHex(buf1[data_num]);UART2PutChar(' ');}
UART2PrintString( "\r\n" );
#endif
phybusif_input_event(cb,buf1,*(DWORD*)data);
}
btClientData.State = BT_STATE_IDLE;
return TRUE;
case EVENT_VBUS_REQUEST_POWER:
// We'll let anything attach.
return TRUE;
case EVENT_VBUS_RELEASE_POWER:
// We aren't keeping track of power.
return TRUE;
case EVENT_HUB_ATTACH:
UART2PrintString( "\r\n***** USB Error - hubs are not supported *****\r\n" );
return TRUE;
break;
case EVENT_UNSUPPORTED_DEVICE:
UART2PrintString( "\r\n***** USB Error - device is not supported *****\r\n" );
return TRUE;
break;
case EVENT_CANNOT_ENUMERATE:
UART2PrintString( "\r\n***** USB Error - cannot enumerate device *****\r\n" );
return TRUE;
break;
case EVENT_CLIENT_INIT_ERROR:
UART2PrintString( "\r\n***** USB Error - client driver initialization error *****\r\n" );
return TRUE;
break;
case EVENT_OUT_OF_MEMORY:
UART2PrintString( "\r\n***** USB Error - out of heap memory *****\r\n" );
return TRUE;
break;
case EVENT_UNSPECIFIED_ERROR: // This should never be generated.
UART2PrintString( "\r\n***** USB Error - unspecified *****\r\n" );
return TRUE;
break;
case EVENT_SUSPEND:
case EVENT_DETACH:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
return TRUE;
break;
default:
break;
}
return FALSE;
} // USB_ApplicationEventHandler
BOOL USBHostMIDIEventHandler ( BYTE address, USB_EVENT event, void *data, DWORD size )
{
unsigned char i;
// Make sure it was for one of our devices
for( i = 0; i < USB_MAX_MIDI_DEVICES; i++)
{
if ( address == devices[i].deviceAddress)
{
break;
}
}
if(i == USB_MAX_MIDI_DEVICES)
{
return FALSE;
}
// Handle specific events
switch (event)
{
case EVENT_DETACH:
// Notify that application that the device has been detached.
USB_HOST_APP_EVENT_HANDLER(devices[i].deviceAddress, EVENT_MIDI_DETACH, &devices[i], sizeof(MIDI_DEVICE) );
devices[i].deviceAddress = 0;
free(devices[i].endpoints);
devices[i].endpoints = NULL;
#ifdef DEBUG_MODE
UART2PrintString( "USB MIDI Client Device Detached: address=" );
UART2PutDec( address );
UART2PrintString( "\r\n" );
#endif
return TRUE;
#ifdef USB_ENABLE_TRANSFER_EVENT
case EVENT_TRANSFER:
if ( (data != NULL) && (size == sizeof(HOST_TRANSFER_DATA)) )
{
unsigned char currentEndpoint;
//DWORD dataCount = ((HOST_TRANSFER_DATA *)data)->dataCount;
for(currentEndpoint = 0; currentEndpoint < devices[i].numEndpoints; currentEndpoint++)
{
if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == devices[i].endpoints[currentEndpoint].endpointAddress )
{
devices[i].endpoints[currentEndpoint].busy = 0;
USB_HOST_APP_EVENT_HANDLER(devices[i].deviceAddress, EVENT_MIDI_TRANSFER_DONE, &devices[i].endpoints[currentEndpoint], sizeof(MIDI_ENDPOINT_DATA));
return TRUE;
}
}
}
return FALSE;
#endif
case EVENT_SUSPEND:
case EVENT_RESUME:
case EVENT_BUS_ERROR:
default:
break;
}
return FALSE;
} // USBHostMIDIEventHandler
BOOL USBHostMIDIInit ( BYTE address, DWORD flags, BYTE clientDriverID )
{
BYTE *config_descriptor;
BYTE *ptr;
BYTE bDescriptorType;
BYTE bLength;
BYTE bNumEndpoints;
BYTE bNumInterfaces;
BYTE bInterfaceNumber;
BYTE bAlternateSetting;
BYTE Class;
BYTE SubClass;
BYTE Protocol;
BYTE currentEndpoint;
WORD wTotalLength;
BYTE index = 0;
BOOL error = FALSE;
MIDI_DEVICE *device = &devices[0];
config_descriptor = USBHostGetCurrentConfigurationDescriptor(address);
ptr = config_descriptor;
// Load up the values from the Configuration Descriptor
bLength = *ptr++;
bDescriptorType = *ptr++;
wTotalLength = *ptr++; // In case these are not word aligned
wTotalLength += (*ptr++) << 8;
bNumInterfaces = *ptr++;
// Skip over the rest of the Configuration Descriptor
index += bLength;
ptr = &config_descriptor[index];
while (!error && (index < wTotalLength))
{
// Check the descriptor length and type
bLength = *ptr++;
bDescriptorType = *ptr++;
// Find an interface descriptor
if (bDescriptorType != USB_DESCRIPTOR_INTERFACE)
{
// Skip over the rest of the Descriptor
index += bLength;
ptr = &config_descriptor[index];
}
else
{
// Read some data from the interface descriptor
bInterfaceNumber = *ptr++;
bAlternateSetting = *ptr++;
bNumEndpoints = *ptr++;
Class = *ptr++;
SubClass = *ptr++;
Protocol = *ptr++;
// Check to see if this is a MIDI inteface descripter
if (Class != AUDIO_CLASS || SubClass != MIDI_SUB_CLASS || Protocol != MIDI_PROTOCOL)
{
// If we cannot support this interface, skip it.
index += bLength;
ptr = &config_descriptor[index];
continue;
}
// Initialize the device
device->deviceAddress = address;
device->clientDriverID = clientDriverID;
device->numEndpoints = bNumEndpoints;
// Allocate enough memory for each endpoint
if ((device->endpoints = (MIDI_ENDPOINT_DATA*)malloc( sizeof(MIDI_ENDPOINT_DATA) * bNumEndpoints)) == NULL)
{
// Out of memory
error = TRUE;
}
if (!error)
{
// Skip over the rest of the Interface Descriptor
index += bLength;
ptr = &config_descriptor[index];
// Find the Endpoint Descriptors. There might be Class and Vendor descriptors in here
currentEndpoint = 0;
while (!error && (index < wTotalLength) && (currentEndpoint < bNumEndpoints))
{
bLength = *ptr++;
bDescriptorType = *ptr++;
if (bDescriptorType != USB_DESCRIPTOR_ENDPOINT)
{
// Skip over the rest of the Descriptor
index += bLength;
ptr = &config_descriptor[index];
}
else
{
device->endpoints[currentEndpoint].endpointAddress = *ptr++;
ptr++;
device->endpoints[currentEndpoint].endpointSize = *ptr++;
device->endpoints[currentEndpoint].endpointSize += (*ptr++) << 8;
device->endpoints[currentEndpoint].busy = FALSE;
if(device->endpoints[currentEndpoint].endpointSize > 64)
{
// For full speed bulk endpoints, only 8, 16, 32, and 64 byte packets are supported
// But we will accept anything less than or equal to 64.
error = TRUE;
}
// Get ready for the next endpoint.
currentEndpoint++;
index += bLength;
ptr = &config_descriptor[index];
}
}
}
// Ensure that we found all the endpoints for this interface.
if (currentEndpoint != bNumEndpoints)
{
error = TRUE;
}
}
}
if (error)
{
// Destroy whatever list of interfaces, settings, and endpoints we created.
// The "new" variables point to the current node we are trying to remove.
if (device->endpoints != NULL)
{
free( device->endpoints );
device->endpoints = NULL;
}
return FALSE;
}
#ifdef DEBUG_MODE
UART2PrintString( "USB MIDI Client Initalized: " );
UART2PrintString( " address=" );
UART2PutDec( address );
UART2PrintString( " Number of Endpoings=" );
UART2PutHex( bNumEndpoints );
UART2PrintString( "\r\n" );
#endif
// Notify that application that we've been attached to a device.
USB_HOST_APP_EVENT_HANDLER(address, EVENT_MIDI_ATTACH, device, sizeof(MIDI_DEVICE) );
return TRUE;
} // USBHostMIDIInit
