 @@ -1,185 +1,184 @@
-.\"	$NetBSD: mkubootimage.1,v 1.13 2019/12/04 11:21:34 jmcneill Exp $
+.\"	$NetBSD: mkubootimage.1,v 1.14 2019/12/07 12:34:17 wiz Exp $
 .\"
 .\" Copyright (c) 2012 The NetBSD Foundation, Inc.
 .\" All rights reserved.
 .\"
 .\" This code is derived from software contributed to The NetBSD Foundation
 .\" by Jeremy C. Reed
 .\"
 .\" 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.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
 .\"
 .Dd December 4, 2019
 .Dt MKUBOOTIMAGE 1
 .Os
 .Sh NAME
 .Nm mkubootimage
 .Nd create U-Boot loader image
 .Sh SYNOPSIS
 .Nm
-.Op Fl h
+.Op Fl hu
 .Fl A No ( arm Ns | Ns arm64 Ns | Ns i386 Ns | Ns mips Ns | Ns mips64 Ns | Ns or1k Ns | Ns powerpc Ns | Ns sh )
 .Fl a Ar address
 .Op Fl C Po bz2 Ns | Ns gz Ns | Ns lzma Ns | Ns lzo Ns | Ns none Pc
 .Op Fl E Ar address
 .Op Fl e Ar address
 .Op Fl f Po arm64 Ns | Ns uimg Pc
 .Op Fl m Ar magic
 .Fl n Ar image
 .Op Fl O Po freebsd Ns | Ns linux Ns | Ns netbsd Ns | Ns openbsd Pc
-.Fl T No ( fs Ns | Ns kernel Ns | Ns kernel_noload Ns | Ns ramdisk Ns | Ns standalone )
+.Fl T No ( fs Ns | Ns kernel Ns | Ns kernel_noload Ns | Ns ramdisk Ns | Ns script Ns | Ns standalone )
 .Op Fl u
 .Ar source destination
 .\"
 .Sh DESCRIPTION
 The
 .Nm
 utility is used to create an image for Das U-Boot, the
 .Qq Universal Boot Loader .
 .Pp
 The arguments are as follows:
 .Bl -tag -width indent
 .It Fl A No ( arm Ns | Ns arm64 Ns | Ns i386 Ns | Ns mips Ns | Ns mips64 Ns | Ns or1k Ns | Ns powerpc Ns | Ns sh )
 Defines the architecture.
 This is required for
 .Qq uimg
 format images.
 .It Fl a Ar address
 Sets the image load address.
 This is an integer between 0 and
 .Dv UINT32_MAX .
 This is required for all
 .Qq uimg
 image types except for script, ramdisk, and kernel_noload.
 .It Fl C No ( bz2 Ns | Ns gz Ns | Ns lzma Ns | Ns lzo Ns | Ns none )
 Defines the compression.
 The default is
 .Qq none .
 .It Fl E Ar address
 Define the entry point.
 This is an integer between 0 and
 .Dv UINT32_MAX .
 This option is the same as
 .Fl e
 but it inverts the bytes to convert the 32 bit integer
 from little to big endian (or vice versa).
 If
 .Fl E
 or
 .Fl e
 are not set, the entry point defaults to the
 image load address
 .Pq Fl a .
 .It Fl e Ar address
 Define the entry point.
 This is an integer between 0 and
 .Dv UINT32_MAX .
 If
 .Fl E
 or
 .Fl e
 are not set, the entry point defaults to the
 image load address
 .Pq Fl a .
 .It Fl f No ( arm64 Ns | Ns uimg )
 Defines the output image format type.
 The default is
 .Qq uimg .
 .It Fl h
 Display the usage and exit.
 .It Fl m Ar magic
 Set the magic used for
 .Qq uimg
 format images.
 This is an integer between 0 and
 .Dv UINT32_MAX .
 The default is
 .Qq 0x27051956 .
 .It Fl n Ar image
 Defines the image name.
 This is required.
 .It Fl O No ( freebsd Ns | Ns linux Ns | Ns netbsd Ns | Ns openbsd )
 Defines the operating system type.
 The default OS name is
 .Qq netbsd .
-.It Fl T No ( fs Ns | Ns kernel Ns | Ns kernel_noload Ns | Ns ramdisk Ns | Ns standalone Ns | Ns script )
+.It Fl T No ( fs Ns | Ns kernel Ns | Ns kernel_noload Ns | Ns ramdisk Ns | Ns script Ns | Ns standalone )
 Defines the image type.
 This is required for
 .Qq uimg
 format images.
 .It Fl u
 Update the header in an existing file instead of creating a new one.
 .El
 .Pp
 The required
 .Ar source
 argument is the filename of the kernel that is read.
 The required
 .Ar destination
 argument is the filename of the image file that is created.
 .\"
 .Sh EXIT STATUS
 .Nm
 returns 1 on failure to read the kernel,
 generate a header, or create the image.
 .\"
 .Sh EXAMPLES
 Before the image is written, the header is displayed to standard out;
 for example:
 .Bd -literal -offset 0
  magic:       0x27051956
  time:        Tue Jun  7 15:58:41 2011
  size:        2482203
  load addr:   0x00020000
  entry point: 0x00020000
  data crc:    0x700fdf53
  os:          2 (netbsd)
  arch:        7 (powerpc)
  type:        2 (kernel)
  comp:        1 (gz)
  name:        NetBSD/evbppc 5.99.52 (INSTALL_PMPPC)
  header crc:  0x94ea96cf
 .Ed
 .\" TODO: check the name line above
 .\" .Sh FILES
 .Sh SEE ALSO
 .Qq Das U-Boot - the Universal Boot Loader
 .Pa http://www.denx.de/wiki/U-Boot/
 .\"
 .\" .Sh STANDARDS
 .\"
 .Sh HISTORY
 The
 .Nm
 command first appeared in
 .Nx 6.0 .
 .\"
 .Sh AUTHORS
 .An -nosplit
 The
 .Nm
 utility was originally written by
 .An Jared McNeill .
 This manual page was written by
 .An Jeremy C. Reed .
 .\" .Sh CAVEATS
 .\" .Sh BUGS
 .\" .Sh SECURITY CONSIDERATIONS

 @@ -1,610 +1,608 @@
-/* $NetBSD: mkubootimage.c,v 1.26 2019/12/04 14:09:47 jmcneill Exp $ */
+/* $NetBSD: mkubootimage.c,v 1.27 2019/12/07 12:34:17 wiz Exp $ */
 /*-
  * Copyright (c) 2010 Jared D. McNeill <jmcneill@invisible.ca>
  * 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. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
-__RCSID("$NetBSD: mkubootimage.c,v 1.26 2019/12/04 14:09:47 jmcneill Exp $");
+__RCSID("$NetBSD: mkubootimage.c,v 1.27 2019/12/07 12:34:17 wiz Exp $");
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <sys/endian.h>
 #include <sys/param.h>
 #include <sys/uio.h>
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <limits.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include "uboot.h"
 #include "arm64.h"
 #ifndef __arraycount
 #define __arraycount(__x)	(sizeof(__x) / sizeof(__x[0]))
 #endif
 enum image_format {
 	FMT_UNKNOWN,
 	FMT_UIMG,	/* Legacy U-Boot image */
 	FMT_ARM64,	/* Linux ARM64 image (booti) */
 };
 extern uint32_t crc32(const void *, size_t);
 extern uint32_t crc32v(const struct iovec *, int);
 static enum uboot_image_os image_os = IH_OS_NETBSD;
 static enum uboot_image_arch image_arch = IH_ARCH_UNKNOWN;
 static enum uboot_image_type image_type = IH_TYPE_UNKNOWN;
 static enum uboot_image_comp image_comp = IH_COMP_NONE;
 static uint32_t image_loadaddr = 0;
 static uint32_t image_entrypoint = 0;
 static char *image_name;
 static uint32_t image_magic = IH_MAGIC;
 static enum image_format image_format = FMT_UIMG;
 static int update_image = 0;
 static const struct uboot_image_format {
 	enum image_format format;
 	const char *name;
 } uboot_image_format[] = {
 	{ FMT_UIMG,		"uimg" },
 	{ FMT_ARM64,		"arm64" },
 };
 static enum image_format
 get_image_format(const char *name)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_image_format); i++) {
 		if (strcmp(uboot_image_format[i].name, name) == 0)
 			return uboot_image_format[i].format;
+	}
 	return FMT_UNKNOWN;
+}
 static const char *
 get_image_format_name(enum image_format format)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_image_format); i++) {
 		if (uboot_image_format[i].format == format)
 			return uboot_image_format[i].name;
+	}
 	return "Unknown";
+}
 static const struct uboot_os {
 	enum uboot_image_os os;
 	const char *name;
 } uboot_os[] = {
 	{ IH_OS_OPENBSD,	"openbsd" },
 	{ IH_OS_NETBSD,		"netbsd" },
 	{ IH_OS_FREEBSD,	"freebsd" },
 	{ IH_OS_LINUX,		"linux" },
 };
 static enum uboot_image_os
 get_os(const char *name)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_os); i++) {
 		if (strcmp(uboot_os[i].name, name) == 0)
 			return uboot_os[i].os;
+	}
 	return IH_OS_UNKNOWN;
+}
 static const char *
 get_os_name(enum uboot_image_os os)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_os); i++) {
 		if (uboot_os[i].os == os)
 			return uboot_os[i].name;
+	}
 	return "Unknown";
+}
 static const struct uboot_arch {
 	enum uboot_image_arch arch;
 	const char *name;
 } uboot_arch[] = {
 	{ IH_ARCH_ARM,		"arm" },
 	{ IH_ARCH_ARM64,	"arm64" },
 	{ IH_ARCH_I386,		"i386" },
 	{ IH_ARCH_MIPS,		"mips" },
 	{ IH_ARCH_MIPS64,	"mips64" },
 	{ IH_ARCH_PPC,		"powerpc" },
 	{ IH_ARCH_OPENRISC,	"or1k" },
 	{ IH_ARCH_SH,		"sh" },
 };
 static enum uboot_image_arch
 get_arch(const char *name)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_arch); i++) {
 		if (strcmp(uboot_arch[i].name, name) == 0)
 			return uboot_arch[i].arch;
+	}
 	return IH_ARCH_UNKNOWN;
+}
 static const char *
 get_arch_name(enum uboot_image_arch arch)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_arch); i++) {
 		if (uboot_arch[i].arch == arch)
 			return uboot_arch[i].name;
+	}
 	return "Unknown";
+}
 static const struct uboot_type {
 	enum uboot_image_type type;
 	const char *name;
 } uboot_type[] = {
 	{ IH_TYPE_STANDALONE,		"standalone" },
 	{ IH_TYPE_KERNEL,		"kernel" },
 	{ IH_TYPE_KERNEL_NOLOAD,	"kernel_noload" },
 	{ IH_TYPE_RAMDISK,		"ramdisk" },
 	{ IH_TYPE_FILESYSTEM,		"fs" },
 	{ IH_TYPE_SCRIPT,		"script" },
 };
 static enum uboot_image_type
 get_type(const char *name)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_type); i++) {
 		if (strcmp(uboot_type[i].name, name) == 0)
 			return uboot_type[i].type;
+	}
 	return IH_TYPE_UNKNOWN;
+}
 static const char *
 get_type_name(enum uboot_image_type type)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_type); i++) {
 		if (uboot_type[i].type == type)
 			return uboot_type[i].name;
+	}
 	return "Unknown";
+}
 static const struct uboot_comp {
 	enum uboot_image_comp comp;
 	const char *name;
 } uboot_comp[] = {
 	{ IH_COMP_NONE,		"none" },
 	{ IH_COMP_GZIP,		"gz" },
 	{ IH_COMP_BZIP2,	"bz2" },
 	{ IH_COMP_LZMA,		"lzma" },
 	{ IH_COMP_LZO,		"lzo" },
 };
 static enum uboot_image_comp
 get_comp(const char *name)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_comp); i++) {
 		if (strcmp(uboot_comp[i].name, name) == 0)
 			return uboot_comp[i].comp;
+	}
 	return IH_COMP_NONE;
+}
 static const char *
 get_comp_name(enum uboot_image_comp comp)
+{
 	unsigned int i;
 	for (i = 0; i < __arraycount(uboot_comp); i++) {
 		if (uboot_comp[i].comp == comp)
 			return uboot_comp[i].name;
+	}
 	return "Unknown";
+}
 __dead static void
 usage(void)
+{
-	fprintf(stderr, "usage: mkubootimage -A "
+	fprintf(stderr, "usage: mkubootimage [-hu] -A "
-	    "<arm|arm64|i386|mips|mips64|or1k|powerpc|sh>");
+	    "<arm|arm64|i386|mips|mips64|or1k|powerpc|sh> -a address\n");
-	fprintf(stderr, " -C <none|bz2|gz|lzma|lzo>");
+	fprintf(stderr, "\t-C <bz2|gz|lzma|lzo|none> [-E address] [-e address]\n");
-	fprintf(stderr, " -O <openbsd|netbsd|freebsd|linux>");
+	fprintf(stderr, "\t[-f <arm64|uimg>] [-m magic] -n image -O <freebsd|linux|netbsd|openbsd>\n");
-	fprintf(stderr, " -T <standalone|kernel|kernel_noload|ramdisk|fs|script>");
+	fprintf(stderr, "\t-T <fs|kernel|kernel_noload|ramdisk|script|standalone>\n");
-	fprintf(stderr, " -a <addr> [-e <ep>] [-m <magic>] -n <name>");
+	fprintf(stderr, "\tsource destination\n");
 	fprintf(stderr, " [-f <uimg|arm64>] [-u]");
 	fprintf(stderr, " <srcfile> <dstfile>\n");
 	exit(EXIT_FAILURE);
+}
 static void
 dump_header_uimg(struct uboot_image_header *hdr)
+{
 	time_t tm = ntohl(hdr->ih_time);
 	printf(" magic:       0x%08x\n", ntohl(hdr->ih_magic));
 	printf(" time:        %s", ctime(&tm));
 	printf(" size:        %u\n", ntohl(hdr->ih_size));
 	printf(" load addr:   0x%08x\n", ntohl(hdr->ih_load));
 	printf(" entry point: 0x%08x\n", ntohl(hdr->ih_ep));
 	printf(" data crc:    0x%08x\n", ntohl(hdr->ih_dcrc));
 	printf(" os:          %d (%s)\n", hdr->ih_os,
 	    get_os_name(hdr->ih_os));
 	printf(" arch:        %d (%s)\n", hdr->ih_arch,
 	    get_arch_name(hdr->ih_arch));
 	printf(" type:        %d (%s)\n", hdr->ih_type,
 	    get_type_name(hdr->ih_type));
 	printf(" comp:        %d (%s)\n", hdr->ih_comp,
 	    get_comp_name(hdr->ih_comp));
 	printf(" name:        %s\n", hdr->ih_name);
 	printf(" header crc:  0x%08x\n", hdr->ih_hcrc);
+}
 static int
 generate_header_uimg(struct uboot_image_header *hdr, int kernel_fd)
+{
 	uint8_t *p;
 	struct stat st;
 	uint32_t crc, dsize, size_buf[2];
 	int error;
 	error = fstat(kernel_fd, &st);
 	if (error == -1) {
 		perror("stat");
 		return errno;
+	}
 	if (st.st_size + sizeof(*hdr) > UINT32_MAX) {
 		fprintf(stderr, "fatal: kernel too big\n");
 		return EINVAL;
+	}
 	p = mmap(0, st.st_size, PROT_READ, MAP_FILE|MAP_SHARED, kernel_fd, 0);
 	if (p == MAP_FAILED) {
 		perror("mmap kernel");
 		return EINVAL;
+	}
 	if (image_type == IH_TYPE_SCRIPT) {
 		struct iovec iov[3];
 		dsize = st.st_size + (sizeof(uint32_t) * 2);
 		size_buf[0] = htonl(st.st_size);
 		size_buf[1] = htonl(0);
 		iov[0].iov_base = &size_buf[0];
 		iov[0].iov_len = sizeof(size_buf[0]);
 		iov[1].iov_base = &size_buf[1];
 		iov[1].iov_len = sizeof(size_buf[1]);
 		iov[2].iov_base = p;
 		iov[2].iov_len = st.st_size;
 		crc = crc32v(iov, 3);
 	} else {
 		dsize = st.st_size;
 		crc = crc32(p, st.st_size);
+	}
 	munmap(p, st.st_size);
 	memset(hdr, 0, sizeof(*hdr));
 	hdr->ih_magic = htonl(image_magic);
 	hdr->ih_time = htonl(st.st_mtime);
 	hdr->ih_size = htonl(dsize);
 	hdr->ih_load = htonl(image_loadaddr);
 	hdr->ih_ep = htonl(image_entrypoint);
 	hdr->ih_dcrc = htonl(crc);
 	hdr->ih_os = image_os;
 	hdr->ih_arch = image_arch;
 	hdr->ih_type = image_type;
 	hdr->ih_comp = image_comp;
 	strlcpy((char *)hdr->ih_name, image_name, sizeof(hdr->ih_name));
 	crc = crc32((void *)hdr, sizeof(*hdr));
 	hdr->ih_hcrc = htonl(crc);
 	dump_header_uimg(hdr);
 	return 0;
+}
 static void
 dump_header_arm64(struct arm64_image_header *hdr)
+{
 	printf(" magic:       0x%" PRIx32 "\n", le32toh(hdr->magic));
 	printf(" text offset: 0x%" PRIx64 "\n", le64toh(hdr->text_offset));
 	printf(" image size:  %" PRIu64 "\n", le64toh(hdr->image_size));
 	printf(" flags:       0x%" PRIx64 "\n", le64toh(hdr->flags));
+}
 static int
 generate_header_arm64(struct arm64_image_header *hdr, int kernel_fd)
+{
 	struct stat st;
 	uint32_t flags;
 	int error;
 	error = fstat(kernel_fd, &st);
 	if (error == -1) {
 		perror("stat");
 		return errno;
+	}
 	flags = 0;
 	flags |= ARM64_FLAGS_PAGE_SIZE_4K;
 #if 0
 	flags |= ARM64_FLAGS_PHYS_PLACEMENT_ANY;
 #endif
 	memset(hdr, 0, sizeof(*hdr));
 	hdr->code0 = htole32(ARM64_CODE0);
 	hdr->text_offset = htole64(image_entrypoint);
 	hdr->image_size = htole64(st.st_size + sizeof(*hdr));
 	hdr->flags = htole32(flags);
 	hdr->magic = htole32(ARM64_MAGIC);
 	dump_header_arm64(hdr);
 	return 0;
+}
 static int
 write_image(void *hdr, size_t hdrlen, int kernel_fd, int image_fd)
+{
 	uint8_t buf[4096];
 	ssize_t rlen, wlen;
 	struct stat st;
 	uint32_t size_buf[2];
 	int error;
 	error = fstat(kernel_fd, &st);
 	if (error == -1) {
 		perror("stat");
 		return errno;
+	}
 	wlen = write(image_fd, hdr, hdrlen);
 	if (wlen != (ssize_t)hdrlen) {
 		perror("short write");
 		return errno;
+	}
 	if (image_type == IH_TYPE_SCRIPT) {
 		size_buf[0] = htonl(st.st_size);
 		size_buf[1] = htonl(0);
 		wlen = write(image_fd, &size_buf, sizeof(size_buf));
 		if (wlen != sizeof(size_buf)) {
 			perror("short write");
 			return errno;
+		}
+	}
 	if (update_image) {
 		if (lseek(kernel_fd, hdrlen, SEEK_SET) != (off_t)hdrlen) {
 			perror("seek failed");
 			return errno;
+		}
+	}
 	while ((rlen = read(kernel_fd, buf, sizeof(buf))) > 0) {
 		wlen = write(image_fd, buf, rlen);
 		if (wlen != rlen) {
 			perror("short write");
 			return errno;
+		}
+	}
 	return 0;
+}
 int
 main(int argc, char *argv[])
+{
 	struct uboot_image_header hdr_uimg;
 	struct arm64_image_header hdr_arm64;
 	const char *src, *dest;
 	char *ep;
 	int kernel_fd, image_fd;
 	int ch;
 	unsigned long long num;
 	while ((ch = getopt(argc, argv, "A:C:E:O:T:a:e:f:hm:n:u")) != -1) {
 		switch (ch) {
 		case 'A':	/* arch */
 			image_arch = get_arch(optarg);
 			break;
 		case 'C':	/* comp */
 			image_comp = get_comp(optarg);
 			break;
 		case 'O':	/* os */
 			image_os = get_os(optarg);
 			break;
 		case 'T':	/* type */
 			image_type = get_type(optarg);
 			break;
 		case 'a':	/* addr */
 			errno = 0;
 			num = strtoull(optarg, &ep, 0);
 			if (*ep != '\0' || (errno == ERANGE &&
 			    (num == ULLONG_MAX || num == 0)) ||
 			    ((signed long long)num != (int32_t)num &&
 			     num != (uint32_t)num))
 				errx(1, "illegal number -- %s", optarg);
 			image_loadaddr = (uint32_t)num;
 			break;
 		case 'E':	/* ep (byte swapped) */
 		case 'e':	/* ep */
 			errno = 0;
 			num = strtoull(optarg, &ep, 0);
 			if (*ep != '\0' || (errno == ERANGE &&
 			    (num == ULLONG_MAX || num == 0)) ||
 			    ((signed long long)num != (int32_t)num &&
 			     num != (uint32_t)num))
 				errx(1, "illegal number -- %s", optarg);
 			image_entrypoint = (uint32_t)num;
 			if (ch == 'E')
 				image_entrypoint = bswap32(image_entrypoint);
 			break;
 		case 'f':	/* image format */
 			image_format = get_image_format(optarg);
 			break;
 		case 'm':	/* magic */
 			errno = 0;
 			num = strtoul(optarg, &ep, 0);
 			if (*ep != '\0' || (errno == ERANGE &&
 			    (num == ULONG_MAX || num == 0)))
 				errx(1, "illegal number -- %s", optarg);
 			image_magic = (uint32_t)num;
 			break;
 		case 'n':	/* name */
 			image_name = strdup(optarg);
 			break;
 		case 'u':	/* update image */
 			update_image = 1;
 			break;
 		case 'h':
 		default:
 			usage();
 			/* NOTREACHED */
+		}
+	}
 	argc -= optind;
 	argv += optind;
 	if (argc != 2)
 		usage();
 	if (image_entrypoint == 0)
 		image_entrypoint = image_loadaddr;
 	switch (image_format) {
 	case FMT_UIMG:
 		if (image_arch == IH_ARCH_UNKNOWN ||
 		    image_type == IH_TYPE_UNKNOWN ||
 		    image_name == NULL)
 			usage();
 			/* NOTREACHED */
 		switch (image_type) {
 		case IH_TYPE_SCRIPT:
 		case IH_TYPE_RAMDISK:
 		case IH_TYPE_KERNEL_NOLOAD:
 			break;
 		default:
 			if (image_loadaddr == 0)
 				usage();
 				/* NOTREACHED */
 			break;
+		}
 		break;
 	case FMT_ARM64:
 		if (image_arch != IH_ARCH_UNKNOWN &&
 		    image_arch != IH_ARCH_ARM64)
 			usage();
 			/* NOTREACHED */
 		break;
 	default:
 		usage();
 		/* NOTREACHED */
+	}
 	src = argv[0];
 	dest = argv[1];
 	kernel_fd = open(src, O_RDONLY);
 	if (kernel_fd == -1) {
 		perror("open kernel");
 		return EXIT_FAILURE;
+	}
 	image_fd = open(dest, O_WRONLY|O_CREAT|O_TRUNC, 0666);
 	if (image_fd == -1) {
 		perror("open image");
 		return EXIT_FAILURE;
+	}
 	printf(" image type:  %s\n", get_image_format_name(image_format));
 	switch (image_format) {
 	case FMT_UIMG:
 		if (generate_header_uimg(&hdr_uimg, kernel_fd) != 0)
 			return EXIT_FAILURE;
 		if (write_image(&hdr_uimg, sizeof(hdr_uimg),
 		    kernel_fd, image_fd) != 0)
 			return EXIT_FAILURE;
 		break;
 	case FMT_ARM64:
 		if (generate_header_arm64(&hdr_arm64, kernel_fd) != 0)
 			return EXIT_FAILURE;
 		if (write_image(&hdr_arm64, sizeof(hdr_arm64),
 		    kernel_fd, image_fd) != 0)
 			return EXIT_FAILURE;
 		break;
 	default:
 		break;
+	}
 	close(image_fd);
 	close(kernel_fd);
 	return EXIT_SUCCESS;
+}