static int h4_process(struct data_source *ds) {
// reset tx state before emitting packet sent event
// to allow for positive can_send_now
if (tx_state == TX_DONE){
tx_state = TX_IDLE;
}
// notify about packet sent
if (tx_send_packet_sent){
// race condition: if tx_state was set after our check, can_send_now will fail, causing a hang
// workaround: assert that tx_state is TX_IDLE if it was just set to done by ISR
if (tx_state == TX_DONE){
tx_state = TX_IDLE;
}
tx_send_packet_sent = 0;
uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0 };
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
}
if (h4_state != H4_PACKET_RECEIVED) return 0;
packet_handler(hci_packet[0], &hci_packet[1], read_pos-1);
h4_rx_init_sm();
return 0;
}
static void handle_isochronous_data(uint8_t * buffer, uint16_t size){
while (size){
if (size < sco_bytes_to_read){
// just store incomplete data
memcpy(&sco_buffer[sco_read_pos], buffer, size);
sco_read_pos += size;
sco_bytes_to_read -= size;
return;
}
// copy requested data
memcpy(&sco_buffer[sco_read_pos], buffer, sco_bytes_to_read);
sco_read_pos += sco_bytes_to_read;
buffer += sco_bytes_to_read;
size -= sco_bytes_to_read;
// chunk read successfully, next action
switch (sco_state){
case H2_W4_SCO_HEADER:
sco_state = H2_W4_PAYLOAD;
sco_bytes_to_read = sco_buffer[2];
break;
case H2_W4_PAYLOAD:
// packet complete
packet_handler(HCI_SCO_DATA_PACKET, sco_buffer, sco_read_pos);
sco_state_machine_init();
break;
}
}
}
void usb_bt_callback(uint8_t event_type, uint8_t *data, uint16_t size)
{
switch(event_type)
{
case USB_BT_EVENT_INTERRUPT_READ:
hci_dump_packet( HCI_EVENT_PACKET, 1, data, size);
packet_handler(HCI_EVENT_PACKET,data,size);
break;
case USB_BT_EVENT_BULK_READ:
hci_dump_packet( HCI_ACL_DATA_PACKET, 1, data, size);
packet_handler(HCI_ACL_DATA_PACKET,data,size);
break;
default:
break;
}
}
void dump_ethernet_raw_packet(uint8 bInput, char* szMessage, uint8 *payload, int32 len)
{
extern int g_modePacketDump;
extern int g_modePacketInfo;
extern uint8_t g_macFilterUse;
extern uint8_t g_macFilter1[6];
extern uint8_t g_macFilter2[6];
if ( g_macFilterUse )
{
if ( memcmp(payload, g_macFilter1, 6)==0 && memcmp(payload+6, g_macFilter1, 6)==0 && memcmp(payload+6, g_macFilter2, 6)==0 && memcmp(payload+6, g_macFilter2, 6)==0 )
{
return;
}
}
if ( g_modePacketDump==1 )
{
ets_uart_printf(szMessage);
ets_uart_printf(" (%d)\r\n", len);
wdump(payload, len);
}
if ( g_modePacketInfo==1 )
{
void packet_handler(uint32_t packet_length, const uint8_t *packet);
packet_handler(len, payload);
}
}
// executed on main run loop
static wiced_result_t h4_main_deliver_packet(void *arg){
// deliver packet
packet_handler(hci_packet[0], &hci_packet[1], rx_worker_read_pos-1);
// trigger receive of next packet
wiced_rtos_send_asynchronous_event(&rx_worker_thread, &h4_rx_worker_receive_packet, NULL);
return WICED_SUCCESS;
}
static void h4_process(btstack_data_source_t *ds, btstack_data_source_callback_type_t callback_type) {
if (hci_transport_h4->ds->fd == 0) return;
// read up to bytes_to_read data in
ssize_t bytes_read = mtk_bt_read(hci_transport_h4->ds->fd, &hci_packet_in[0], sizeof(hci_packet_in));
if (bytes_read == 0) return;
// iterate over packets
uint16_t pos = 0;
while (pos < bytes_read) {
uint16_t packet_len;
switch(hci_packet_in[pos]){
case HCI_EVENT_PACKET:
packet_len = hci_packet_in[pos+2] + 3;
break;
case HCI_ACL_DATA_PACKET:
packet_len = little_endian_read_16(hci_packet_in, pos + 3) + 5;
break;
default:
log_error("h4_process: invalid packet type 0x%02x\n", hci_packet_in[pos]);
return;
}
packet_handler(hci_packet_in[pos], &hci_packet_in[pos+1], packet_len-1);
pos += packet_len;
}
}
/* function: read_packet
* reads a packet from the tunnel fd and passes it down the stack
* active_fd - tun file descriptor marked ready for reading
* tunnel - tun device data
*/
void read_packet(int active_fd, const struct tun_data *tunnel) {
ssize_t readlen;
char packet[PACKETLEN];
// in case something ignores the packet length
memset(packet, 0, PACKETLEN);
readlen = read(active_fd,packet,PACKETLEN);
if(readlen < 0) {
logmsg(ANDROID_LOG_WARN,"read_packet/read error: %s", strerror(errno));
return;
} else if(readlen == 0) {
logmsg(ANDROID_LOG_WARN,"read_packet/tun interface removed");
running = 0;
} else {
struct tun_pi tun_header;
ssize_t header_size = sizeof(struct tun_pi);
if(readlen < header_size) {
logmsg(ANDROID_LOG_WARN,"read_packet/short read: got %ld bytes", readlen);
return;
}
packet_handler(tunnel, (struct tun_pi *) packet, packet + header_size, readlen - header_size);
}
}
// executed on main run loop
static wiced_result_t h4_main_notify_packet_send(void *arg){
// prepare for next packet
tx_worker_data_size = 0;
// notify upper stack that it might be possible to send again
uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0};
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
return WICED_SUCCESS;
}
static void h4_deliver_packet(void) {
if (read_pos < 3) return; // sanity check
packet_handler(hci_packet[0], &hci_packet[1], read_pos-1);
h4_state = H4_W4_PACKET_TYPE;
read_pos = 0;
bytes_to_read = 1;
}
int
main (int argc, char **argv)
{
SLpacket * slpack;
int seqnum;
int ptype;
#ifndef WIN32
/* Signal handling, use POSIX calls with standardized semantics */
struct sigaction sa;
sigemptyset (&sa.sa_mask);
sa.sa_flags = SA_RESTART;
sa.sa_handler = term_handler;
sigaction (SIGINT, &sa, NULL);
sigaction (SIGQUIT, &sa, NULL);
sigaction (SIGTERM, &sa, NULL);
sa.sa_handler = SIG_IGN;
sigaction (SIGHUP, &sa, NULL);
sigaction (SIGPIPE, &sa, NULL);
#endif
/* Allocate and initialize a new connection description */
slconn = sl_newslcd();
/* Process given parameters (command line and parameter file) */
if (parameter_proc (argc, argv) < 0)
{
fprintf(stderr, "Parameter processing failed\n\n");
fprintf(stderr, "Try '-h' for detailed help\n");
return -1;
}
/* Loop with the connection manager */
while ( sl_collect (slconn, &slpack) )
{
ptype = sl_packettype (slpack);
seqnum = sl_sequence (slpack);
packet_handler ((char *) &slpack->msrecord, ptype, seqnum, SLRECSIZE);
/* It would be possible to send an in-line INFO request
here with sl_request_info().
*/
}
/* Make sure everything is shut down and save the state file */
if (slconn->link != -1)
sl_disconnect (slconn);
if (statefile)
sl_savestate (slconn, statefile);
return 0;
} /* End of main() */
static int h4_process(struct data_source *ds) {
// notify about packet sent
if (tx_state == TX_DONE){
// reset state
tx_state = TX_IDLE;
uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0 };
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
}
if (h4_state != H4_PACKET_RECEIVED) return 0;
packet_handler(hci_packet[0], &hci_packet[1], read_pos-1);
h4_init_sm();
return 0;
}
static void h4_process(btstack_data_source_t *ds, btstack_data_source_callback_type_t callback_type) {
// notify about packet sent
if (tx_state == TX_DONE){
// reset state
tx_state = TX_IDLE;
uint8_t event[] = { HCI_EVENT_TRANSPORT_PACKET_SENT, 0 };
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
}
if (h4_state != H4_PACKET_RECEIVED) return;
packet_handler(hci_packet[0], &hci_packet[1], read_pos-1);
h4_init_sm();
return;
}
BOOL USBHostBluetoothCallback(BLUETOOTH_EVENT event,
USB_EVENT status,
void *data,
DWORD size) {
uint8_t e;
switch (event) {
case BLUETOOTH_EVENT_WRITE_BULK_DONE:
case BLUETOOTH_EVENT_WRITE_CONTROL_DONE:
e = DAEMON_EVENT_HCI_PACKET_SENT;
packet_handler(HCI_EVENT_PACKET, &e, 1);
return TRUE;
case BLUETOOTH_EVENT_ATTACHED:
case BLUETOOTH_EVENT_DETACHED:
return TRUE;
case BLUETOOTH_EVENT_READ_BULK_DONE:
if (status == USB_SUCCESS) {
if (size) {
if (packet_handler) {
packet_handler(HCI_ACL_DATA_PACKET, data, size);
}
}
} else {
log_printf("Read bulk failure");
}
return TRUE;
case BLUETOOTH_EVENT_READ_INTERRUPT_DONE:
if (status == USB_SUCCESS) {
if (size) {
if (packet_handler) {
packet_handler(HCI_EVENT_PACKET, data, size);
}
}
} else {
log_printf("Read bulk failure");
}
return TRUE;
default:
return FALSE;
}
}
int
Client_Poll(NNET_STATUS *status)
{
u32 _err = 0;
switch (NNet_GetStatus(status))
{
case State_NoData:
{
/* NEURO_TRACE("No data", NULL); */
}
break;
case State_Disconnect:
{
TRACE("Internal Quit flagged, leaving");
return 1;
}
case State_ClientDisconnect:
{
TRACE("Disconnect order by the server, leaving");
/* closing the server */
return 1;
}
break;
case State_DataAvail:
{
_err = packet_handler(NNet_GetSlave(status), NNet_GetPacket(status), NNet_GetPacketLen(status));
}
break;
default:
{
ERROR(Neuro_s("unknown status %d", NNet_GetStatus(status)));
return 1;
}
break;
}
if (ACTIVE_CLIENT_ENABLED && client_active == 1)
Active_Poll();
if (alive_time < Neuro_GetTickCount())
{
alive_time = Neuro_GetTickCount() + ALIVE_TIME;
Packet_Reset(pktbuf);
Packet_Push32(pktbuf, NET_ALIVE);
Packet_Push32(pktbuf, 0);
Client_SendPacket(Packet_GetBuffer(pktbuf), Packet_GetLen(pktbuf));
}
return _err;
}
static void handoff_handler(GstFakeSink *fakesink, GstBuffer *buffer,
GstPad *pad, gpointer user_data)
{
struct ausrc_st *st = user_data;
(void)fakesink;
(void)pad;
format_check(st, gst_caps_get_structure(GST_BUFFER_CAPS(buffer), 0));
packet_handler(st, buffer);
}
static void handoff_handler(GstFakeSink *fakesink, GstBuffer *buffer,
GstPad *pad, gpointer user_data)
{
struct ausrc_st *st = user_data;
GstCaps *caps;
(void)fakesink;
caps = gst_pad_get_current_caps(pad);
format_check(st, gst_caps_get_structure(caps, 0));
packet_handler(st, buffer);
}
ssize_t read_from_sock(int sockfd, rtp_session_type_t session_type, int is_rtcp, struct rtp_stream *stream)
{
struct timeval now;
ssize_t len = -1;
RD_buffer_t packet;
gettimeofday(&now, 0);
len = recv(sockfd, packet.p.data, sizeof(packet.p.data), 0); //v originale recvfrom
if(len == -1) {
rtp_print_log(RTP_WARN, "recv() failed with errno %s\n", strerror(errno));
return 0;
}
packet_handler(now, is_rtcp, &packet, len, session_type, stream);
return len;
}
static int usb_send_sco_packet(uint8_t *packet, int size){
#ifdef HAVE_SCO
int r;
if (libusb_state != LIB_USB_TRANSFERS_ALLOCATED) return -1;
// log_info("usb_send_acl_packet enter, size %u", size);
// store packet in free slot
int tranfer_index = sco_ring_write;
uint8_t * data = &sco_ring_buffer[tranfer_index * SCO_PACKET_SIZE];
memcpy(data, packet, size);
// setup transfer
struct libusb_transfer * sco_transfer = sco_ring_transfers[tranfer_index];
libusb_fill_iso_transfer(sco_transfer, handle, sco_out_addr, data, size, NUM_ISO_PACKETS, async_callback, NULL, 0);
libusb_set_iso_packet_lengths(sco_transfer, ISO_PACKET_SIZE);
r = libusb_submit_transfer(sco_transfer);
if (r < 0) {
log_error("Error submitting sco transfer, %d", r);
return -1;
}
// mark slot as full
sco_ring_write++;
if (sco_ring_write == SCO_RING_BUFFER_COUNT){
sco_ring_write = 0;
}
sco_ring_transfers_active++;
// log_info("H2: queued packet at index %u, num active %u", tranfer_index, sco_ring_transfers_active);
// notify upper stack that packet processed and that it might be possible to send again
if (sco_ring_have_space()){
uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0};
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
}
#endif
return 0;
}
static void read_handler(nl_event_t *ev)
{
static char s_recv_buff[RECV_BUFF_SIZE];
int rc;
nl_socket_t *sock;
nl_stream_t *s;
sock = ev->data;
log_trace("#%d read_handler", sock->fd);
s = sock->data;
s->error = 0;
for ( ; ; ) {
rc = nl_recv(sock, s_recv_buff, RECV_BUFF_SIZE);
if (rc < 0) {
if (!sock->error) {
/* EAGAIN || EWOULDBLOCK */
return;
}
s->error = 1;
break;
}
else if (rc == 0) {
break;
}
else {
rc = packet_handler(s, s_recv_buff, rc);
if (rc < 0) {
s->error = 1;
break;
}
else if (!sock->rev.active) {
return;
}
}
}
nl_stream_close(s);
}
void loop()
{
//// Using this, instead of timer_interrupt
//if (Serial1.available()) {
//GPS.read();
//}
// if a sentence is received, we can check the checksum, parse it...
if (GPS.newNMEAreceived()) {
// a tricky thing here is if we print the NMEA sentence, or data
// we end up not listening and catching other sentences!
// so be very wary if using OUTPUT_ALLDATA and trytng to print out data
//SerialUSB.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false
if (!GPS.parse(GPS.lastNMEA())) { // this also sets the newNMEAreceived() flag to false
SerialUSB.println("parsed: FAILED");
return;// continue; // we can fail to parse a sentence in which case we should just wait for another
}
else {
// Format the data
crim::GPSData gps_data;
gps_data.set_time(GPS.hour, GPS.minute, GPS.seconds, GPS.milliseconds);
gps_data.set_date(GPS.year, GPS.month, GPS.day);
gps_data.set_pose(GPS.latitude, GPS.lat, GPS.longitude, GPS.lon, GPS.altitude);
gps_data.set_misc(GPS.speed, GPS.angle);
gps_data.set_note(GPS.fix, GPS.fixquality, GPS.satellites);
crim::FlymaplePacketHandler packet_handler("Serial1", SERIAL1_BAUD_RATE);
packet_handler.wrap(gps_data);
packet_handler.send();
}
}
else {
SerialUSB.println("!GPS.newNMEAreceived()");
}
}
int main(int argc, char *argv[])
{
int result;
int pcap_available=0;
char dev_name[20];
signal(SIGUSR2, signal_key);
if(argc>1){
strcpy(dev_name,argv[1]);
}else{
strcpy(dev_name,DEFAULT_PCAP_DEV);
}
init_gcrypt(&gcry_hd);
struct hostent *hp;
sock= socket(AF_INET, SOCK_DGRAM, 0);
server.sin_family = AF_INET;
server.sin_port = htons(PORT_IMU);
hp = gethostbyname(IP_IMU);
if (hp==0) printf("IMU IP no alcanzable");
bcopy((char *)hp->h_addr, (char *)&server.sin_addr,hp->h_length);
const u_char pkt_data[4096];
u_char *param;
int rawSocket = openSocket( dev_name );
if ( rawSocket < 0 )
{
fprintf( stderr, "error opening socket\n" );
return 1;
}
gcry_cipher_setkey (gcry_hd,gcry_key,GCRY_KEYLEN);
printf("\r\nINIT INTERCEPTOR");
fflush(stdout);
while(1){
fd_set readfds;
FD_ZERO( &readfds );
FD_SET( rawSocket, &readfds );
int numFds = select( rawSocket+1, &readfds, NULL, NULL, NULL );
if ( numFds == 1 )
{
int caplen = read( rawSocket, pkt_data, sizeof( pkt_data) );
if(pkt_data!=NULL){
packet_handler(pkt_data,caplen);
}
}
}
printf("\r\n EXITED");
return(0);
}
static void h4_deliver_packet(void){
if (read_pos < 3) return; // sanity check
packet_handler(hci_packet[0], &hci_packet[1], read_pos-1);
h4_reset_statemachine();
}
static void handle_completed_transfer(struct libusb_transfer *transfer){
int resubmit = 0;
int signal_done = 0;
if (transfer->endpoint == event_in_addr) {
packet_handler(HCI_EVENT_PACKET, transfer-> buffer, transfer->actual_length);
resubmit = 1;
} else if (transfer->endpoint == acl_in_addr) {
// log_info("-> acl");
packet_handler(HCI_ACL_DATA_PACKET, transfer-> buffer, transfer->actual_length);
resubmit = 1;
} else if (transfer->endpoint == sco_in_addr) {
// log_info("handle_completed_transfer for SCO IN! num packets %u", transfer->NUM_ISO_PACKETS);
int i;
for (i = 0; i < transfer->num_iso_packets; i++) {
struct libusb_iso_packet_descriptor *pack = &transfer->iso_packet_desc[i];
if (pack->status != LIBUSB_TRANSFER_COMPLETED) {
log_error("Error: pack %u status %d\n", i, pack->status);
continue;
}
if (!pack->actual_length) continue;
uint8_t * data = libusb_get_iso_packet_buffer_simple(transfer, i);
// printf_hexdump(data, pack->actual_length);
// log_info("handle_isochronous_data,size %u/%u", pack->length, pack->actual_length);
handle_isochronous_data(data, pack->actual_length);
}
resubmit = 1;
} else if (transfer->endpoint == 0){
// log_info("command done, size %u", transfer->actual_length);
usb_command_active = 0;
signal_done = 1;
} else if (transfer->endpoint == acl_out_addr){
// log_info("acl out done, size %u", transfer->actual_length);
usb_acl_out_active = 0;
signal_done = 1;
} else if (transfer->endpoint == sco_out_addr){
log_info("sco out done, {{ %u/%u (%x)}, { %u/%u (%x)}, { %u/%u (%x)}}",
transfer->iso_packet_desc[0].actual_length, transfer->iso_packet_desc[0].length, transfer->iso_packet_desc[0].status,
transfer->iso_packet_desc[1].actual_length, transfer->iso_packet_desc[1].length, transfer->iso_packet_desc[1].status,
transfer->iso_packet_desc[2].actual_length, transfer->iso_packet_desc[2].length, transfer->iso_packet_desc[2].status);
if (!sco_ring_have_space()) {
// if there isn't space, the last SCO send didn't emit a packet sent event
signal_done = 1;
}
// decrease tab
sco_ring_transfers_active--;
// log_info("H2: sco out complete, num active num active %u", sco_ring_transfers_active);
} else {
log_info("usb_process_ds endpoint unknown %x", transfer->endpoint);
}
if (signal_done){
// notify upper stack that iit might be possible to send again
uint8_t event[] = { DAEMON_EVENT_HCI_PACKET_SENT, 0};
packet_handler(HCI_EVENT_PACKET, &event[0], sizeof(event));
}
if (libusb_state != LIB_USB_TRANSFERS_ALLOCATED) return;
if (resubmit){
// Re-submit transfer
transfer->user_data = NULL;
int r = libusb_submit_transfer(transfer);
if (r) {
log_error("Error re-submitting transfer %d", r);
}
}
}
static int
packet_handler(NNET_SLAVE *conn, const char *data, u32 len)
{
Pkt_Header *whole;
void *buffer;
char *newData = NULL;
int newLen = 0;
char *nextData = NULL;
int nextLen = 0;
int handleNextData = 0;
/* NEURO_TRACE("recieved packet len %d", len); */
if (len <= 0 || !data)
{
WARN("Invalid packet recieved");
return 1;
}
{
int _err = 0;
_err = PktAsm_Process(pktAsmCtx, packetGetSize, (char*)data, len, &newData, &newLen, &nextData, &nextLen);
switch (_err)
{
case 0:
{
/* needs more data */
return 0;
}
break;
case 1:
{
/* successfully scavenged a new packet */
whole = (Pkt_Header*)newData;
len = newLen;
PktAsm_Reset(pktAsmCtx);
}
break;
case 2:
{
/* successfully scavenged a new packet and got more data available */
handleNextData = 1;
whole = (Pkt_Header*)newData;
len = newLen;
PktAsm_Reset(pktAsmCtx);
}
break;
case 3:
{
/* could not do anything with the data. */
}
break;
default:
{
ERROR("PktAsm_Process : unrecoverable error");
return 1;
}
break;
}
}
buffer = &whole[1];
switch (whole->type)
{
case NET_DATA:
{
/* we remove the length of the header variables */
Passive_HandleData(buffer, whole->size - 8);
}
break;
case NET_INFO:
{
Pkt_Info *tmp;
int cols = 0, rows = 0;
TRACE("NET_INFO packet received");
tmp = (Pkt_Info*)buffer;
if (tmp->access == 0)
{
TRACE("Server access denied");
return 1;
}
if (newLen >= sizeof(Pkt_WSize))
{
cols = tmp->cols;
rows = tmp->rows;
}
else
{
/* we disconnect */
return 1;
}
if (client_active == 1)
{
TRACE("Starting Active Session");
Active_SendWSize();
Active_StartSession();
}
else
{
Passive_SetScreenSize(cols, rows);
}
}
case NET_ALIVE:
{
}
break;
case NET_DISCONNECT:
{
printf("Disconnection packet recieved from server... bailing out\n");
return 1;
}
break;
case NET_LIST:
{
Pkt_List *buf;
buf = buffer;
printf(Neuro_s("Active client %s -- Session Layer #%d\n", buf->name, buf->layers));
}
break;
default:
{
WARN(Neuro_s("Unhandled packet type recieved -- type %d", whole->type));
}
break;
}
Packet_Reset(pktbuf);
if (handleNextData)
{
return packet_handler(conn, nextData, nextLen);
}
return 0;
}
BOOL USBHostUSBBTEventHandler( BYTE address, USB_EVENT event, void *data, DWORD size )
{
switch (event)
{
case EVENT_NONE: // No event occured (NULL event)
return TRUE;
break;
case EVENT_DETACH: // USB cable has been detached (data: BYTE, address of device)
g_usbbt.initialized = 0;
g_usbbt.deviceAddress = 0;
UART2PrintString( "USBBT detach \r\n" );
return TRUE;
break;
case EVENT_TRANSFER: // A USB transfer has completed - optional
#if defined( USB_ENABLE_TRANSFER_EVENT )
if ( (data != NULL) && (size == sizeof(HOST_TRANSFER_DATA)) )
{
DWORD i;
DWORD dataCount = ((HOST_TRANSFER_DATA *)data)->dataCount;
BYTE *userData = ((HOST_TRANSFER_DATA *)data)->pUserData;
// BYTE errorCode = ((HOST_TRANSFER_DATA *)data)->bErrorCode;
if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointBulkIN )
{
g_usbbt.endpointBulkIN_Busy = 0;
if(dataCount != 0)
{
UART2PrintString( "BulkIN " );
for(i = 0; i < dataCount; i++)
{
UART2PutHex(userData[i]);
}
UART2PrintString( "\r\n" );
// bt event
usb_bt_call_handler(USB_BT_EVENT_BULK_READ,userData,dataCount);
}
}
else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointBulkOUT )
{
UART2PrintString( "BulkOUT \r\n" );
g_usbbt.endpointBulkOUT_Busy = 0;
uint8_t dummy_event = DAEMON_EVENT_HCI_PACKET_SENT;
packet_handler(HCI_EVENT_PACKET, &dummy_event, 1);
}
else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointCtrl )
{
UART2PrintString( "Ctrl \r\n" );
g_usbbt.endpointCtrl_Busy = 0;
uint8_t dummy_event = DAEMON_EVENT_HCI_PACKET_SENT;
packet_handler(HCI_EVENT_PACKET, &dummy_event, 1);
}
else if ( ((HOST_TRANSFER_DATA *)data)->bEndpointAddress == g_usbbt.endpointInt )
{
g_usbbt.endpointInt_Busy = 0;
if(dataCount != 0)
{
UART2PrintString( "Int " );
for(i = 0; i < dataCount; i++)
{
UART2PutHex(userData[i]);
}
UART2PrintString( "\r\n" );
// bt event
usb_bt_call_handler(USB_BT_EVENT_INTERRUPT_READ,userData,dataCount);
}
}
else
{
return FALSE;
}
if(!g_usbbt.endpointCtrl_Busy && !g_usbbt.endpointBulkOUT_Busy)
{
if(g_usbbt.endpointBulkIN_Busy == 0)
{
USBHostBlukRead(g_usbbt.deviceAddress,bulk_buf,MAX_DATA_PACKET_LENGTH);
}
if(g_usbbt.endpointInt_Busy == 0)
{
USBHostIntRead(g_usbbt.deviceAddress,int_buf,MAX_DATA_PACKET_LENGTH);
}
}
return TRUE;
}
else
return FALSE;
#endif
case EVENT_SOF: // Start of frame - NOT NEEDED
case EVENT_RESUME: // Device-mode resume received
case EVENT_SUSPEND: // Device-mode suspend/idle event received
case EVENT_RESET: // Device-mode bus reset received
case EVENT_STALL: // A stall has occured
case EVENT_BUS_ERROR:
default:
break;
}
return FALSE;
}
static void packet_handler2 (void * connection, uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
packet_handler(packet_type, 0, packet, size);
}
