bladeRF/host/common/src/conversions.c

730 lines
18 KiB
C

/*
* This file is part of the bladeRF project:
* http://www.github.com/nuand/bladeRF
*
* Copyright (c) 2017-2018 Nuand LLC.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#include "conversions.h"
int str2version(const char *str, struct bladerf_version *version)
{
unsigned long tmp;
const char *start = str;
char *end;
/* Major version */
errno = 0;
tmp = strtoul(start, &end, 10);
if (errno != 0 || tmp > UINT16_MAX || end == start || *end != '.') {
return -1;
}
version->major = (uint16_t)tmp;
/* Minor version */
if (end[0] == '\0' || end[1] == '\0') {
return -1;
}
errno = 0;
start = &end[1];
tmp = strtoul(start, &end, 10);
if (errno != 0 || tmp > UINT16_MAX || end == start || *end != '.') {
return -1;
}
version->minor = (uint16_t)tmp;
/* Patch version */
if (end[0] == '\0' || end[1] == '\0') {
return -1;
}
errno = 0;
start = &end[1];
tmp = strtoul(start, &end, 10);
if (errno != 0 || tmp > UINT16_MAX || end == start ||
(*end != '-' && *end != '\0')) {
return -1;
}
version->patch = (uint16_t)tmp;
version->describe = str;
return 0;
}
const char *devspeed2str(bladerf_dev_speed speed)
{
switch (speed) {
case BLADERF_DEVICE_SPEED_HIGH:
/* Yeah, the USB IF actually spelled it "Hi" instead of "High".
* I know. It hurts me too. */
return "Hi-Speed";
case BLADERF_DEVICE_SPEED_SUPER:
/* ...and no hyphen :( */
return "SuperSpeed";
default:
return "Unknown";
}
}
bladerf_log_level str2loglevel(const char *str, bool *ok)
{
bladerf_log_level level = BLADERF_LOG_LEVEL_ERROR;
bool valid = true;
if (!strcasecmp(str, "critical")) {
level = BLADERF_LOG_LEVEL_CRITICAL;
} else if (!strcasecmp(str, "error")) {
level = BLADERF_LOG_LEVEL_ERROR;
} else if (!strcasecmp(str, "warning")) {
level = BLADERF_LOG_LEVEL_WARNING;
} else if (!strcasecmp(str, "info")) {
level = BLADERF_LOG_LEVEL_INFO;
} else if (!strcasecmp(str, "debug")) {
level = BLADERF_LOG_LEVEL_DEBUG;
} else if (!strcasecmp(str, "verbose")) {
level = BLADERF_LOG_LEVEL_VERBOSE;
} else {
valid = false;
}
*ok = valid;
return level;
}
const char *module2str(bladerf_module m)
{
switch (m) {
case BLADERF_MODULE_RX:
return "RX";
case BLADERF_MODULE_TX:
return "TX";
default:
return "Unknown";
}
}
bladerf_module str2module(const char *str)
{
if (!strcasecmp(str, "RX")) {
return BLADERF_MODULE_RX;
} else if (!strcasecmp(str, "TX")) {
return BLADERF_MODULE_TX;
} else {
return BLADERF_MODULE_INVALID;
}
}
const char *channel2str(bladerf_channel ch)
{
switch (ch) {
case BLADERF_CHANNEL_RX(0):
return "RX1";
case BLADERF_CHANNEL_TX(0):
return "TX1";
case BLADERF_CHANNEL_RX(1):
return "RX2";
case BLADERF_CHANNEL_TX(1):
return "TX2";
default:
return "Unknown";
}
}
bladerf_channel str2channel(char const *str)
{
bladerf_channel rv;
if (strcasecmp(str, "rx") == 0 || strcasecmp(str, "rx1") == 0) {
rv = BLADERF_CHANNEL_RX(0);
} else if (strcasecmp(str, "rx2") == 0) {
rv = BLADERF_CHANNEL_RX(1);
} else if (strcasecmp(str, "tx") == 0 || strcasecmp(str, "tx1") == 0) {
rv = BLADERF_CHANNEL_TX(0);
} else if (strcasecmp(str, "tx2") == 0) {
rv = BLADERF_CHANNEL_TX(1);
} else {
rv = BLADERF_CHANNEL_INVALID;
}
return rv;
}
bladerf_direction channel2direction (bladerf_channel ch) {
if (ch == BLADERF_CHANNEL_RX(0) || ch == BLADERF_CHANNEL_RX(1)) {
return BLADERF_RX;
} else {
return BLADERF_TX;
}
}
const char *direction2str(bladerf_direction dir)
{
switch (dir) {
case BLADERF_RX:
return "RX";
case BLADERF_TX:
return "TX";
default:
return "Unknown";
}
}
const char *trigger2str(bladerf_trigger_signal trigger)
{
switch (trigger) {
case BLADERF_TRIGGER_J71_4:
return "J71-4";
case BLADERF_TRIGGER_J51_1:
return "J51-1";
case BLADERF_TRIGGER_MINI_EXP_1:
return "MiniExp-1";
case BLADERF_TRIGGER_USER_0:
return "User-0";
case BLADERF_TRIGGER_USER_1:
return "User-1";
case BLADERF_TRIGGER_USER_2:
return "User-2";
case BLADERF_TRIGGER_USER_3:
return "User-3";
case BLADERF_TRIGGER_USER_4:
return "User-4";
case BLADERF_TRIGGER_USER_5:
return "User-5";
case BLADERF_TRIGGER_USER_6:
return "User-6";
case BLADERF_TRIGGER_USER_7:
return "User-7";
default:
return "Unknown";
}
}
bladerf_trigger_signal str2trigger(const char *str)
{
if (!strcasecmp("J71-4", str)) {
return BLADERF_TRIGGER_J71_4;
} else if (!strcasecmp("J51-1", str)) {
return BLADERF_TRIGGER_J51_1;
} else if (!strcasecmp("Miniexp-1", str)) {
return BLADERF_TRIGGER_MINI_EXP_1;
} else if (!strcasecmp("User-0", str)) {
return BLADERF_TRIGGER_USER_0;
} else if (!strcasecmp("User-1", str)) {
return BLADERF_TRIGGER_USER_1;
} else if (!strcasecmp("User-2", str)) {
return BLADERF_TRIGGER_USER_2;
} else if (!strcasecmp("User-3", str)) {
return BLADERF_TRIGGER_USER_3;
} else if (!strcasecmp("User-4", str)) {
return BLADERF_TRIGGER_USER_4;
} else if (!strcasecmp("User-5", str)) {
return BLADERF_TRIGGER_USER_5;
} else if (!strcasecmp("User-6", str)) {
return BLADERF_TRIGGER_USER_6;
} else if (!strcasecmp("User-7", str)) {
return BLADERF_TRIGGER_USER_7;
} else {
return BLADERF_TRIGGER_INVALID;
}
}
const char *triggerrole2str(bladerf_trigger_role role)
{
switch (role) {
case BLADERF_TRIGGER_ROLE_MASTER:
return "Master";
case BLADERF_TRIGGER_ROLE_SLAVE:
return "Slave";
case BLADERF_TRIGGER_ROLE_DISABLED:
return "Disabled";
default:
return "Unknown";
}
}
bladerf_trigger_role str2triggerrole(const char *str)
{
if (!strcasecmp("Master", str)) {
return BLADERF_TRIGGER_ROLE_MASTER;
} else if (!strcasecmp("Slave", str)) {
return BLADERF_TRIGGER_ROLE_SLAVE;
} else if (!strcasecmp("Disabled", str) || !strcasecmp("Off", str)) {
return BLADERF_TRIGGER_ROLE_DISABLED;
} else {
return BLADERF_TRIGGER_ROLE_INVALID;
}
}
int str2loopback(const char *str, bladerf_loopback *loopback)
{
int status = 0;
if (!strcasecmp("firmware", str)) {
*loopback = BLADERF_LB_FIRMWARE;
} else if (!strcasecmp("bb_txlpf_rxvga2", str)) {
*loopback = BLADERF_LB_BB_TXLPF_RXVGA2;
} else if (!strcasecmp("bb_txlpf_rxlpf", str)) {
*loopback = BLADERF_LB_BB_TXLPF_RXLPF;
} else if (!strcasecmp("bb_txvga1_rxvga2", str)) {
*loopback = BLADERF_LB_BB_TXVGA1_RXVGA2;
} else if (!strcasecmp("bb_txvga1_rxlpf", str)) {
*loopback = BLADERF_LB_BB_TXVGA1_RXLPF;
} else if (!strcasecmp("rf_lna1", str)) {
*loopback = BLADERF_LB_RF_LNA1;
} else if (!strcasecmp("rf_lna2", str)) {
*loopback = BLADERF_LB_RF_LNA2;
} else if (!strcasecmp("rf_lna3", str)) {
*loopback = BLADERF_LB_RF_LNA3;
} else if (!strcasecmp("rfic_bist", str)) {
*loopback = BLADERF_LB_RFIC_BIST;
} else if (!strcasecmp("none", str)) {
*loopback = BLADERF_LB_NONE;
} else {
status = -1;
}
return status;
}
char const *loopback2str(bladerf_loopback loopback)
{
switch (loopback) {
case BLADERF_LB_BB_TXLPF_RXVGA2:
return "bb_txlpf_rxvga2";
case BLADERF_LB_BB_TXLPF_RXLPF:
return "bb_txlpf_rxlpf";
case BLADERF_LB_BB_TXVGA1_RXVGA2:
return "bb_txvga1_rxvga2";
case BLADERF_LB_BB_TXVGA1_RXLPF:
return "bb_txvga1_rxlpf";
case BLADERF_LB_RF_LNA1:
return "rf_lna1";
case BLADERF_LB_RF_LNA2:
return "rf_lna2";
case BLADERF_LB_RF_LNA3:
return "rf_lna3";
case BLADERF_LB_FIRMWARE:
return "firmware";
case BLADERF_LB_NONE:
return "none";
case BLADERF_LB_RFIC_BIST:
return "rfic_bist";
default:
return "unknown";
}
}
int str2lnagain(const char *str, bladerf_lna_gain *gain)
{
*gain = BLADERF_LNA_GAIN_MAX;
if (!strcasecmp("max", str) || !strcasecmp("BLADERF_LNA_GAIN_MAX", str)) {
*gain = BLADERF_LNA_GAIN_MAX;
return 0;
} else if (!strcasecmp("mid", str) ||
!strcasecmp("BLADERF_LNA_GAIN_MID", str)) {
*gain = BLADERF_LNA_GAIN_MID;
return 0;
} else if (!strcasecmp("bypass", str) ||
!strcasecmp("BLADERF_LNA_GAIN_BYPASS", str)) {
*gain = BLADERF_LNA_GAIN_BYPASS;
return 0;
} else {
*gain = BLADERF_LNA_GAIN_UNKNOWN;
return -1;
}
}
char const *tuningmode2str(bladerf_tuning_mode mode)
{
switch (mode) {
case BLADERF_TUNING_MODE_HOST:
return "Host";
case BLADERF_TUNING_MODE_FPGA:
return "FPGA";
default:
return "Unknown";
}
}
const char *backend_description(bladerf_backend b)
{
switch (b) {
case BLADERF_BACKEND_ANY:
return "Any";
case BLADERF_BACKEND_LINUX:
return "Linux kernel driver";
case BLADERF_BACKEND_LIBUSB:
return "libusb";
case BLADERF_BACKEND_CYPRESS:
return "Cypress driver";
case BLADERF_BACKEND_DUMMY:
return "Dummy";
default:
return "Unknown";
}
}
void sc16q11_to_float(const int16_t *in, float *out, unsigned int n)
{
unsigned int i;
for (i = 0; i < (2 * n); i += 2) {
out[i] = (float)in[i] * (1.0f / 2048.0f);
out[i + 1] = (float)in[i + 1] * (1.0f / 2048.0f);
}
}
void float_to_sc16q11(const float *in, int16_t *out, unsigned int n)
{
unsigned int i;
for (i = 0; i < (2 * n); i += 2) {
out[i] = (int16_t)(in[i] * 2048.0f);
out[i + 1] = (int16_t)(in[i + 1] * 2048.0f);
}
}
bladerf_cal_module str_to_bladerf_cal_module(const char *str)
{
bladerf_cal_module module = BLADERF_DC_CAL_INVALID;
if (!strcasecmp(str, "lpf_tuning") || !strcasecmp(str, "lpftuning") ||
!strcasecmp(str, "tuning")) {
module = BLADERF_DC_CAL_LPF_TUNING;
} else if (!strcasecmp(str, "tx_lpf") || !strcasecmp(str, "txlpf")) {
module = BLADERF_DC_CAL_TX_LPF;
} else if (!strcasecmp(str, "rx_lpf") || !strcasecmp(str, "rxlpf")) {
module = BLADERF_DC_CAL_RX_LPF;
} else if (!strcasecmp(str, "rx_vga2") || !strcasecmp(str, "rxvga2")) {
module = BLADERF_DC_CAL_RXVGA2;
}
return module;
}
const char *smb_mode_to_str(bladerf_smb_mode mode)
{
switch (mode) {
case BLADERF_SMB_MODE_DISABLED:
return "Disabled";
case BLADERF_SMB_MODE_OUTPUT:
return "Output";
case BLADERF_SMB_MODE_INPUT:
return "Input";
case BLADERF_SMB_MODE_UNAVAILBLE:
return "Unavailable";
default:
return "Unknown";
}
};
bladerf_smb_mode str_to_smb_mode(const char *str)
{
if (!strcasecmp(str, "disabled") || !strcasecmp(str, "off")) {
return BLADERF_SMB_MODE_DISABLED;
} else if (!strcasecmp(str, "output")) {
return BLADERF_SMB_MODE_OUTPUT;
} else if (!strcasecmp(str, "input")) {
return BLADERF_SMB_MODE_INPUT;
} else if (!strcasecmp(str, "unavailable")) {
return BLADERF_SMB_MODE_UNAVAILBLE;
} else {
return BLADERF_SMB_MODE_INVALID;
}
}
bladerf_tuning_mode str_to_tuning_mode(const char *str)
{
if (!strcasecmp(str, "fpga")) {
return BLADERF_TUNING_MODE_FPGA;
} else if (!strcasecmp(str, "host")) {
return BLADERF_TUNING_MODE_HOST;
} else {
return BLADERF_TUNING_MODE_INVALID;
}
}
unsigned int str2uint(const char *str,
unsigned int min,
unsigned int max,
bool *ok)
{
unsigned int ret;
char *optr;
errno = 0;
ret = strtoul(str, &optr, 0);
if (errno == ERANGE || (errno != 0 && ret == 0)) {
*ok = false;
return 0;
}
if (str == optr) {
*ok = false;
return 0;
}
if (ret >= min && ret <= max) {
*ok = true;
return (unsigned int)ret;
}
*ok = false;
return 0;
}
int str2int(const char *str, int min, int max, bool *ok)
{
long int ret;
char *optr;
errno = 0;
ret = strtol(str, &optr, 0);
if ((errno == ERANGE && (ret == LONG_MAX || ret == LONG_MIN)) ||
(errno != 0 && ret == 0)) {
*ok = false;
return 0;
}
if (str == optr) {
*ok = false;
return 0;
}
if (ret >= min && ret <= max) {
*ok = true;
return (int)ret;
}
*ok = false;
return 0;
}
uint64_t str2uint64(const char *str, uint64_t min, uint64_t max, bool *ok)
{
uint64_t ret;
char *optr;
errno = 0;
ret = (uint64_t)strtod(str, &optr);
if ((errno == ERANGE && ret == ULONG_MAX) || (errno != 0 && ret == 0)) {
*ok = false;
return 0;
}
if (str == optr) {
*ok = false;
return 0;
}
if (ret >= min && ret <= max) {
*ok = true;
return ret;
}
*ok = false;
return 0;
}
double str2double(const char *str, double min, double max, bool *ok)
{
double ret;
char *optr;
errno = 0;
ret = strtod(str, &optr);
if (errno == ERANGE || (errno != 0 && ret == 0)) {
*ok = false;
return NAN;
}
if (str == optr) {
*ok = false;
return NAN;
}
if (ret >= min && ret <= max) {
*ok = true;
return ret;
}
*ok = false;
return NAN;
}
static uint64_t suffix_multiplier(const char *str,
const struct numeric_suffix *suffixes,
const size_t num_suff,
bool *ok)
{
unsigned i;
*ok = true;
if (!strlen(str))
return 1;
for (i = 0; i < num_suff; i++) {
if (!strcasecmp(suffixes[i].suffix, str)) {
return suffixes[i].multiplier;
}
}
*ok = false;
return 0;
}
unsigned int str2uint_suffix(const char *str,
unsigned int min,
unsigned int max,
const struct numeric_suffix *suffixes,
const size_t num_suff,
bool *ok)
{
uint64_t mult;
unsigned int rv;
double val;
char *optr;
errno = 0;
val = strtod(str, &optr);
if (errno == ERANGE || (errno != 0 && val == 0)) {
*ok = false;
return 0;
}
if (str == optr) {
*ok = false;
return 0;
}
mult = suffix_multiplier(optr, suffixes, num_suff, ok);
if (!*ok)
return false;
rv = (unsigned int)(val * mult);
if (rv >= min && rv <= max) {
return rv;
}
*ok = false;
return 0;
}
uint64_t str2uint64_suffix(const char *str,
uint64_t min,
uint64_t max,
const struct numeric_suffix *suffixes,
const size_t num_suff,
bool *ok)
{
uint64_t mult, rv;
long double val;
char *optr;
errno = 0;
val = strtold(str, &optr);
if (errno == ERANGE && (errno != 0 && val == 0)) {
*ok = false;
return 0;
}
if (str == optr) {
*ok = false;
return 0;
}
mult = suffix_multiplier(optr, suffixes, num_suff, ok);
if (!*ok)
return false;
rv = (uint64_t)(val * mult);
if (rv >= min && rv <= max) {
return rv;
}
*ok = false;
return 0;
}
int str2bool(const char *str, bool *val)
{
unsigned int i;
char *str_true[] = { "true", "t", "one", "1", "enable", "en", "on" };
char *str_false[] = { "false", "f", "zero", "0", "disable", "dis", "off" };
for (i = 0; i < ARRAY_SIZE(str_true); i++) {
if (!strcasecmp(str_true[i], str)) {
*val = true;
return 0;
}
}
for (i = 0; i < ARRAY_SIZE(str_false); i++) {
if (!strcasecmp(str_false[i], str)) {
*val = false;
return 0;
}
}
return BLADERF_ERR_INVAL;
}