hosted: rename bmda_probe_s info global variable

This hopefully helps
- code readability with a more contextually obvious name
- avoiding variable shadowing

src/platforms/hosted/bmp_hosted.h

@@ -93,7 +93,7 @@ typedef struct bmda_probe {
 
 typedef struct timeval timeval_s;
 
-extern bmda_probe_s info;
+extern bmda_probe_s bmda_probe_info;
 void bmp_ident(bmda_probe_s *info);
 int find_debuggers(bmda_cli_options_s *cl_opts, bmda_probe_s *info);
 void libusb_exit_function(bmda_probe_s *info);

src/platforms/hosted/cmsis_dap.c

@@ -164,14 +164,14 @@ static bool dap_init_hid(void)
 	if (hid_init())
 		return false;
 
-	const size_t size = mbslen(info.serial);
+	const size_t size = mbslen(bmda_probe_info.serial);
 	if (size > 64U) {
 		DEBUG_ERROR("Serial number invalid, aborting\n");
 		hid_exit();
 		return false;
 	}
 	wchar_t serial[65] = {0};
-	if (mbstowcs(serial, info.serial, size) != size) {
+	if (mbstowcs(serial, bmda_probe_info.serial, size) != size) {
 		DEBUG_ERROR("Serial number conversion failed, aborting\n");
 		hid_exit();
 		return false;
@@ -181,15 +181,15 @@ static bool dap_init_hid(void)
 	 * Special-case devices that do not work with 513 byte report length
 	 * FIXME: Find a solution to decipher from the device.
 	 */
-	if (info.vid == 0x1fc9U && info.pid == 0x0132U) {
+	if (bmda_probe_info.vid == 0x1fc9U && bmda_probe_info.pid == 0x0132U) {
 		DEBUG_WARN("Device does not work with the normal report length, activating quirk\n");
 		report_size = 64U + 1U;
 	}
-	handle = hid_open(info.vid, info.pid, serial[0] ? serial : NULL);
+	handle = hid_open(bmda_probe_info.vid, bmda_probe_info.pid, serial[0] ? serial : NULL);
 	if (!handle) {
 		DEBUG_ERROR("hid_open failed: %ls\n", hid_error(NULL));
 #ifdef __linux__
-		dap_hid_print_permissions(info.vid, info.pid, serial[0] ? serial : NULL);
+		dap_hid_print_permissions(bmda_probe_info.vid, bmda_probe_info.pid, serial[0] ? serial : NULL);
 #endif
 		hid_exit();
 		return false;
@@ -200,25 +200,25 @@ static bool dap_init_hid(void)
 static bool dap_init_bulk(void)
 {
 	DEBUG_INFO("Using bulk transfer\n");
-	int res = libusb_open(info.libusb_dev, &usb_handle);
+	int res = libusb_open(bmda_probe_info.libusb_dev, &usb_handle);
 	if (res != LIBUSB_SUCCESS) {
 		DEBUG_ERROR("libusb_open() failed (%d): %s\n", res, libusb_error_name(res));
 		return false;
 	}
-	if (libusb_claim_interface(usb_handle, info.interface_num) < 0) {
+	if (libusb_claim_interface(usb_handle, bmda_probe_info.interface_num) < 0) {
 		DEBUG_ERROR("libusb_claim_interface() failed\n");
 		return false;
 	}
-	in_ep = info.in_ep;
-	out_ep = info.out_ep;
+	in_ep = bmda_probe_info.in_ep;
+	out_ep = bmda_probe_info.out_ep;
 	return true;
 }
 
 /* LPC845 Breakout Board Rev. 0 reports an invalid response with > 65 bytes */
 bool dap_init(void)
 {
 	/* Initialise the adaptor via a suitable protocol */
-	if (info.in_ep && info.out_ep) {
+	if (bmda_probe_info.in_ep && bmda_probe_info.out_ep) {
 		type = CMSIS_TYPE_BULK;
 		if (!dap_init_bulk())
 			return false;
@@ -266,7 +266,7 @@ bool dap_init(void)
 
 	dap_quirks = 0;
 	/* Handle multi-TAP JTAG on older ORBTrace gateware being broken */
-	if (strcmp(info.product, "Orbtrace") == 0 &&
+	if (strcmp(bmda_probe_info.product, "Orbtrace") == 0 &&
 		(adaptor_version.major < 1 || (adaptor_version.major == 1 && adaptor_version.minor <= 2))) {
 		dap_quirks |= DAP_QUIRK_NO_JTAG_MUTLI_TAP;
 	}

src/platforms/hosted/ftdi_bmp.c

@@ -542,7 +542,7 @@ bool ftdi_bmp_init(bmda_cli_options_s *const cl_opts)
 		goto error_2;
 	}
 
-	info.ftdi_ctx = ctx;
+	bmda_probe_info.ftdi_ctx = ctx;
 	ftdi_init[index++] = TCK_DIVISOR;
 	/* Use CLK/2 for about 50 % SWDCLK duty cycle on FT2232c.*/
 	ftdi_init[index++] = 1;
@@ -671,9 +671,9 @@ void ftdi_buffer_flush(void)
 #if defined(USE_USB_VERSION_BIT)
 	if (tc_write)
 		ftdi_transfer_data_done(tc_write);
-	tc_write = ftdi_write_data_submit(info.ftdi_ctx, outbuf, bufptr);
+	tc_write = ftdi_write_data_submit(bmda_probe_info.ftdi_ctx, outbuf, bufptr);
 #else
-	assert(ftdi_write_data(info.ftdi_ctx, outbuf, bufptr) == bufptr);
+	assert(ftdi_write_data(bmda_probe_info.ftdi_ctx, outbuf, bufptr) == bufptr);
 #endif
 	bufptr = 0;
 }
@@ -706,11 +706,11 @@ size_t ftdi_buffer_read(void *const buffer, const size_t size)
 
 	uint8_t *const data = (uint8_t *)buffer;
 #if defined(USE_USB_VERSION_BIT)
-	ftdi_transfer_control_s *transfer = ftdi_read_data_submit(info.ftdi_ctx, data, (int)size);
+	ftdi_transfer_control_s *transfer = ftdi_read_data_submit(bmda_probe_info.ftdi_ctx, data, (int)size);
 	ftdi_transfer_data_done(transfer);
 #else
 	for (size_t index = 0; index < size;)
-		index += ftdi_read_data(info.ftdi_ctx, data + index, size - index);
+		index += ftdi_read_data(bmda_probe_info.ftdi_ctx, data + index, size - index);
 #endif
 
 	DEBUG_WIRE("%s: %zu bytes:", __func__, size);
@@ -830,14 +830,14 @@ static uint16_t divisor;
 void ftdi_max_frequency_set(uint32_t freq)
 {
 	uint32_t clock;
-	if (info.ftdi_ctx->type == TYPE_2232C)
+	if (bmda_probe_info.ftdi_ctx->type == TYPE_2232C)
 		clock = 12U * 1000U * 1000U;
 	else
 		/* Undivided clock set during startup*/
 		clock = 60U * 1000U * 1000U;
 
 	uint32_t div = (clock + 2U * freq - 1U) / freq;
-	if (div < 4U && info.ftdi_ctx->type == TYPE_2232C)
+	if (div < 4U && bmda_probe_info.ftdi_ctx->type == TYPE_2232C)
 		div = 4U; /* Avoid bad asymmetric FT2232C clock at 6 MHz*/
 	divisor = div / 2U - 1U;
 	uint8_t buf[3];
@@ -850,7 +850,7 @@ void ftdi_max_frequency_set(uint32_t freq)
 uint32_t libftdi_max_frequency_get(void)
 {
 	uint32_t clock;
-	if (info.ftdi_ctx->type == TYPE_2232C)
+	if (bmda_probe_info.ftdi_ctx->type == TYPE_2232C)
 		clock = 12U * 1000U * 1000U;
 	else
 		/* Undivided clock set during startup*/

src/platforms/hosted/ftdi_jtag.c

@@ -56,7 +56,7 @@ static bool ftdi_jtag_next(bool tms, bool tdi);
 void ftdi_jtag_drain_potential_garbage(void)
 {
 	uint8_t data[16];
-	int garbage = ftdi_read_data(info.ftdi_ctx, data, sizeof(data));
+	int garbage = ftdi_read_data(bmda_probe_info.ftdi_ctx, data, sizeof(data));
 	if (garbage > 0) {
 		DEBUG_WARN("FTDI JTAG init got garbage:");
 		for (int i = 0; i < garbage; i++)

src/platforms/hosted/jlink.c

@@ -62,29 +62,33 @@ jlink_s jlink;
 
 bool jlink_simple_query(const uint8_t command, void *const rx_buffer, const size_t rx_len)
 {
-	return bmda_usb_transfer(info.usb_link, &command, sizeof(command), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
+	return bmda_usb_transfer(
+			   bmda_probe_info.usb_link, &command, sizeof(command), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
 }
 
 bool jlink_simple_request_8(const uint8_t command, const uint8_t operation, void *const rx_buffer, const size_t rx_len)
 {
 	const uint8_t request[2U] = {command, operation};
-	return bmda_usb_transfer(info.usb_link, request, sizeof(request), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
+	return bmda_usb_transfer(
+			   bmda_probe_info.usb_link, request, sizeof(request), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
 }
 
 bool jlink_simple_request_16(
 	const uint8_t command, const uint16_t operation, void *const rx_buffer, const size_t rx_len)
 {
 	uint8_t request[3U] = {command};
 	write_le2(request, 1U, operation);
-	return bmda_usb_transfer(info.usb_link, request, sizeof(request), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
+	return bmda_usb_transfer(
+			   bmda_probe_info.usb_link, request, sizeof(request), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
 }
 
 bool jlink_simple_request_32(
 	const uint8_t command, const uint32_t operation, void *const rx_buffer, const size_t rx_len)
 {
 	uint8_t request[5U] = {command};
 	write_le4(request, 1U, operation);
-	return bmda_usb_transfer(info.usb_link, request, sizeof(request), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
+	return bmda_usb_transfer(
+			   bmda_probe_info.usb_link, request, sizeof(request), rx_buffer, rx_len, JLINK_USB_TIMEOUT) >= 0;
 }
 
 /*
@@ -134,10 +138,10 @@ bool jlink_transfer(const uint16_t clock_cycles, const uint8_t *const tms, const
 	if (tdi)
 		memcpy(buffer + 4U + byte_count, tdi, byte_count);
 	/* Send the resulting transaction and try to read back the response data */
-	if (bmda_usb_transfer(
-			info.usb_link, buffer, sizeof(*header) + (byte_count * 2U), buffer, byte_count, JLINK_USB_TIMEOUT) < 0 ||
+	if (bmda_usb_transfer(bmda_probe_info.usb_link, buffer, sizeof(*header) + (byte_count * 2U), buffer, byte_count,
+			JLINK_USB_TIMEOUT) < 0 ||
 		/* Try to read back the transaction return code */
-		bmda_usb_transfer(info.usb_link, NULL, 0, buffer + byte_count, 1U, JLINK_USB_TIMEOUT) < 0)
+		bmda_usb_transfer(bmda_probe_info.usb_link, NULL, 0, buffer + byte_count, 1U, JLINK_USB_TIMEOUT) < 0)
 		return false;
 	/* Copy out the response into the TDO buffer (if present) */
 	if (tdo)
@@ -186,7 +190,7 @@ bool jlink_transfer_swd(
 /*
  * Try to claim the debugging interface of a J-Link adaptor.
  * On success this copies the endpoint addresses identified into the
- * usb_link_s sub-structure of bmda_probe_s (info.usb_link) for later use.
+ * usb_link_s sub-structure of bmda_probe_s (bmda_probe_info.usb_link) for later use.
  * Returns true for success, false for failure.
  *
  * Note: Newer J-Links use 2 bulk endpoints, one for "IN" (EP1) and one
@@ -197,7 +201,7 @@ bool jlink_transfer_swd(
 static bool jlink_claim_interface(void)
 {
 	libusb_config_descriptor_s *config;
-	const int get_descriptor_result = libusb_get_active_config_descriptor(info.libusb_dev, &config);
+	const int get_descriptor_result = libusb_get_active_config_descriptor(bmda_probe_info.libusb_dev, &config);
 	if (get_descriptor_result != LIBUSB_SUCCESS) {
 		DEBUG_ERROR("Failed to get configuration descriptor: %s\n", libusb_error_name(get_descriptor_result));
 		return false;
@@ -209,12 +213,12 @@ static bool jlink_claim_interface(void)
 		const libusb_interface_descriptor_s *const interface_desc = &interface->altsetting[0];
 		if (interface_desc->bInterfaceClass == LIBUSB_CLASS_VENDOR_SPEC &&
 			interface_desc->bInterfaceSubClass == LIBUSB_CLASS_VENDOR_SPEC && interface_desc->bNumEndpoints > 1U) {
-			const int claim_result = libusb_claim_interface(info.usb_link->device_handle, (int)idx);
+			const int claim_result = libusb_claim_interface(bmda_probe_info.usb_link->device_handle, (int)idx);
 			if (claim_result) {
 				DEBUG_ERROR("Can not claim handle: %s\n", libusb_error_name(claim_result));
 				break;
 			}
-			info.usb_link->interface = idx;
+			bmda_probe_info.usb_link->interface = idx;
 			descriptor = interface_desc;
 		}
 	}
@@ -226,9 +230,9 @@ static bool jlink_claim_interface(void)
 	for (size_t i = 0; i < descriptor->bNumEndpoints; i++) {
 		const libusb_endpoint_descriptor_s *endpoint = &descriptor->endpoint[i];
 		if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN)
-			info.usb_link->ep_rx = endpoint->bEndpointAddress;
+			bmda_probe_info.usb_link->ep_rx = endpoint->bEndpointAddress;
 		else
-			info.usb_link->ep_tx = endpoint->bEndpointAddress;
+			bmda_probe_info.usb_link->ep_tx = endpoint->bEndpointAddress;
 	}
 	libusb_free_config_descriptor(config);
 	return true;
@@ -292,7 +296,7 @@ static bool jlink_get_version(void)
 		return false;
 
 	/* Read vesion string directly into jlink.version */
-	bmda_usb_transfer(info.usb_link, NULL, 0, jlink.fw_version, version_length, JLINK_USB_TIMEOUT);
+	bmda_usb_transfer(bmda_probe_info.usb_link, NULL, 0, jlink.fw_version, version_length, JLINK_USB_TIMEOUT);
 	jlink.fw_version[version_length - 1U] = '\0'; /* Ensure null termination */
 
 	DEBUG_INFO("Firmware version: %s\n", jlink.fw_version);
@@ -571,30 +575,30 @@ bool jlink_init(void)
 	usb_link_s *link = calloc(1, sizeof(usb_link_s));
 	if (!link)
 		return false;
-	info.usb_link = link;
-	link->context = info.libusb_ctx;
-	const int result = libusb_open(info.libusb_dev, &link->device_handle);
+	bmda_probe_info.usb_link = link;
+	link->context = bmda_probe_info.libusb_ctx;
+	const int result = libusb_open(bmda_probe_info.libusb_dev, &link->device_handle);
 	if (result != LIBUSB_SUCCESS) {
 		DEBUG_ERROR("libusb_open() failed (%d): %s\n", result, libusb_error_name(result));
 		return false;
 	}
 	if (!jlink_claim_interface()) {
-		libusb_close(info.usb_link->device_handle);
+		libusb_close(bmda_probe_info.usb_link->device_handle);
 		return false;
 	}
 	if (!link->ep_tx || !link->ep_rx) {
 		DEBUG_ERROR("Device setup failed\n");
-		libusb_release_interface(info.usb_link->device_handle, info.usb_link->interface);
-		libusb_close(info.usb_link->device_handle);
+		libusb_release_interface(bmda_probe_info.usb_link->device_handle, bmda_probe_info.usb_link->interface);
+		libusb_close(bmda_probe_info.usb_link->device_handle);
 		return false;
 	}
 	if (!jlink_get_capabilities() || !jlink_get_version() || !jlink_get_interfaces()) {
 		DEBUG_ERROR("Failed to read J-Link information\n");
-		libusb_release_interface(info.usb_link->device_handle, info.usb_link->interface);
-		libusb_close(info.usb_link->device_handle);
+		libusb_release_interface(bmda_probe_info.usb_link->device_handle, bmda_probe_info.usb_link->interface);
+		libusb_close(bmda_probe_info.usb_link->device_handle);
 		return false;
 	}
-	memcpy(info.version, jlink.fw_version, strlen(jlink.fw_version) + 1U);
+	memcpy(bmda_probe_info.version, jlink.fw_version, strlen(jlink.fw_version) + 1U);
 	return true;
 }
 
@@ -633,15 +637,15 @@ bool jlink_nrst_get_val(void)
 
 void jlink_max_frequency_set(const uint32_t frequency)
 {
-	const uint8_t bmda_interface = info.is_jtag ? JLINK_INTERFACE_JTAG : JLINK_INTERFACE_SWD;
+	const uint8_t bmda_interface = bmda_probe_info.is_jtag ? JLINK_INTERFACE_JTAG : JLINK_INTERFACE_SWD;
 
 	if (!jlink_set_interface_frequency(bmda_interface, frequency))
 		DEBUG_ERROR("Failed to set J-Link %s interface frequency\n", jlink_interface_to_string(bmda_interface));
 }
 
 uint32_t jlink_max_frequency_get(void)
 {
-	const uint8_t bmda_interface = info.is_jtag ? JLINK_INTERFACE_JTAG : JLINK_INTERFACE_SWD;
+	const uint8_t bmda_interface = bmda_probe_info.is_jtag ? JLINK_INTERFACE_JTAG : JLINK_INTERFACE_SWD;
 
 	/* Ensure we have the frequency info for the requested interface */
 	if (!jlink_get_interface_frequency(bmda_interface)) {