static void ub_sighup(struct ubus_context *ctx, struct ubus_event_handler *ev,
const char *type, struct blob_attr *msg)
{
if (conf.verbosity > 0) {
fprintf(stdout, "[ubus] rx %s event\n", CONFIG_UBUS_EV_SIGHUP);
}
config_init();
config_load_all();
}
int main(int argc, char **argv)
{
int opt, rc = 0;
while ((opt = getopt(argc, argv, "hv")) != -1) {
switch (opt) {
case 'v':
conf.verbosity++;
break;
case 'h':
default:
return usage(argv[0]);
}
}
conf.flx_ufd.fd = open(FLX_DEV, O_RDWR);
if (conf.flx_ufd.fd < 0) {
perror(FLX_DEV);
rc = 1;
goto finish;
}
if (!configure_tty(conf.flx_ufd.fd)) {
fprintf(stderr, "%s: Failed to configure tty params\n", FLX_DEV);
rc = 2;
goto finish;
}
if (!config_init()) {
rc = 3;
goto oom;
}
if (!config_load_all()) {
rc = 4;
goto finish;
}
conf.ubus_ctx = ubus_connect(NULL);
if (!conf.ubus_ctx) {
fprintf(stderr, "Failed to connect to ubus\n");
rc = 5;
goto finish;
}
#ifdef WITH_YKW
conf.ykw = ykw_new(YKW_DEFAULT_THETA);
if (conf.ykw == NULL) {
rc = 6;
goto oom;
}
#endif
mosquitto_lib_init();
snprintf(conf.mqtt.id, MQTT_ID_LEN, MQTT_ID_TPL, getpid());
conf.mosq = mosquitto_new(conf.mqtt.id, conf.mqtt.clean_session, &conf);
if (!conf.mosq) {
switch (errno) {
case ENOMEM:
rc = 7;
goto oom;
case EINVAL:
fprintf(stderr, "mosq_new: Invalid id and/or clean_session.\n");
rc = 8;
goto finish;
}
}
rc = mosquitto_loop_start(conf.mosq);
switch (rc) {
case MOSQ_ERR_INVAL:
fprintf(stderr, "mosq_loop_start: Invalid input parameters.\n");
goto finish;
case MOSQ_ERR_NOT_SUPPORTED:
fprintf(stderr, "mosq_loop_start: No threading support.\n");
goto finish;
};
rc = mosquitto_connect_async(conf.mosq, conf.mqtt.host, conf.mqtt.port,
conf.mqtt.keepalive);
switch (rc) {
case MOSQ_ERR_INVAL:
fprintf(stderr, "mosq_connect_async: Invalid input parameters.\n");
goto finish;
case MOSQ_ERR_ERRNO:
perror("mosq_connect_async");
goto finish;
}
uloop_init();
uloop_fd_add(&conf.flx_ufd, ULOOP_READ);
uloop_timeout_set(&conf.timeout, CONFIG_ULOOP_TIMEOUT);
ubus_add_uloop(conf.ubus_ctx);
ubus_register_event_handler(conf.ubus_ctx, &conf.ubus_ev_sighup,
CONFIG_UBUS_EV_SIGHUP);
ubus_register_event_handler(conf.ubus_ctx, &conf.ubus_ev_shift_calc,
CONFIG_UBUS_EV_SHIFT_CALC);
uloop_run();
uloop_done();
goto finish;
oom:
fprintf(stderr, "error: Out of memory.\n");
finish:
mosquitto_disconnect(conf.mosq);
mosquitto_loop_stop(conf.mosq, false);
mosquitto_destroy(conf.mosq);
mosquitto_lib_cleanup();
ykw_free(conf.ykw);
if (conf.ubus_ctx != NULL) {
ubus_free(conf.ubus_ctx);
}
close(conf.flx_ufd.fd);
uci_free_context(conf.uci_ctx);
return rc;
}
int bladerf_open_with_devinfo(struct bladerf **opened_device,
struct bladerf_devinfo *devinfo)
{
struct bladerf *dev;
int status;
*opened_device = NULL;
dev = (struct bladerf *)calloc(1, sizeof(struct bladerf));
if (dev == NULL) {
return BLADERF_ERR_MEM;
}
MUTEX_INIT(&dev->ctrl_lock);
MUTEX_INIT(&dev->sync_lock[BLADERF_MODULE_RX]);
MUTEX_INIT(&dev->sync_lock[BLADERF_MODULE_TX]);
dev->fpga_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1);
if (dev->fpga_version.describe == NULL) {
free(dev);
return BLADERF_ERR_MEM;
}
dev->fw_version.describe = calloc(1, BLADERF_VERSION_STR_MAX + 1);
if (dev->fw_version.describe == NULL) {
free((void*)dev->fpga_version.describe);
free(dev);
return BLADERF_ERR_MEM;
}
status = backend_open(dev, devinfo);
if (status != 0) {
free((void*)dev->fw_version.describe);
free((void*)dev->fpga_version.describe);
free(dev);
return status;
}
status = dev->fn->get_device_speed(dev, &dev->usb_speed);
if (status < 0) {
log_debug("Failed to get device speed: %s\n",
bladerf_strerror(status));
goto error;
}
if (dev->usb_speed != BLADERF_DEVICE_SPEED_HIGH &&
dev->usb_speed != BLADERF_DEVICE_SPEED_SUPER) {
log_debug("Unsupported device speed: %d\n", dev->usb_speed);
goto error;
}
/* Verify that we have a sufficent firmware version before continuing. */
status = version_check_fw(dev);
if (status != 0) {
#ifdef LOGGING_ENABLED
if (status == BLADERF_ERR_UPDATE_FW) {
struct bladerf_version req;
const unsigned int dev_maj = dev->fw_version.major;
const unsigned int dev_min = dev->fw_version.minor;
const unsigned int dev_pat = dev->fw_version.patch;
unsigned int req_maj, req_min, req_pat;
version_required_fw(dev, &req, false);
req_maj = req.major;
req_min = req.minor;
req_pat = req.patch;
log_warning("Firmware v%u.%u.%u was detected. libbladeRF v%s "
"requires firmware v%u.%u.%u or later. An upgrade via "
"the bootloader is required.\n\n",
dev_maj, dev_min, dev_pat,
LIBBLADERF_VERSION,
req_maj, req_min, req_pat);
}
#endif
goto error;
}
/* VCTCXO trim and FPGA size are non-fatal indicators that we've
* trashed the calibration region of flash. If these were made fatal,
* we wouldn't be able to open the device to restore them. */
status = get_and_cache_vctcxo_trim(dev);
if (status < 0) {
log_warning("Failed to get VCTCXO trim value: %s\n",
bladerf_strerror(status));
}
status = get_and_cache_fpga_size(dev);
if (status < 0) {
log_warning("Failed to get FPGA size %s\n",
bladerf_strerror(status));
}
status = FPGA_IS_CONFIGURED(dev);
if (status > 0) {
/* If the FPGA version check fails, just warn, but don't error out.
*
* If an error code caused this function to bail out, it would prevent a
* user from being able to unload and reflash a bitstream being
* "autoloaded" from SPI flash. */
fpga_check_version(dev);
status = init_device(dev);
if (status != 0) {
goto error;
}
}
dev->rx_filter = -1;
dev->tx_filter = -1;
/* Load any configuration files or FPGA images that a user has stored
* for this device in their bladerf config directory */
status = config_load_all(dev);
error:
if (status < 0) {
bladerf_close(dev);
} else {
*opened_device = dev;
}
return status;
}
