github: update libxml DLL bundled with Windows binary

Include new version of libxml DLL in Windows CI build.

Signed-off-by: Julien Vanier <julien@particle.io>

.checkpatch.conf

@@ -0,0 +1,35 @@
+--no-tree
+--strict
+--max-line-length=120
+--ignore FILE_PATH_CHANGES
+--ignore EMAIL_SUBJECT
+--ignore SPLIT_STRING
+
+# NEW_TYPEDEFS reports "do not add new typedefs"
+# typedef struct __attribute__((__packed__)) sparse_header {
+--ignore NEW_TYPEDEFS
+
+# PREFER_DEFINED_ATTRIBUTE_MACRO reports this kind of messages:
+# WARNING: Prefer __packed over __attribute__((__packed__))
+--ignore PREFER_DEFINED_ATTRIBUTE_MACRO
+
+# PREFER_KERNEL_TYPES reports this kind of messages (when using --strict):
+# "Prefer kernel type 'u32' over 'uint32_t'"
+--ignore PREFER_KERNEL_TYPES
+
+# BRACES reports this kind of messages:
+# braces {} are not necessary for any arm of this statement
+--ignore BRACES
+
+# CAMELCASE reports this kind of messages:
+# Avoid CamelCase: <xmlFreeDoc>
+--ignore CAMELCASE
+
+# AVOID_EXTERNS reports this kind of messages:
+# externs should be avoided in .c files
+# extern const char *__progname;
+--ignore AVOID_EXTERNS
+
+# COMMIT_LOG_LONG_LINE reports line lengths > 75 in commit log
+# Lets ignore this
+--ignore COMMIT_LOG_LONG_LINE

.github/workflows/build.yml

@@ -5,28 +5,151 @@ on:
   push:
 
 jobs:
-  build:
+  build-linux:
     strategy:
       fail-fast: false
       matrix:
-        os: [ ubuntu-24.04, ubuntu-22.04, ubuntu-20.04, macos-latest ]
-    runs-on: ${{ matrix.os }}
+        include:
+          - { arch: x64, os: 24, runner: ubuntu-24.04 }
+          - { arch: arm64, os: 24, runner: ubuntu-24.04-arm }
+          - { arch: x64, os: 22, runner: ubuntu-22.04 }
+          - { arch: arm64, os: 22, runner: ubuntu-22.04-arm }
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Dependencies
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y libxml2-dev libusb-1.0-0-dev
+
+      - name: Build
+        run: make
+
+      - name: Run tests
+        run: make tests
+
+      - name: Package
+        run: |
+          mkdir dist
+          cp `pkg-config --variable=libdir libusb-1.0`/libusb-1.0.so.0 dist
+          chmod 0644 dist/*
+          cp qdl dist
+          patchelf --set-rpath '$ORIGIN' dist/qdl
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: qdl-binary-ubuntu-${{matrix.os}}-${{ matrix.arch }}
+          path: dist/*
+
+
+  build-mac:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { sys: macos-14, arch: arm64 }
+          - { sys: macos-13, arch: intel }
+    runs-on: ${{ matrix.sys }}
 
     steps:
       - name: Checkout
         uses: actions/checkout@v4
 
-      - name: Dependencies (Ubuntu)
-        if: runner.os == 'Linux'
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libxml2-dev libusb-1.0-0-dev
-
-      - name: Dependencies (macOS)
-        if: runner.os == 'macOS'
+      - name: Dependencies
         run: |
           brew install libxml2
-          brew install libusb
 
       - name: Build
         run: make
+
+      - name: Run tests
+        run: make tests
+
+      - name: Package
+        run: |
+          set -x
+          mkdir dist
+          cp `pkg-config --variable=libdir libusb-1.0`/libusb-1.0.0.dylib dist
+          cp `pkg-config --variable=libdir liblzma`/liblzma.5.dylib dist
+          chmod 0644 dist/*
+          cp qdl dist
+
+          if uname -a | grep -q arm64; then
+            LIBUSB_DIR=/opt/homebrew/opt/libusb/lib
+            LIBLZMA_DIR=/usr/lib
+          else
+            LIBUSB_DIR=/usr/local/opt/libusb/lib
+            LIBLZMA_DIR=/usr/local/opt/xz/lib
+          fi
+
+          install_name_tool -add_rpath @executable_path dist/qdl
+          install_name_tool -change $LIBUSB_DIR/libusb-1.0.0.dylib @rpath/libusb-1.0.0.dylib dist/qdl
+          install_name_tool -change $LIBLZMA_DIR/liblzma.5.dylib @rpath/liblzma.5.dylib dist/qdl
+          otool -L dist/qdl
+          dist/qdl || true
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: qdl-binary-macos-${{ matrix.arch }}
+          path: dist/*
+
+  build-windows:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { sys: windows-latest, arch: x64 }
+          - { sys: windows-11-arm, arch: arm64 }
+    runs-on: ${{ matrix.sys }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup MSYS2
+        id: msys2
+        uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          install: >
+            base-devel
+            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-make
+            mingw-w64-x86_64-pkg-config
+            mingw-w64-x86_64-libxml2
+            mingw-w64-x86_64-libusb
+
+      - name: Build
+        run: make
+        shell: msys2 {0}
+
+      - name: Run tests
+        run: make tests
+        shell: msys2 {0}
+
+      - name: Package
+        shell: pwsh
+        run: |
+          $MSYS2_LOCATION = "${{ steps.msys2.outputs.msys2-location }}"
+          $BIN_DIR = Join-Path $MSYS2_LOCATION "mingw64\bin"
+          $DistDir = "dist"
+          New-Item -ItemType Directory -Path $DistDir | Out-Null
+
+          Copy-Item (Join-Path $BIN_DIR "zlib1.dll") $DistDir
+          Copy-Item (Join-Path $BIN_DIR "libxml2-16.dll") $DistDir
+          Copy-Item (Join-Path $BIN_DIR "libusb-1.0.dll") $DistDir
+          Copy-Item (Join-Path $BIN_DIR "liblzma-5.dll") $DistDir
+          Copy-Item (Join-Path $BIN_DIR "libiconv-2.dll") $DistDir
+
+          Copy-Item "qdl.exe" $DistDir
+
+      - name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: qdl-binary-windows-${{ matrix.arch }}
+          path: dist/*
+

.github/workflows/checkpatch.yml

@@ -0,0 +1,15 @@
+name: Checkpatch Review
+on: [pull_request]
+jobs:
+  check-patch:
+    name: checkpatch review
+    runs-on: ubuntu-latest
+    steps:
+    - name: 'Calculate PR commits + 1'
+      run: echo "PR_FETCH_DEPTH=$(( ${{ github.event.pull_request.commits }} + 1 ))" >> $GITHUB_ENV
+    - uses: actions/checkout@v4
+      with:
+        ref: ${{ github.event.pull_request.head.sha }}
+        fetch-depth: 0
+    - name: Run checkpatch review
+      uses: webispy/checkpatch-action@v9

.github/workflows/markdown-lint.yml

@@ -0,0 +1,11 @@
+name: Markdown Lint
+on: [pull_request]
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v4
+    - uses: DavidAnson/markdownlint-cli2-action@v20
+      with:
+        globs: |
+          README.md

.gitignore

@@ -2,5 +2,10 @@
 qdl
 qdl-ramdump
 ks
+*.exe
 compile_commands.json
 .cache
+.version.h
+version.h
+scripts
+.checkpatch-camelcase.git.

Makefile

@@ -1,20 +1,31 @@
 QDL := qdl
 RAMDUMP := qdl-ramdump
+VERSION := $(or $(VERSION), $(shell git describe --dirty --always --tags 2>/dev/null), "unknown-version")
 
 CFLAGS += -O2 -Wall -g `pkg-config --cflags libxml-2.0 libusb-1.0`
 LDFLAGS += `pkg-config --libs libxml-2.0 libusb-1.0`
+ifeq ($(OS),Windows_NT)
+LDFLAGS += -lws2_32
+endif
 prefix := /usr/local
 
-QDL_SRCS := firehose.c qdl.c sahara.c util.c patch.c program.c read.c ufs.c usb.c
+QDL_SRCS := firehose.c io.c qdl.c sahara.c util.c patch.c program.c read.c sha2.c sim.c ufs.c usb.c ux.c oscompat.c vip.c sparse.c
 QDL_OBJS := $(QDL_SRCS:.c=.o)
 
-RAMDUMP_SRCS := ramdump.c sahara.c usb.c util.c
+RAMDUMP_SRCS := ramdump.c sahara.c io.c sim.c usb.c util.c ux.c oscompat.c
 RAMDUMP_OBJS := $(RAMDUMP_SRCS:.c=.o)
 
 KS_OUT := ks
-KS_SRCS := ks.c sahara.c util.c
+KS_SRCS := ks.c sahara.c util.c ux.c oscompat.c
 KS_OBJS := $(KS_SRCS:.c=.o)
 
+CHECKPATCH_SOURCES := $(shell find . -type f \( -name "*.c" -o -name "*.h" -o -name "*.sh" \) ! -name "sha2.c" ! -name "sha2.h" ! -name "*version.h")
+CHECKPATCH_ROOT := https://raw.githubusercontent.com/torvalds/linux/v6.15/scripts
+CHECKPATCH_URL := $(CHECKPATCH_ROOT)/checkpatch.pl
+CHECKPATCH_SP_URL := $(CHECKPATCH_ROOT)/spelling.txt
+CHECKPATCH := ./.scripts/checkpatch.pl
+CHECKPATCH_SP := ./.scripts/spelling.txt
+
 default: $(QDL) $(RAMDUMP) $(KS_OUT)
 
 $(QDL): $(QDL_OBJS)
@@ -29,12 +40,44 @@ $(KS_OUT): $(KS_OBJS)
 compile_commands.json: $(QDL_SRCS) $(KS_SRCS)
 	@echo -n $^ | jq -snR "[inputs|split(\" \")[]|{directory:\"$(PWD)\", command: \"$(CC) $(CFLAGS) -c \(.)\", file:.}]" > $@
 
+version.h::
+	@echo "#define VERSION \"$(VERSION)\"" > .version.h
+	@cmp -s .version.h version.h || cp .version.h version.h
+
+util.o: version.h
+
 clean:
 	rm -f $(QDL) $(QDL_OBJS)
 	rm -f $(RAMDUMP) $(RAMDUMP_OBJS)
 	rm -f $(KS_OUT) $(KS_OBJS)
 	rm -f compile_commands.json
+	rm -f version.h .version.h
+	rm -f $(CHECKPATCH)
+	rm -f $(CHECKPATCH_SP)
+	if [ -d .scripts ]; then rmdir .scripts; fi
 
 install: $(QDL) $(RAMDUMP) $(KS_OUT)
 	install -d $(DESTDIR)$(prefix)/bin
 	install -m 755 $^ $(DESTDIR)$(prefix)/bin
+
+tests: default
+tests:
+	@./tests/run_tests.sh
+
+# Target to download checkpatch.pl if not present
+$(CHECKPATCH):
+	@echo "Downloading checkpatch.pl..."
+	@mkdir -p $(dir $(CHECKPATCH))
+	@curl -sSfL $(CHECKPATCH_URL) -o $(CHECKPATCH)
+	@curl -sSfL $(CHECKPATCH_SP_URL) -o $(CHECKPATCH_SP)
+	@chmod +x $(CHECKPATCH)
+
+check: $(CHECKPATCH)
+	@echo "Running checkpatch on source files (excluding sha2.c and sha2.h)..."
+	@for file in $(CHECKPATCH_SOURCES); do \
+		perl $(CHECKPATCH) --no-tree -f $$file || exit 1; \
+	done
+
+check-cached: $(CHECKPATCH)
+	@echo "Running checkpatch on staged changes..."
+	@git diff --cached -- . | perl $(CHECKPATCH) --no-tree -

README

@@ -1,16 +0,0 @@
-Qualcomm Download
-=================
-
-This tool communicates with USB devices of id 05c6:9008 to upload a flash
-loader and use this to flash images.
-
-Usage:
-  qdl <prog.mbn> [<program> <patch> ...]
-
-Building
-========
-In order to build the project you need libxml2 and libusb-1.0 headers
-and libraries, found in e.g. the libxml2-dev and libusb-1.0.0-dev packages
-
-With these installed run:
-  make

README.md

@@ -0,0 +1,170 @@
+# Qualcomm Download
+
+[![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+[![Build on push](https://github.com/linux-msm/qdl/actions/workflows/build.yml/badge.svg)](https://github.com/linux-msm/qdl/actions/workflows/build.yml/badge.svg)
+
+This tool communicates with USB devices of id `05c6:9008` to upload a flash
+loader and use this to flash images.
+
+## Build
+
+### Linux
+
+```bash
+sudo apt install libxml2 libusb-1.0-0-dev
+make
+```
+
+### MacOS
+
+```bash
+brew install libxml2 pkg-config libusb
+make
+```
+
+### Windows
+
+First, install the [MSYS2 environment](https://www.msys2.org/). Then, run the
+MSYS2 MinGW64 terminal (located at `<msys2-installation-path>\mingw64.exe`) and
+install additional packages needed for QDL compilation using the `pacman` tool:
+
+```bash
+pacman -S base-devel --needed
+pacman -S mingw-w64-x86_64-gcc
+pacman -S mingw-w64-x86_64-make
+pacman -S mingw-w64-x86_64-pkg-config
+pacman -S mingw-w64-x86_64-libusb
+pacman -S mingw-w64-x86_64-libxml2
+```
+
+Then use the `make` tool to build QDL:
+
+```bash
+make
+```
+
+## Use QDL
+
+### EDL mode
+
+The device intended for flashing must be booted into **Emergency Download (EDL)**
+mode. EDL is a special boot mode available on Qualcomm-based devices that provides
+low-level access for firmware flashing and recovery. It bypasses the standard boot
+process, allowing operations such as flashing firmware even on unresponsive devices
+or those with locked bootloaders.
+
+Please consult your device’s documentation for instructions on how to enter EDL mode.
+
+### Flash device
+
+Run QDL with the `--help` option to view detailed usage information.
+
+Below is an example of how to invoke QDL to flash a FLAT build:
+
+```bash
+qdl --dry-run prog_firehose_ddr.elf rawprogram*.xml patch*.xml
+```
+
+If you have multiple boards connected the host, provide the serial number of
+the board to flash through `--serial` param:
+
+```bash
+qdl --serial=0AA94EFD prog_firehose_ddr.elf rawprogram*.xml patch*.xml
+```
+
+### Validated Image Programming (VIP)
+
+QDL now supports **Validated Image Programming (VIP)** mode , which is activated
+when Secure Boot is enabled on the target. VIP controls which packets are allowed
+to be issued to the target. Controlling the packets that can be sent to the target
+is done through hashing. The target applies a hashing function to all received data,
+comparing the resulting hash digest against an existing digest table in memory.
+If the calculated hash digest matches the next entry in the table, the packet
+(data or command) is accepted; otherwise, the packet is rejected,and the target halts.
+
+To use VIP programming, a digest table must be generated prior to flashing the device.
+To generate table of digests run QDL with `--create-digests` param,
+providing a path to store VIP tables. For example:
+
+```bash
+mkdir vip
+qdl --create-digests=./vip prog_firehose_ddr.elf rawprogram*.xml patch*.xml
+```
+
+As a result 3 types of files are generated:
+
+- `DIGEST_TABLE.bin` - contains the SHA256 table of digests for all firehose
+  packets to be sent to the target. It is an intermediary table and is
+  used only for the subsequent generation of `DigestsToSign.bin` and
+  `ChainedTableOfDigests\<n\>.bin` files. It is not used by QDL for VIP
+  programming.
+
+- `DigestsToSign.bin` - first 53 digests + digest of `ChainedTableOfDigests.bin`.
+  This file has to be converted to MBN format and then signed with sectools:
+
+  ```bash
+  sectools mbn-tool generate --data DigestsToSign.bin --mbn-version 6 --outfile DigestsToSign.bin.mbn
+  sectools secure-image --sign DigestsToSign.bin.mbn --image-id=VIP
+  ```
+
+  Please check the security profile for your SoC to determine which version of
+  the MBN format should be used.
+
+- `ChainedTableOfDigests\<n\>.bin` - contains left digests, split on
+  multiple files with 255 digests + appended hash of next table.
+
+To flash board using VIP mode provide a path where previously generated and signed
+table of digests are stored using `--vip-table-path` param:
+
+```bash
+qdl --vip-table-path=./vip prog_firehose_ddr.elf rawprogram*.xml patch*.xml
+```
+
+## Run tests
+
+To run the integration test suite for QDL, use the `make tests` target:
+
+```bash
+make tests
+```
+
+## Contributing
+
+Please submit any patches to the qdl (`master` branch) by using the GitHub pull
+request feature. Fork the repo, create a branch, do the work, rebase with upstream,
+and submit the pull request.
+
+The preferred coding style for this tool is [Linux kernel coding style](https://www.kernel.org/doc/html/v6.15/process/coding-style.html).
+
+Before creating a commit, please ensure that your changes adhere to the coding style
+by using the `make check-cached` target, for example:
+
+```bash
+$ git status
+On branch improvements
+Changes to be committed:
+  (use "git restore --staged <file>..." to unstage)
+  modified:   qdl.c
+  modified:   qdl.h
+
+$ make check-cached
+Running checkpatch on staged changes...
+ERROR: trailing whitespace
+#28: FILE: qdl.h:32:
++^IQDL_DEVICE_USB,   $
+
+total: 1 errors, 0 warnings, 0 checks, 27 lines checked
+
+NOTE: For some of the reported defects, checkpatch may be able to
+      mechanically convert to the typical style using --fix or --fix-inplace.
+
+NOTE: Whitespace errors detected.
+      You may wish to use scripts/cleanpatch or scripts/cleanfile
+
+Your patch has style problems, please review.
+```
+
+## License
+
+This tool is licensed under the BSD 3-Clause licensed. Check out [LICENSE](LICENSE)
+for more detais.

io.c

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: BSD-3-Clause
+/*
+ * Copyright (c) 2025, Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+#include <stdlib.h>
+
+#include "qdl.h"
+
+struct qdl_device *qdl_init(enum QDL_DEVICE_TYPE type)
+{
+	if (type == QDL_DEVICE_USB)
+		return usb_init();
+
+	if (type == QDL_DEVICE_SIM)
+		return sim_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);
+}

ks.c

@@ -1,21 +1,24 @@
+// SPDX-License-Identifier: BSD-3-Clause
 #include <sys/types.h>
 #include <assert.h>
 #include <ctype.h>
 #include <dirent.h>
-#include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <getopt.h>
-#include <poll.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <termios.h>
 #include <unistd.h>
 
 #include "qdl.h"
+#include "oscompat.h"
+
+#ifdef _WIN32
+const char *__progname = "ks";
+#endif
 
 static struct qdl_device qdl;
 
@@ -28,13 +31,13 @@ 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)
 {
-
 	return write(qdl->fd, buf, len);
 }
 
 static void print_usage(void)
 {
 	extern const char *__progname;
+
 	fprintf(stderr,
 		"%s -p <sahara dev_node> -s <id:file path> ...\n",
 		__progname);
@@ -44,7 +47,7 @@ static void print_usage(void)
 		"\n"
 		"One -p instance is required.  One or more -s instances are required.\n"
 		"\n"
-		"Example: \n"
+		"Example:\n"
 		"ks -p /dev/mhi0_QAIC_SAHARA -s 1:/opt/qti-aic/firmware/fw1.bin -s 2:/opt/qti-aic/firmware/fw2.bin\n");
 }
 
@@ -58,13 +61,21 @@ int main(int argc, char **argv)
 	int ret;
 
 	static struct option options[] = {
+		{"debug", no_argument, 0, 'd'},
+		{"version", no_argument, 0, 'v'},
 		{"port", required_argument, 0, 'p'},
 		{"sahara", required_argument, 0, 's'},
 		{0, 0, 0, 0}
 	};
 
-	while ((opt = getopt_long(argc, argv, "p:s:", options, NULL )) != -1) {
+	while ((opt = getopt_long(argc, argv, "dvp:s:", options, NULL)) != -1) {
 		switch (opt) {
+		case 'd':
+			qdl_debug = true;
+			break;
+		case 'v':
+			print_version();
+			return 0;
 		case 'p':
 			dev_node = optarg;
 			printf("Using port - %s\n", dev_node);
@@ -103,6 +114,9 @@ int main(int argc, char **argv)
 		return 1;
 	}
 
+	if (qdl_debug)
+		print_version();
+
 	qdl.fd = open(dev_node, O_RDWR);
 	if (qdl.fd < 0) {
 		fprintf(stderr, "Unable to open %s\n", dev_node);

oscompat.c

@@ -0,0 +1,76 @@
+// SPDX-License-Identifier: BSD-3-Clause
+#ifdef _WIN32
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include "oscompat.h"
+
+extern const char *__progname;
+
+void timeradd(const struct timeval *a, const struct timeval *b, struct timeval *result)
+{
+	result->tv_sec = a->tv_sec + b->tv_sec;
+	result->tv_usec = a->tv_usec + b->tv_usec;
+	if (result->tv_usec >= 1000000) {
+		result->tv_sec += 1;
+		result->tv_usec -= 1000000;
+	}
+}
+
+void err(int eval, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	fprintf(stderr, "%s: ", __progname);
+	if (fmt) {
+		vfprintf(stderr, fmt, ap);
+		fprintf(stderr, ": ");
+	}
+	fprintf(stderr, "%s\n", strerror(errno));
+	va_end(ap);
+	exit(eval);
+}
+
+void errx(int eval, const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	fprintf(stderr, "%s: ", __progname);
+	if (fmt)
+		vfprintf(stderr, fmt, ap);
+	fprintf(stderr, "\n");
+	va_end(ap);
+	exit(eval);
+}
+
+void warn(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	fprintf(stderr, "%s: ", __progname);
+	if (fmt) {
+		vfprintf(stderr, fmt, ap);
+		fprintf(stderr, ": ");
+	}
+	fprintf(stderr, "%s\n", strerror(errno));
+	va_end(ap);
+}
+
+void warnx(const char *fmt, ...)
+{
+	va_list ap;
+
+	va_start(ap, fmt);
+	fprintf(stderr, "%s: ", __progname);
+	if (fmt)
+		vfprintf(stderr, fmt, ap);
+	fprintf(stderr, "\n");
+	va_end(ap);
+}
+
+#endif // _WIN32

oscompat.h

@@ -0,0 +1,25 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
+#ifndef __OSCOMPAT_H__
+#define __OSCOMPAT_H__
+
+#ifndef _WIN32
+
+#include <err.h>
+
+#define O_BINARY 0
+
+#else // _WIN32
+
+#include <sys/time.h>
+#include <stdbool.h>
+
+void timeradd(const struct timeval *a, const struct timeval *b, struct timeval *result);
+
+void err(int eval, const char *fmt, ...);
+void errx(int eval, const char *fmt, ...);
+void warn(const char *fmt, ...);
+void warnx(const char *fmt, ...);
+
+#endif
+
+#endif

patch.c

@@ -1,42 +1,18 @@
+// SPDX-License-Identifier: BSD-3-Clause
 /*
  * Copyright (c) 2016-2017, Linaro Ltd.
  * 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 <errno.h>
 #include <string.h>
 #include <stdlib.h>
 #include <libxml/parser.h>
 #include <libxml/tree.h>
+#include <unistd.h>
 
 #include "patch.h"
 #include "qdl.h"
-		
+
 static struct patch *patches;
 static struct patch *patches_last;
 
@@ -50,7 +26,7 @@ int patch_load(const char *patch_file)
 
 	doc = xmlReadFile(patch_file, NULL, 0);
 	if (!doc) {
-		fprintf(stderr, "[PATCH] failed to parse %s\n", patch_file);
+		ux_err("failed to parse patch-type file \"%s\"\n", patch_file);
 		return -EINVAL;
 	}
 
@@ -59,8 +35,8 @@ int patch_load(const char *patch_file)
 		if (node->type != XML_ELEMENT_NODE)
 			continue;
 
-		if (xmlStrcmp(node->name, (xmlChar*)"patch")) {
-			fprintf(stderr, "[PATCH] unrecognized tag \"%s\", ignoring\n", node->name);
+		if (xmlStrcmp(node->name, (xmlChar *)"patch")) {
+			ux_err("unrecognized tag \"%s\" in patch-type file, ignoring\n", node->name);
 			continue;
 		}
 
@@ -78,7 +54,7 @@ int patch_load(const char *patch_file)
 		patch->what = attr_as_string(node, "what", &errors);
 
 		if (errors) {
-			fprintf(stderr, "[PATCH] errors while parsing patch\n");
+			ux_err("errors while parsing patch-type file \"%s\"\n", patch_file);
 			free(patch);
 			continue;
 		}
@@ -96,12 +72,19 @@ int patch_load(const char *patch_file)
 
 	return 0;
 }
-	
+
 int patch_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, struct patch *patch))
 {
 	struct patch *patch;
+	unsigned int count = 0;
+	unsigned int idx = 0;
 	int ret;
 
+	for (patch = patches; patch; patch = patch->next) {
+		if (!strcmp(patch->filename, "DISK"))
+			count++;
+	}
+
 	for (patch = patches; patch; patch = patch->next) {
 		if (strcmp(patch->filename, "DISK"))
 			continue;
@@ -109,7 +92,28 @@ int patch_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, s
 		ret = apply(qdl, patch);
 		if (ret)
 			return ret;
+
+		ux_progress("Applying patches", idx++, count);
 	}
 
+	ux_info("%d patches applied\n", idx);
+
 	return 0;
 }
+
+void free_patches(void)
+{
+	struct patch *patch = patches;
+	struct patch *next;
+
+	for (patch = patches; patch; patch = next) {
+		next = patch->next;
+		free((void *)patch->filename);
+		free((void *)patch->start_sector);
+		free((void *)patch->value);
+		free((void *)patch->what);
+		free(patch);
+	}
+
+	patches = NULL;
+}

patch.h

@@ -1,14 +1,15 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 #ifndef __PATCH_H__
 #define __PATCH_H__
 
 struct qdl_device;
 
 struct patch {
-	unsigned sector_size;
-	unsigned byte_offset;
+	unsigned int sector_size;
+	unsigned int byte_offset;
 	const char *filename;
-	unsigned partition;
-	unsigned size_in_bytes;
+	unsigned int partition;
+	unsigned int size_in_bytes;
 	const char *start_sector;
 	const char *value;
 	const char *what;
@@ -18,5 +19,6 @@ struct patch {
 
 int patch_load(const char *patch_file);
 int patch_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, struct patch *patch));
+void free_patches(void);
 
 #endif

program.c

@@ -1,35 +1,13 @@
+// SPDX-License-Identifier: BSD-3-Clause
 /*
  * Copyright (c) 2016-2017, Linaro Ltd.
  * 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.
  */
+#define _FILE_OFFSET_BITS 64
 #include <errno.h>
 #include <fcntl.h>
+#include <inttypes.h>
+#include <limits.h>
 #include <string.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -38,6 +16,8 @@
 
 #include "program.h"
 #include "qdl.h"
+#include "oscompat.h"
+#include "sparse.h"
 
 static struct program *programes;
 static struct program *programes_last;
@@ -47,24 +27,21 @@ static int load_erase_tag(xmlNode *node, bool is_nand)
 	struct program *program;
 	int errors = 0;
 
-	if (!is_nand) {
-		fprintf(stderr, "got \"erase\" tag for non-NAND storage\n");
-		return -EINVAL;
-	}
-
 	program = calloc(1, sizeof(struct program));
 
-
-	program->is_nand = true;
+	program->is_nand = is_nand;
 	program->is_erase = true;
 
-	program->pages_per_block = attr_as_unsigned(node, "PAGES_PER_BLOCK", &errors);
 	program->sector_size = attr_as_unsigned(node, "SECTOR_SIZE_IN_BYTES", &errors);
 	program->num_sectors = attr_as_unsigned(node, "num_partition_sectors", &errors);
+	program->partition = attr_as_unsigned(node, "physical_partition_number", &errors);
 	program->start_sector = attr_as_string(node, "start_sector", &errors);
+	if (is_nand) {
+		program->pages_per_block = attr_as_unsigned(node, "PAGES_PER_BLOCK", &errors);
+	}
 
 	if (errors) {
-		fprintf(stderr, "[PROGRAM] errors while parsing erase tag\n");
+		ux_err("errors while parsing erase tag\n");
 		free(program);
 		return -EINVAL;
 	}
@@ -80,6 +57,125 @@ static int load_erase_tag(xmlNode *node, bool is_nand)
 	return 0;
 }
 
+static struct program *program_load_sparse(struct program *program, int fd)
+{
+	struct program *program_sparse = NULL;
+	struct program *programes_sparse = NULL;
+	struct program *programes_sparse_last = NULL;
+	char tmp[PATH_MAX];
+
+	sparse_header_t sparse_header;
+	unsigned int start_sector;
+	uint32_t sparse_fill_value;
+	uint64_t chunk_size;
+	off_t sparse_offset;
+	int chunk_type;
+
+	if (sparse_header_parse(fd, &sparse_header)) {
+		/*
+		 * If the XML tag "program" contains the attribute 'sparse="true"'
+		 * for a partition node but lacks a sparse header,
+		 * it will be validated against the defined partition size.
+		 * If the sizes match, it is likely that the 'sparse="true"' attribute
+		 * was set by mistake.
+		 */
+		if ((off_t)program->sector_size * program->num_sectors ==
+		    lseek(fd, 0, SEEK_END)) {
+			program_sparse = calloc(1, sizeof(struct program));
+			memcpy(program_sparse, program, sizeof(struct program));
+			program_sparse->sparse = false;
+			program_sparse->next = NULL;
+			return program_sparse;
+		}
+
+		ux_err("[PROGRAM] Unable to parse sparse header at %s...failed\n",
+		       program->filename);
+		return NULL;
+	}
+
+	for (uint32_t i = 0; i < sparse_header.total_chunks; ++i) {
+		chunk_type = sparse_chunk_header_parse(fd, &sparse_header,
+						       &chunk_size,
+						       &sparse_fill_value,
+						       &sparse_offset);
+		if (chunk_type < 0) {
+			ux_err("[PROGRAM] Unable to parse sparse chunk %i at %s...failed\n",
+			       i, program->filename);
+			return NULL;
+		}
+
+		if (chunk_size == 0)
+			continue;
+
+		if (chunk_size % program->sector_size != 0) {
+			ux_err("[SPARSE] File chunk #%u size %" PRIu64 " is not a sector-multiple\n",
+			       i, chunk_size);
+			return NULL;
+		}
+
+		if (chunk_size / program->sector_size >= UINT_MAX) {
+			/*
+			 * Perhaps the programmer can handle larger "num_sectors"?
+			 * Let's cap it for now, it's big enough for now...
+			 */
+			ux_err("[SPARSE] File chunk #%u size %" PRIu64 " is too large\n",
+			       i, chunk_size);
+			return NULL;
+		}
+
+		switch (chunk_type) {
+		case CHUNK_TYPE_RAW:
+			program_sparse = calloc(1, sizeof(struct program));
+			memcpy(program_sparse, program, sizeof(struct program));
+
+			program_sparse->next = NULL;
+			program_sparse->num_sectors = chunk_size / program->sector_size;
+
+			program_sparse->sparse_chunk_type = CHUNK_TYPE_RAW;
+			program_sparse->sparse_offset = sparse_offset;
+
+			if (programes_sparse) {
+				programes_sparse_last->next = program_sparse;
+				programes_sparse_last = program_sparse;
+			} else {
+				programes_sparse = program_sparse;
+				programes_sparse_last = program_sparse;
+			}
+
+			break;
+		case CHUNK_TYPE_FILL:
+
+			program_sparse = calloc(1, sizeof(struct program));
+			memcpy(program_sparse, program, sizeof(struct program));
+
+			program_sparse->next = NULL;
+			program_sparse->num_sectors = chunk_size / program->sector_size;
+
+			program_sparse->sparse_chunk_type = CHUNK_TYPE_FILL;
+			program_sparse->sparse_fill_value = sparse_fill_value;
+
+			if (programes_sparse) {
+				programes_sparse_last->next = program_sparse;
+				programes_sparse_last = program_sparse;
+			} else {
+				programes_sparse = program_sparse;
+				programes_sparse_last = program_sparse;
+			}
+
+			break;
+		default:
+			break;
+		}
+
+		start_sector = (unsigned int)strtoul(program->start_sector, NULL, 0);
+		start_sector += chunk_size / program->sector_size;
+		sprintf(tmp, "%u", start_sector);
+		program->start_sector = strdup(tmp);
+	}
+
+	return programes_sparse;
+}
+
 static int load_program_tag(xmlNode *node, bool is_nand)
 {
 	struct program *program;
@@ -94,11 +190,12 @@ static int load_program_tag(xmlNode *node, bool is_nand)
 	program->label = attr_as_string(node, "label", &errors);
 	program->num_sectors = attr_as_unsigned(node, "num_partition_sectors", &errors);
 	program->partition = attr_as_unsigned(node, "physical_partition_number", &errors);
+	program->sparse = attr_as_bool(node, "sparse", &errors);
 	program->start_sector = attr_as_string(node, "start_sector", &errors);
 
 	if (is_nand) {
 		program->pages_per_block = attr_as_unsigned(node, "PAGES_PER_BLOCK", &errors);
-		if (NULL != xmlGetProp(node, (xmlChar *)"last_sector")) {
+		if (xmlGetProp(node, (xmlChar *)"last_sector")) {
 			program->last_sector = attr_as_unsigned(node, "last_sector", &errors);
 		}
 	} else {
@@ -106,7 +203,7 @@ static int load_program_tag(xmlNode *node, bool is_nand)
 	}
 
 	if (errors) {
-		fprintf(stderr, "[PROGRAM] errors while parsing program\n");
+		ux_err("errors while parsing program tag\n");
 		free(program);
 		return -EINVAL;
 	}
@@ -131,7 +228,7 @@ int program_load(const char *program_file, bool is_nand)
 
 	doc = xmlReadFile(program_file, NULL, 0);
 	if (!doc) {
-		fprintf(stderr, "[PROGRAM] failed to parse %s\n", program_file);
+		ux_err("failed to parse program-type file \"%s\"\n", program_file);
 		return -EINVAL;
 	}
 
@@ -145,7 +242,7 @@ int program_load(const char *program_file, bool is_nand)
 		else if (!xmlStrcmp(node->name, (xmlChar *)"program"))
 			errors = load_program_tag(node, is_nand);
 		else {
-			fprintf(stderr, "[PROGRAM] unrecognized tag \"%s\"\n", node->name);
+			ux_err("unrecognized tag \"%s\" in program-type file \"%s\"\n", node->name, program_file);
 			errors = -EINVAL;
 		}
 
@@ -163,6 +260,7 @@ int program_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl,
 		    const char *incdir, bool allow_missing)
 {
 	struct program *program;
+	struct program *program_sparse;
 	const char *filename;
 	char tmp[PATH_MAX];
 	int ret;
@@ -179,19 +277,33 @@ int program_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl,
 				filename = tmp;
 		}
 
-		fd = open(filename, O_RDONLY);
+		fd = open(filename, O_RDONLY | O_BINARY);
 
 		if (fd < 0) {
-			printf("Unable to open %s", program->filename);
+			ux_info("unable to open %s", program->filename);
 			if (!allow_missing) {
-				printf("...failing\n");
+				ux_info("...failing\n");
 				return -1;
 			}
-			printf("...ignoring\n");
+			ux_info("...ignoring\n");
 			continue;
 		}
 
-		ret = apply(qdl, program, fd);
+		if (!program->sparse) {
+			ret = apply(qdl, program, fd);
+		} else {
+			program_sparse = program_load_sparse(program, fd);
+			if (!program_sparse) {
+				ux_err("[PROGRAM] load sparse failed\n");
+				return -EINVAL;
+			}
+
+			for (; program_sparse; program_sparse = program_sparse->next) {
+				ret = apply(qdl, program_sparse, fd);
+				if (ret)
+					break;
+			}
+		}
 
 		close(fd);
 		if (ret)
@@ -206,7 +318,6 @@ int erase_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, s
 	struct program *program;
 	int ret;
 
-
 	for (program = programes; program; program = program->next) {
 		if (!program->is_erase)
 			continue;
@@ -219,6 +330,23 @@ int erase_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, s
 	return 0;
 }
 
+static struct program *program_find_partition(const char *partition)
+{
+	struct program *program;
+	const char *label;
+
+	for (program = programes; program; program = program->next) {
+		label = program->label;
+		if (!label)
+			continue;
+
+		if (!strcmp(label, partition))
+			return program;
+	}
+
+	return NULL;
+}
+
 /**
  * program_find_bootable_partition() - find one bootable partition
  *
@@ -226,27 +354,71 @@ int erase_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, s
  *
  * Scan program tags for a partition with the label "sbl1", "xbl" or "xbl_a"
  * and return the partition number for this. If more than one line matches
- * we're assuming our logic is flawed and return an error.
+ * we're informing the caller so that they can warn the user about the
+ * uncertainty of this logic.
  */
-int program_find_bootable_partition(void)
+int program_find_bootable_partition(bool *multiple_found)
 {
 	struct program *program;
-	const char *label;
 	int part = -ENOENT;
 
-	for (program = programes; program; program = program->next) {
-		label = program->label;
-		if (!label)
-			continue;
+	*multiple_found = false;
 
-		if (!strcmp(label, "xbl") || !strcmp(label, "xbl_a") ||
-		    !strcmp(label, "sbl1")) {
-			if (part != -ENOENT)
-				return -EINVAL;
+	program = program_find_partition("xbl");
+	if (program)
+		part = program->partition;
 
+	program = program_find_partition("xbl_a");
+	if (program) {
+		if (part != -ENOENT)
+			*multiple_found = true;
+		else
+			part = program->partition;
+	}
+
+	program = program_find_partition("sbl1");
+	if (program) {
+		if (part != -ENOENT)
+			*multiple_found = true;
+		else
 			part = program->partition;
-		}
 	}
 
 	return part;
 }
+
+/**
+ * program_is_sec_partition_flashed() - find if secdata partition is flashed
+ *
+ * Returns true if filename for secdata is set in program*.xml,
+ * or false otherwise.
+ */
+int program_is_sec_partition_flashed(void)
+{
+	struct program *program;
+
+	program = program_find_partition("secdata");
+	if (!program)
+		return false;
+
+	if (program->filename)
+		return true;
+
+	return false;
+}
+
+void free_programs(void)
+{
+	struct program *program = programes;
+	struct program *next;
+
+	for (program = programes; program; program = next) {
+		next = program->next;
+		free((void *)program->filename);
+		free((void *)program->label);
+		free((void *)program->start_sector);
+		free(program);
+	}
+
+	programes = NULL;
+}

program.h

@@ -1,23 +1,31 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 #ifndef __PROGRAM_H__
 #define __PROGRAM_H__
 
+#include <sys/types.h>
 #include <stdbool.h>
+#include <stdint.h>
 #include "qdl.h"
 
 struct program {
-	unsigned pages_per_block;
-	unsigned sector_size;
-	unsigned file_offset;
+	unsigned int pages_per_block;
+	unsigned int sector_size;
+	unsigned int file_offset;
 	const char *filename;
 	const char *label;
-	unsigned num_sectors;
-	unsigned partition;
+	unsigned int num_sectors;
+	unsigned int partition;
+	bool sparse;
 	const char *start_sector;
-	unsigned last_sector;
+	unsigned int last_sector;
 
 	bool is_nand;
 	bool is_erase;
 
+	unsigned int sparse_chunk_type;
+	uint32_t sparse_fill_value;
+	off_t sparse_offset;
+
 	struct program *next;
 };
 
@@ -25,6 +33,9 @@ int program_load(const char *program_file, bool is_nand);
 int program_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, struct program *program, int fd),
 		    const char *incdir, bool allow_missing);
 int erase_execute(struct qdl_device *qdl, int (*apply)(struct qdl_device *qdl, struct program *program));
-int program_find_bootable_partition(void);
+int program_find_bootable_partition(bool *multiple_found);
+int program_is_sec_partition_flashed(void);
+
+void free_programs(void);
 
 #endif

qdl.c

@@ -1,35 +1,9 @@
+// SPDX-License-Identifier: BSD-3-Clause
 /*
  * Copyright (c) 2016-2017, Linaro Ltd.
  * Copyright (c) 2018, The Linux Foundation. All rights reserved.
  * 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 <err.h>
 #include <errno.h>
 #include <getopt.h>
 #include <stdbool.h>
@@ -41,9 +15,16 @@
 
 #include "qdl.h"
 #include "patch.h"
+#include "program.h"
 #include "ufs.h"
+#include "oscompat.h"
+#include "vip.h"
 
-#define MAX_USBFS_BULK_SIZE	(16*1024)
+#ifdef _WIN32
+const char *__progname = "qdl";
+#endif
+
+#define MAX_USBFS_BULK_SIZE	(16 * 1024)
 
 enum {
 	QDL_FILE_UNKNOWN,
@@ -55,7 +36,6 @@ enum {
 };
 
 bool qdl_debug;
-static struct qdl_device qdl;
 
 static int detect_type(const char *xml_file)
 {
@@ -66,31 +46,31 @@ static int detect_type(const char *xml_file)
 
 	doc = xmlReadFile(xml_file, NULL, 0);
 	if (!doc) {
-		fprintf(stderr, "[PATCH] failed to parse %s\n", xml_file);
+		ux_err("failed to parse XML file \"%s\"\n", xml_file);
 		return -EINVAL;
 	}
 
 	root = xmlDocGetRootElement(doc);
-	if (!xmlStrcmp(root->name, (xmlChar*)"patches")) {
+	if (!xmlStrcmp(root->name, (xmlChar *)"patches")) {
 		type = QDL_FILE_PATCH;
-	} else if (!xmlStrcmp(root->name, (xmlChar*)"data")) {
+	} else if (!xmlStrcmp(root->name, (xmlChar *)"data")) {
 		for (node = root->children; node ; node = node->next) {
 			if (node->type != XML_ELEMENT_NODE)
 				continue;
-			if (!xmlStrcmp(node->name, (xmlChar*)"program")) {
+			if (!xmlStrcmp(node->name, (xmlChar *)"program")) {
 				type = QDL_FILE_PROGRAM;
 				break;
 			}
-			if (!xmlStrcmp(node->name, (xmlChar*)"read")) {
+			if (!xmlStrcmp(node->name, (xmlChar *)"read")) {
 				type = QDL_FILE_READ;
 				break;
 			}
-			if (!xmlStrcmp(node->name, (xmlChar*)"ufs")) {
+			if (!xmlStrcmp(node->name, (xmlChar *)"ufs")) {
 				type = QDL_FILE_UFS;
 				break;
 			}
 		}
-	} else if (!xmlStrcmp(root->name, (xmlChar*)"contents")) {
+	} else if (!xmlStrcmp(root->name, (xmlChar *)"contents")) {
 		type = QDL_FILE_CONTENTS;
 	}
 
@@ -99,46 +79,77 @@ static int detect_type(const char *xml_file)
 	return type;
 }
 
-static void print_usage(void)
+static void print_usage(FILE *out)
 {
 	extern const char *__progname;
-	fprintf(stderr,
-		"%s [--debug] [--allow-missing] [--storage <emmc|nand|ufs>] [--finalize-provisioning] [--include <PATH>] [--serial <NUM>] [--out-chunk-size <SIZE>] <prog.mbn> [<program> <patch> ...]\n",
-		__progname);
-}
 
-enum {
-	OPT_OUT_CHUNK_SIZE = 1000,
-};
+	fprintf(out, "Usage: %s [options] <prog.mbn> [<program> <patch> ...]\n", __progname);
+	fprintf(out, " -d, --debug\t\t\tPrint detailed debug info\n");
+	fprintf(out, " -v, --version\t\t\tPrint the current version and exit\n");
+	fprintf(out, " -n, --dry-run\t\t\tDry run execution, no device reading or flashing\n");
+	fprintf(out, " -f, --allow-missing\t\tAllow skipping of missing files during flashing\n");
+	fprintf(out, " -s, --storage=T\t\tSet target storage type T: <emmc|nand|ufs>\n");
+	fprintf(out, " -l, --finalize-provisioning\tProvision the target storage\n");
+	fprintf(out, " -i, --include=T\t\tSet an optional folder T to search for files\n");
+	fprintf(out, " -S, --serial=T\t\t\tSelect target by serial number T (e.g. <0AA94EFD>)\n");
+	fprintf(out, " -u, --out-chunk-size=T\t\tOverride chunk size for transaction with T\n");
+	fprintf(out, " -t, --create-digests=T\t\tGenerate table of digests in the T folder\n");
+	fprintf(out, " -D, --vip-table-path=T\t\tUse digest tables in the T folder for VIP\n");
+	fprintf(out, " -h, --help\t\t\tPrint this usage info\n");
+	fprintf(out, "\n");
+	fprintf(out, "Example: %s prog_firehose_ddr.elf rawprogram*.xml patch*.xml\n", __progname);
+}
 
 int main(int argc, char **argv)
 {
-	char *prog_mbn, *storage="ufs";
+	char *prog_mbn, *storage = "ufs";
 	char *incdir = NULL;
 	char *serial = NULL;
+	const char *vip_generate_dir = NULL;
+	const char *vip_table_path = NULL;
 	int type;
 	int ret;
 	int opt;
 	bool qdl_finalize_provisioning = false;
+	bool allow_fusing = 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'},
+		{"version", no_argument, 0, 'v'},
 		{"include", required_argument, 0, 'i'},
 		{"finalize-provisioning", no_argument, 0, 'l'},
-		{"out-chunk-size", required_argument, 0, OPT_OUT_CHUNK_SIZE },
+		{"out-chunk-size", required_argument, 0, 'u' },
 		{"serial", required_argument, 0, 'S'},
+		{"vip-table-path", required_argument, 0, 'D'},
 		{"storage", required_argument, 0, 's'},
 		{"allow-missing", no_argument, 0, 'f'},
+		{"allow-fusing", no_argument, 0, 'c'},
+		{"dry-run", no_argument, 0, 'n'},
+		{"create-digests", required_argument, 0, 't'},
+		{"help", no_argument, 0, 'h'},
 		{0, 0, 0, 0}
 	};
 
-	while ((opt = getopt_long(argc, argv, "dfi:S:", options, NULL )) != -1) {
+	while ((opt = getopt_long(argc, argv, "dvi:lu:S:D:s:fcnt:h", options, NULL)) != -1) {
 		switch (opt) {
 		case 'd':
 			qdl_debug = true;
 			break;
+		case 'n':
+			qdl_dev_type = QDL_DEVICE_SIM;
+			break;
+		case 't':
+			vip_generate_dir = optarg;
+			/* we also enforce dry-run mode */
+			qdl_dev_type = QDL_DEVICE_SIM;
+			break;
+		case 'v':
+			print_version();
+			return 0;
 		case 'f':
 			allow_missing = true;
 			break;
@@ -148,9 +159,11 @@ int main(int argc, char **argv)
 		case 'l':
 			qdl_finalize_provisioning = true;
 			break;
-		case OPT_OUT_CHUNK_SIZE:
+		case 'c':
+			allow_fusing = true;
+			break;
+		case 'u':
 			out_chunk_size = strtol(optarg, NULL, 10);
-			qdl_set_out_chunk_size(&qdl, out_chunk_size);
 			break;
 		case 's':
 			storage = optarg;
@@ -158,18 +171,52 @@ int main(int argc, char **argv)
 		case 'S':
 			serial = optarg;
 			break;
+		case 'D':
+			vip_table_path = optarg;
+			break;
+		case 'h':
+			print_usage(stdout);
+			return 0;
 		default:
-			print_usage();
+			print_usage(stderr);
 			return 1;
 		}
 	}
 
 	/* at least 2 non optional args required */
 	if ((optind + 2) > argc) {
-		print_usage();
+		print_usage(stderr);
 		return 1;
 	}
 
+	qdl = qdl_init(qdl_dev_type);
+	if (!qdl) {
+		ret = -1;
+		goto out_cleanup;
+	}
+
+	if (vip_table_path) {
+		if (vip_generate_dir)
+			errx(1, "VIP mode and VIP table generation can't be enabled together\n");
+		ret = vip_transfer_init(qdl, vip_table_path);
+		if (ret)
+			errx(1, "VIP initialization failed\n");
+	}
+
+	if (out_chunk_size)
+		qdl_set_out_chunk_size(qdl, out_chunk_size);
+
+	if (vip_generate_dir) {
+		ret = vip_gen_init(qdl, vip_generate_dir);
+		if (ret)
+			goto out_cleanup;
+	}
+
+	ux_init();
+
+	if (qdl_debug)
+		print_version();
+
 	prog_mbn = argv[optind++];
 
 	do {
@@ -187,6 +234,10 @@ int main(int argc, char **argv)
 			ret = program_load(argv[optind], !strcmp(storage, "nand"));
 			if (ret < 0)
 				errx(1, "program_load %s failed", argv[optind]);
+
+			if (!allow_fusing && program_is_sec_partition_flashed())
+				errx(1, "secdata partition to be programmed, which can lead to irreversible"
+					" changes. Allow explicitly with --allow-fusing parameter");
 			break;
 		case QDL_FILE_READ:
 			ret = read_op_load(argv[optind]);
@@ -194,7 +245,7 @@ int main(int argc, char **argv)
 				errx(1, "read_op_load %s failed", argv[optind]);
 			break;
 		case QDL_FILE_UFS:
-			ret = ufs_load(argv[optind],qdl_finalize_provisioning);
+			ret = ufs_load(argv[optind], qdl_finalize_provisioning);
 			if (ret < 0)
 				errx(1, "ufs_load %s failed", argv[optind]);
 			break;
@@ -204,18 +255,31 @@ int main(int argc, char **argv)
 		}
 	} while (++optind < argc);
 
-	ret = qdl_open(&qdl, serial);
+	ret = qdl_open(qdl, serial);
 	if (ret)
-		return 1;
+		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)
-		return 1;
+		goto out_cleanup;
 
-	ret = firehose_run(&qdl, incdir, storage, allow_missing);
+	ret = firehose_run(qdl, incdir, storage, allow_missing);
 	if (ret < 0)
-		return 1;
+		goto out_cleanup;
 
-	return 0;
+out_cleanup:
+	if (vip_generate_dir)
+		vip_gen_finalize(qdl);
+
+	qdl_close(qdl);
+	free_programs();
+	free_patches();
+
+	if (qdl->vip_data.state != VIP_DISABLED)
+		vip_transfer_deinit(qdl);
+
+	qdl_deinit(qdl);
+
+	return !!ret;
 }

qdl.h

@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 #ifndef __QDL_H__
 #define __QDL_H__
 
@@ -7,36 +8,79 @@
 #include "program.h"
 #include "read.h"
 #include <libxml/tree.h>
+#include "vip.h"
+
+#define container_of(ptr, typecast, member) ({                  \
+	void *_ptr = (void *)(ptr);		                \
+	((typeof(typecast) *)(_ptr - offsetof(typecast, member))); })
+
+#define MIN(x, y) ({		\
+	__typeof__(x) _x = (x);	\
+	__typeof__(y) _y = (y);	\
+	_x < _y ? _x : _y;	\
+})
+
+#define ROUND_UP(x, a) ({		\
+	__typeof__(x) _x = (x);		\
+	__typeof__(a) _a = (a);		\
+	(_x + _a - 1) & ~(_a - 1);	\
+})
 
 #define MAPPING_SZ 64
 
-struct libusb_device_handle;
-
-struct qdl_device {
-        struct libusb_device_handle *usb_handle;
-        int fd;
-
-        int in_ep;
-        int out_ep;
-
-        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
+enum QDL_DEVICE_TYPE {
+	QDL_DEVICE_USB,
+	QDL_DEVICE_SIM,
 };
 
+struct qdl_device {
+	enum QDL_DEVICE_TYPE dev_type;
+	int fd;
+	size_t max_payload_size;
+
+	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);
+	void (*set_vip_transfer)(struct qdl_device *qdl, const char *signed_table,
+				 const char *chained_table);
+
+	char *mappings[MAPPING_SZ]; // array index is the id from the device
+
+	struct vip_transfer_data vip_data;
+};
+
+struct libusb_device_handle;
+
+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);
+int qdl_vip_transfer_enable(struct qdl_device *qdl, const char *vip_table_path);
+
+struct qdl_device *usb_init(void);
+struct qdl_device *sim_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);
 void print_hex_dump(const char *prefix, const void *buf, size_t len);
-unsigned attr_as_unsigned(xmlNode *node, const char *attr, int *errors);
+unsigned int attr_as_unsigned(xmlNode *node, const char *attr, int *errors);
 const char *attr_as_string(xmlNode *node, const char *attr, int *errors);
+bool attr_as_bool(xmlNode *node, const char *attr, int *errors);
+
+void ux_init(void);
+void ux_err(const char *fmt, ...);
+void ux_info(const char *fmt, ...);
+void ux_log(const char *fmt, ...);
+void ux_debug(const char *fmt, ...);
+void ux_progress(const char *fmt, unsigned int value, unsigned int size, ...);
+
+void print_version(void);
 
 extern bool qdl_debug;
 

ramdump.c

@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: BSD-3-Clause
 #include <getopt.h>
 #include <stdbool.h>
 #include <stdio.h>
@@ -5,11 +6,16 @@
 
 #include "qdl.h"
 
+#ifdef _WIN32
+const char *__progname = "ramdump";
+#endif
+
 bool qdl_debug;
 
 static void print_usage(void)
 {
 	extern const char *__progname;
+
 	fprintf(stderr,
 		"%s [--debug] [-o <ramdump-path>] [segment-filter,...]\n",
 		__progname);
@@ -18,25 +24,35 @@ static void print_usage(void)
 
 int main(int argc, char **argv)
 {
-	struct qdl_device qdl;
+	struct qdl_device *qdl;
+
+	qdl = qdl_init(QDL_DEVICE_USB);
+	if (!qdl)
+		return 1;
+
 	char *ramdump_path = ".";
 	char *filter = NULL;
 	char *serial = NULL;
-	int ret;
+	int ret = 0;
 	int opt;
 
 	static struct option options[] = {
 		{"debug", no_argument, 0, 'd'},
+		{"version", no_argument, 0, 'v'},
 		{"output", required_argument, 0, 'o'},
 		{"serial", required_argument, 0, 'S'},
 		{0, 0, 0, 0}
 	};
 
-	while ((opt = getopt_long(argc, argv, "do:S:", options, NULL )) != -1) {
+	while ((opt = getopt_long(argc, argv, "dvo:S:", options, NULL)) != -1) {
 		switch (opt) {
 		case 'd':
 			qdl_debug = true;
 			break;
+		case 'v':
+			print_version();
+			ret = 0;
+			goto out_cleanup;
 		case 'o':
 			ramdump_path = optarg;
 			break;
@@ -54,13 +70,24 @@ int main(int argc, char **argv)
 	if (optind != argc)
 		print_usage();
 
-	ret = qdl_open(&qdl, serial);
-	if (ret)
-		return 1;
+	if (qdl_debug)
+		print_version();
 
-	ret = sahara_run(&qdl, NULL, true, ramdump_path, filter);
-	if (ret < 0)
-		return 1;
+	ret = qdl_open(qdl, serial);
+	if (ret) {
+		ret = 1;
+		goto out_cleanup;
+	}
 
-	return 0;
+	ret = sahara_run(qdl, NULL, true, ramdump_path, filter);
+	if (ret < 0) {
+		ret = 1;
+		goto out_cleanup;
+	}
+
+out_cleanup:
+	qdl_close(qdl);
+	qdl_deinit(qdl);
+
+	return ret;
 }