sysmo-bts
/
barebox
9
0
Fork 0
Code Releases Activity
barebox/scripts/omap3-usb-loader.c

922 lines
23 KiB
C
Raw Permalink Blame History

/*
* OMAP Loader, a USB uploader application targeted at OMAP3 processors
* Copyright (C) 2008 Martin Mueller <martinmm@pfump.org>
* Copyright (C) 2014 Grant Hernandez <grant.h.hernandez@gmail.com>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*/
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdarg.h>
#include <string.h>
#include <stdbool.h>
/*
* Reasons for the name change: this is a complete rewrite of
* the unversioned omap3_usbload so to lower ambiguity the name was changed.
* The GPLv2 license specifies rewrites as derived work.
*/
#define PROG_NAME "OMAP Loader"
#define VERSION "1.0.0"
#if defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __ORDER_BIG_ENDIAN__)
#define OMAP_IS_BIG_ENDIAN
#endif
#ifdef OMAP_IS_BIG_ENDIAN
#include <arpa/inet.h>
#endif
#include <unistd.h> /* for usleep and friends */
#include <getopt.h>
#include <errno.h>
#include <libgen.h> /* for basename */
#include <libusb-1.0/libusb.h> /* the main event */
/* Device specific defines (OMAP)
* Primary source: http://www.ti.com/lit/pdf/sprugn4
* Section 26.4.5 "Peripheral Booting"
*/
#define OMAP_BASE_ADDRESS 0x40200000
#define OMAP_PERIPH_BOOT 0xF0030002
#define OMAP_VENDOR_ID 0x0451
#define OMAP_PRODUCT_ID 0xD00E
/* TODO: dynamically discover these endpoints */
#define OMAP_USB_BULK_IN 0x81
#define OMAP_USB_BULK_OUT 0x01
#define OMAP_ASIC_ID_LEN 69
#ifdef OMAP_IS_BIG_ENDIAN
#define cpu_to_le32(v) (((v & 0xff) << 24) | ((v & 0xff00) << 8) | \
((v & 0xff0000) >> 8) | ((v & 0xff000000) >> 24))
#define le32_to_cpu(v) cpu_to_le32(v)
#else
#define cpu_to_le32(v) (v)
#define le32_to_cpu(v) (v)
#endif
/*
* taken from x-loader/drivers/usb/usb.c
* All credit to Martin Mueller
*/
#define PACK4(a,b,c,d) (((d)<<24) | ((c)<<16) | ((b)<<8) | (a))
#define USBLOAD_CMD_FILE PACK4('U','S','B','s') /* file size request */
#define USBLOAD_CMD_FILE_REQ PACK4('U','S','B','f') /* file size resp */
#define USBLOAD_CMD_JUMP PACK4('U','S','B','j') /* execute code here */
#define USBLOAD_CMD_ECHO_SZ PACK4('U','S','B','n') /* file size confirm to */
#define USBLOAD_CMD_REPORT_SZ PACK4('U','S','B','o') /* confirm full file */
#define USBLOAD_CMD_MESSAGE PACK4('U','S','B','m') /* debug message */
/* USB transfer characteristics */
#define USB_MAX_WAIT 5000
#define USB_TIMEOUT 1000
#define USB_MAX_TIMEOUTS (USB_MAX_WAIT/USB_TIMEOUT)
/* stores the data and attributes of a file to upload in to memory */
struct file_upload {
size_t size;
void *data;
uint32_t addr;
char *path;
char *basename;
};
/* stores all of the arguments read in by getopt in main() */
struct arg_state {
struct file_upload **files;
int numfiles;
uint32_t jumptarget;
uint16_t vendor, product;
};
static int g_verbose = 0;
static void log_error(char *fmt, ...)
{
va_list va;
va_start(va, fmt);
fprintf(stdout, "[-] ");
vfprintf(stdout, fmt, va);
va_end(va);
}
static void log_info(char *fmt, ...)
{
va_list va;
va_start(va, fmt);
fprintf(stdout, "[+] ");
vfprintf(stdout, fmt, va);
va_end(va);
}
static bool omap_usb_read(libusb_device_handle *handle, unsigned char *data,
int length, int *actuallength)
{
int ret = 0;
int iter = 0;
int sizeleft = length;
if (!actuallength)
return false;
while (sizeleft > 0) {
int actualread = 0;
int readamt = sizeleft;
ret = libusb_bulk_transfer(handle, OMAP_USB_BULK_IN, data + iter,
readamt, &actualread, USB_TIMEOUT);
if (ret == LIBUSB_ERROR_TIMEOUT) {
sizeleft -= actualread;
iter += actualread;
/* we got some data, lets cut our losses and stop here */
if (iter > 0)
break;
log_error("device timed out while transfering in %d bytes (got %d)\n",
length, iter);
return false;
} else if (ret == LIBUSB_SUCCESS) {
/* we cant trust actualRead on anything but a timeout or success */
sizeleft -= actualread;
iter += actualread;
/* stop at the first sign of data */
if (iter > 0)
break;
} else {
log_error("fatal transfer error (BULK_IN) for %d bytes (got %d): %s\n",
length, iter, libusb_error_name(ret));
return false;
}
}
*actuallength = iter;
return true;
}
static bool omap_usb_write(libusb_device_handle *handle, void *data, int length)
{
int ret = 0;
int numtimeouts = 0;
int iter = 0;
int sizeleft = length;
while (sizeleft > 0) {
int actualwrite = 0;
int writeamt = sizeleft > 512 ? 512 : sizeleft;
ret = libusb_bulk_transfer(handle, OMAP_USB_BULK_OUT, data + iter,
writeamt, &actualwrite, USB_TIMEOUT);
if (ret == LIBUSB_ERROR_TIMEOUT) {
numtimeouts++;
sizeleft -= actualwrite;
iter += actualwrite;
/* build in some reliablity */
if (numtimeouts > USB_MAX_TIMEOUTS) {
log_error("device timed out while transfering out %d bytes (%d made it)\n",
length, iter);
return false;
}
} else if (ret == LIBUSB_SUCCESS) {
/* we cant trust actualWrite on anything but a timeout or success */
sizeleft -= actualwrite;
iter += actualwrite;
} else {
log_error("fatal transfer error (BULK_OUT) for %d bytes (%d made it): %s\n",
length, iter, libusb_error_name(ret));
return false;
}
}
return true;
}
static unsigned char *omap_usb_get_string(libusb_device_handle *handle, uint8_t idx)
{
unsigned char *data = NULL;
int len = 0;
int ret = 0;
if (!handle)
return NULL;
while (true) {
if (!len || ret < 0) {
len += 256;
data = realloc(data, len);
if (!data)
return NULL;
}
ret = libusb_get_string_descriptor_ascii(handle, idx, data, len);
/* we can still recover... */
if (ret < 0) {
if (ret == LIBUSB_ERROR_INVALID_PARAM)
continue; /* try again with an increased size */
log_error("failed to lookup string index %hhu: %s\n",
idx, libusb_error_name(ret));
/* unrecoverable */
free(data);
return NULL;
} else {
/* we got something! */
break;
}
}
return data;
}
uint16_t omap_products[] = {
0xd009,
0xd00f,
};
static libusb_device_handle *omap_usb_open(libusb_context *ctx, uint16_t vendor, uint16_t product)
{
libusb_device **devlist;
libusb_device_handle *handle;
struct libusb_device_descriptor desc;
ssize_t count, i;
int ret;
log_info("scanning for USB device matching %04hx:%04hx...\n",
vendor, product);
while (1) {
if ((count = libusb_get_device_list(ctx, &devlist)) < 0) {
log_error("failed to gather USB device list: %s\n",
libusb_error_name(count));
return NULL;
}
for (i = 0; i < count; i++) {
ret = libusb_get_device_descriptor(devlist[i], &desc);
if (ret < 0) {
log_error("failed to get USB device descriptor: %s\n",
libusb_error_name(ret));
libusb_free_device_list(devlist, 1);
return NULL;
}
if (desc.idVendor != vendor)
continue;
if (product) {
if (desc.idProduct != product)
continue;
goto found;
}
for (i = 0; i < sizeof(omap_products) / sizeof(uint16_t); i++)
if (desc.idProduct == omap_products[i]) {
product = desc.idProduct;
goto found;
}
}
libusb_free_device_list(devlist, 1);
/* nothing found yet. have a 10ms nap */
usleep(10000);
}
found:
ret = libusb_open(devlist[i], &handle);
if (ret < 0) {
log_error("failed to open USB device %04hx:%04hx: %s\n",
vendor, product, libusb_error_name(ret));
libusb_free_device_list(devlist, 1);
return NULL;
}
ret = libusb_claim_interface(handle, 0);
if (ret) {
printf("Claim failed\n");
return NULL;
}
/* grab the manufacturer and product strings for printing */
unsigned char *mfgstr = omap_usb_get_string(handle, desc.iManufacturer);
unsigned char *prodstr = omap_usb_get_string(handle, desc.iProduct);
log_info("successfully opened %04hx:%04hx (", vendor, product);
if (mfgstr) {
fprintf(stdout, prodstr ? "%s " : "%s", mfgstr);
free(mfgstr);
}
if (prodstr) {
fprintf(stdout, "%s", prodstr);
free(prodstr);
}
fprintf(stdout, ")\n");
return handle;
}
static unsigned char *read_file(char *path, size_t *readamt)
{
FILE *fp = fopen(path, "rb");
if (!fp) {
log_error("failed to open file \'%s\': %s\n", path,
strerror(errno));
return NULL;
}
unsigned char *data = NULL;
size_t allocsize = 0;
size_t iter = 0;
while (1) {
if (iter >= iter) {
allocsize += 1024;
data = realloc(data, allocsize);
if (!data)
return NULL;
}
size_t readsize = allocsize - iter;
size_t ret = fread(data + iter, sizeof (unsigned char), readsize, fp);
iter += ret;
if (ret != readsize) {
if (feof(fp)) {
break;
} else if (ferror(fp)) {
log_error("error file reading file \'%s\': %s\n",
path, strerror(errno));
free(data);
return NULL;
}
}
}
/* trim the allocation down to size */
data = realloc(data, iter);
*readamt = iter;
return data;
}
static int transfer_first_stage(libusb_device_handle * handle, struct arg_state *args)
{
unsigned char *buffer = NULL;
uint32_t cmd = 0;
uint32_t filelen = 0;
int bufsize = 0x200;
int transLen = 0;
int i;
void *data;
uint32_t *dbuf;
struct file_upload *file = args->files[0];
/* TODO determine buffer size based on endpoint */
buffer = calloc(bufsize, sizeof (unsigned char));
filelen = cpu_to_le32(file->size);
data = file->data;
dbuf = data;
if (le32toh(dbuf[5]) == 0x45534843) {
int chsettingssize = 512 + 2 * sizeof(uint32_t);
log_info("CHSETTINGS image detected. Skipping header\n");
data += chsettingssize;
filelen -= chsettingssize;
}
/* read the ASIC ID */
if (!omap_usb_read(handle, buffer, bufsize, &transLen)) {
log_error("failed to read ASIC ID from USB connection. "
"Check your USB device!\n");
goto fail;
}
if (transLen != OMAP_ASIC_ID_LEN) {
log_error("got some ASIC ID, but it's not the right length, %d "
"(expected %d)\n", transLen, OMAP_ASIC_ID_LEN);
goto fail;
}
/* optionally, print some ASIC ID info */
if (g_verbose) {
char *fields[] =
{ "Num Subblocks", "Device ID Info", "Reserved",
"Ident Data", "Reserved", "CRC (4 bytes)"
};
int fieldLen[] = { 1, 7, 4, 23, 23, 11 };
int field = 0;
int nextSep = 0;
log_info("got ASIC ID - ");
for (i = 0; i < transLen; i++) {
if (i == nextSep) {
fprintf(stdout, "%s%s ",
(field > 0) ? ", " : "", fields[field]);
nextSep += fieldLen[field];
field++;
fprintf(stdout, "[");
}
fprintf(stdout, "%02x", buffer[i]);
if (i + 1 == nextSep)
fprintf(stdout, "]");
}
fprintf(stdout, "\n");
}
/* send the peripheral boot command */
cmd = cpu_to_le32(OMAP_PERIPH_BOOT);
if (!omap_usb_write(handle, (unsigned char *) &cmd, sizeof (cmd))) {
log_error("failed to send the peripheral boot command 0x%08x\n",
OMAP_PERIPH_BOOT);
goto fail;
}
/* send the length of the first file (little endian) */
if (!omap_usb_write
(handle, (unsigned char *) &filelen, sizeof (filelen))) {
log_error("failed to length specifier of %u to OMAP BootROM\n",
filelen);
goto fail;
}
/* send the file! */
if (!omap_usb_write(handle, data, filelen)) {
log_error("failed to send file \'%s\' (size %u)\n",
file->basename, filelen);
goto fail;
}
free(buffer);
return 1;
fail:
free(buffer);
return 0;
}
static int transfer_other_files(libusb_device_handle *handle, struct arg_state *args)
{
uint32_t *buffer = NULL;
int bufsize = 128 * sizeof (*buffer);
int numfailures = 0; /* build in some reliablity */
int maxfailures = 3;
int transLen = 0;
int curfile = 1; /* skip the first file */
size_t len;
buffer = calloc(bufsize, sizeof(unsigned char));
/* handle the state machine for the X-Loader */
while (curfile < args->numfiles) {
uint32_t opcode = 0;
uint8_t *extra = NULL;
struct file_upload *f = args->files[curfile];
/* read the opcode from xloader ID */
if (!omap_usb_read
(handle, (unsigned char *) buffer, bufsize, &transLen)) {
numfailures++;
if (numfailures >= maxfailures) {
log_error("failed to read command from X-Loader\n");
goto fail;
}
/* sleep a bit */
usleep(2000 * 1000); /* 2s */
continue; /* try the opcode read again */
}
if (transLen < 8) {
log_error("failed to recieve enough data for the opcode\n");
goto fail;
}
/* extract the opcode and extra data pointer */
opcode = le32_to_cpu(buffer[0]);
extra = (uint8_t *)buffer;
switch (opcode) {
case USBLOAD_CMD_FILE_REQ:
/* X-loader is requesting a file to be sent */
/* send the opcode, size, and addr */
buffer[0] = cpu_to_le32(USBLOAD_CMD_FILE);
buffer[1] = cpu_to_le32(f->size);
buffer[2] = cpu_to_le32(f->addr);
if (!omap_usb_write(handle, (unsigned char *)buffer, sizeof(*buffer) * 3)) {
log_error("failed to send load file command to the X-loader\n");
goto fail;
}
if (g_verbose) {
log_info("uploading \'%s\' (size %zu) to 0x%08x\n",
f->basename, f->size, f->addr);
}
break;
case USBLOAD_CMD_ECHO_SZ:
/* X-loader confirms the size to recieve */
if (buffer[1] != f->size) {
log_error
("X-loader failed to recieve the right file size for "
"file \'%s\' (got %u, expected %zu)\n",
f->basename, buffer[1], f->size);
goto fail;
}
/* upload the raw file data */
if (!omap_usb_write(handle, f->data, f->size)) {
log_error
("failed to send file \'%s\' to the X-loader\n",
f->basename);
goto fail;
}
break;
case USBLOAD_CMD_REPORT_SZ:
/* X-loader confirms the amount of data it recieved */
if (buffer[1] != f->size) {
log_error
("X-loader failed to recieve the right amount of data for "
"file \'%s\' (got %u, expected %zu)\n",
f->basename, buffer[1], f->size);
goto fail;
}
curfile++; /* move on to the next file */
break;
case USBLOAD_CMD_MESSAGE:
/* X-loader debug message */
len = strlen((char *)extra);
if (len > (bufsize - sizeof (opcode) - 1))
log_error("X-loader debug message not NUL terminated (size %zu)\n",
len);
else
fprintf(stdout, "X-loader Debug: %s\n", extra);
break;
default:
log_error("unknown X-Loader opcode 0x%08X (%c%c%c%c)\n",
opcode, extra[0], extra[1], extra[2],
extra[3]);
goto fail;
}
}
/* we're done uploading files to X-loader send the jump command */
buffer[0] = cpu_to_le32(USBLOAD_CMD_JUMP);
buffer[1] = cpu_to_le32(args->jumptarget);
if (!omap_usb_write
(handle, (unsigned char *) buffer, sizeof (*buffer) * 2)) {
log_error
("failed to send the final jump command to the X-loader. "
"Target was 0x%08x\n", args->jumptarget);
goto fail;
}
if (g_verbose)
log_info("jumping to address 0x%08x\n", args->jumptarget);
free(buffer);
return 1;
fail:
free(buffer);
return 0;
}
static int process_args(struct arg_state *args)
{
int i;
/* For each file, load it in to memory
* TODO: defer this until transfer time (save memory and pipeline IO)
*/
for (i = 0; i < args->numfiles; i++) {
struct file_upload *f = args->files[i];
f->data = read_file(f->path, &f->size);
if (!f->data) {
return 1;
}
}
if (g_verbose > 0) {
for (i = 0; i < args->numfiles; i++) {
struct file_upload *f = args->files[i];
printf("File \'%s\' at 0x%08x, size %zu\n",
f->basename, f->addr, f->size);
}
}
libusb_context *ctx;
libusb_device_handle *dev;
int ret;
if ((ret = libusb_init(&ctx)) < 0) {
log_error("failed to initialize libusb context: %s\n",
libusb_error_name(ret));
return ret;
}
dev = omap_usb_open(ctx, args->vendor, args->product);
if (!dev) {
libusb_exit(ctx);
return 1;
}
/* Communicate with the TI BootROM directly
* - retrieve ASIC ID
* - start peripheral boot
* - upload first file
* - execute first file
*/
if (!transfer_first_stage(dev, args)) {
log_error("failed to transfer the first stage file \'%s\'\n",
args->files[0]->basename);
goto fail;
}
/* Note: this is a race between the target's processor getting X-loader
* running and our processor. If we fail to communicate with the X-loader,
* it's possible that it hasn't been fully initialized. I'm not going to put
* some stupid, arbitrary sleep value here. The transfer_other_files function
* should be robust enough to handle some errors.
*/
/* If we are passed one file, assume that the user just wants to
* upload some initial code with no X-loader chaining
*/
if (args->numfiles > 1) {
if (!transfer_other_files(dev, args)) {
log_error
("failed to transfer the additional files in to memory\n");
goto fail;
}
}
log_info("successfully transfered %d %s\n", args->numfiles,
(args->numfiles > 1) ? "files" : "file");
/* safely close our USB handle and context */
libusb_close(dev);
libusb_exit(ctx);
return 0;
fail:
libusb_close(dev);
libusb_exit(ctx);
return 1;
}
/* getopt configuration */
static int do_version = 0;
static const char *const short_opt = "f:a:j:i:p:vh";
static const struct option long_opt[] = {
{"file", 1, NULL, 'f'},
{"addr", 1, NULL, 'a'},
{"jump", 1, NULL, 'j'},
{"vendor", 1, NULL, 'i'},
{"product", 1, NULL, 'p'},
{"verbose", 0, NULL, 'v'},
{"help", 0, NULL, 'h'},
{"version", 0, &do_version, 1},
{NULL, 0, NULL, 0}
};
static void usage(char *exe)
{
printf(
"Usage: %s [options] -f first-stage [-f file -a addr]...\n"
"Options:\n"
" -f, --file Provide the filename of a binary file to be\n"
" uploaded. The first file specified is uploaded to\n"
" the fixed address 0x%08x as defined by the manual.\n"
" Additional files must be followed by an address\n"
" argument (-a).\n"
" -a, --addr The address to load the prior file at.\n"
" -j, --jump Specify the address to jump to after loading all\n"
" of the files in to memory.\n"
" -i, --vendor Override the default vendor ID to poll for\n"
" (default 0x%04x).\n"
" -p, --product Poll for specific product id. Default: All known OMAP chips\n"
" -h, --help Display this message.\n"
" -v, --verbose Enable verbose output.\n"
"\n"
"Description:\n"
" %s's basic usage is to upload an arbitrary file in to the memory\n"
" of a TI OMAP3 compatible processor. This program directly\n"
" communicates with the TI BootROM in order to upload a first stage\n"
" payload, in most cases, TI's X-Loader. Using a compatible X-Loader\n"
" will enable the upload of any file to any part in device memory.\n"
"\n"
"Examples:\n"
" Uploading a compatible X-Loader, U-Boot, Kernel, and RAMDisk, then jumping\n"
" to the U-Boot image for further bootloading:\n"
" %s -f x-load.bin -f u-boot.bin -a 0x80200000 -f uImage -a 0x80800000 \\\n"
" -f uRamdisk -a 0x81000000 -j 0x80200000\n"
" Uploading arbitrary code to be executed (doesn't have to be X-loader):\n"
" %s -f exec_me.bin\n"
" Trying to debug an upload issue using verbose output:\n"
" %s -v -f exec_me.bin -f file1.bin -a 0xdeadbeef -j 0xabad1dea\n"
"\n"
"Authors:\n"
" Grant Hernandez <grant.h.hernandez@gmail.com> - rewrite of omap3_usbload to\n"
" use the newer libusb 1.0\n"
" Martin Mueller <martinmm@pfump.org> - initial code (omap3_usbload)\n"
" and X-Loader patch\n",
exe, OMAP_BASE_ADDRESS, OMAP_VENDOR_ID, PROG_NAME, exe, exe, exe
);
}
static void license(void)
{
printf(
"Copyright (C) 2008 Martin Mueller <martinmm@pfump.org>\n"
"Copyright (C) 2014 Grant Hernandez <grant.h.hernandez@gmail.com>\n"
"License GPLv2: GNU GPL version 2 or later <http://gnu.org/licenses/gpl.html>.\n"
"This is free software: you are free to change and redistribute it.\n"
"There is NO WARRANTY, to the extent permitted by law.\n"
);
}
int main(int argc, char *argv[])
{
int opt;
bool gotfile = false;
bool gotjump = false;
int filecount = 0;
char *exe = NULL;
/* temporary local file object */
struct file_upload file;
/* total arg state */
struct arg_state *args = calloc(1, sizeof (*args));
if (argc < 1) {
log_error("invalid arguments (no argv[0])\n");
return 1;
}
exe = argv[0];
fprintf(stdout, "%s %s\n", PROG_NAME, VERSION);
/* set the default vendor and product */
args->vendor = OMAP_VENDOR_ID;
args->product = 0;
while ((opt = getopt_long(argc, argv, short_opt, long_opt, NULL)) != -1) {
switch (opt) {
case 0:
if (do_version) {
license();
return 0;
}
break;
case 'f':
if (gotfile) {
log_error("missing address argument (-a) for file \'%s\'\n",
file.path);
usage(exe);
return 1;
}
file.path = strdup(optarg);
/* necessary to be sure that we own all the memory
and that the path input can be modified */
char *tmpPath = strdup(file.path);
file.basename = strdup(basename(tmpPath));
free(tmpPath);
filecount++;
/* the first file gets uploaded to a fixed address
as specified by the technical reference manual */
if (filecount == 1) {
file.addr = OMAP_BASE_ADDRESS;
/* commit the file object with the processor specified base address */
args->files = realloc(args->files, filecount);
args->numfiles = filecount;
args->files[filecount - 1] = malloc(sizeof (file));
memcpy(args->files[filecount - 1], &file, sizeof (file));
} else {
/* commit only after an address is specified */
gotfile = true;
}
break;
case 'a':
if (!gotfile) {
log_error
("missing file argument (-f) before address \'%s\'\n",
optarg);
usage(exe);
return 1;
}
/* passing 0 to strtoul enables detection of the 0x prefix with
base-10 fallback if missing */
file.addr = strtoul(optarg, NULL, 0);
/* commit the file object */
args->files = realloc(args->files, filecount);
args->numfiles = filecount;
args->files[filecount - 1] = malloc(sizeof(file));
memcpy(args->files[filecount - 1], &file, sizeof(file));
gotfile = false;
break;
case 'j':
args->jumptarget = strtoul(optarg, NULL, 0);
gotjump = true;
break;
case 'i':
args->vendor = (uint16_t)strtoul(optarg, NULL, 0);
break;
case 'p':
args->product = (uint16_t)strtoul(optarg, NULL, 0);
break;
case 'v':
g_verbose++;
break;
case 'h':
usage(exe);
return 0;
default:
usage(exe);
return 1;
}
}
if (gotfile) {
log_error("got file \'%s\', but no address!\n", file.path);
usage(exe);
return 1;
}
if (args->numfiles <= 0) {
log_error("at least one file needs to be specified\n");
usage(exe);
return 1;
}
if (args->numfiles == 1 && gotjump) {
log_info
("WARNING: jump target 0x%08x specified, but will never be taken "
"(more than one file required)\n", args->jumptarget);
} else if (args->numfiles > 1 && !gotjump) {
log_info
("WARNING: no jump target specified. Defaulting to the first "
"file's (\'%s\') address 0x%08x\n",
args->files[1]->basename, args->files[1]->addr);
args->jumptarget = args->files[1]->addr;
}
return process_args(args);
}
View Git Blame Copy Permalink