340 lines
8.3 KiB
C
340 lines
8.3 KiB
C
/*
|
|
* Written by Oron Peled <oron@actcom.co.il>
|
|
* Copyright (C) 2008, Xorcom
|
|
*
|
|
* All rights reserved.
|
|
*
|
|
* 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.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*
|
|
*/
|
|
|
|
#include <unistd.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#include <stdarg.h>
|
|
#include <errno.h>
|
|
#include <assert.h>
|
|
#include <arpa/inet.h>
|
|
#include <autoconfig.h>
|
|
#include <xtalk/debug.h>
|
|
#include <xtalk/xusb.h>
|
|
#include "hexfile.h"
|
|
#include "mpptalk.h"
|
|
#include "astribank.h"
|
|
#include "pic_loader.h"
|
|
#include "echo_loader.h"
|
|
|
|
#define DBG_MASK 0x80
|
|
#define MAX_HEX_LINES 64000
|
|
#define HAVE_OCTASIC 1
|
|
#define DEF_SPAN_SPEC_FORMAT "*:%c1" /* %c: 'E' or 'T' */
|
|
|
|
static char *progname;
|
|
|
|
static void usage()
|
|
{
|
|
fprintf(stderr, "Usage: %s [options...] -D {/proc/bus/usb|/dev/bus/usb}/<bus>/<dev> hexfile...\n", progname);
|
|
fprintf(stderr, "\tOptions: {-F|-p}\n");
|
|
fprintf(stderr, "\t\t[-E] # Burn to EEPROM\n");
|
|
#if HAVE_OCTASIC
|
|
fprintf(stderr, "\t\t[-O] # Load Octasic firmware\n");
|
|
fprintf(stderr, "\t\t[-o] # Show Octasic version\n");
|
|
fprintf(stderr, "\t\t[-S <pri-spec>] # Set PRI type specification string\n");
|
|
#endif
|
|
fprintf(stderr, "\t\t[-F] # Load FPGA firmware\n");
|
|
fprintf(stderr, "\t\t[-p] # Load PIC firmware\n");
|
|
fprintf(stderr, "\t\t[-v] # Increase verbosity\n");
|
|
fprintf(stderr, "\t\t[-A] # Set A-Law for 1st module\n");
|
|
fprintf(stderr, "\t\t[-d mask] # Debug mask (0xFF for everything)\n");
|
|
exit(1);
|
|
}
|
|
|
|
int handle_hexline(struct mpp_device *mpp, struct hexline *hexline)
|
|
{
|
|
uint16_t len;
|
|
uint16_t offset_dummy;
|
|
uint8_t *data;
|
|
int ret;
|
|
|
|
assert(hexline);
|
|
assert(mpp);
|
|
if(hexline->d.content.header.tt != TT_DATA) {
|
|
DBG("Non data record type = %d\n", hexline->d.content.header.tt);
|
|
return 0;
|
|
}
|
|
len = hexline->d.content.header.ll;
|
|
offset_dummy = hexline->d.content.header.offset;
|
|
data = hexline->d.content.tt_data.data;
|
|
if((ret = mpp_send_seg(mpp, data, offset_dummy, len)) < 0) {
|
|
ERR("Failed hexfile send line: %d\n", ret);
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef __GNUC__
|
|
static void print_parse_errors(int level, const char *msg, ...) __attribute__((format(printf,2,3)));
|
|
#endif
|
|
|
|
static void print_parse_errors(int level, const char *msg, ...)
|
|
{
|
|
va_list ap;
|
|
|
|
if (verbose > level) {
|
|
va_start (ap, msg);
|
|
vfprintf (stderr, msg, ap);
|
|
va_end (ap);
|
|
}
|
|
}
|
|
|
|
static int load_hexfile(struct mpp_device *mpp, const char *hexfile, enum dev_dest dest)
|
|
{
|
|
struct hexdata *hexdata = NULL;
|
|
int finished = 0;
|
|
int ret;
|
|
unsigned i;
|
|
char star[] = "+\\+|+/+-";
|
|
const char *devstr;
|
|
struct xusb_device *xusb_device;
|
|
struct xusb_iface *xusb_iface;
|
|
|
|
|
|
parse_hexfile_set_reporting(print_parse_errors);
|
|
if((hexdata = parse_hexfile(hexfile, MAX_HEX_LINES)) == NULL) {
|
|
perror(hexfile);
|
|
return -errno;
|
|
}
|
|
xusb_iface = xubs_iface_of_mpp(mpp);
|
|
xusb_device = xusb_deviceof(xusb_iface);
|
|
devstr = xusb_devpath(xusb_device);
|
|
INFO("%s [%s]: Loading %s Firmware: %s (version %s)\n",
|
|
devstr,
|
|
xusb_serial(xusb_device),
|
|
dev_dest2str(dest),
|
|
hexdata->fname, hexdata->version_info);
|
|
if((ret = mpp_send_start(mpp, dest, hexdata->version_info)) < 0) {
|
|
ERR("%s: Failed hexfile send start: %d\n", devstr, ret);
|
|
return ret;
|
|
}
|
|
for(i = 0; i < hexdata->maxlines; i++) {
|
|
struct hexline *hexline = hexdata->lines[i];
|
|
|
|
if(!hexline)
|
|
break;
|
|
if(verbose > LOG_INFO) {
|
|
printf("Sending: %4d%% %c\r", (100 * i) / hexdata->last_line, star[i % sizeof(star)]);
|
|
fflush(stdout);
|
|
}
|
|
if(finished) {
|
|
ERR("%s: Extra data after End Of Data Record (line %d)\n", devstr, i);
|
|
return 0;
|
|
}
|
|
if(hexline->d.content.header.tt == TT_EOF) {
|
|
DBG("End of data\n");
|
|
finished = 1;
|
|
continue;
|
|
}
|
|
if((ret = handle_hexline(mpp, hexline)) < 0) {
|
|
ERR("%s: Failed hexfile sending in lineno %d (ret=%d)\n", devstr, i, ret);;
|
|
return ret;
|
|
}
|
|
}
|
|
if(verbose > LOG_INFO) {
|
|
putchar('\n');
|
|
fflush(stdout);
|
|
}
|
|
if((ret = mpp_send_end(mpp)) < 0) {
|
|
ERR("%s: Failed hexfile send end: %d\n", devstr, ret);
|
|
return ret;
|
|
}
|
|
#if 0
|
|
fclose(fp);
|
|
#endif
|
|
free_hexdata(hexdata);
|
|
DBG("hexfile loaded successfully\n");
|
|
return 0;
|
|
}
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
char *devpath = NULL;
|
|
int opt_pic = 0;
|
|
int opt_echo = 0;
|
|
int opt_ecver = 0;
|
|
#if HAVE_OCTASIC
|
|
int opt_alaw = 0;
|
|
const char *span_spec = NULL;
|
|
char def_span_spec[sizeof(DEF_SPAN_SPEC_FORMAT)];
|
|
#endif
|
|
int opt_dest = 0;
|
|
int opt_sum = 0;
|
|
enum dev_dest dest = DEST_NONE;
|
|
const char options[] = "vd:D:EFOopAS:";
|
|
int ret;
|
|
|
|
progname = argv[0];
|
|
while (1) {
|
|
int c;
|
|
|
|
c = getopt (argc, argv, options);
|
|
if (c == -1)
|
|
break;
|
|
|
|
switch (c) {
|
|
case 'D':
|
|
devpath = optarg;
|
|
break;
|
|
case 'E':
|
|
if(dest != DEST_NONE) {
|
|
ERR("The -F and -E options are mutually exclusive.\n");
|
|
usage();
|
|
}
|
|
opt_dest++;
|
|
dest = DEST_EEPROM;
|
|
break;
|
|
case 'F':
|
|
if(dest != DEST_NONE) {
|
|
ERR("The -F and -E options are mutually exclusive.\n");
|
|
usage();
|
|
}
|
|
opt_dest++;
|
|
dest = DEST_FPGA;
|
|
break;
|
|
#if HAVE_OCTASIC
|
|
case 'O':
|
|
opt_echo = 1;
|
|
break;
|
|
case 'o':
|
|
opt_ecver = 1;
|
|
break;
|
|
case 'A':
|
|
opt_alaw = 1;
|
|
break;
|
|
case 'S':
|
|
span_spec = optarg;
|
|
break;
|
|
#endif
|
|
case 'p':
|
|
opt_pic = 1;
|
|
break;
|
|
case 'v':
|
|
verbose++;
|
|
break;
|
|
case 'd':
|
|
debug_mask = strtoul(optarg, NULL, 0);
|
|
break;
|
|
case 'h':
|
|
default:
|
|
ERR("Unknown option '%c'\n", c);
|
|
usage();
|
|
}
|
|
}
|
|
opt_sum = opt_dest + opt_pic + opt_echo;
|
|
if(opt_sum > 1 || (opt_sum == 0 && opt_ecver == 0)) {
|
|
ERR("The -F, -E"
|
|
#if HAVE_OCTASIC
|
|
", -O"
|
|
#endif
|
|
" and -p options are mutually exclusive, if neither is used then -o should present\n");
|
|
usage();
|
|
}
|
|
if(!opt_pic && !opt_ecver) {
|
|
if(optind != argc - 1) {
|
|
ERR("Got %d hexfile names (Need exactly one hexfile)\n",
|
|
argc - 1 - optind);
|
|
usage();
|
|
}
|
|
}
|
|
if(!devpath) {
|
|
ERR("Missing device path.\n");
|
|
usage();
|
|
}
|
|
# ifdef HAVE_OCTASIC
|
|
if (!span_spec) {
|
|
snprintf(def_span_spec, sizeof(def_span_spec),
|
|
DEF_SPAN_SPEC_FORMAT, opt_alaw? 'E' : 'T');
|
|
span_spec = def_span_spec;
|
|
}
|
|
#endif
|
|
if(opt_dest) {
|
|
/*
|
|
* MPP Interface
|
|
*/
|
|
struct astribank *astribank;
|
|
struct mpp_device *mpp;
|
|
|
|
astribank = astribank_new(devpath);
|
|
if(!astribank) {
|
|
ERR("%s: Opening astribank failed\n", devpath);
|
|
return 1;
|
|
}
|
|
mpp = astribank_mpp_open(astribank);
|
|
if(!mpp) {
|
|
ERR("%s: Opening astribank XPP interface failed\n", devpath);
|
|
return 1;
|
|
}
|
|
show_astribank_info(astribank);
|
|
if(load_hexfile(mpp, argv[optind], dest) < 0) {
|
|
ERR("%s: Loading firmware to %s failed\n", devpath, dev_dest2str(dest));
|
|
return 1;
|
|
}
|
|
astribank_destroy(astribank);
|
|
} else if(opt_pic || opt_echo || opt_ecver) {
|
|
/*
|
|
* XPP Interface
|
|
*/
|
|
struct astribank *astribank;
|
|
struct xusb_iface *xpp_iface;
|
|
|
|
astribank = astribank_new(devpath);
|
|
if (!astribank) {
|
|
ERR("%s: Opening astribank failed\n", devpath);
|
|
return 1;
|
|
}
|
|
xpp_iface = astribank_xpp_open(astribank);
|
|
if(!xpp_iface) {
|
|
ERR("%s: Opening astribank XPP interface failed\n", devpath);
|
|
return 1;
|
|
}
|
|
show_astribank_info(astribank);
|
|
#if HAVE_OCTASIC
|
|
if (opt_ecver) {
|
|
if((ret = echo_ver(astribank)) < 0) {
|
|
ERR("%s: Get Octasic version failed (Is Echo canceller card connected?)\n", devpath);
|
|
return 1;
|
|
} else
|
|
INFO("Octasic version: 0x%0X\n", ret);
|
|
}
|
|
#endif
|
|
if (opt_pic) {
|
|
if ((ret = load_pic(astribank, argc - optind, argv + optind)) < 0) {
|
|
ERR("%s: Loading PIC's failed\n", devpath);
|
|
return 1;
|
|
}
|
|
#if HAVE_OCTASIC
|
|
} else if (opt_echo) {
|
|
if((ret = load_echo(astribank, argv[optind], opt_alaw, span_spec)) < 0) {
|
|
ERR("%s: Loading ECHO's failed\n", devpath);
|
|
return 1;
|
|
}
|
|
#endif
|
|
}
|
|
astribank_destroy(astribank);
|
|
}
|
|
return 0;
|
|
}
|