void FX3Stream::init(unsigned short vid, unsigned short pid) {
this->vid = vid;
this->pid = pid;
error = libusb_init(0);
if( error < 0 ) {
cerr << "Error initialising libusb: " << libusb_error_name(error) << endl;
return;
}
if( FX3_DEBUG ) {
libusb_set_debug(0,LIBUSB_LOG_LEVEL_WARNING);
}
devhandle = libusb_open_device_with_vid_pid(0, vid, pid);
if( !devhandle ) {
cerr << "Error opening the device" << endl;
error = 1;
return;
}
error = libusb_reset_device( devhandle );
if( error < 0 ) {
cerr << "Error resetting the device: " << libusb_error_name(error) << endl;
return;
}
error = libusb_kernel_driver_active( devhandle, 1 );
if( error < 0 ) {
cerr << "Error checking for kernel driver: " << libusb_error_name(error) << endl;
return;
}
else if( error == 1 ) {
cerr << "Error: Kernel driver active." << endl;
return;
}
error = libusb_set_configuration( devhandle, 1 );
if( error < 0 ) {
cerr << "Error setting the configuration: " << libusb_error_name(error) << endl;
return;
}
error = libusb_claim_interface( devhandle, 0 );
if( error < 0 ) {
cerr << "Error claiming the interface: " << libusb_error_name(error) << endl;
return;
}
interfaceClaimed = true;
inPktSize = libusb_get_max_packet_size( libusb_get_device(devhandle), FX3_IN_EP );
if( inPktSize < 0 ) {
cerr << "Error getting IN EP packet size: " << libusb_error_name(error) << endl;
return;
}
outPktSize = libusb_get_max_packet_size( libusb_get_device(devhandle), FX3_OUT_EP );
if( outPktSize < 0 ) {
cerr << "Error getting OUT EP packet size: " << libusb_error_name(error) << endl;
return;
}
if( FX3_DEBUG ) {
cerr << "inPktSize: " << inPktSize << ", outPktSize: " << outPktSize << endl;
}
allocTransfers();
}
void init_mouse2(libusbSource * usb_source){
int iface_nums[1] = {0};
libusb_device_handle * handle = open_usb_device_handle(usb_source, is_mouse2, iface_nums, 1);
if(!handle) {
return;
}
g_packet_size = libusb_get_max_packet_size (libusb_get_device (handle), g_dev_IN_EP);
start_mouse_transfer(handle, g_dev_IN_EP, mouse_cb, NULL, 0);
}
void init()
{
memset(&_ctx_data, 0, sizeof (_ctx_data));
_ctx = &_ctx_data;
libusb_init( & _ctx->libusb_ctx );
_ctx->dev_handle = libusb_open_device_with_vid_pid(_ctx->libusb_ctx, LEAP_VID, LEAP_PID);
if (_ctx->dev_handle == NULL) {
fprintf(stderr, "ERROR: can't find leap.\n");
exit(EXIT_FAILURE);
}
debug_printf("Found leap\n");
int ret;
ret = libusb_reset_device(_ctx->dev_handle);
debug_printf("libusb_reset_device() ret: %i: %s\n", ret, libusb_error_name(ret));
ret = libusb_kernel_driver_active(_ctx->dev_handle, 0);
if ( ret == 1 ) {
debug_printf("kernel active for interface 0\n");
libusb_detach_kernel_driver(_ctx->dev_handle, 0);
}
else if (ret != 0) {
printf("error\n");
exit(EXIT_FAILURE);
}
ret = libusb_kernel_driver_active(_ctx->dev_handle, 1);
if ( ret == 1 ) {
debug_printf("kernel active\n");
libusb_detach_kernel_driver(_ctx->dev_handle, 1);
}
else if (ret != 0) {
printf("error\n");
exit(EXIT_FAILURE);
}
ret = libusb_claim_interface(_ctx->dev_handle, 0);
debug_printf("libusb_claim_interface() ret: %i: %s\n", ret, libusb_error_name(ret));
ret = libusb_claim_interface(_ctx->dev_handle, 1);
debug_printf("libusb_claim_interface() ret: %i: %s\n", ret, libusb_error_name(ret));
leap_init(_ctx);
debug_printf( "max %i\n", libusb_get_max_packet_size(libusb_get_device( _ctx->dev_handle ), 0x83));
}
int
libusb_get_max_iso_packet_size(libusb_device *dev, uint8_t endpoint)
{
int multiplier;
int ret;
ret = libusb_get_max_packet_size(dev, endpoint);
switch (libusb20_dev_get_speed(dev->os_priv)) {
case LIBUSB20_SPEED_LOW:
case LIBUSB20_SPEED_FULL:
break;
default:
if (ret > -1) {
multiplier = (1 + ((ret >> 11) & 3));
if (multiplier > 3)
multiplier = 3;
ret = (ret & 0x7FF) * multiplier;
}
break;
}
static int
gp_libusb1_find_path_lib(GPPort *port)
{
char *s;
int d, busnr = 0, devnr = 0;
GPPortPrivateLibrary *pl;
C_PARAMS (port);
pl = port->pl;
s = strchr (port->settings.usb.port,':');
C_PARAMS (s && (s[1] != '\0'));
C_PARAMS (sscanf (s+1, "%d,%d", &busnr, &devnr) == 2); /* usb:%d,%d */
pl->nrofdevs = load_devicelist (port->pl);
for (d = 0; d < pl->nrofdevs; d++) {
struct libusb_config_descriptor *confdesc;
int config = -1, interface = -1, altsetting = -1;
if (busnr != libusb_get_bus_number (pl->devs[d]))
continue;
if (devnr != libusb_get_device_address (pl->devs[d]))
continue;
port->pl->d = pl->devs[d];
GP_LOG_D ("Found path %s", port->settings.usb.port);
/* Use the first config, interface and altsetting we find */
gp_libusb1_find_first_altsetting(pl->devs[d], &config, &interface, &altsetting);
if (LOG_ON_LIBUSB_E (libusb_get_config_descriptor (pl->devs[d], config, &confdesc)))
continue;
/* Set the defaults */
port->settings.usb.config = confdesc->bConfigurationValue;
port->settings.usb.interface = confdesc->interface[interface].altsetting[altsetting].bInterfaceNumber;
port->settings.usb.altsetting = confdesc->interface[interface].altsetting[altsetting].bAlternateSetting;
port->settings.usb.inep = gp_libusb1_find_ep(pl->devs[d], config, interface, altsetting, LIBUSB_ENDPOINT_IN, LIBUSB_TRANSFER_TYPE_BULK);
port->settings.usb.outep = gp_libusb1_find_ep(pl->devs[d], config, interface, altsetting, LIBUSB_ENDPOINT_OUT, LIBUSB_TRANSFER_TYPE_BULK);
port->settings.usb.intep = gp_libusb1_find_ep(pl->devs[d], config, interface, altsetting, LIBUSB_ENDPOINT_IN, LIBUSB_TRANSFER_TYPE_INTERRUPT);
port->settings.usb.maxpacketsize = libusb_get_max_packet_size (pl->devs[d], port->settings.usb.inep);
GP_LOG_D ("Detected defaults: config %d, interface %d, altsetting %d, "
"inep %02x, outep %02x, intep %02x, class %02x, subclass %02x",
port->settings.usb.config,
port->settings.usb.interface,
port->settings.usb.altsetting,
port->settings.usb.inep,
port->settings.usb.outep,
port->settings.usb.intep,
confdesc->interface[interface].altsetting[altsetting].bInterfaceClass,
confdesc->interface[interface].altsetting[altsetting].bInterfaceSubClass
);
libusb_free_config_descriptor (confdesc);
return GP_OK;
}
#if 0
gp_port_set_error (port, _("Could not find USB device "
"(vendor 0x%x, product 0x%x). Make sure this device "
"is connected to the computer."), idvendor, idproduct);
#endif
return GP_ERROR_IO_USB_FIND;
}
static int
gp_libusb1_find_device_lib(GPPort *port, int idvendor, int idproduct)
{
char *s;
int d, busnr = 0, devnr = 0;
GPPortPrivateLibrary *pl;
C_PARAMS (port);
pl = port->pl;
s = strchr (port->settings.usb.port,':');
if (s && (s[1] != '\0')) { /* usb:%d,%d */
if (sscanf (s+1, "%d,%d", &busnr, &devnr) != 2) {
devnr = 0;
sscanf (s+1, "%d", &busnr);
}
}
/*
* 0x0000 idvendor is not valid.
* 0x0000 idproduct is ok.
* Should the USB layer report that ? I don't know.
* Better to check here.
*/
if (!idvendor) {
gp_port_set_error (port, _("The supplied vendor or product "
"id (0x%x,0x%x) is not valid."), idvendor, idproduct);
return GP_ERROR_BAD_PARAMETERS;
}
pl->nrofdevs = load_devicelist (port->pl);
for (d = 0; d < pl->nrofdevs; d++) {
struct libusb_config_descriptor *confdesc;
int config = -1, interface = -1, altsetting = -1;
if ((pl->descs[d].idVendor != idvendor) ||
(pl->descs[d].idProduct != idproduct))
continue;
if (busnr && (busnr != libusb_get_bus_number (pl->devs[d])))
continue;
if (devnr && (devnr != libusb_get_device_address (pl->devs[d])))
continue;
port->pl->d = pl->devs[d];
GP_LOG_D ("Looking for USB device (vendor 0x%x, product 0x%x)... found.", idvendor, idproduct);
/* Use the first config, interface and altsetting we find */
gp_libusb1_find_first_altsetting(pl->devs[d], &config, &interface, &altsetting);
if (LOG_ON_LIBUSB_E (libusb_get_config_descriptor (pl->devs[d], config, &confdesc)))
continue;
/* Set the defaults */
if (confdesc->interface[interface].altsetting[altsetting].bInterfaceClass
== LIBUSB_CLASS_MASS_STORAGE) {
GP_LOG_D ("USB device (vendor 0x%x, product 0x%x) is a mass"
" storage device, and might not function with gphoto2."
" Reference: %s", idvendor, idproduct, URL_USB_MASSSTORAGE);
}
port->settings.usb.config = confdesc->bConfigurationValue;
port->settings.usb.interface = confdesc->interface[interface].altsetting[altsetting].bInterfaceNumber;
port->settings.usb.altsetting = confdesc->interface[interface].altsetting[altsetting].bAlternateSetting;
port->settings.usb.inep = gp_libusb1_find_ep(pl->devs[d], config, interface, altsetting, LIBUSB_ENDPOINT_IN, LIBUSB_TRANSFER_TYPE_BULK);
port->settings.usb.outep = gp_libusb1_find_ep(pl->devs[d], config, interface, altsetting, LIBUSB_ENDPOINT_OUT, LIBUSB_TRANSFER_TYPE_BULK);
port->settings.usb.intep = gp_libusb1_find_ep(pl->devs[d], config, interface, altsetting, LIBUSB_ENDPOINT_IN, LIBUSB_TRANSFER_TYPE_INTERRUPT);
port->settings.usb.maxpacketsize = libusb_get_max_packet_size (pl->devs[d], port->settings.usb.inep);
GP_LOG_D ("Detected defaults: config %d, interface %d, altsetting %d, "
"inep %02x, outep %02x, intep %02x, class %02x, subclass %02x",
port->settings.usb.config,
port->settings.usb.interface,
port->settings.usb.altsetting,
port->settings.usb.inep,
port->settings.usb.outep,
port->settings.usb.intep,
confdesc->interface[interface].altsetting[altsetting].bInterfaceClass,
confdesc->interface[interface].altsetting[altsetting].bInterfaceSubClass
);
libusb_free_config_descriptor (confdesc);
return GP_OK;
}
#if 0
gp_port_set_error (port, _("Could not find USB device "
"(vendor 0x%x, product 0x%x). Make sure this device "
"is connected to the computer."), idvendor, idproduct);
#endif
return GP_ERROR_IO_USB_FIND;
}
int cyusb_get_max_packet_size(cyusb_handle *h, unsigned char endpoint)
{
cyusb_device *tdev = libusb_get_device(h);
return ( libusb_get_max_packet_size(tdev, endpoint) );
}
///////////////////////////////////////////////////////////////////////////////
///@author Nicolae Bodislav
///@brief Reads data from the USB device on bulk.
///@param [out]p_pData - Buffer to store output data
///@param [in]p_nLegth - Size of the output buffer
///@param [in]p_nMiliSec - How much to wait for data before abandoning the read operation
///@retval size of the data written in the output buffer or < 0 for error
///////////////////////////////////////////////////////////////////////////////
int CUSBLink::ReadBulk(unsigned char* p_pData, uint32_t p_nLegth, unsigned int p_nMiliSec /*= 10*/ )
{
m_nCb = 0;
m_nTrasferedLength = 0;
if(m_pDevh == NULL)
{
NLOG_ERR("[CUSBLink][ReadBulk] Device not open.");
return -1;
}
int rez = libusb_claim_interface(m_pDevh, 0);
if (rez < 0)
{
NLOG_ERR("[CUSBLink][ReadBulk] Couldn't claim interface.");
return -1;
}
m_enumDealoc = CUSBLink::INTERFACE;
m_pData_transfer = NULL;
m_pData_transfer = libusb_alloc_transfer(0);
if (!m_pData_transfer)
{
NLOG_ERR("[CUSBLink][ReadBulk] Transfer couldn't be allocated.");
return -ENOMEM;
}
m_pDev = libusb_get_device(m_pDevh);
int max_packet_size = libusb_get_max_packet_size(m_pDev, m_cReadEndpoint);
libusb_fill_bulk_transfer(m_pData_transfer, m_pDevh, m_cReadEndpoint, m_pData, max_packet_size, Cb_TransferRead, this, p_nMiliSec);
m_enumDealoc = CUSBLink::TRANSFER;
rez = libusb_submit_transfer(m_pData_transfer);
if (rez < 0)
{
NLOG_ERR("[CUSBLink][ReadBulk] Transfer couldn't be submitted.");
libusb_cancel_transfer(m_pData_transfer);
m_enumDealoc = CUSBLink::INTERFACE;
while (!m_nCb)
{ rez = libusb_handle_events(m_pContex);
if (rez < 0)
{ break;
}
}
libusb_free_transfer(m_pData_transfer);
return -1;
}
while (!m_nCb)
{ rez = libusb_handle_events(m_pContex);
if (rez < 0)
{ libusb_free_transfer(m_pData_transfer);
return -1;
}
}
if(m_bHaveData)
{
if(m_nTrasferedLength > 0)
{ memcpy(p_pData, m_pData, m_nTrasferedLength);
if (m_bRawLog)
{ NLOG_DBG_HEX("[CUSBLink][ReadBulk] Received packet:", m_pData, m_nTrasferedLength);
}
}
else
p_pData = NULL;
}
return m_nTrasferedLength;
}
RESPONSECODE IFDHCreateChannel ( DWORD Lun, DWORD Channel ) {
//RESPONSECODE IO_Create_Channel ( DWORD Channel ) {
//DWORD Lun = 0;
/* Lun - Logical Unit Number, use this for multiple card slots
or multiple readers. 0xXXXXYYYY - XXXX multiple readers,
YYYY multiple slots. The resource manager will set these
automatically. By default the resource manager loads a new
instance of the driver so if your reader does not have more than
one smartcard slot then ignore the Lun in all the functions.
Future versions of PC/SC might support loading multiple readers
through one instance of the driver in which XXXX would be important
to implement if you want this.
*/
/* Channel - Channel ID. This is denoted by the following:
0x000001 - /dev/pcsc/1
0x000002 - /dev/pcsc/2
0x000003 - /dev/pcsc/3
USB readers may choose to ignore this parameter and query
the bus for the particular reader.
*/
/* This function is required to open a communications channel to the
port listed by Channel. For example, the first serial reader on COM1 would
link to /dev/pcsc/1 which would be a sym link to /dev/ttyS0 on some machines
This is used to help with intermachine independance.
Once the channel is opened the reader must be in a state in which it is possible
to query IFDHICCPresence() for card status.
returns:
IFD_SUCCESS
IFD_COMMUNICATION_ERROR
*/
syslog(LOG_INFO, "This is the Myson driver");
srand(time(0));
int readerNum = (Lun & 0xFFFF0000) >> 16;
libusb_context *context;
if(libusb_init(&context) != 0) //unable to initialize libusb
{
syslog(LOG_INFO, "Unable to initialize libusb");
return IFD_COMMUNICATION_ERROR;
}
rd[readerNum].context = context;
rd[readerNum].handle = libusb_open_device_with_vid_pid(context, 0x04cf, 0x9920);
syslog(LOG_INFO, "Success");
if(rd[readerNum].handle == NULL)
{
syslog(LOG_INFO, "Did you connect the Myson?");
return IFD_COMMUNICATION_ERROR;
}
libusb_device* dev = libusb_get_device(rd[readerNum].handle);
//avoid conflict with an existing mass storage driver
//this function, although it is in the documentation, is absent from libusb.h...
//libusb_set_auto_detach_kernel_driver(rd[readerNum].handle,1);
//we will claim the interface
if(libusb_kernel_driver_active(rd[readerNum].handle,0) == 1) //then we free it
{
if(libusb_detach_kernel_driver(rd[readerNum].handle,0) != 0) //error when freeing?
{
syslog(LOG_INFO, "Unable to detach interface from kernel driver");
libusb_close(rd[readerNum].handle);
libusb_exit(context);
return IFD_COMMUNICATION_ERROR;
}
}
if(libusb_claim_interface(rd[readerNum].handle, 0) != 0)
{
syslog(LOG_INFO, "Unable to claim interface");
libusb_close(rd[readerNum].handle);
libusb_exit(context);
return IFD_COMMUNICATION_ERROR;
}
syslog(LOG_INFO, "Myson successfully initialized");
int maxsize = libusb_get_max_packet_size(dev, IN_ENDPOINT);
printf("Max IN packet size: %d\n", maxsize);
maxsize = libusb_get_max_packet_size(dev, OUT_ENDPOINT);
printf("Max OUT packet size: %d\n", maxsize);
return IFD_SUCCESS;
}
