508 lines
19 KiB
C
508 lines
19 KiB
C
#include <Windows.h>
|
||
#include <SetupAPI.h>
|
||
#include <initguid.h>
|
||
#include <stddef.h>
|
||
#include <tchar.h>
|
||
|
||
#include "../l502api_private.h"
|
||
|
||
#include <winioctl.h>
|
||
|
||
|
||
|
||
/* GUID интерфейса устройств lpcie для связи приложения с драйвером */
|
||
DEFINE_GUID (GUID_LPCIE_INTERFACE,
|
||
0x53869b9a, 0x7875, 0x4fd3, 0x9e, 0x04, 0xbe, 0xc8, 0x1a, 0x92, 0xf9, 0xa9);
|
||
|
||
#define L502_IOCTL_TIMEOUT 500
|
||
|
||
|
||
typedef struct {
|
||
int32_t size;
|
||
SP_DEVICE_INTERFACE_DETAIL_DATA *intf_detail;
|
||
} t_lpcie_devlst_intptr;
|
||
|
||
|
||
static int32_t f_ioctl(HANDLE hDevice,
|
||
uint32_t dwIoControlCode, // control code of operation to perform
|
||
void* lpInBuffer, // pointer to buffer to supply input data
|
||
uint32_t nInBufferSize, // size of input buffer in bytes
|
||
void* lpOutBuffer, // pointer to buffer to receive output data
|
||
uint32_t nOutBufferSize, // size of output buffer in bytes
|
||
uint32_t* rx_size,
|
||
uint32_t TimeOut) { // таймаут в мс
|
||
uint32_t RealBytesTransferred;
|
||
uint32_t BytesReturned;
|
||
OVERLAPPED Ov;
|
||
int32_t err = X502_ERR_OK;
|
||
uint32_t syserr = 0;
|
||
|
||
|
||
// инициализируем OVERLAPPED структуру
|
||
memset(&Ov, 0x0, sizeof(OVERLAPPED));
|
||
// создаём событие для асинхронного запроса
|
||
Ov.hEvent = CreateEvent(NULL, FALSE , FALSE, NULL);
|
||
if(!Ov.hEvent) {
|
||
err = X502_ERR_MEMORY_ALLOC;
|
||
} else {
|
||
// посылаем требуемый запрос
|
||
if(!DeviceIoControl( hDevice, dwIoControlCode,
|
||
lpInBuffer, nInBufferSize,
|
||
lpOutBuffer, nOutBufferSize,
|
||
&BytesReturned, &Ov)) {
|
||
syserr = GetLastError();
|
||
if(syserr != ERROR_IO_PENDING) {
|
||
CloseHandle(Ov.hEvent);
|
||
err = X502_ERR_IOCTL_FAILD;
|
||
GetOverlappedResult(hDevice, &Ov, &RealBytesTransferred, TRUE);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (err == X502_ERR_OK) {
|
||
// ждём окончания выполнения запроса
|
||
if (WaitForSingleObject(Ov.hEvent, TimeOut) == WAIT_TIMEOUT) {
|
||
CancelIo(hDevice);
|
||
CloseHandle(Ov.hEvent);
|
||
err = X502_ERR_IOCTL_TIMEOUT;
|
||
GetOverlappedResult(hDevice, &Ov, &RealBytesTransferred, TRUE);
|
||
}
|
||
}
|
||
// попробуем получить кол-во реально переданных байт данных
|
||
if (err == X502_ERR_OK) {
|
||
if(!GetOverlappedResult(hDevice, &Ov, &RealBytesTransferred, TRUE)) {
|
||
syserr = GetLastError();
|
||
CancelIo(hDevice);
|
||
CloseHandle(Ov.hEvent);
|
||
err = X502_ERR_IOCTL_FAILD;
|
||
} else if(nOutBufferSize != RealBytesTransferred) {
|
||
CancelIo(hDevice);
|
||
CloseHandle(Ov.hEvent);
|
||
} else {
|
||
CloseHandle(Ov.hEvent);
|
||
}
|
||
}
|
||
|
||
if ((err == X502_ERR_OK) && (rx_size != NULL)) {
|
||
*rx_size = RealBytesTransferred;
|
||
}
|
||
|
||
if (err==X502_ERR_IOCTL_FAILD) {
|
||
if (syserr == ERROR_NO_SYSTEM_RESOURCES)
|
||
err = X502_ERR_INSUFFICIENT_SYSTEM_RESOURCES;
|
||
}
|
||
return err;
|
||
}
|
||
|
||
|
||
int32_t l502_port_fpga_reg_write(t_x502_hnd hnd, uint32_t reg, uint32_t val) {
|
||
t_lpcie_mem_rw mem_wr = {reg,val};
|
||
return f_ioctl (L502_PCI_IFACE_FILE(hnd),
|
||
LPCIE_IOCTL_MEMFPGA_WR, &mem_wr, sizeof(mem_wr),
|
||
NULL, 0, NULL, L502_IOCTL_TIMEOUT) ?
|
||
X502_ERR_FPGA_REG_READ : 0;
|
||
}
|
||
|
||
|
||
int32_t l502_port_fpga_reg_read(t_x502_hnd hnd, uint32_t reg, uint32_t *val) {
|
||
uint32_t rd_val;
|
||
int32_t err = f_ioctl (L502_PCI_IFACE_FILE(hnd),
|
||
LPCIE_IOCTL_MEMFPGA_RD, ®, sizeof(reg),
|
||
&rd_val, sizeof(rd_val), NULL, L502_IOCTL_TIMEOUT);
|
||
if (err != X502_ERR_OK) {
|
||
err = X502_ERR_FPGA_REG_READ;
|
||
} else if (val != NULL) {
|
||
*val = rd_val;
|
||
}
|
||
return err;
|
||
}
|
||
|
||
int32_t l502_port_stream_set_params(t_x502_hnd hnd, t_lpcie_stream_ch_params *par) {
|
||
return f_ioctl(L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_STREAM_SET_PARAMS, par,
|
||
sizeof(t_lpcie_stream_ch_params), NULL, 0, NULL,
|
||
L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
int32_t l502_port_stream_start(t_x502_hnd hnd, uint32_t ch, uint32_t single) {
|
||
return f_ioctl(L502_PCI_IFACE_FILE(hnd), single ? LPCIE_IOCTL_STREAM_START_SINGLE :
|
||
LPCIE_IOCTL_STREAM_START,
|
||
&ch, sizeof(ch), NULL, 0, NULL,
|
||
L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
int32_t l502_port_stream_stop(t_x502_hnd hnd, uint32_t ch, uint32_t flags) {
|
||
return f_ioctl(L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_STREAM_STOP, &ch, sizeof(ch), NULL, 0, NULL,
|
||
L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
int32_t l502_port_stream_free(t_x502_hnd hnd, uint32_t ch, uint32_t flags) {
|
||
return f_ioctl(L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_STREAM_FREE, &ch, sizeof(ch), NULL, 0, NULL,
|
||
L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
|
||
int32_t l502_port_stream_rdy_size(t_x502_hnd hnd, uint32_t ch, uint32_t *rdy_size) {
|
||
uint32_t rd_val;
|
||
int32_t err = f_ioctl (L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_STREAM_GET_RDY_SIZE, &ch, sizeof(ch),
|
||
&rd_val, sizeof(rd_val), NULL, L502_IOCTL_TIMEOUT);
|
||
if ((err == X502_ERR_OK) && (rdy_size != NULL))
|
||
*rdy_size = rd_val;
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
int32_t l502_port_cycle_load_start(t_x502_hnd hnd, uint32_t ch, uint32_t size, uint32_t min_irq_step) {
|
||
t_lpcie_cycle_set_par par;
|
||
memset(&par, 0, sizeof(par));
|
||
par.ch = ch;
|
||
par.size = size;
|
||
par.irq_step = min_irq_step;
|
||
return f_ioctl (L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_CYCLE_LOAD, &par, sizeof(par), NULL, 0,
|
||
NULL, L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
int32_t l502_port_cycle_setup(t_x502_hnd hnd, uint32_t ch, uint32_t evt) {
|
||
t_lpcie_cycle_evt_par par;
|
||
memset(&par, 0, sizeof(par));
|
||
par.ch = ch;
|
||
par.evt = evt;
|
||
return f_ioctl (L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_CYCLE_SWITCH, &par, sizeof(par), NULL, 0,
|
||
NULL, L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
int32_t l502_port_cycle_stop(t_x502_hnd hnd, uint32_t ch, uint32_t evt) {
|
||
t_lpcie_cycle_evt_par par;
|
||
memset(&par, 0, sizeof(par));
|
||
par.ch = ch;
|
||
par.evt = evt;
|
||
return f_ioctl (L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_CYCLE_STOP, &par, sizeof(par), NULL, 0,
|
||
NULL, L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
int32_t l502_port_cycle_check_setup(t_x502_hnd hnd, uint32_t ch, uint32_t *done) {
|
||
uint32_t rd_val;
|
||
int32_t err = f_ioctl (L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_CYCLE_CHECK_SETUP, &ch, sizeof(ch),
|
||
&rd_val, sizeof(rd_val), NULL, L502_IOCTL_TIMEOUT);
|
||
if ((err == X502_ERR_OK) && (done != NULL))
|
||
*done = rd_val;
|
||
return err;
|
||
}
|
||
|
||
int32_t l502_port_renew_info(t_x502_hnd hnd) {
|
||
return f_ioctl(L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_RELOAD_DEVINFO, NULL, 0, NULL, 0, NULL,
|
||
L502_IOCTL_TIMEOUT);
|
||
}
|
||
|
||
int32_t l502_port_get_drv_ver(t_x502_hnd hnd, uint32_t *ver) {
|
||
uint32_t rd_val;
|
||
int32_t err = f_ioctl (L502_PCI_IFACE_FILE(hnd), LPCIE_IOCTL_GET_DRV_VERSION, NULL, 0,
|
||
&rd_val, sizeof(rd_val), NULL, L502_IOCTL_TIMEOUT);
|
||
if ((err == X502_ERR_OK) && (ver != NULL))
|
||
*ver = rd_val;
|
||
return err;
|
||
}
|
||
|
||
|
||
int32_t l502_port_stream_read(t_x502_hnd hnd, uint32_t* buff, uint32_t size, uint32_t timeout) {
|
||
int send_size = 4*size;
|
||
uint32_t NumberOfBytesRead = 0;
|
||
int32_t err = X502_ERR_OK;
|
||
OVERLAPPED Ov;
|
||
|
||
// инициализируем OVERLAPPED структуру
|
||
memset(&Ov, 0, sizeof(OVERLAPPED));
|
||
Ov.hEvent = CreateEvent(NULL, FALSE , FALSE, NULL);
|
||
if(!Ov.hEvent) {
|
||
err = X502_ERR_MEMORY_ALLOC;
|
||
}
|
||
|
||
if (err == X502_ERR_OK) {
|
||
// посылаем асинхронный запрос на сбор необходимого кол-ва данных
|
||
if(!ReadFile(L502_PCI_IFACE_FILE(hnd), buff, send_size, NULL, &Ov)) {
|
||
if(GetLastError() != ERROR_IO_PENDING) {
|
||
CancelIo(L502_PCI_IFACE_FILE(hnd));
|
||
CloseHandle(Ov.hEvent);
|
||
err = X502_ERR_RECV;
|
||
GetOverlappedResult(L502_PCI_IFACE_FILE(hnd), &Ov, &NumberOfBytesRead, TRUE);
|
||
}
|
||
}
|
||
}
|
||
// ждём окончания выполнения запроса
|
||
if (err == X502_ERR_OK) {
|
||
if (WaitForSingleObject(Ov.hEvent, timeout) == WAIT_TIMEOUT) {
|
||
CancelIo(L502_PCI_IFACE_FILE(hnd));
|
||
CloseHandle(Ov.hEvent);
|
||
GetOverlappedResult(L502_PCI_IFACE_FILE(hnd), &Ov, &NumberOfBytesRead, TRUE);
|
||
} else if(!GetOverlappedResult(L502_PCI_IFACE_FILE(hnd), &Ov, &NumberOfBytesRead, TRUE)) {
|
||
CancelIo(L502_PCI_IFACE_FILE(hnd));
|
||
CloseHandle(Ov.hEvent);
|
||
err = X502_ERR_RECV;
|
||
} else {
|
||
CloseHandle(Ov.hEvent);
|
||
}
|
||
}
|
||
return err != X502_ERR_OK ? err : NumberOfBytesRead/4;
|
||
}
|
||
|
||
|
||
|
||
int32_t l502_port_stream_write(t_x502_hnd hnd, const uint32_t* buff,
|
||
uint32_t size, uint32_t timeout) {
|
||
int send_size = 4*size;
|
||
uint32_t NumberOfBytesRead = 0;
|
||
int32_t err = X502_ERR_OK;
|
||
OVERLAPPED Ov;
|
||
|
||
// инициализируем OVERLAPPED структуру
|
||
memset(&Ov, 0, sizeof(OVERLAPPED));
|
||
Ov.hEvent = CreateEvent(NULL, FALSE , FALSE, NULL);
|
||
if(!Ov.hEvent) {
|
||
err = X502_ERR_MEMORY_ALLOC;
|
||
}
|
||
if (err == X502_ERR_OK) {
|
||
// посылаем асинхронный запрос на сбор необходимого кол-ва данных
|
||
if(!WriteFile(L502_PCI_IFACE_FILE(hnd), buff, send_size, NULL, &Ov)) {
|
||
if(GetLastError() != ERROR_IO_PENDING) {
|
||
CancelIo(L502_PCI_IFACE_FILE(hnd));
|
||
CloseHandle(Ov.hEvent);
|
||
err = X502_ERR_SEND;
|
||
GetOverlappedResult(L502_PCI_IFACE_FILE(hnd), &Ov, &NumberOfBytesRead, TRUE);
|
||
}
|
||
}
|
||
}
|
||
// ждём окончания выполнения запроса
|
||
if (err == X502_ERR_OK) {
|
||
if (WaitForSingleObject(Ov.hEvent, timeout) == WAIT_TIMEOUT) {
|
||
CancelIo(L502_PCI_IFACE_FILE(hnd));
|
||
CloseHandle(Ov.hEvent);
|
||
GetOverlappedResult(L502_PCI_IFACE_FILE(hnd), &Ov, &NumberOfBytesRead, TRUE);
|
||
} else if(!GetOverlappedResult(L502_PCI_IFACE_FILE(hnd), &Ov, &NumberOfBytesRead, TRUE)) {
|
||
CancelIo(L502_PCI_IFACE_FILE(hnd));
|
||
CloseHandle(Ov.hEvent);
|
||
err = X502_ERR_SEND;
|
||
} else {
|
||
CloseHandle(Ov.hEvent);
|
||
}
|
||
}
|
||
return err != X502_ERR_OK ? err : NumberOfBytesRead/4;
|
||
}
|
||
|
||
|
||
|
||
static int32_t f_get_file_par(SP_DEVICE_INTERFACE_DETAIL_DATA *detail, TCHAR* filebuf,
|
||
const TCHAR* file, char* res, uint32_t req_size,
|
||
uint32_t* read_size) {
|
||
HANDLE ifile;
|
||
int32_t err = 0;
|
||
_tcscpy(filebuf, TEXT(detail->DevicePath));
|
||
_tcscat(filebuf, file);
|
||
|
||
ifile = CreateFile(filebuf, GENERIC_READ,
|
||
FILE_SHARE_READ,
|
||
NULL, OPEN_EXISTING,
|
||
0, NULL);
|
||
if (ifile != INVALID_HANDLE_VALUE) {
|
||
DWORD read_cnt=0;
|
||
if (!ReadFile(ifile, res, req_size, &read_cnt, NULL)) {
|
||
err = X502_ERR_GET_INFO;
|
||
} else {
|
||
if (read_size!=NULL)
|
||
*read_size = read_cnt;
|
||
}
|
||
CloseHandle(ifile);
|
||
} else {
|
||
err = X502_ERR_GET_INFO;
|
||
}
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
|
||
static int f_fill_devlist(SP_DEVICE_INTERFACE_DETAIL_DATA *detail,
|
||
t_x502_devrec *info) {
|
||
int32_t err = X502_ERR_OK;
|
||
TCHAR *filename = malloc(sizeof(TCHAR)*21 + _tcslen(detail->DevicePath));
|
||
|
||
if (filename == NULL) {
|
||
err = X502_ERR_MEMORY_ALLOC;
|
||
} else {
|
||
err = f_get_file_par(detail, filename, TEXT("\\name"), info->devname,
|
||
sizeof(info->devname), NULL);
|
||
if (err == X502_ERR_OK) {
|
||
/* получаем серийный номер устройства */
|
||
err = f_get_file_par(detail, filename, TEXT("\\sn"), info->serial,
|
||
sizeof(info->serial), NULL);
|
||
}
|
||
|
||
/* получаем информацию, открыто ли устройство */
|
||
if (err == X502_ERR_OK) {
|
||
char val = '0';
|
||
f_get_file_par(detail, filename, TEXT("\\opened"), &val, 1, NULL);
|
||
if (!err && (val!='0'))
|
||
info->flags |= X502_DEVFLAGS_DEVREC_OPENED;
|
||
}
|
||
|
||
/* получаем информацию, присутствует ли BlackFin */
|
||
if (err == X502_ERR_OK) {
|
||
char val = '0';
|
||
if ((f_get_file_par(detail, filename, TEXT("\\bf"), &val, 1, NULL)==0)
|
||
&& (val != '0')) {
|
||
info->flags |= X502_DEVFLAGS_BF_PRESENT;
|
||
}
|
||
|
||
if ((f_get_file_par(detail, filename, TEXT("\\dac"), &val, 1, NULL)==0)
|
||
&& (val != '0')) {
|
||
info->flags |= X502_DEVFLAGS_DAC_PRESENT;
|
||
}
|
||
|
||
if ((f_get_file_par(detail, filename, TEXT("\\gal"), &val, 1, NULL)==0)
|
||
&& (val != '0')) {
|
||
info->flags |= X502_DEVFLAGS_GAL_PRESENT;
|
||
}
|
||
}
|
||
|
||
if (err == X502_ERR_OK) {
|
||
err = l502_devlist_gen(info, detail);
|
||
}
|
||
free(filename);
|
||
}
|
||
return err;
|
||
}
|
||
|
||
int32_t l502_port_free_iface_data(void *intptr) {
|
||
free(intptr);
|
||
return X502_ERR_OK;
|
||
}
|
||
|
||
|
||
int32_t l502_port_open(t_x502_hnd hnd, const t_x502_devrec *devinfo) {
|
||
SP_DEVICE_INTERFACE_DETAIL_DATA *detail = (SP_DEVICE_INTERFACE_DETAIL_DATA *)devinfo->internal->iface_data;
|
||
int32_t err = X502_ERR_OK;
|
||
HANDLE file = CreateFile(detail->DevicePath, GENERIC_READ | GENERIC_WRITE,
|
||
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
||
NULL, OPEN_EXISTING,
|
||
FILE_FLAG_OVERLAPPED, NULL);
|
||
if (file != INVALID_HANDLE_VALUE) {
|
||
hnd->iface_data = malloc(sizeof(t_pci_iface_data));
|
||
if (hnd->iface_data == NULL) {
|
||
err = X502_ERR_MEMORY_ALLOC;
|
||
CloseHandle(file);
|
||
} else {
|
||
L502_PCI_IFACE_FILE(hnd) = file;
|
||
}
|
||
} else {
|
||
DWORD syserr = GetLastError();
|
||
if (syserr == ERROR_ACCESS_DENIED) {
|
||
err = X502_ERR_DEVICE_ACCESS_DENIED;
|
||
} else if (syserr == ERROR_FILE_NOT_FOUND) {
|
||
err = X502_ERR_DEVICE_NOT_FOUND;
|
||
} else {
|
||
err = X502_ERR_DEVICE_OPEN;
|
||
}
|
||
}
|
||
return err;
|
||
}
|
||
|
||
int32_t l502_port_close(t_x502_hnd hnd) {
|
||
if (hnd->iface_data !=NULL) {
|
||
CloseHandle(L502_PCI_IFACE_FILE(hnd));
|
||
free(hnd->iface_data);
|
||
hnd->iface_data = NULL;
|
||
}
|
||
return X502_ERR_OK;
|
||
}
|
||
|
||
|
||
|
||
X502_EXPORT(int32_t) L502_GetDevRecordsList(t_x502_devrec *list, uint32_t size,
|
||
uint32_t flags, uint32_t *devcnt) {
|
||
HDEVINFO infoSet;
|
||
SP_DEVINFO_DATA infoData;
|
||
DWORD index=0;
|
||
uint32_t curcnt=0;
|
||
int32_t err = X502_ERR_OK;
|
||
|
||
|
||
infoData.cbSize = sizeof(SP_DEVINFO_DATA);
|
||
|
||
/* получаем список устройств с подержкой интерфейса lpcie */
|
||
infoSet = SetupDiGetClassDevs(&GUID_LPCIE_INTERFACE,NULL,
|
||
NULL,
|
||
DIGCF_DEVICEINTERFACE | DIGCF_PRESENT);
|
||
|
||
/* проходимся по всем устройствам из списка */
|
||
while (SetupDiEnumDeviceInfo(infoSet, index, &infoData)) {
|
||
SP_DEVICE_INTERFACE_DATA intfData;
|
||
intfData.cbSize = sizeof(intfData);
|
||
/* получаем информацию о интерфейсе */
|
||
if (SetupDiEnumDeviceInterfaces(infoSet, &infoData, &GUID_LPCIE_INTERFACE,
|
||
0, &intfData)) {
|
||
DWORD req_size;
|
||
/* узнаем резмер детальной информации о интерфейсе (нужна для
|
||
получения имени устройства) */
|
||
if (!SetupDiGetDeviceInterfaceDetail(infoSet, &intfData, NULL,
|
||
0, &req_size, NULL)
|
||
&& (GetLastError() == ERROR_INSUFFICIENT_BUFFER)) {
|
||
SP_DEVICE_INTERFACE_DETAIL_DATA* detail =
|
||
(SP_DEVICE_INTERFACE_DETAIL_DATA*) malloc(req_size);
|
||
|
||
if (detail != NULL) {
|
||
int detail_used = 0;
|
||
|
||
/* пытаемся получить всю информацию */
|
||
detail->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA);
|
||
|
||
if (SetupDiGetDeviceInterfaceDetail(infoSet, &intfData,
|
||
detail, req_size,
|
||
NULL, NULL)) {
|
||
t_x502_devrec info;
|
||
int info_used = 0;
|
||
detail_used = 1;
|
||
|
||
X502_DevRecordInit(&info);
|
||
|
||
/* получаем информацию о устройстве из служебных файлов,
|
||
* предоставляемых драйвером */
|
||
if (f_fill_devlist(detail, &info) == X502_ERR_OK) {
|
||
/* если нужны только не открытые, то уже открытое
|
||
* устройство пропускаем */
|
||
if (!(flags & X502_GETDEVS_FLAGS_ONLY_NOT_OPENED) ||
|
||
!(info.flags & X502_DEVFLAGS_DEVREC_OPENED)) {
|
||
/* если есть место в списке - то сохраняем
|
||
* полученную информацию */
|
||
if ((list!=NULL) && (curcnt < size)) {
|
||
list[curcnt] = info;
|
||
info_used = 1;
|
||
}
|
||
curcnt++;
|
||
}
|
||
}
|
||
|
||
if (!info_used)
|
||
X502_FreeDevRecordList(&info,1);
|
||
}
|
||
|
||
if (!detail_used) {
|
||
free(detail);
|
||
}
|
||
} else {
|
||
err = X502_ERR_MEMORY_ALLOC;
|
||
}
|
||
}
|
||
}
|
||
index++;
|
||
}
|
||
|
||
|
||
if (infoSet != NULL) {
|
||
SetupDiDestroyDeviceInfoList(infoSet);
|
||
}
|
||
|
||
if (devcnt != NULL)
|
||
*devcnt = curcnt;
|
||
|
||
return err != X502_ERR_OK ? err : curcnt > size ? size : curcnt ;
|
||
}
|