qdl: decouple transport logic

Decouple the flashing logic from the underlying type of communication.

Signed-off-by: Igor Opaniuk <igor.opaniuk@oss.qualcomm.com>

Author: igoropaniuk

Makefile

@@ -6,10 +6,10 @@ CFLAGS += -O2 -Wall -g `pkg-config --cflags libxml-2.0 libusb-1.0`
 LDFLAGS += `pkg-config --libs libxml-2.0 libusb-1.0`
 prefix := /usr/local
 
-QDL_SRCS := firehose.c qdl.c sahara.c util.c patch.c program.c read.c ufs.c usb.c ux.c
+QDL_SRCS := firehose.c io.c qdl.c sahara.c util.c patch.c program.c read.c ufs.c usb.c ux.c
 QDL_OBJS := $(QDL_SRCS:.c=.o)
 
-RAMDUMP_SRCS := ramdump.c sahara.c usb.c util.c ux.c
+RAMDUMP_SRCS := ramdump.c sahara.c io.c usb.c util.c ux.c
 RAMDUMP_OBJS := $(RAMDUMP_SRCS:.c=.o)
 
 KS_OUT := ks

io.c

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2025, Qualcomm Innovation Center, Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ * this list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ *
+ * 3. Neither the name of the copyright holder nor the names of its contributors
+ * may be used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ * POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "qdl.h"
+
+struct qdl_device *qdl_init(enum QDL_DEVICE_TYPE type)
+{
+	if (type == QDL_DEVICE_USB)
+		return usb_init();
+
+	return NULL;
+}
+
+void qdl_deinit(struct qdl_device *qdl)
+{
+	if (qdl)
+		free(qdl);
+}
+
+void qdl_set_out_chunk_size(struct qdl_device *qdl, long size)
+{
+	qdl->set_out_chunk_size(qdl, size);
+}
+
+int qdl_open(struct qdl_device *qdl, const char *serial)
+{
+	return qdl->open(qdl, serial);
+}
+
+void qdl_close(struct qdl_device *qdl)
+{
+	qdl->close(qdl);
+}
+
+int qdl_read(struct qdl_device *qdl, void *buf, size_t len, unsigned int timeout)
+{
+	return qdl->read(qdl, buf, len, timeout);
+}
+
+int qdl_write(struct qdl_device *qdl, const void *buf, size_t len)
+{
+	return qdl->write(qdl, buf, len);
+}

qdl.c

@@ -55,7 +55,6 @@ enum {
 };
 
 bool qdl_debug;
-static struct qdl_device qdl;
 
 static int detect_type(const char *xml_file)
 {
@@ -121,7 +120,9 @@ int main(int argc, char **argv)
 	int opt;
 	bool qdl_finalize_provisioning = false;
 	bool allow_missing = false;
-	long out_chunk_size;
+	long out_chunk_size = 0;
+	struct qdl_device *qdl = NULL;
+	enum QDL_DEVICE_TYPE qdl_dev_type = QDL_DEVICE_USB;
 
 	static struct option options[] = {
 		{"debug", no_argument, 0, 'd'},
@@ -154,7 +155,6 @@ int main(int argc, char **argv)
 			break;
 		case OPT_OUT_CHUNK_SIZE:
 			out_chunk_size = strtol(optarg, NULL, 10);
-			qdl_set_out_chunk_size(&qdl, out_chunk_size);
 			break;
 		case 's':
 			storage = optarg;
@@ -174,6 +174,15 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
+	qdl = qdl_init(qdl_dev_type);
+	if (!qdl) {
+		ret = -1;
+		goto out_cleanup;
+	}
+
+	if (out_chunk_size)
+		qdl_set_out_chunk_size(qdl, out_chunk_size);
+
 	ux_init();
 
 	if (qdl_debug)
@@ -213,23 +222,25 @@ int main(int argc, char **argv)
 		}
 	} while (++optind < argc);
 
-	ret = qdl_open(&qdl, serial);
+	ret = qdl_open(qdl, serial);
 	if (ret)
 		goto out_cleanup;
 
-	qdl.mappings[0] = prog_mbn;
-	ret = sahara_run(&qdl, qdl.mappings, true, NULL, NULL);
+	qdl->mappings[0] = prog_mbn;
+	ret = sahara_run(qdl, qdl->mappings, true, NULL, NULL);
 	if (ret < 0)
 		goto out_cleanup;
 
-	ret = firehose_run(&qdl, incdir, storage, allow_missing);
+	ret = firehose_run(qdl, incdir, storage, allow_missing);
 	if (ret < 0)
 		goto out_cleanup;
 
 out_cleanup:
-	qdl_close(&qdl);
+	qdl_close(qdl);
 	free_programs();
 	free_patches();
 
+	qdl_deinit(qdl);
+
 	return !!ret;
 }

qdl.h

@@ -8,30 +8,56 @@
 #include "read.h"
 #include <libxml/tree.h>
 
+#define container_of(ptr, typecast, member) ({                  \
+	void *_ptr = (void *)(ptr);		                \
+	((typecast *)(_ptr - offsetof(typecast, member))); })
+
 #define MAPPING_SZ 64
 
-struct libusb_device_handle;
+enum QDL_DEVICE_TYPE
+{
+	QDL_DEVICE_USB,
+};
 
-struct qdl_device {
-        struct libusb_device_handle *usb_handle;
-        int fd;
+struct qdl_device
+{
+	enum QDL_DEVICE_TYPE dev_type;
+	int fd;
 
-        int in_ep;
-        int out_ep;
+	int (*open)(struct qdl_device *qdl, const char *serial);
+	int (*read)(struct qdl_device *qdl, void *buf, size_t len, unsigned int timeout);
+	int (*write)(struct qdl_device *qdl, const void *buf, size_t nbytes);
+	void (*close)(struct qdl_device *qdl);
+	void (*set_out_chunk_size)(struct qdl_device *qdl, long size);
 
-        size_t in_maxpktsize;
-        size_t out_maxpktsize;
-        size_t out_chunk_size;
+	char *mappings[MAPPING_SZ]; // array index is the id from the device
+};
 
-        char *mappings[MAPPING_SZ]; // array index is the id from the device
+struct libusb_device_handle;
+
+struct qdl_device_usb
+{
+	struct qdl_device base;
+	struct libusb_device_handle *usb_handle;
+
+	int in_ep;
+	int out_ep;
+
+	size_t in_maxpktsize;
+	size_t out_maxpktsize;
+	size_t out_chunk_size;
 };
 
+struct qdl_device *qdl_init(enum QDL_DEVICE_TYPE type);
+void qdl_deinit(struct qdl_device *qdl);
 int qdl_open(struct qdl_device *qdl, const char *serial);
 void qdl_close(struct qdl_device *qdl);
 int qdl_read(struct qdl_device *qdl, void *buf, size_t len, unsigned int timeout);
 int qdl_write(struct qdl_device *qdl, const void *buf, size_t len);
 void qdl_set_out_chunk_size(struct qdl_device *qdl, long size);
 
+struct qdl_device *usb_init(void);
+
 int firehose_run(struct qdl_device *qdl, const char *incdir, const char *storage, bool allow_missing);
 int sahara_run(struct qdl_device *qdl, char *img_arr[], bool single_image,
 	       const char *ramdump_path, const char *ramdump_filter);

ramdump.c

@@ -18,7 +18,9 @@ static void print_usage(void)
 
 int main(int argc, char **argv)
 {
-	struct qdl_device qdl;
+	struct qdl_device_usb qdl;
+	qdl.base.dev_type = QDL_DEVICE_USB;
+
 	char *ramdump_path = ".";
 	char *filter = NULL;
 	char *serial = NULL;
@@ -61,11 +63,11 @@ int main(int argc, char **argv)
 	if (qdl_debug)
 		print_version();
 
-	ret = qdl_open(&qdl, serial);
+	ret = qdl_open(&qdl.base, serial);
 	if (ret)
 		return 1;
 
-	ret = sahara_run(&qdl, NULL, true, ramdump_path, filter);
+	ret = sahara_run(&qdl.base, NULL, true, ramdump_path, filter);
 	if (ret < 0)
 		return 1;
 

usb.c

@@ -22,7 +22,7 @@
 #define LIBUSB_ENDPOINT_TRANSFER_TYPE_BULK LIBUSB_TRANSFER_TYPE_BULK
 #endif
 
-static bool qdl_match_usb_serial(struct libusb_device_handle *handle, const char *serial,
+static bool usb_match_usb_serial(struct libusb_device_handle *handle, const char *serial,
 				 const struct libusb_device_descriptor *desc)
 {
 	char buf[128];
@@ -49,7 +49,7 @@ static bool qdl_match_usb_serial(struct libusb_device_handle *handle, const char
 	return strcmp(p, serial) == 0;
 }
 
-static int qdl_try_open(libusb_device *dev, struct qdl_device *qdl, const char *serial)
+static int usb_try_open(libusb_device *dev, struct qdl_device_usb *qdl, const char *serial)
 {
 	const struct libusb_endpoint_descriptor *endpoint;
 	const struct libusb_interface_descriptor *ifc;
@@ -123,7 +123,7 @@ static int qdl_try_open(libusb_device *dev, struct qdl_device *qdl, const char *
 			continue;
 		}
 
-		if (!qdl_match_usb_serial(handle, serial, &desc)) {
+		if (!usb_match_usb_serial(handle, serial, &desc)) {
 			libusb_close(handle);
 			continue;
 		}
@@ -161,10 +161,11 @@ static int qdl_try_open(libusb_device *dev, struct qdl_device *qdl, const char *
 	return !!qdl->usb_handle;
 }
 
-int qdl_open(struct qdl_device *qdl, const char *serial)
+static int usb_open(struct qdl_device *qdl, const char *serial)
 {
 	struct libusb_device **devs;
 	struct libusb_device *dev;
+	struct qdl_device_usb *qdl_usb = container_of(qdl, struct qdl_device_usb, base);
 	bool wait_printed = false;
 	bool found = false;
 	ssize_t n;
@@ -183,7 +184,7 @@ int qdl_open(struct qdl_device *qdl, const char *serial)
 		for (i = 0; devs[i]; i++) {
 			dev = devs[i];
 
-			ret = qdl_try_open(dev, qdl, serial);
+			ret = usb_try_open(dev, qdl_usb, serial);
 			if (ret == 1) {
 				found = true;
 				break;
@@ -206,38 +207,42 @@ int qdl_open(struct qdl_device *qdl, const char *serial)
 	return -1;
 }
 
-void qdl_close(struct qdl_device *qdl)
+static void usb_close(struct qdl_device *qdl)
 {
-	libusb_close(qdl->usb_handle);
+	struct qdl_device_usb *qdl_usb = container_of(qdl, struct qdl_device_usb, base);
+
+	libusb_close(qdl_usb->usb_handle);
 	libusb_exit(NULL);
 }
 
-int qdl_read(struct qdl_device *qdl, void *buf, size_t len, unsigned int timeout)
+static int usb_read(struct qdl_device *qdl, void *buf, size_t len, unsigned int timeout)
 {
+	struct qdl_device_usb *qdl_usb = container_of(qdl, struct qdl_device_usb, base);
 	int actual;
 	int ret;
 
-	ret = libusb_bulk_transfer(qdl->usb_handle, qdl->in_ep, buf, len, &actual, timeout);
+	ret = libusb_bulk_transfer(qdl_usb->usb_handle, qdl_usb->in_ep, buf, len, &actual, timeout);
 	if ((ret != 0 && ret != LIBUSB_ERROR_TIMEOUT) ||
 	    (ret == LIBUSB_ERROR_TIMEOUT && actual == 0))
 		return -1;
 
 	return actual;
 }
 
-int qdl_write(struct qdl_device *qdl, const void *buf, size_t len)
+static int usb_write(struct qdl_device *qdl, const void *buf, size_t len)
 {
 	unsigned char *data = (unsigned char*) buf;
+	struct qdl_device_usb *qdl_usb = container_of(qdl, struct qdl_device_usb, base);
 	unsigned int count = 0;
 	size_t len_orig = len;
 	int actual;
 	int xfer;
 	int ret;
 
 	while (len > 0) {
-		xfer = (len > qdl->out_chunk_size) ? qdl->out_chunk_size : len;
+		xfer = (len > qdl_usb->out_chunk_size) ? qdl_usb->out_chunk_size : len;
 
-		ret = libusb_bulk_transfer(qdl->usb_handle, qdl->out_ep, data,
+		ret = libusb_bulk_transfer(qdl_usb->usb_handle, qdl_usb->out_ep, data,
 					   xfer, &actual, 1000);
 		if ((ret != 0 && ret != LIBUSB_ERROR_TIMEOUT) ||
 		    (ret == LIBUSB_ERROR_TIMEOUT && actual == 0)) {
@@ -250,8 +255,8 @@ int qdl_write(struct qdl_device *qdl, const void *buf, size_t len)
 		data += actual;
 	}
 
-	if (len_orig % qdl->out_maxpktsize == 0) {
-		ret = libusb_bulk_transfer(qdl->usb_handle, qdl->out_ep, NULL,
+	if (len_orig % qdl_usb->out_maxpktsize == 0) {
+		ret = libusb_bulk_transfer(qdl_usb->usb_handle, qdl_usb->out_ep, NULL,
 					   0, &actual, 1000);
 		if (ret < 0)
 			return -1;
@@ -260,7 +265,25 @@ int qdl_write(struct qdl_device *qdl, const void *buf, size_t len)
 	return count;
 }
 
-void qdl_set_out_chunk_size(struct qdl_device *qdl, long size)
+static void usb_set_out_chunk_size(struct qdl_device *qdl, long size)
 {
-	qdl->out_chunk_size = size;
+	struct qdl_device_usb *qdl_usb = container_of(qdl, struct qdl_device_usb, base);
+
+	qdl_usb->out_chunk_size = size;
 }
+
+struct qdl_device *usb_init(void)
+{
+	struct qdl_device *qdl = malloc(sizeof(struct qdl_device_usb));
+	if (!qdl)
+		return NULL;
+
+	qdl->dev_type = QDL_DEVICE_USB;
+	qdl->open = usb_open;
+	qdl->read = usb_read;
+	qdl->write = usb_write;
+	qdl->close = usb_close;
+	qdl->set_out_chunk_size = usb_set_out_chunk_size;
+
+	return qdl;
+}