/* ARGSUSED */
static ldma_request_status_t
ldma_dio_pcidev_info_handler(ds_ver_t *ver, ldma_message_header_t *request,
size_t request_dlen, ldma_message_header_t **replyp, size_t *reply_dlenp)
{
ldma_message_header_t *reply;
char *data;
uint8_t *md_bufp = NULL;
size_t md_size;
int rv;
LDMA_DBG("%s: PCI device info request", __func__);
rv = get_devinfo(&md_bufp, &md_size);
if (rv != 0) {
LDMA_ERR("Failed to generate devinfo MD");
return (LDMA_REQ_FAILED);
}
reply = ldma_alloc_result_msg(request, md_size);
if (reply == NULL) {
LDMA_ERR("Memory allocation failure");
free(md_bufp);
return (LDMA_REQ_FAILED);
}
reply->msg_info = md_size;
data = LDMA_HDR2DATA(reply);
(void) memcpy(data, md_bufp, md_size);
*replyp = reply;
*reply_dlenp = md_size;
free(md_bufp);
LDMA_DBG("%s: sending PCI device info", __func__);
return (LDMA_REQ_COMPLETED);
}
static int lusb_probe(backend_probe_target probe_target,
struct bladerf_devinfo_list *info_list)
{
int status, i, n;
ssize_t count;
libusb_device **list;
struct bladerf_devinfo info;
libusb_context *context;
/* Initialize libusb for device tree walking */
status = libusb_init(&context);
if (status) {
log_error("Could not initialize libusb: %s\n",
libusb_error_name(status));
goto lusb_probe_done;
}
count = libusb_get_device_list(context, &list);
/* Iterate through all the USB devices */
for (i = 0, n = 0; i < count && status == 0; i++) {
if (device_is_probe_target(probe_target, list[i])) {
/* Open the USB device and get some information */
status = get_devinfo(list[i], &info);
if (status) {
/* We may not be able to open the device if another
* driver (e.g., CyUSB3) is associated with it. Therefore,
* just log to the debug level and carry on. */
status = 0;
log_debug("Could not open device: %s\n",
libusb_error_name(status) );
} else {
info.instance = n++;
status = bladerf_devinfo_list_add(info_list, &info);
if( status ) {
log_error("Could not add device to list: %s\n",
bladerf_strerror(status) );
} else {
log_verbose("Added instance %d to device list\n",
info.instance);
}
}
}
}
libusb_free_device_list(list, 1);
libusb_exit(context);
lusb_probe_done:
return status;
}
static int find_and_open_device(libusb_context *context,
const struct bladerf_devinfo *info_in,
struct bladerf_lusb **dev_out,
struct bladerf_devinfo *info_out)
{
int status = BLADERF_ERR_NODEV;
int i, n;
ssize_t count;
struct libusb_device **list;
struct bladerf_devinfo curr_info;
bool printed_access_warning = false;
*dev_out = NULL;
count = libusb_get_device_list(context, &list);
if (count < 0) {
if (count < INT_MIN) {
/* Ensure we don't have a situation where we accidentally return 0
* due to a narrowing conversion */
return BLADERF_ERR_UNEXPECTED;
} else {
return error_conv((int) count);
}
}
for (i = 0, n = 0; (i < count) && (*dev_out == NULL); i++) {
if (device_is_bladerf(list[i])) {
log_verbose("Found a bladeRF (idx=%d)\n", i);
/* Open the USB device and get some information */
status = get_devinfo(list[i], &curr_info);
if (status < 0) {
/* Give the user a helpful hint in case the have forgotten
* to update their udev rules */
if (status == LIBUSB_ERROR_ACCESS && !printed_access_warning) {
printed_access_warning = true;
log_warning("Found a bladeRF via VID/PID, but could not "
"open it due to insufficient permissions.\n");
} else {
log_debug("Could not open bladeRF device: %s\n",
libusb_error_name(status) );
}
status = BLADERF_ERR_NODEV;
continue; /* Continue trying the next devices */
} else {
curr_info.instance = n++;
}
/* Check to see if this matches the info struct */
if (bladerf_devinfo_matches(&curr_info, info_in)) {
status = open_device(&curr_info, context, list[i], dev_out);
if (status < 0) {
status = BLADERF_ERR_NODEV;
continue; /* Continue trying the next matching device */
} else {
memcpy(info_out, &curr_info, sizeof(info_out[0]));
}
} else {
status = BLADERF_ERR_NODEV;
log_verbose("Devinfo doesn't match - skipping"
"(instance=%d, serial=%d, bus/addr=%d\n",
bladerf_instance_matches(&curr_info, info_in),
bladerf_serial_matches(&curr_info, info_in),
bladerf_bus_addr_matches(&curr_info, info_in));
}
}
}
if (status == 0) {
/* Returning 0 indicates this function is providing a device */
assert(*dev_out != NULL);
}
libusb_free_device_list(list, 1);
return status;
}
static int lusb_probe(backend_probe_target probe_target,
struct bladerf_devinfo_list *info_list)
{
int status, i, n;
ssize_t count;
libusb_device **list;
struct bladerf_devinfo info;
bool printed_access_warning = false;
libusb_context *context;
/* Initialize libusb for device tree walking */
status = libusb_init(&context);
if (status) {
log_error("Could not initialize libusb: %s\n",
libusb_error_name(status));
goto lusb_probe_done;
}
count = libusb_get_device_list(context, &list);
/* Iterate through all the USB devices */
for (i = 0, n = 0; i < count && status == 0; i++) {
if (device_is_probe_target(probe_target, list[i])) {
/* Open the USB device and get some information */
status = get_devinfo(list[i], &info);
if (status) {
/* We may not be able to open the device if another
* driver (e.g., CyUSB3) is associated with it. Therefore,
* just log to the debug level and carry on. */
log_debug("Could not open device: %s\n",
libusb_error_name(status) );
if (status == LIBUSB_ERROR_ACCESS && !printed_access_warning) {
printed_access_warning = true;
log_warning("Found a bladeRF via VID/PID, but could not "
"open it due to insufficient permissions.\n");
}
/* Don't stop probing because one device was "problematic" */
status = 0;
} else {
info.instance = n++;
status = bladerf_devinfo_list_add(info_list, &info);
if( status ) {
log_error("Could not add device to list: %s\n",
bladerf_strerror(status) );
} else {
log_verbose("Added instance %d to device list\n",
info.instance);
}
}
}
}
libusb_free_device_list(list, 1);
libusb_exit(context);
lusb_probe_done:
return status;
}
static int lusb_open(void **driver,
struct bladerf_devinfo *info_in,
struct bladerf_devinfo *info_out)
{
int status, i, n;
int fx3_status;
ssize_t count;
struct bladerf_lusb *lusb = NULL;
libusb_device **list = NULL;
struct bladerf_devinfo thisinfo;
libusb_context *context;
/* Initialize libusb for device tree walking */
status = libusb_init(&context);
if (status) {
log_error("Could not initialize libusb: %s\n",
libusb_error_name(status));
status = error_conv(status);
goto error;
}
/* We can only print this out when log output is enabled, or else we'll
* get snagged by -Werror=unused-but-set-variable */
# ifdef LOGGING_ENABLED
{
char buf[64];
get_libusb_version(buf, sizeof(buf));
log_verbose("Using libusb version: %s\n", buf);
}
# endif
/* Iterate through all the USB devices */
count = libusb_get_device_list(context, &list);
for (i = 0, n = 0; i < count; i++) {
if (device_is_bladerf(list[i])) {
log_verbose("Found a bladeRF (based upon VID/PID)\n");
/* Open the USB device and get some information */
status = get_devinfo(list[i], &thisinfo);
if(status < 0) {
log_debug("Could not open bladeRF device: %s\n",
libusb_error_name(status) );
status = error_conv(status);
goto error;
}
thisinfo.instance = n++;
/* Check to see if this matches the info struct */
if (bladerf_devinfo_matches(&thisinfo, info_in)) {
lusb = (struct bladerf_lusb *)malloc(sizeof(struct bladerf_lusb));
if (lusb == NULL) {
log_debug("Skipping instance %d due to failed allocation\n",
thisinfo.instance);
lusb = NULL;
continue;
}
lusb->context = context;
lusb->dev = list[i];
status = libusb_open(list[i], &lusb->handle);
if (status < 0) {
status = error_conv(status);
goto error;
}
status = libusb_claim_interface(lusb->handle, 0);
if(status < 0) {
log_debug("Could not claim interface: %s\n",
libusb_error_name(status));
status = error_conv(status);
goto error;
}
memcpy(info_out, &thisinfo, sizeof(struct bladerf_devinfo));
*driver = lusb;
break;
} else {
log_verbose("Devinfo doesn't match - skipping"
"(instance=%d, serial=%d, bus/addr=%d\n",
bladerf_instance_matches(&thisinfo, info_in),
bladerf_serial_matches(&thisinfo, info_in),
bladerf_bus_addr_matches(&thisinfo, info_in));
}
}
if (device_is_fx3_bootloader(list[i])) {
fx3_status = get_devinfo(list[i], &thisinfo);
if (fx3_status != 0) {
log_debug("Could not open FX3 bootloader device: %s\n",
libusb_error_name(fx3_status));
continue;
}
log_info("Found FX3 bootloader device on bus=%d addr=%d. "
"This may be a bladeRF.\n",
thisinfo.usb_bus, thisinfo.usb_addr);
log_info("Use bladeRF-cli command \"recover %d %d "
"<FX3 firmware>\" to boot the bladeRF firmware.\n",
thisinfo.usb_bus, thisinfo.usb_addr);
}
}
error:
if (list) {
libusb_free_device_list(list, 1);
}
if (lusb == NULL) {
log_debug("No devices available on the libusb backend.\n");
status = BLADERF_ERR_NODEV;
}
if (status != 0) {
if (lusb != NULL) {
if (lusb->handle) {
libusb_close(lusb->handle);
}
free(lusb);
}
libusb_exit(context);
}
return status;
}
static int lusb_probe(struct bladerf_devinfo_list *info_list)
{
int status, i, n;
ssize_t count;
libusb_device **list;
struct bladerf_devinfo info;
libusb_context *context;
/* Initialize libusb for device tree walking */
status = libusb_init(&context);
if (status) {
log_error("Could not initialize libusb: %s\n",
libusb_error_name(status));
goto lusb_probe_done;
}
count = libusb_get_device_list(context, &list);
/* Iterate through all the USB devices */
for (i = 0, n = 0; i < count && status == 0; i++) {
if (device_is_bladerf(list[i])) {
log_verbose("Found bladeRF (based upon VID/PID)\n");
/* Open the USB device and get some information */
status = get_devinfo(list[i], &info);
if (status) {
log_error("Could not open bladeRF device: %s\n",
libusb_error_name(status) );
} else {
info.instance = n++;
status = bladerf_devinfo_list_add(info_list, &info);
if( status ) {
log_error("Could not add device to list: %s\n",
bladerf_strerror(status) );
} else {
log_verbose("Added instance %d to device list\n",
info.instance);
}
}
}
if (device_is_fx3_bootloader(list[i])) {
status = get_devinfo(list[i], &info);
if (status) {
log_error("Could not open bladeRF device: %s\n",
libusb_error_name(status) );
continue;
}
log_info("Found FX3 bootloader device on bus=%d addr=%d. This may "
"be a bladeRF.\nUse the bladeRF-cli command \"recover"
" %d %d <FX3 firmware>\" to boot the bladeRF firmware.\n",
info.usb_bus, info.usb_addr, info.usb_bus, info.usb_addr);
}
}
libusb_free_device_list(list, 1);
libusb_exit(context);
lusb_probe_done:
return status;
}
int get_partlist(struct s_devinfo *blkdev, int maxblkdev, int *diskcount, int *partcount)
{
struct s_devinfo blkdev1[FSA_MAX_BLKDEVICES];
struct s_devinfo tmpdev;
int best; // index of the best item found in old array
int pos=0; // pos of latest item in new array
char devname[1024];
char longname[1024];
char delims[]=" \t\n";
char line[1024];
char *saveptr;
char *result;
char major[256];
char minor[256];
FILE *fpart;
int count=0;
int i, j;
// init
*diskcount=0;
*partcount=0;
// browse list in "/proc/partitions"
if ((fpart=fopen("/proc/partitions","rb"))==NULL)
return -1;
while(!feof(fpart) && (count < FSA_MAX_BLKDEVICES) && (count < maxblkdev))
{
if (stream_readline(fpart, line, sizeof(line))>1)
{
minor[0]=major[0]=0;
devname[0]=0;
result=strtok_r(line, delims, &saveptr);
for(i=0; result != NULL && i<=4; i++)
{
switch(i)
{
case 0: // col0 = major
snprintf(major, sizeof(major), "%s", result);
break;
case 1: // col1 = minor
snprintf(minor, sizeof(minor), "%s", result);
break;
case 3: // col3 = devname
snprintf(devname, sizeof(devname), "%s", result);
break;
}
result = strtok_r(NULL, delims, &saveptr);
}
// ignore invalid entries
if ((strlen(devname)==0) || (atoi(major)==0 && atoi(minor)==0))
continue;
snprintf(longname, sizeof(longname), "/dev/%s", devname);
if (get_devinfo(&tmpdev, longname, atoi(minor), atoi(major))!=0)
continue; // to to the next part
// check that this device is not already in the list
for (i=0; i < count; i++)
if (blkdev1[i].rdev==tmpdev.rdev)
continue; // to to the next part
// add the device to list if it is a real device and it's not already in the list
blkdev1[count++]=tmpdev;
}
}
fclose(fpart);
// ---- 2. sort the devices
for (pos=0, i=0; i<count; i++)
{
// set best to the first available item in the old array
for (j=0, best=-1; (j<count) && (best==-1); j++)
if (blkdev1[j].rdev!=0)
best=j;
// find the index of the best item in the old array
for (j=0; j<count; j++)
if ((blkdev1[j].rdev > 0) && (blkdev1[j].rdev < blkdev1[best].rdev))
best=j;
// update counters
switch (blkdev1[best].devtype)
{
case BLKDEV_FILESYSDEV:
(*partcount)++;
break;
case BLKDEV_PHYSDISK:
(*diskcount)++;
break;
}
// move item to the new array
blkdev[pos++]=blkdev1[best];
blkdev1[best].rdev=0;
}
return count;
}
