Merge pull request #1632 from greatscottgadgets/praline

Add support for HackRF Pro (code name: Praline)

host/hackrf-tools/src/hackrf_clock.c

@@ -28,6 +28,10 @@
 #include <stdlib.h>
 #include <getopt.h>
 
+#ifdef _MSC_VER
+	#define strcasecmp _stricmp
+#endif
+
 #define CLOCK_UNDEFINED  0xFF
 #define REGISTER_INVALID 32767
 
@@ -59,6 +63,46 @@ int parse_int(char* s, uint8_t* const value)
 	}
 }
 
+int parse_p1_ctrl_signal(char* s, enum p1_ctrl_signal* const signal)
+{
+	if (strcasecmp("trigger_in", s) == 0) {
+		*signal = P1_SIGNAL_TRIGGER_IN;
+	} else if (strcasecmp("aux_clk1", s) == 0) {
+		*signal = P1_SIGNAL_AUX_CLK1;
+	} else if (strcasecmp("clkin", s) == 0) {
+		*signal = P1_SIGNAL_CLKIN;
+	} else if (strcasecmp("trigger_out", s) == 0) {
+		*signal = P1_SIGNAL_TRIGGER_OUT;
+	} else if (strcasecmp("p22_clkin", s) == 0) {
+		*signal = P1_SIGNAL_P22_CLKIN;
+	} else if (strcasecmp("pps_out", s) == 0) {
+		*signal = P1_SIGNAL_P2_5;
+	} else if (strcasecmp("off", s) == 0) {
+		*signal = P1_SIGNAL_NC;
+	} else if (strcasecmp("aux_clk2", s) == 0) {
+		*signal = P1_SIGNAL_AUX_CLK2;
+	} else {
+		fprintf(stderr, "Invalid signal '%s'\n", s);
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
+	return HACKRF_SUCCESS;
+}
+
+int parse_p2_ctrl_signal(char* s, enum p2_ctrl_signal* const signal)
+{
+	if (strcasecmp("clkout", s) == 0) {
+		*signal = P2_SIGNAL_CLK3;
+	} else if (strcasecmp("trigger_in", s) == 0) {
+		*signal = P2_SIGNAL_TRIGGER_IN;
+	} else if (strcasecmp("trigger_out", s) == 0) {
+		*signal = P2_SIGNAL_TRIGGER_OUT;
+	} else {
+		fprintf(stderr, "Invalid signal '%s'\n", s);
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
+	return HACKRF_SUCCESS;
+}
+
 int si5351c_read_register(hackrf_device* device, const uint16_t register_number)
 {
 	uint16_t register_value;
@@ -247,6 +291,10 @@ static void usage()
 	printf("\t-a, --all: read settings for all clocks\n");
 	printf("\t-i, --clkin: get CLKIN status\n");
 	printf("\t-o, --clkout <clkout_enable>: enable/disable CLKOUT\n");
+	printf("\t-1, --p1 <signal>: select the HackRF Pro P1 SMA connector signal (default: clkin)\n");
+	printf("\tone of: clkin, trigger_in, trigger_out, p22_clkin, pps_out, aux_clk1, aux_clk2, off\n");
+	printf("\t-2, --p2 <signal>: select the signal for the HackRF Pro P2 SMA connector (default: clkout)\n");
+	printf("\tone of: clkout, trigger_in, trigger_out\n");
 	printf("\t-d, --device <serial_number>: Serial number of desired HackRF.\n");
 	printf("\nExamples:\n");
 	printf("\thackrf_clock -r 3 : prints settings for CLKOUT\n");
@@ -258,6 +306,8 @@ static struct option long_options[] = {
 	{"all", no_argument, 0, 'a'},
 	{"clkin", required_argument, 0, 'i'},
 	{"clkout", required_argument, 0, 'o'},
+	{"p1", required_argument, 0, '1'},
+	{"p2", required_argument, 0, '2'},
 	{"device", required_argument, 0, 'd'},
 	{0, 0, 0, 0},
 };
@@ -272,6 +322,10 @@ int main(int argc, char** argv)
 	bool clkin = false;
 	uint8_t clkout_enable;
 	uint8_t clkin_status;
+	bool p1_ctrl = false;
+	bool p2_ctrl = false;
+	enum p1_ctrl_signal p1_signal = P1_SIGNAL_CLKIN;
+	enum p2_ctrl_signal p2_signal = P2_SIGNAL_CLK3;
 	const char* serial_number = NULL;
 
 	int result = hackrf_init();
@@ -282,8 +336,12 @@ int main(int argc, char** argv)
 		return EXIT_FAILURE;
 	}
 
-	while ((opt = getopt_long(argc, argv, "r:aio:d:h?", long_options, &option_index)) !=
-	       EOF) {
+	while ((opt = getopt_long(
+			argc,
+			argv,
+			"r:aio:1:2:d:h?",
+			long_options,
+			&option_index)) != EOF) {
 		switch (opt) {
 		case 'r':
 			read = true;
@@ -303,6 +361,16 @@ int main(int argc, char** argv)
 			result = parse_int(optarg, &clkout_enable);
 			break;
 
+		case '1':
+			p1_ctrl = true;
+			result = parse_p1_ctrl_signal(optarg, &p1_signal);
+			break;
+
+		case '2':
+			p2_ctrl = true;
+			result = parse_p2_ctrl_signal(optarg, &p2_signal);
+			break;
+
 		case 'd':
 			serial_number = optarg;
 			break;
@@ -326,7 +394,7 @@ int main(int argc, char** argv)
 		}
 	}
 
-	if (!clkin && !clkout && !read) {
+	if (!clkin && !clkout && !read && !p1_ctrl && !p2_ctrl) {
 		fprintf(stderr, "An operation must be specified.\n");
 		usage();
 		return EXIT_FAILURE;
@@ -372,6 +440,26 @@ int main(int argc, char** argv)
 		}
 	}
 
+	if (p1_ctrl) {
+		result = hackrf_set_p1_ctrl(device, p1_signal);
+		if (result) {
+			printf("hackrf_set_p1_ctrl() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+	}
+
+	if (p2_ctrl) {
+		result = hackrf_set_p2_ctrl(device, p2_signal);
+		if (result) {
+			printf("hackrf_set_p2_ctrl() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+	}
+
 	result = hackrf_close(device);
 	if (result) {
 		printf("hackrf_close() failed: %s (%d)\n",

host/hackrf-tools/src/hackrf_debug.c

@@ -32,6 +32,15 @@
 
 #define REGISTER_INVALID 32767
 
+enum parts {
+	PART_NONE = 0,
+	PART_MAX2837 = 1,
+	PART_SI5351C = 2,
+	PART_RFFC5072 = 3,
+	PART_MAX2831 = 4,
+	PART_GATEWARE = 5,
+};
+
 int parse_int(char* s, uint32_t* const value)
 {
 	uint_fast8_t base = 10;
@@ -60,11 +69,30 @@ int parse_int(char* s, uint32_t* const value)
 	}
 }
 
-int max2837_read_register(hackrf_device* device, const uint16_t register_number)
+int max283x_read_register(
+	hackrf_device* device,
+	const uint16_t register_number,
+	uint8_t part)
 {
 	uint16_t register_value;
-	int result =
-		hackrf_max2837_read(device, (uint8_t) register_number, &register_value);
+	int result = HACKRF_SUCCESS;
+
+	switch (part) {
+	case PART_MAX2837:
+		result = hackrf_max2837_read(
+			device,
+			(uint8_t) register_number,
+			&register_value);
+		break;
+	case PART_MAX2831:
+		result = hackrf_max2831_read(
+			device,
+			(uint8_t) register_number,
+			&register_value);
+		break;
+	default:
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
 
 	if (result == HACKRF_SUCCESS) {
 		printf("[%2d] -> 0x%03x\n", register_number, register_value);
@@ -76,13 +104,25 @@ int max2837_read_register(hackrf_device* device, const uint16_t register_number)
 	return result;
 }
 
-int max2837_read_registers(hackrf_device* device)
+int max283x_read_registers(hackrf_device* device, uint8_t part)
 {
 	uint16_t register_number;
+	uint16_t register_count;
 	int result = HACKRF_SUCCESS;
 
-	for (register_number = 0; register_number < 32; register_number++) {
-		result = max2837_read_register(device, register_number);
+	switch (part) {
+	case PART_MAX2837:
+		register_count = 32;
+		break;
+	case PART_MAX2831:
+		register_count = 16;
+		break;
+	default:
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
+
+	for (register_number = 0; register_number < register_count; register_number++) {
+		result = max283x_read_register(device, register_number, part);
 		if (result != HACKRF_SUCCESS) {
 			break;
 		}
@@ -90,13 +130,30 @@ int max2837_read_registers(hackrf_device* device)
 	return result;
 }
 
-int max2837_write_register(
+int max283x_write_register(
 	hackrf_device* device,
 	const uint16_t register_number,
-	const uint16_t register_value)
+	const uint16_t register_value,
+	uint8_t part)
 {
 	int result = HACKRF_SUCCESS;
-	result = hackrf_max2837_write(device, (uint8_t) register_number, register_value);
+
+	switch (part) {
+	case PART_MAX2837:
+		result = hackrf_max2837_write(
+			device,
+			(uint8_t) register_number,
+			register_value);
+		break;
+	case PART_MAX2831:
+		result = hackrf_max2831_write(
+			device,
+			(uint8_t) register_number,
+			register_value);
+		break;
+	default:
+		return HACKRF_ERROR_INVALID_PARAM;
+	}
 
 	if (result == HACKRF_SUCCESS) {
 		printf("0x%03x -> [%2d]\n", register_value, register_number);
@@ -150,7 +207,7 @@ int si5351c_write_register(
 	if (result == HACKRF_SUCCESS) {
 		printf("0x%2x -> [%3d]\n", register_value, register_number);
 	} else {
-		printf("hackrf_max2837_write() failed: %s (%d)\n",
+		printf("hackrf_si5351c_write() failed: %s (%d)\n",
 		       hackrf_error_name(result),
 		       result);
 	}
@@ -360,22 +417,74 @@ int rffc5072_write_register(
 	return result;
 }
 
-enum parts {
-	PART_NONE = 0,
-	PART_MAX2837 = 1,
-	PART_SI5351C = 2,
-	PART_RFFC5072 = 3,
-};
+int fpga_read_register(hackrf_device* device, const uint16_t register_number)
+{
+	uint8_t register_value;
+	int result = hackrf_fpga_read_register(
+		device,
+		(uint8_t) register_number,
+		&register_value);
+
+	if (result == HACKRF_SUCCESS) {
+		printf("[%2d] -> 0x%02x\n", register_number, register_value);
+	} else {
+		printf("hackrf_fpga_read_register() failed: %s (%d)\n",
+		       hackrf_error_name(result),
+		       result);
+	}
+
+	return result;
+}
+
+int fpga_read_registers(hackrf_device* device)
+{
+	uint16_t register_number;
+	int result = HACKRF_SUCCESS;
+
+	for (register_number = 1; register_number <= 5; register_number++) {
+		result = fpga_read_register(device, register_number);
+		if (result != HACKRF_SUCCESS) {
+			break;
+		}
+	}
+
+	return result;
+}
+
+int fpga_write_register(
+	hackrf_device* device,
+	const uint16_t register_number,
+	const uint16_t register_value)
+{
+	int result = HACKRF_SUCCESS;
+	result = hackrf_fpga_write_register(
+		device,
+		(uint8_t) register_number,
+		register_value);
+
+	if (result == HACKRF_SUCCESS) {
+		printf("0x%02x -> [%2d]\n", register_value, register_number);
+	} else {
+		printf("hackrf_fpga_write_register() failed: %s (%d)\n",
+		       hackrf_error_name(result),
+		       result);
+	}
+
+	return result;
+}
 
 int read_register(hackrf_device* device, uint8_t part, const uint16_t register_number)
 {
 	switch (part) {
 	case PART_MAX2837:
-		return max2837_read_register(device, register_number);
+	case PART_MAX2831:
+		return max283x_read_register(device, register_number, part);
 	case PART_SI5351C:
 		return si5351c_read_register(device, register_number);
 	case PART_RFFC5072:
 		return rffc5072_read_register(device, register_number);
+	case PART_GATEWARE:
+		return fpga_read_register(device, register_number);
 	}
 	return HACKRF_ERROR_INVALID_PARAM;
 }
@@ -384,11 +493,14 @@ int read_registers(hackrf_device* device, uint8_t part)
 {
 	switch (part) {
 	case PART_MAX2837:
-		return max2837_read_registers(device);
+	case PART_MAX2831:
+		return max283x_read_registers(device, part);
 	case PART_SI5351C:
 		return si5351c_read_registers(device);
 	case PART_RFFC5072:
 		return rffc5072_read_registers(device);
+	case PART_GATEWARE:
+		return fpga_read_registers(device);
 	}
 	return HACKRF_ERROR_INVALID_PARAM;
 }
@@ -401,11 +513,18 @@ int write_register(
 {
 	switch (part) {
 	case PART_MAX2837:
-		return max2837_write_register(device, register_number, register_value);
+	case PART_MAX2831:
+		return max283x_write_register(
+			device,
+			register_number,
+			register_value,
+			part);
 	case PART_SI5351C:
 		return si5351c_write_register(device, register_number, register_value);
 	case PART_RFFC5072:
 		return rffc5072_write_register(device, register_number, register_value);
+	case PART_GATEWARE:
+		return fpga_write_register(device, register_number, register_value);
 	}
 	return HACKRF_ERROR_INVALID_PARAM;
 }
@@ -465,19 +584,28 @@ static void usage()
 	printf("\t-w, --write <v>: write register specified by last -n argument with value <v>\n");
 	printf("\t-c, --config: print SI5351C multisynth configuration information\n");
 	printf("\t-d, --device <s>: specify a particular device by serial number\n");
-	printf("\t-m, --max2837: target MAX2837\n");
+	printf("\t-m, --max283x: target MAX283x\n");
 	printf("\t-s, --si5351c: target SI5351C\n");
 	printf("\t-f, --rffc5072: target RFFC5072\n");
+	printf("\t-g, --gateware: target gateware registers\n");
+	printf("\t-P, --fpga <n>: load the n-th bitstream to the FPGA\n");
+	printf("\t-1, --p1 <n>: P1 control\n");
+	printf("\t-2, --p2 <n>: P2 control\n");
+	printf("\t-C, --clkin <0/1>: CLKIN control (0 for P1_CLKIN, 1 for P22_CLKIN)\n");
+	printf("\t-N, --narrowband <0/1>: narrowband filter disable/enable\n");
 	printf("\t-S, --state: display M0 state\n");
 	printf("\t-T, --tx-underrun-limit <n>: set TX underrun limit in bytes (0 for no limit)\n");
 	printf("\t-R, --rx-overrun-limit <n>: set RX overrun limit in bytes (0 for no limit)\n");
 	printf("\t-u, --ui <1/0>: enable/disable UI\n");
 	printf("\t-l, --leds <state>: configure LED state (0 for all off, 1 for default)\n");
+	printf("\t-t, --selftest: read self-test report\n");
+	printf("\t-o, --rtc-osc: test 32.768kHz RTC oscillator\n");
+	printf("\t-a, --adc <channel>: read value from an ADC channel. Add 0x80 for alternate pin\n");
 	printf("\nExamples:\n");
 	printf("\thackrf_debug --si5351c -n 0 -r     # reads from si5351c register 0\n");
 	printf("\thackrf_debug --si5351c -c          # displays si5351c multisynth configuration\n");
 	printf("\thackrf_debug --rffc5072 -r         # reads all rffc5072 registers\n");
-	printf("\thackrf_debug --max2837 -n 10 -w 22 # writes max2837 register 10 with 22 decimal\n");
+	printf("\thackrf_debug --max283x -n 10 -w 22 # writes max283x register 10 with 22 decimal\n");
 	printf("\thackrf_debug --state               # displays M0 state\n");
 }
 
@@ -489,19 +617,30 @@ static struct option long_options[] = {
 	{"device", required_argument, 0, 'd'},
 	{"help", no_argument, 0, 'h'},
 	{"max2837", no_argument, 0, 'm'},
+	{"max283x", no_argument, 0, 'm'},
 	{"si5351c", no_argument, 0, 's'},
 	{"rffc5072", no_argument, 0, 'f'},
+	{"gateware", no_argument, 0, 'g'},
+	{"fpga", required_argument, 0, 'P'},
+	{"p1", required_argument, 0, '1'},
+	{"p2", required_argument, 0, '2'},
+	{"clkin", required_argument, 0, 'C'},
+	{"narrowband", required_argument, 0, 'N'},
 	{"state", no_argument, 0, 'S'},
 	{"tx-underrun-limit", required_argument, 0, 'T'},
 	{"rx-overrun-limit", required_argument, 0, 'R'},
 	{"ui", required_argument, 0, 'u'},
 	{"leds", required_argument, 0, 'l'},
+	{"selftest", no_argument, 0, 't'},
+	{"rtc-osc", no_argument, 0, 'o'},
+	{"adc", required_argument, 0, 'a'},
 	{0, 0, 0, 0},
 };
 
 int main(int argc, char** argv)
 {
 	int opt;
+	uint8_t board_id = BOARD_ID_UNDETECTED;
 	uint32_t register_number = REGISTER_INVALID;
 	uint32_t register_value;
 	hackrf_device* device = NULL;
@@ -518,8 +657,22 @@ int main(int argc, char** argv)
 	uint32_t led_state;
 	uint32_t tx_limit;
 	uint32_t rx_limit;
+	uint32_t p1_state;
+	uint32_t p2_state;
+	uint32_t clkin_state;
+	uint32_t narrowband_state;
+	uint32_t bitstream_index;
+	uint32_t adc_channel;
 	bool set_tx_limit = false;
 	bool set_rx_limit = false;
+	bool set_p1 = false;
+	bool set_p2 = false;
+	bool set_clkin = false;
+	bool set_narrowband = false;
+	bool set_fpga_bitstream = false;
+	bool read_selftest = false;
+	bool test_rtc_osc = false;
+	bool read_adc = false;
 
 	int result = hackrf_init();
 	if (result) {
@@ -532,7 +685,7 @@ int main(int argc, char** argv)
 	while ((opt = getopt_long(
 			argc,
 			argv,
-			"n:rw:d:cmsfST:R:h?u:l:",
+			"n:rw:d:cmsfg1:2:C:N:P:ST:R:h?u:l:ta:o",
 			long_options,
 			&option_index)) != EOF) {
 		switch (opt) {
@@ -594,6 +747,39 @@ int main(int argc, char** argv)
 			part = PART_RFFC5072;
 			break;
 
+		case 'g':
+			if (part != PART_NONE) {
+				fprintf(stderr, "Only one part can be specified.'\n");
+				return EXIT_FAILURE;
+			}
+			part = PART_GATEWARE;
+			break;
+
+		case '1':
+			set_p1 = true;
+			result = parse_int(optarg, &p1_state);
+			break;
+
+		case '2':
+			set_p2 = true;
+			result = parse_int(optarg, &p2_state);
+			break;
+
+		case 'C':
+			set_clkin = true;
+			result = parse_int(optarg, &clkin_state);
+			break;
+
+		case 'N':
+			set_narrowband = true;
+			result = parse_int(optarg, &narrowband_state);
+			break;
+
+		case 'P':
+			set_fpga_bitstream = true;
+			result = parse_int(optarg, &bitstream_index);
+			break;
+
 		case 'u':
 			set_ui = true;
 			result = parse_int(optarg, &ui_enable);
@@ -603,6 +789,17 @@ int main(int argc, char** argv)
 			set_leds = true;
 			result = parse_int(optarg, &led_state);
 			break;
+		case 't':
+			read_selftest = true;
+			break;
+		case 'o':
+			test_rtc_osc = true;
+			break;
+
+		case 'a':
+			read_adc = true;
+			result = parse_int(optarg, &adc_channel);
+			break;
 
 		case 'h':
 		case '?':
@@ -642,14 +839,18 @@ int main(int argc, char** argv)
 	}
 
 	if (!(write || read || dump_config || dump_state || set_tx_limit ||
-	      set_rx_limit || set_ui || set_leds)) {
+	      set_rx_limit || set_ui || set_leds || set_p1 || set_p2 || set_clkin ||
+	      set_narrowband || set_fpga_bitstream || read_selftest || test_rtc_osc ||
+	      read_adc)) {
 		fprintf(stderr, "Specify read, write, or config option.\n");
 		usage();
 		return EXIT_FAILURE;
 	}
 
 	if (part == PART_NONE && !set_ui && !dump_state && !set_tx_limit &&
-	    !set_rx_limit && !set_leds) {
+	    !set_rx_limit && !set_leds && !set_p1 && !set_p2 && !set_clkin &&
+	    !set_narrowband && !set_fpga_bitstream && !read_selftest && !test_rtc_osc &&
+	    !read_adc) {
 		fprintf(stderr, "Specify a part to read, write, or print config from.\n");
 		usage();
 		return EXIT_FAILURE;
@@ -663,6 +864,20 @@ int main(int argc, char** argv)
 		return EXIT_FAILURE;
 	}
 
+	if (part == PART_MAX2837) {
+		result = hackrf_board_id_read(device, &board_id);
+		if (result != HACKRF_SUCCESS) {
+			fprintf(stderr,
+				"hackrf_board_id_read() failed: %s (%d)\n",
+				hackrf_error_name(result),
+				result);
+			return EXIT_FAILURE;
+		}
+		if (board_id == BOARD_ID_PRALINE) {
+			part = PART_MAX2831;
+		}
+	}
+
 	if (write) {
 		result = write_register(device, part, register_number, register_value);
 	}
@@ -699,6 +914,56 @@ int main(int argc, char** argv)
 		}
 	}
 
+	if (set_p1) {
+		result = hackrf_set_p1_ctrl(device, p1_state);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_set_p1_ctrl() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+	}
+
+	if (set_p2) {
+		result = hackrf_set_p2_ctrl(device, p2_state);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_set_p2_ctrl() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+	}
+
+	if (set_clkin) {
+		result = hackrf_set_clkin_ctrl(device, clkin_state);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_set_clkin_ctrl() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+	}
+
+	if (set_narrowband) {
+		result = hackrf_set_narrowband_filter(device, narrowband_state);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_set_narrowband_filter() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+	}
+
+	if (set_fpga_bitstream) {
+		result = hackrf_set_fpga_bitstream(device, bitstream_index);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_set_fpga_bitstream() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+	}
+
 	if (dump_state) {
 		hackrf_m0_state state;
 		result = hackrf_get_m0_state(device, &state);
@@ -725,6 +990,46 @@ int main(int argc, char** argv)
 		result = hackrf_set_leds(device, led_state);
 	}
 
+	if (read_selftest) {
+		hackrf_selftest selftest;
+		result = hackrf_read_selftest(device, &selftest);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_read_selftest() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+		printf("Self-test result: %s\n", selftest.pass ? "PASS" : "FAIL");
+		printf("%s", selftest.msg);
+	}
+
+	if (test_rtc_osc) {
+		bool pass;
+		result = hackrf_test_rtc_osc(device, &pass);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_test_rtc_osc() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+		printf("RTC test result: %s\n", pass ? "PASS" : "FAIL");
+	}
+
+	if (read_adc) {
+		uint16_t value;
+		result = hackrf_read_adc(device, adc_channel, &value);
+		if (result != HACKRF_SUCCESS) {
+			printf("hackrf_read_adc() failed: %s (%d)\n",
+			       hackrf_error_name(result),
+			       result);
+			return EXIT_FAILURE;
+		}
+		printf("ADC0_%d (%s pin): %d\n",
+		       adc_channel & 0x7,
+		       adc_channel & 0x80 ? "alternate" : "dedicated",
+		       value);
+	}
+
 	result = hackrf_close(device);
 	if (result) {
 		printf("hackrf_close() failed: %s (%d)\n",

host/hackrf-tools/src/hackrf_info.c

@@ -46,7 +46,7 @@ void print_board_rev(uint8_t board_rev)
 	}
 }
 
-void print_supported_platform(uint32_t platform, uint8_t board_id)
+void print_supported_platform(uint32_t platform, uint8_t board_id, uint8_t board_rev)
 {
 	printf("Hardware supported by installed firmware:\n");
 	if (platform & HACKRF_PLATFORM_JAWBREAKER) {
@@ -59,6 +59,13 @@ void print_supported_platform(uint32_t platform, uint8_t board_id)
 	    (platform & HACKRF_PLATFORM_HACKRF1_R9)) {
 		printf("    HackRF One\n");
 	}
+	if (platform & HACKRF_PLATFORM_PRALINE) {
+		if (board_rev & HACKRF_BOARD_REV_GSG) {
+			printf("    HackRF Pro\n");
+		} else {
+			printf("    Praline\n");
+		}
+	}
 	switch (board_id) {
 	case BOARD_ID_HACKRF1_OG:
 		if (!(platform & HACKRF_PLATFORM_HACKRF1_OG)) {
@@ -79,6 +86,11 @@ void print_supported_platform(uint32_t platform, uint8_t board_id)
 			break;
 		}
 		printf("Error: Firmware does not support hardware platform.\n");
+	case BOARD_ID_PRALINE:
+		if (platform & HACKRF_PLATFORM_PRALINE) {
+			break;
+		}
+		printf("Error: Firmware does not support hardware platform.\n");
 	}
 }
 
@@ -188,7 +200,8 @@ int main(void)
 		       read_partid_serialno.part_id[0],
 		       read_partid_serialno.part_id[1]);
 
-		if ((usb_version >= 0x0106) && ((board_id == 2) || (board_id == 4))) {
+		if ((usb_version >= 0x0106) &&
+		    ((board_id == 2) || (board_id == 4) || (board_id == 5))) {
 			result = hackrf_board_rev_read(device, &board_rev);
 			if (result != HACKRF_SUCCESS) {
 				fprintf(stderr,
@@ -210,7 +223,7 @@ int main(void)
 					result);
 				return EXIT_FAILURE;
 			}
-			print_supported_platform(supported_platform, board_id);
+			print_supported_platform(supported_platform, board_id, board_rev);
 		}
 
 		result = hackrf_get_operacake_boards(device, &operacakes[0]);
@@ -247,6 +260,21 @@ int main(void)
 		}
 #endif /* HACKRF_ISSUE_609_IS_FIXED */
 
+		if (usb_version >= 0x0109) {
+			hackrf_selftest selftest;
+			result = hackrf_read_selftest(device, &selftest);
+			if (result != HACKRF_SUCCESS) {
+				printf("hackrf_read_selftest() failed: %s (%d)\n",
+				       hackrf_error_name(result),
+				       result);
+				return EXIT_FAILURE;
+			}
+			if (!selftest.pass) {
+				printf("Self-test FAIL:\n");
+				printf("%s", selftest.msg);
+			}
+		}
+
 		result = hackrf_close(device);
 		if (result != HACKRF_SUCCESS) {
 			fprintf(stderr,

host/hackrf-tools/src/hackrf_sweep.c

@@ -96,7 +96,6 @@ int gettimeofday(struct timeval* tv, void* ignored)
 #define OFFSET    7500000
 
 #define BLOCKS_PER_TRANSFER 16
-#define THROWAWAY_BLOCKS    2
 
 #if defined _WIN32
 	#define m_sleep(a) Sleep((a))