[libusb] Issue with Bulk Transfer in Raspberry PI

[Abhishek M. <abm...@ya...>]

struct USBHandler
{
	struct libusb_device_handle *m_USBDevHandle;
	libusb_context *m_Context;
	struct libusb_transfer *m_BulkTransfer;
	struct libusb_transfer *m_ControlTransfer;
};
void cb_response(struct libusb_transfer *transfer);

void cb_response(struct libusb_transfer *transfer)
{
	 int *complete = (int *)transfer->user_data;
	 *complete = 1;
	  return; 
}

int completed = 0;
int StartCamera(USBHandler *pUSBHandler)
{
  
    int iBusChanges;
    int iDevChanges;
  

    int iEZUSBCam=0;

    
    errno = ENODEV;
    
  //  usb_init();

  	  libusb_device **devs;

	  int r ;
	  ssize_t cnt;
	  r = libusb_init(&pUSBHandler->m_Context);
	  if(r<0)
	  {
	       VDBG("Init Error %d\n",r);
	       return -1;
	  }
	  libusb_set_debug(pUSBHandler->m_Context,3);
	  
	  cnt = libusb_get_device_list(pUSBHandler->m_Context,&devs); //get the list of devices;
	  if(cnt<0)
	  {
	       VDBG("Get Device Error\n");
	       return -1;
	  }
	  VDBG("%d Devices in lilst.",(int)cnt);
	  
	  pUSBHandler->m_USBDevHandle = libusb_open_device_with_vid_pid(pUSBHandler->m_Context,0x04b4,0x1004);
	  if(pUSBHandler->m_USBDevHandle==NULL)
	  {
	      VDBG("Cannot open device\n");
	  }
	  else
	  {
	       VDBG("Opened Device\n");
	  }
	  libusb_free_device_list(devs,1);//free the list, unref the devices in it.
	  
	  if(libusb_kernel_driver_active(pUSBHandler->m_USBDevHandle,0)==1) //find out if the kernel driver is attached.
	  {
	       VDBG("Kernel Driver Active\n");
	       if(libusb_detach_kernel_driver(pUSBHandler->m_USBDevHandle,0)==0) //detach it
		    VDBG("Kernel Driver Detached!\n");
	  }
	
	libusb_set_configuration(pUSBHandler->m_USBDevHandle,1);
	
	r  = libusb_claim_interface(pUSBHandler->m_USBDevHandle,0); //claim interface 0 (the first) of device.
	if(r<0)
	  {
	       printf("Cannot Claim Interface\n");
	       return -1;
	  }
	
    return(1);
}

void AllocTransfer(USBHandler *pUSBHandler,unsigned short *imageData,int nSize)
{
	if(pUSBHandler!=NULL)
	{
		if(pUSBHandler->m_USBDevHandle==NULL)
		{
			VDBG("Null USB Handler\n");
			return EINVAL;
		}
		//Allocating the Bulk Transfer.

		pUSBHandler->m_BulkTransfer = libusb_alloc_transfer(0);
		libusb_fill_bulk_transfer(pUSBHandler->m_BulkTransfer_0,pUSBHandler->m_USBDevHandle,(0x2|LIBUSB_ENDPOINT_IN),imageData,size,cb_response,&completed,1000);

		int _completed=0;
		pUSBHandler->m_ControlTransfer = libusb_alloc_transfer(0);
		unsigned char *buffer;
		int r;
		int wLength = 1;
		uint8_t bRequest = 0xD2;
		unsigned char data[1];
		uint8_t bmRequestType = LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE | LIBUSB_ENDPOINT_OUT;
		uint16_t wValue = 0;
		uint16_t wIndex = 0;
		int timeout = 10;
		buffer = malloc(LIBUSB_CONTROL_SETUP_SIZE + wLength);
		libusb_fill_control_setup(buffer, bmRequestType, bRequest, wValue, wIndex,wLength);
		if ((bmRequestType & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT)
			memcpy(buffer + LIBUSB_CONTROL_SETUP_SIZE, data, wLength);
		libusb_fill_control_transfer(pUSBHandler->m_ControlTransfer, pUSBHandler->m_USBDevHandle, buffer,ctrl_transfer_cb, &_completed, timeout);
		//End Allocating the Control Transfer.

	}
}

int GetImageFrame(USBHandler *pUSBHandler)
{
		int r= -1;
	if(pUSBHandler!=NULL)
	{
		if(pUSBHandler->m_USBDevHandle==NULL)
		{
			VDBG("Null USB Handler\n");
			return EINVAL;
		}
		if(pUSBHandler->m_ControlTransfer==NULL)
		{
			VDBG("Null Control Transfer\n");
			return EINVAL;
		}

		libusb_submit_transfer(pUSBHandler->m_BulkTransfer);
		libusb_submit_transfer(pUSBHandler->m_ControlTransfer);

		completed = 0;
		while(!completed_0)
		{
			struct timeval tv;
			tv.tv_sec = 0;
			tv.tv_usec =0;
			r = libusb_handle_events_timeout_completed(pUSBHandler->m_Context,&tv,&completed);
		}	
		r = pUSBHandler->m_BulkTransfer->actual_length;
	}
    return r;
}



int main(void)
{
	
	int low=-1,high=-1;
	unsigned char *image8;
	unsigned char *imageDisplayData = (unsigned char *)malloc(nWidth * nHeight);
	USBHandler usbHandler;
	StartCamera(&usbHandler);
	int nSize = sizeof(unsigned short)*640*480;
	unsigned short *imageData;
	imageData = (unsigned short *)malloc(nSize);
	AllocTransfer(&usbHandler,imageData,nSize);
	while(1)
	{
		int RtnBytes = GetImageFrame(&usbHandler);
		printf("Number of Bytes received = %d\n",RtnBytes);
	}

}