644 lines
26 KiB
C
644 lines
26 KiB
C
/*
|
|
* USB routines of Cypress USB Serial
|
|
* Copyright (C) 2013 Cypress Semiconductor
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#include "CyUSBCommon.h"
|
|
|
|
static bool glDriverInit = false;
|
|
static libusb_device **glDeviceList;
|
|
static UINT32 glNumDevices;
|
|
/*The API initializes the Libusb library
|
|
*/
|
|
pthread_mutex_t criticalSection;
|
|
CY_RETURN_STATUS CyLibraryInit ()
|
|
{
|
|
UINT32 rStatus;
|
|
rStatus = libusb_init (NULL);
|
|
|
|
if (glDriverInit != true){
|
|
if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Driver Init Failed ...\n");
|
|
return CY_ERROR_DRIVER_INIT_FAILED;
|
|
}
|
|
glNumDevices = libusb_get_device_list (NULL, &glDeviceList);
|
|
if (glNumDevices < 0){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Building device list Failed ...\n");
|
|
glNumDevices = -1;
|
|
return CY_ERROR_DRIVER_INIT_FAILED;
|
|
}
|
|
pthread_mutex_init (&criticalSection, NULL);
|
|
glDriverInit = true;
|
|
return CY_SUCCESS;
|
|
}
|
|
else{
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error ... library already initialized \n");
|
|
return CY_ERROR_DRIVER_INIT_FAILED;
|
|
}
|
|
}
|
|
/*
|
|
This API needs to be called after Calling CyGetListofDevices.
|
|
*/
|
|
CY_RETURN_STATUS CyLibraryExit ()
|
|
{
|
|
if (glDriverInit == true){
|
|
if (glNumDevices >= 0)
|
|
libusb_free_device_list (glDeviceList, 1);
|
|
libusb_exit (NULL);
|
|
glDriverInit = false;
|
|
pthread_mutex_destroy (&criticalSection);
|
|
return CY_SUCCESS;
|
|
}
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error ... Library not initialized \n");
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
/*
|
|
* This function Gets the number of all the devices currently
|
|
* Connected to the host (It includes Cypress Device as well as
|
|
* no Cypress Devices connected)
|
|
*/
|
|
CY_RETURN_STATUS CyGetListofDevices (
|
|
UINT8 *numDevices
|
|
)
|
|
{
|
|
// Use this variable to call libusb_close and exit of the application
|
|
if (numDevices == NULL)
|
|
return CY_ERROR_INVALID_PARAMETER;
|
|
if (!glDriverInit){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error Library not initialised ...function is %s\n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
pthread_mutex_lock (&criticalSection);
|
|
libusb_free_device_list (glDeviceList, 1);
|
|
glNumDevices = (*numDevices) = libusb_get_device_list (NULL, &glDeviceList);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
if (glNumDevices < 0){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Building device list Failed ...function is %s\n", __func__);
|
|
glNumDevices = -1;
|
|
(*numDevices) = -1;
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
return CY_SUCCESS;
|
|
}
|
|
/* This function gets all the neccessary info such as VID,PID,
|
|
String Descriptors and if is a cypress serial device you will
|
|
get the info on class and device type
|
|
*/
|
|
CY_RETURN_STATUS CyGetDeviceInfo (
|
|
UINT8 deviceNumber,
|
|
CY_DEVICE_INFO *deviceInfo
|
|
)
|
|
{
|
|
struct libusb_device_descriptor deviceDesc;
|
|
UINT32 rStatus, numInterfaces;
|
|
UINT8 iManufacturer, iProduct, iSerial;
|
|
libusb_device *usbDevice;;
|
|
struct libusb_config_descriptor *configDesc;
|
|
libusb_device_handle *devHandle;
|
|
|
|
// Get the list of descriptor info for the device
|
|
if (glDriverInit == false){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error Library not initialised ...function is %s\n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
if (deviceInfo == NULL)
|
|
return CY_ERROR_INVALID_PARAMETER;
|
|
pthread_mutex_lock (&criticalSection);
|
|
if (deviceNumber >= glNumDevices){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error invalid device number... \n");
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_INVALID_PARAMETER;
|
|
}
|
|
usbDevice = glDeviceList[deviceNumber];
|
|
rStatus = libusb_get_device_descriptor (usbDevice, &deviceDesc);
|
|
if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error ... unable to retrieve device descriptor \n");
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_DEVICE_INFO_FETCH_FAILED;
|
|
}
|
|
|
|
deviceInfo->vidPid.vid = deviceDesc.idVendor;
|
|
deviceInfo->vidPid.pid = deviceDesc.idProduct;
|
|
// Get the all the index of the String descriptors so that it can be used
|
|
// to retrieve the string descriptor info.
|
|
iManufacturer = deviceDesc.iManufacturer;
|
|
iProduct = deviceDesc.iProduct;
|
|
iSerial = deviceDesc.iSerialNumber;
|
|
//Get the Device handle so that we can communicate with the device retreiving
|
|
// descriptor info
|
|
deviceInfo->manufacturerName[0] = '\0';
|
|
deviceInfo->productName[0] = '\0';
|
|
deviceInfo->serialNum[0] = '\0';
|
|
rStatus = libusb_open (usbDevice, &devHandle);
|
|
if (rStatus == LIBUSB_ERROR_ACCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error ...Insufficient permission... Libusb error is %d \n", rStatus);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_ACCESS_DENIED;
|
|
}
|
|
else if (rStatus != CY_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in opening the device... Libusb error is %d \n", rStatus);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_DEVICE_INFO_FETCH_FAILED;
|
|
}
|
|
if (iManufacturer > 0){
|
|
rStatus = libusb_get_string_descriptor_ascii (devHandle, iManufacturer, deviceInfo->manufacturerName, 256);
|
|
if (rStatus <= LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in Getting Manufacturer name Error is <%x> \n", rStatus);
|
|
}
|
|
}
|
|
if (iProduct > 0){
|
|
rStatus = libusb_get_string_descriptor_ascii (devHandle, iProduct, deviceInfo->productName, 256);
|
|
if (rStatus <= LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in Getting product name Error is <%d> \n", rStatus);
|
|
}
|
|
}
|
|
if (iSerial > 0){
|
|
rStatus = libusb_get_string_descriptor_ascii (devHandle, iSerial, deviceInfo->serialNum, 256);
|
|
if (rStatus <= LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in Getting Serial name <%d>\n", rStatus);
|
|
}
|
|
}
|
|
rStatus = libusb_get_config_descriptor (usbDevice, 0, &configDesc);
|
|
if (rStatus == LIBUSB_SUCCESS){
|
|
UINT32 index_i = 0;
|
|
const struct libusb_interface *interface;
|
|
numInterfaces = configDesc->bNumInterfaces;
|
|
deviceInfo->numInterfaces = numInterfaces;
|
|
interface = configDesc->interface;
|
|
while ((numInterfaces) && (index_i < CY_MAX_DEVICE_INTERFACE)){
|
|
deviceInfo->deviceClass[index_i] = (CY_DEVICE_CLASS)interface->altsetting->bInterfaceClass;
|
|
if (deviceInfo->deviceClass[index_i] == CY_CLASS_VENDOR){
|
|
deviceInfo->deviceType[index_i] = (CY_DEVICE_CLASS)interface->altsetting->bInterfaceSubClass;
|
|
}
|
|
else
|
|
deviceInfo->deviceType[index_i] = CY_TYPE_DISABLED;
|
|
index_i++;
|
|
numInterfaces--;
|
|
interface++;
|
|
}
|
|
libusb_free_config_descriptor(configDesc);
|
|
}
|
|
else {
|
|
CY_DEBUG_PRINT_ERROR ("CY: Error in Getting config descriptor ...Libusb error is %d \n", rStatus);
|
|
if (devHandle)
|
|
libusb_close (devHandle);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_DEVICE_INFO_FETCH_FAILED;
|
|
}
|
|
if (devHandle)
|
|
libusb_close (devHandle);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_SUCCESS;
|
|
}
|
|
/* This function gets all the neccessary info such as VID,PID,
|
|
String Descriptors and if is a cypress serial device you will
|
|
get the info on class and device type
|
|
*/
|
|
CY_RETURN_STATUS CyGetDeviceInfoVidPid (
|
|
CY_VID_PID vidPid,
|
|
UINT8 *deviceNumber,
|
|
PCY_DEVICE_INFO deviceInfoList,
|
|
UINT8 *deviceCount,
|
|
UINT8 infoListLength
|
|
)
|
|
{
|
|
struct libusb_device_descriptor deviceDesc;
|
|
UINT32 rStatus = CY_ERROR_DRIVER_INIT_FAILED, numInterfaces, index = 0, devNum;
|
|
uint8_t iManufacturer, iProduct, iSerial;
|
|
libusb_device *usbDevice;
|
|
struct libusb_config_descriptor *configDesc;
|
|
libusb_device_handle *devHandle = NULL;
|
|
PCY_DEVICE_INFO deviceInfo;
|
|
|
|
if (glDriverInit == false){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error Library not initialised ...function is %s\n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
if ((infoListLength) < 1){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error invalid device info list length specified should be > 0 .. function is %s\n", __func__);
|
|
return CY_ERROR_INVALID_PARAMETER;
|
|
}
|
|
if (deviceNumber == NULL || deviceInfoList == NULL || deviceCount == NULL)
|
|
return CY_ERROR_INVALID_PARAMETER;
|
|
// Get the list of descriptor info for the device
|
|
(*deviceCount) = 0;
|
|
pthread_mutex_lock (&criticalSection);
|
|
for (devNum = 0; devNum < glNumDevices; devNum++) {
|
|
//We are making sure that we do not overrun
|
|
//the list.
|
|
deviceInfo = &(deviceInfoList [index]);
|
|
usbDevice = glDeviceList[devNum];
|
|
rStatus = libusb_get_device_descriptor (usbDevice, &deviceDesc);
|
|
if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in getting device descriptor for device-%d... Libusb Error is %d \n", devNum, rStatus);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_DEVICE_INFO_FETCH_FAILED;
|
|
}
|
|
if ((deviceDesc.idVendor != vidPid.vid) || (deviceDesc.idProduct != vidPid.pid)){
|
|
continue;
|
|
}
|
|
(*deviceCount)++;
|
|
if (index > infoListLength){
|
|
continue;
|
|
}
|
|
rStatus = libusb_open (usbDevice, &devHandle);
|
|
if (rStatus == LIBUSB_ERROR_ACCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Insufficient permission ... Libusb error is %d \n", rStatus);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_ACCESS_DENIED;
|
|
}
|
|
else if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in Opening the Device ...Error is %d \n", rStatus);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_DEVICE_INFO_FETCH_FAILED;
|
|
}
|
|
deviceNumber[index] = devNum;
|
|
index++;
|
|
deviceInfo->vidPid.vid = deviceDesc.idVendor;
|
|
deviceInfo->vidPid.pid = deviceDesc.idProduct;
|
|
// Get all the index of the String descriptors so that it can be used
|
|
// to retrieve the string descriptor info.
|
|
iManufacturer = deviceDesc.iManufacturer;
|
|
iProduct = deviceDesc.iProduct;
|
|
iSerial = deviceDesc.iSerialNumber;
|
|
//Get the Device handle so that we can communicate with the device retreiving
|
|
// descriptor info
|
|
//Initialise manufacturer, product and serial names
|
|
deviceInfo->manufacturerName[0] = '\0';
|
|
deviceInfo->productName[0] = '\0';
|
|
deviceInfo->serialNum[0] = '\0';
|
|
if (iManufacturer > 0) {
|
|
rStatus = libusb_get_string_descriptor_ascii (devHandle, iManufacturer, deviceInfo->manufacturerName, 256);
|
|
if (rStatus <= LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_INFO ("CY:Error in Getting Manufacturer name Error is <%d> \n",rStatus);
|
|
}
|
|
}
|
|
if (iProduct > 0){
|
|
rStatus = libusb_get_string_descriptor_ascii (devHandle, iProduct, deviceInfo->productName, 256);
|
|
if (rStatus <= LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_INFO ("CY:Error in Getting product name Error is <%d> \n", rStatus);
|
|
}
|
|
}
|
|
if (iSerial > 0){
|
|
rStatus = libusb_get_string_descriptor_ascii (devHandle, iSerial, deviceInfo->serialNum, 256);
|
|
if (rStatus <= LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_INFO ("CY:Error in Getting Serial name <%d>\n", rStatus);
|
|
}
|
|
}
|
|
CY_DEBUG_PRINT_INFO ("Manufacturer name <%s> \nProduct Name <%s> \nserial number <%s> \n",
|
|
deviceInfo->manufacturerName,deviceInfo->productName,deviceInfo->serialNum);
|
|
rStatus = libusb_get_config_descriptor (usbDevice, 0, &configDesc);
|
|
if (rStatus == LIBUSB_SUCCESS){
|
|
int index_i = 0;
|
|
const struct libusb_interface *interfaceDesc;
|
|
numInterfaces = configDesc->bNumInterfaces;
|
|
deviceInfo->numInterfaces = numInterfaces;
|
|
interfaceDesc = configDesc->interface;
|
|
while ((numInterfaces) && (index_i < CY_MAX_DEVICE_INTERFACE)){
|
|
deviceInfo->deviceClass[index_i] = (CY_DEVICE_CLASS)interfaceDesc->altsetting->bInterfaceClass;
|
|
if (deviceInfo->deviceClass[index_i] == CY_CLASS_VENDOR)
|
|
deviceInfo->deviceType[index_i] = (CY_DEVICE_CLASS)interfaceDesc->altsetting->bInterfaceSubClass;
|
|
else
|
|
deviceInfo->deviceType[index_i] = CY_TYPE_DISABLED;
|
|
|
|
index_i++;
|
|
numInterfaces--;
|
|
interfaceDesc++;
|
|
}
|
|
}
|
|
else {
|
|
CY_DEBUG_PRINT_ERROR ("CY: Error in Getting config descriptor ... Libusb Error is %d\n", rStatus);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_DEVICE_INFO_FETCH_FAILED;
|
|
}
|
|
libusb_free_config_descriptor (configDesc);
|
|
libusb_close (devHandle);
|
|
}
|
|
if ((*deviceCount) == 0)
|
|
rStatus = CY_ERROR_DEVICE_NOT_FOUND;
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return rStatus;
|
|
}
|
|
/*
|
|
This API will claim the interface in the device
|
|
To make sure only claimed application speaks to device.
|
|
*/
|
|
CY_RETURN_STATUS CySelectInterface (
|
|
CY_HANDLE handle,
|
|
UINT8 interfaceNum
|
|
)
|
|
{
|
|
UINT32 rStatus, numEP;
|
|
CY_DEVICE *device;
|
|
libusb_device_handle *devHandle;
|
|
libusb_device *usbDev;
|
|
struct libusb_config_descriptor *configDesc;
|
|
const struct libusb_interface *interfaceDesc;
|
|
const struct libusb_endpoint_descriptor *epDesc;
|
|
|
|
if (handle == NULL)
|
|
return CY_ERROR_INVALID_HANDLE;
|
|
device = (CY_DEVICE *)handle;
|
|
devHandle = device->devHandle;
|
|
|
|
usbDev = libusb_get_device (devHandle);
|
|
if (usbDev == NULL){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error Invalide handle ..function is %s\n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
//Get the config descriptor and parse it to get the
|
|
//interface and endpoint descriptor
|
|
rStatus = libusb_get_config_descriptor (usbDev, 0, &configDesc);
|
|
if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in Getting Config Desc ...function is %s\n", __func__);
|
|
printf("\n rstatus10= %d",rStatus);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
interfaceDesc = configDesc->interface;
|
|
//Interface Number should be a valid one and should not exceed
|
|
// total number of interfaces
|
|
if (interfaceNum >= configDesc->bNumInterfaces){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Interface Number not valid... \n");
|
|
libusb_free_config_descriptor (configDesc);
|
|
printf("\n rstatus11= %d",rStatus);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
if (libusb_kernel_driver_active (devHandle, interfaceNum)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Kernel driver active on the interface number %d \n", interfaceNum);;
|
|
/*User can uncomment this section if needed.
|
|
#ifdef CY_DETACH_KERNEL_DRIVER
|
|
if (!libusb_detach_kernel_driver (devHandle, interfaceNum)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Kernel driver detach failed %d\n", interfaceNum);
|
|
printf("\n rstatus12= %d",rStatus);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
#else
|
|
printf("\n rstatus13= %d",rStatus);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
#endif
|
|
}
|
|
rStatus = libusb_claim_interface (devHandle, interfaceNum);
|
|
if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in claiming interface -interface num %d... Libusb error is %d \n", interfaceNum, rStatus);
|
|
printf("\n rstatus14= %d",rStatus);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}*/
|
|
}
|
|
device->interfaceNum = interfaceNum;
|
|
while (interfaceNum--)
|
|
interfaceDesc++;
|
|
|
|
epDesc = interfaceDesc->altsetting->endpoint;
|
|
numEP = interfaceDesc->altsetting->bNumEndpoints;
|
|
device->numEndpoints = numEP;
|
|
// Check the total number of endpoints interface has
|
|
// and get all the endpoint add
|
|
CY_DEBUG_PRINT_INFO ("CY:Info The total number of endpoints are %d \n", numEP);
|
|
while (numEP){
|
|
if (epDesc->bmAttributes == 0x2){ //Bulk EP checking
|
|
if (epDesc->bEndpointAddress & 0x80)
|
|
device->inEndpoint = epDesc->bEndpointAddress;
|
|
else
|
|
device->outEndpoint = epDesc->bEndpointAddress;
|
|
}
|
|
else if (epDesc->bmAttributes == 0x3) //Interrupt EP checking (We have only one interrupt EP)
|
|
device->interruptEndpoint = epDesc->bEndpointAddress;
|
|
epDesc++;
|
|
numEP--;
|
|
}
|
|
CY_DEBUG_PRINT_INFO ("CY:Info The Endpoints are in %d and out %d and interrup %d\n",
|
|
device->inEndpoint, device->outEndpoint, device->interruptEndpoint);
|
|
libusb_free_config_descriptor (configDesc);
|
|
return CY_SUCCESS;
|
|
}
|
|
/*
|
|
* This API selects the type of the device
|
|
*/
|
|
void CySelectDeviceType (CY_DEVICE *device, libusb_device *libUsbdev, unsigned char interfaceNum)
|
|
{
|
|
int rStatus, numInterfaces;
|
|
struct libusb_config_descriptor *configDesc;
|
|
int index = 0;
|
|
const struct libusb_interface *interfaceDesc;
|
|
device->deviceType = CY_TYPE_DISABLED;
|
|
|
|
rStatus = libusb_get_config_descriptor (libUsbdev, 0, &configDesc);
|
|
if (0 == rStatus){
|
|
interfaceDesc = configDesc->interface;
|
|
numInterfaces = configDesc->bNumInterfaces;
|
|
if (interfaceNum >= numInterfaces)
|
|
return;
|
|
while (index != interfaceNum) {
|
|
index++;
|
|
interfaceDesc++;
|
|
}
|
|
if (interfaceDesc->altsetting->bInterfaceClass == CY_CLASS_VENDOR)
|
|
device->deviceType = (CY_DEVICE_CLASS)interfaceDesc->altsetting->bInterfaceSubClass;
|
|
libusb_free_config_descriptor (configDesc);
|
|
}
|
|
CY_DEBUG_PRINT_INFO ("CY:Info The device type is %d \n", device->deviceType);
|
|
}
|
|
/*
|
|
The Api Gets the handle for the specified device number
|
|
(refer to usage guide and example for usage)
|
|
and this handle should be called for further communication
|
|
with the device
|
|
*/
|
|
CY_RETURN_STATUS CyOpen (
|
|
unsigned char deviceNumber,
|
|
unsigned char interfaceNum,
|
|
CY_HANDLE *handle
|
|
)
|
|
{
|
|
libusb_device_handle *devHandle;
|
|
libusb_device *dev;
|
|
CY_DEVICE *device;
|
|
UINT32 rStatus;
|
|
|
|
if (glDriverInit == false){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error Library not initialised ...function is %s\n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
pthread_mutex_lock (&criticalSection);
|
|
if (glDriverInit == true){
|
|
if (deviceNumber >= glNumDevices){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error ... Invalid device number ... \n");
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_INVALID_PARAMETER;
|
|
}
|
|
dev = glDeviceList [deviceNumber];
|
|
rStatus = libusb_open (dev, &devHandle);
|
|
if (rStatus == LIBUSB_ERROR_ACCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in opening the device ..Access denied \n");
|
|
handle = NULL;
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_ACCESS_DENIED;
|
|
}
|
|
if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in Opening the Device ...Error is %d \n", rStatus);
|
|
printf("rstatus1 %d", rStatus);
|
|
handle = NULL;
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_DRIVER_OPEN_FAILED;
|
|
}
|
|
device = (CY_DEVICE *)malloc(sizeof (CY_DEVICE));
|
|
if (device == NULL){
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_ERROR_ALLOCATION_FAILED;
|
|
}
|
|
device->devHandle = devHandle;
|
|
(*handle) = device;
|
|
rStatus = CySelectInterface (device, interfaceNum);
|
|
if (rStatus != CY_SUCCESS){
|
|
libusb_close (devHandle);
|
|
free (device);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
printf("rstatus2 %d", rStatus);
|
|
return CY_ERROR_DRIVER_OPEN_FAILED;
|
|
}
|
|
CySelectDeviceType (device, dev, interfaceNum);
|
|
if (device->deviceType == CY_TYPE_UART) {
|
|
CyUartSetRts (*handle);
|
|
CyUartSetDtr (*handle);
|
|
if (!CyUartSetHwFlowControl (*handle, CY_UART_FLOW_CONTROL_DISABLE))
|
|
device->uartFlowControlMode = CY_UART_FLOW_CONTROL_DISABLE;
|
|
}
|
|
//initialising structure elements
|
|
device->spiThreadId = (pthread_t)0;
|
|
device->uartThreadId = (pthread_t)0;
|
|
device->spiCancelEvent = false;
|
|
device->uartCancelEvent = false;
|
|
device->spiTransfer = NULL;
|
|
device->uartTransfer = NULL;
|
|
if (pthread_mutex_init (&device->readLock, NULL)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error initializing the read mutex .. Function is %s \n", __func__);
|
|
libusb_close (devHandle);
|
|
free (device);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
printf("rstatus3 %d", rStatus);
|
|
return CY_ERROR_DRIVER_OPEN_FAILED;
|
|
}
|
|
if (pthread_mutex_init (&device->writeLock, NULL)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error initializing the write mutex .. Function is %s \n", __func__);
|
|
libusb_close (devHandle);
|
|
free (device);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
printf("rstatus4 %d", rStatus);
|
|
return CY_ERROR_DRIVER_OPEN_FAILED;
|
|
}
|
|
if (pthread_mutex_init (&device->notificationLock, NULL)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error initializing the write mutex .. Function is %s \n", __func__);
|
|
libusb_close (devHandle);
|
|
free (device);
|
|
pthread_mutex_unlock (&criticalSection);
|
|
printf("rstatus5 %d", rStatus);
|
|
return CY_ERROR_DRIVER_OPEN_FAILED;
|
|
}
|
|
pthread_mutex_unlock (&criticalSection);
|
|
return CY_SUCCESS;
|
|
}
|
|
else{
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error iniitalise library by calling CyLibraryInit()....function is %s\n", __func__);
|
|
printf("rstatus6 %d", rStatus);
|
|
return CY_ERROR_DRIVER_OPEN_FAILED;
|
|
}
|
|
|
|
|
|
}
|
|
/*
|
|
The Api Closes the handle and needs to be called only if CyGetNumDevices
|
|
or CyOpen is called
|
|
*/
|
|
CY_RETURN_STATUS CyClose (
|
|
CY_HANDLE handle
|
|
)
|
|
{
|
|
CY_DEVICE *device;
|
|
libusb_device_handle *devHandle;
|
|
|
|
if (handle == NULL)
|
|
return CY_ERROR_INVALID_HANDLE;
|
|
device = (CY_DEVICE *)handle;
|
|
devHandle = device->devHandle;
|
|
if (device->deviceType == CY_TYPE_UART) {
|
|
CyUartClearRts (handle);
|
|
CyUartClearDtr (handle);
|
|
CyUartSetHwFlowControl (handle, CY_UART_FLOW_CONTROL_DISABLE);
|
|
}
|
|
if (glDriverInit == true){
|
|
if (device->deviceType == CY_TYPE_SPI || device->deviceType == CY_TYPE_UART){
|
|
if (device->spiThreadId != 0 || device->uartThreadId != 0){
|
|
CyAbortEventNotification(handle);
|
|
}
|
|
}
|
|
if (pthread_mutex_destroy (&device->readLock)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error de initializing the read mutex .. Function is %s \n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
if (pthread_mutex_destroy (&device->writeLock)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error de initializing the write mutex .. Function is %s \n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
if (pthread_mutex_destroy (&device->notificationLock)){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error de initializing the write mutex .. Function is %s \n", __func__);
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
libusb_close ((libusb_device_handle*)devHandle);
|
|
free (device);
|
|
}
|
|
return CY_SUCCESS;
|
|
}
|
|
/*
|
|
This Api will reset the pipe and clears the endpoint
|
|
*/
|
|
CY_RETURN_STATUS CyResetPipe (
|
|
CY_HANDLE handle,
|
|
UINT8 endPointAddress
|
|
)
|
|
{
|
|
UINT32 rStatus;
|
|
CY_DEVICE *device;
|
|
libusb_device_handle *devHandle;
|
|
|
|
if (handle == NULL)
|
|
return CY_ERROR_INVALID_HANDLE;
|
|
device = (CY_DEVICE *)handle;
|
|
devHandle = device->devHandle;
|
|
|
|
rStatus = libusb_clear_halt ((libusb_device_handle *)devHandle, endPointAddress);
|
|
if (rStatus != LIBUSB_SUCCESS){
|
|
CY_DEBUG_PRINT_ERROR ("CY:Error in resetting the pipe ... \n");
|
|
return CY_ERROR_REQUEST_FAILED;
|
|
}
|
|
return CY_SUCCESS;
|
|
}
|
|
/*
|
|
This Api will get the library version,patch
|
|
and build number
|
|
*/
|
|
CY_RETURN_STATUS CyGetLibraryVersion (
|
|
CY_HANDLE handle,
|
|
PCY_LIBRARY_VERSION version
|
|
)
|
|
{
|
|
version->majorVersion = CY_US_VERSION_MAJOR;
|
|
version->minorVersion = CY_US_VERSION_MINOR;
|
|
version->patch = CY_US_VERSION_PATCH;
|
|
version->buildNumber = CY_US_VERSION_BUILD;
|
|
return CY_SUCCESS;
|
|
}
|