FGCOM/dahdi-tools
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

xpp: migrate everything to libxtalk

Browse Source 
* Build new libxtalk as local convenience library
 * Have new mpptalk.[ch] and astribank.[ch] wrap the new API
 * Modify all tools to use the new API

Signed-off-by: Oron Peled <oron.peled@xorcom.com>
Signed-off-by: Tzafrir Cohen <tzafrir.cohen@xorcom.com>
This commit is contained in:
Oron Peled 2014-12-21 14:58:03 -05:00 committed by Tzafrir Cohen
parent 9c61e40187
commit 0e6b068e89
26 changed files with 1007 additions and 3017 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
xpp/Makefile.am
View File

@ -8,7 +8,7 @@ man_MANS =
# FIXME: try to improve code, so we can use $(PEDANTIC) # FIXME: try to improve code, so we can use $(PEDANTIC)
#PEDANTIC = -ansi -pedantic -std=c99 #PEDANTIC = -ansi -pedantic -std=c99
GLOBAL_CFLAGS = -I$(srcdir) -I$(srcdir)/xtalk $(PEDANTIC) GLOBAL_CFLAGS = -I$(srcdir) -I$(srcdir)/xtalk/include $(PEDANTIC) -Wall
if DAHDI_DEVMODE if DAHDI_DEVMODE
GLOBAL_CFLAGS += \ GLOBAL_CFLAGS += \
@ -81,24 +81,14 @@ endif
noinst_LTLIBRARIES = libastribank.la libecholoader.la libhexfile.la noinst_LTLIBRARIES = libastribank.la libecholoader.la libhexfile.la
libastribank_la_SOURCES = \ libastribank_la_SOURCES = \
astribank_usb.c \ astribank.c \
astribank_usb.h \ astribank.h \
mpptalk.c \ mpptalk.c \
mpptalk.h \ mpptalk.h \
mpp.h \
mpptalk_defs.h \
xtalk/debug.c \
xtalk/debug.h \
xtalk/xlist.c \
xtalk/xlist.h \
xtalk/xtalk.c \
xtalk/xtalk.h \
xtalk/xtalk_defs.h \
xtalk/xusb.c \
xtalk/xusb.h \
# #
libastribank_la_CFLAGS = $(GLOBAL_CFLAGS) libastribank_la_CFLAGS = $(GLOBAL_CFLAGS)
libastribank_la_LIBADD = xtalk/libxtalk.la
if USE_OCTASIC if USE_OCTASIC
libecholoader_la_SOURCES = \ libecholoader_la_SOURCES = \

177
xpp/astribank.c Normal file
View File

@ -0,0 +1,177 @@
#include <assert.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <xtalk/debug.h>
#include <xtalk/xusb.h>
#include "mpptalk.h"
#include "astribank.h"
#define DBG_MASK 0x08
struct astribank {
struct xusb_device *xusb_device;
struct xusb_iface *xpp_iface;
struct xusb_iface *mpp_iface;
struct mpp_device *mpp;
char *path;
};
struct astribank *astribank_new(const char *path)
{
struct astribank *ab;
ab = calloc(sizeof(*ab), 1);
if (!ab) {
ERR("%s: Failed allocating Astribank device\n", path);
goto err;
}
ab->xusb_device = xusb_find_bypath(path);
if (!ab->xusb_device) {
ERR("%s: Cannot find Astribank\n", path);
goto err;
}
ab->path = strdup(path);
if (!ab->path) {
ERR("%s: Failed allocating Astribank path\n", path);
goto err;
}
return ab;
err:
astribank_destroy(ab);
return NULL;
}
void astribank_destroy(struct astribank *ab)
{
if (ab) {
if (ab->path)
free(ab->path);
if (ab->xpp_iface)
xusb_release(ab->xpp_iface);
if (ab->mpp) {
mpp_delete(ab->mpp); /* this also closes the underlying xusb */
ab->mpp = NULL;
}
if (ab->xusb_device) {
xusb_destroy(ab->xusb_device);
ab->xusb_device = NULL;
}
free(ab);
ab = NULL;
}
}
struct xusb_iface *astribank_xpp_open(struct astribank *ab)
{
int ret;
ret = xusb_claim(ab->xusb_device, 0, &ab->xpp_iface);
if (ret < 0) {
ERR("%s: Cannot claim XPP interface\n", ab->path);
goto err;
}
DBG("%s: Claimed Astribank XPP interface\n", ab->path);
return ab->xpp_iface;
err:
if (ab->xpp_iface)
xusb_release(ab->xpp_iface);
return NULL;
}
struct mpp_device *astribank_mpp_open(struct astribank *ab)
{
int ret;
ret = xusb_claim(ab->xusb_device, 1, &ab->mpp_iface);
if (ret < 0) {
ERR("%s: Cannot claim MPP interface\n", ab->path);
goto err;
}
DBG("%s: Claimed Astribank MPP interface\n", ab->path);
ab->mpp = mpp_new(ab->mpp_iface);
if (!ab->mpp) {
ERR("Failed initializing MPP protocol\n");
goto err;
}
ret = mpp_status_query(ab->mpp);
if (ret < 0) {
ERR("status query failed (ret=%d)\n", ret);
goto err;
}
return ab->mpp;
err:
if (ab->mpp) {
mpp_delete(ab->mpp); /* this also closes the underlying xusb */
ab->mpp = NULL;
}
return NULL;
}
struct xusb_device *xusb_dev_of_astribank(const struct astribank *ab)
{
assert(ab->xusb_device);
return ab->xusb_device;
}
const char *astribank_devpath(const struct astribank *ab)
{
return xusb_devpath(ab->xusb_device);
}
const char *astribank_serial(const struct astribank *ab)
{
return xusb_serial(ab->xusb_device);
}
void show_astribank_info(const struct astribank *ab)
{
struct xusb_device *xusb_device;
assert(ab != NULL);
xusb_device = ab->xusb_device;
assert(xusb_device != NULL);
if(verbose <= LOG_INFO) {
xusb_showinfo(xusb_device);
} else {
const struct xusb_spec *spec;
spec = xusb_spec(xusb_device);
printf("USB Bus/Device: [%s]\n", xusb_devpath(xusb_device));
printf("USB Firmware Type: [%s]\n", spec->name);
printf("USB iSerialNumber: [%s]\n", xusb_serial(xusb_device));
printf("USB iManufacturer: [%s]\n", xusb_manufacturer(xusb_device));
printf("USB iProduct: [%s]\n", xusb_product(xusb_device));
}
}
int astribank_send(struct astribank *ab, int interface_num, const char *buf, int len, int timeout)
{
struct xusb_iface *iface;
if (interface_num == 0)
iface = ab->xpp_iface;
else if (interface_num == 1)
iface = ab->mpp_iface;
else {
ERR("Unknown interface number (%d)\n", interface_num);
return -EINVAL;
}
return xusb_send(iface, buf, len, timeout);
}
int astribank_recv(struct astribank *ab, int interface_num, char *buf, size_t len, int timeout)
{
struct xusb_iface *iface;
if (interface_num == 0)
iface = ab->xpp_iface;
else if (interface_num == 1)
iface = ab->mpp_iface;
else {
ERR("Unknown interface number (%d)\n", interface_num);
return -EINVAL;
}
return xusb_recv(iface, buf, len, timeout);
}

33
xpp/astribank.h Normal file
View File

@ -0,0 +1,33 @@
#ifndef ASTRIBANK_H
#define ASTRIBANK_H
#include <mpptalk.h>
struct astribank *astribank_new(const char *path);
void astribank_destroy(struct astribank *ab);
void show_astribank_info(const struct astribank *ab);
struct xusb_iface *astribank_xpp_open(struct astribank *ab);
struct mpp_device *astribank_mpp_open(struct astribank *ab);
struct xusb_device *xusb_dev_of_astribank(const struct astribank *ab);
const char *astribank_devpath(const struct astribank *ab);
const char *astribank_serial(const struct astribank *ab);
int astribank_send(struct astribank *ab, int interface_num, const char *buf, int len, int timeout);
int astribank_recv(struct astribank *ab, int interface_num, char *buf, size_t len, int timeout);
#define AB_REPORT(report_type, astribank, fmt, ...) \
report_type("%s [%s]: " fmt, \
astribank_devpath(astribank), \
astribank_serial(astribank), \
## __VA_ARGS__)
#define AB_INFO(astribank, fmt, ...) \
AB_REPORT(INFO, astribank, fmt, ## __VA_ARGS__)
#define AB_ERR(astribank, fmt, ...) \
AB_REPORT(ERR, astribank, fmt, ## __VA_ARGS__)
#endif /* ASTRIBANK_H */

47
xpp/astribank_allow.c
View File

@ -31,9 +31,9 @@
#include <sys/types.h> #include <sys/types.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <ctype.h> #include <ctype.h>
#include "mpp.h" #include <xtalk/debug.h>
#include "mpptalk.h" #include "mpptalk.h"
#include <debug.h> #include "astribank.h"
#include "astribank_license.h" #include "astribank_license.h"
static const char rcsid[] = "$Id$"; static const char rcsid[] = "$Id$";
@ -55,28 +55,11 @@ static void usage()
exit(1); exit(1);
} }
static int capabilities_burn(
struct astribank_device *astribank,
struct eeprom_table *eeprom_table,
struct capabilities *capabilities,
struct capkey *key)
{
int ret;
INFO("Burning capabilities\n");
ret = mpp_caps_set(astribank, eeprom_table, capabilities, key);
if(ret < 0) {
ERR("Capabilities burning failed: %d\n", ret);
return ret;
}
INFO("Done\n");
return 0;
}
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
char *devpath = NULL; char *devpath = NULL;
struct astribank_device *astribank; struct astribank *astribank;
struct mpp_device *mpp;
struct eeprom_table eeprom_table; struct eeprom_table eeprom_table;
struct capabilities caps; struct capabilities caps;
struct capkey key; struct capkey key;
@ -127,16 +110,19 @@ int main(int argc, char *argv[])
usage(); usage();
} }
DBG("Startup %s\n", devpath); DBG("Startup %s\n", devpath);
if((astribank = mpp_init(devpath, 1)) == NULL) { astribank = astribank_new(devpath);
ERR("Failed initializing MPP\n"); if(!astribank) {
ERR("Failed initializing Astribank\n");
return 1; return 1;
} }
if(astribank->eeprom_type != EEPROM_TYPE_LARGE) { mpp = astribank_mpp_open(astribank);
ret = mpp_eeprom_type(mpp);
if(ret != EEPROM_TYPE_LARGE) {
ERR("Cannot use this program with astribank EEPROM type %d (need %d)\n", ERR("Cannot use this program with astribank EEPROM type %d (need %d)\n",
astribank->eeprom_type, EEPROM_TYPE_LARGE); ret, EEPROM_TYPE_LARGE);
return 1; return 1;
} }
ret = mpp_caps_get(astribank, &eeprom_table, &caps, &key); ret = mpp_caps_get(mpp, &eeprom_table, &caps, &key);
if(ret < 0) { if(ret < 0) {
ERR("Failed to get original capabilities: %d\n", ret); ERR("Failed to get original capabilities: %d\n", ret);
return 1; return 1;
@ -158,8 +144,13 @@ int main(int argc, char *argv[])
return 1; return 1;
} }
show_capabilities(&caps, stderr); show_capabilities(&caps, stderr);
if (capabilities_burn(astribank, &eeprom_table, &caps, &key) < 0) INFO("Burning capabilities\n");
ret = mpp_caps_set(mpp, &eeprom_table, &caps, &key);
if(ret < 0) {
ERR("Capabilities burning failed: %d\n", ret);
return 1; return 1;
}
INFO("Done\n");
if (file != stdin) if (file != stdin)
fclose(file); fclose(file);
} else { } else {
@ -180,6 +171,6 @@ int main(int argc, char *argv[])
if (file != stdout) if (file != stdout)
fclose(file); fclose(file);
} }
mpp_exit(astribank); astribank_destroy(astribank);
return 0; return 0;
} }

64
xpp/astribank_hexload.c
View File

@ -28,13 +28,14 @@
#include <errno.h> #include <errno.h>
#include <assert.h> #include <assert.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include <debug.h> #include <autoconfig.h>
#include <xtalk/debug.h>
#include <xtalk/xusb.h>
#include "hexfile.h" #include "hexfile.h"
#include "mpptalk.h" #include "mpptalk.h"
#include "astribank.h"
#include "pic_loader.h" #include "pic_loader.h"
#include "echo_loader.h" #include "echo_loader.h"
#include "astribank_usb.h"
#include "../autoconfig.h"
#define DBG_MASK 0x80 #define DBG_MASK 0x80
#define MAX_HEX_LINES 64000 #define MAX_HEX_LINES 64000
@ -61,7 +62,7 @@ static void usage()
exit(1); exit(1);
} }
int handle_hexline(struct astribank_device *astribank, struct hexline *hexline) int handle_hexline(struct mpp_device *mpp, struct hexline *hexline)
{ {
uint16_t len; uint16_t len;
uint16_t offset_dummy; uint16_t offset_dummy;
@ -69,7 +70,7 @@ int handle_hexline(struct astribank_device *astribank, struct hexline *hexline)
int ret; int ret;
assert(hexline); assert(hexline);
assert(astribank); assert(mpp);
if(hexline->d.content.header.tt != TT_DATA) { if(hexline->d.content.header.tt != TT_DATA) {
DBG("Non data record type = %d\n", hexline->d.content.header.tt); DBG("Non data record type = %d\n", hexline->d.content.header.tt);
return 0; return 0;
@ -77,7 +78,7 @@ int handle_hexline(struct astribank_device *astribank, struct hexline *hexline)
len = hexline->d.content.header.ll; len = hexline->d.content.header.ll;
offset_dummy = hexline->d.content.header.offset; offset_dummy = hexline->d.content.header.offset;
data = hexline->d.content.tt_data.data; data = hexline->d.content.tt_data.data;
if((ret = mpp_send_seg(astribank, data, offset_dummy, len)) < 0) { if((ret = mpp_send_seg(mpp, data, offset_dummy, len)) < 0) {
ERR("Failed hexfile send line: %d\n", ret); ERR("Failed hexfile send line: %d\n", ret);
return -EINVAL; return -EINVAL;
} }
@ -100,7 +101,7 @@ static void print_parse_errors(int level, const char *msg, ...)
} }
} }
static int load_hexfile(struct astribank_device *astribank, const char *hexfile, enum dev_dest dest) static int load_hexfile(struct mpp_device *mpp, const char *hexfile, enum dev_dest dest)
{ {
struct hexdata *hexdata = NULL; struct hexdata *hexdata = NULL;
int finished = 0; int finished = 0;
@ -108,19 +109,24 @@ static int load_hexfile(struct astribank_device *astribank, const char *hexfile,
unsigned i; unsigned i;
char star[] = "+\\+|+/+-"; char star[] = "+\\+|+/+-";
const char *devstr; const char *devstr;
struct xusb_device *xusb_device;
struct xusb_iface *xusb_iface;
parse_hexfile_set_reporting(print_parse_errors); parse_hexfile_set_reporting(print_parse_errors);
if((hexdata = parse_hexfile(hexfile, MAX_HEX_LINES)) == NULL) { if((hexdata = parse_hexfile(hexfile, MAX_HEX_LINES)) == NULL) {
perror(hexfile); perror(hexfile);
return -errno; return -errno;
} }
devstr = xusb_devpath(astribank->xusb); 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", INFO("%s [%s]: Loading %s Firmware: %s (version %s)\n",
devstr, devstr,
xusb_serial(astribank->xusb), xusb_serial(xusb_device),
dev_dest2str(dest), dev_dest2str(dest),
hexdata->fname, hexdata->version_info); hexdata->fname, hexdata->version_info);
if((ret = mpp_send_start(astribank, dest, hexdata->version_info)) < 0) { if((ret = mpp_send_start(mpp, dest, hexdata->version_info)) < 0) {
ERR("%s: Failed hexfile send start: %d\n", devstr, ret); ERR("%s: Failed hexfile send start: %d\n", devstr, ret);
return ret; return ret;
} }
@ -142,7 +148,7 @@ static int load_hexfile(struct astribank_device *astribank, const char *hexfile,
finished = 1; finished = 1;
continue; continue;
} }
if((ret = handle_hexline(astribank, hexline)) < 0) { if((ret = handle_hexline(mpp, hexline)) < 0) {
ERR("%s: Failed hexfile sending in lineno %d (ret=%d)\n", devstr, i, ret);; ERR("%s: Failed hexfile sending in lineno %d (ret=%d)\n", devstr, i, ret);;
return ret; return ret;
} }
@ -151,7 +157,7 @@ static int load_hexfile(struct astribank_device *astribank, const char *hexfile,
putchar('\n'); putchar('\n');
fflush(stdout); fflush(stdout);
} }
if((ret = mpp_send_end(astribank)) < 0) { if((ret = mpp_send_end(mpp)) < 0) {
ERR("%s: Failed hexfile send end: %d\n", devstr, ret); ERR("%s: Failed hexfile send end: %d\n", devstr, ret);
return ret; return ret;
} }
@ -178,7 +184,6 @@ int main(int argc, char *argv[])
int opt_sum = 0; int opt_sum = 0;
enum dev_dest dest = DEST_NONE; enum dev_dest dest = DEST_NONE;
const char options[] = "vd:D:EFOopAS:"; const char options[] = "vd:D:EFOopAS:";
int iface_num;
int ret; int ret;
progname = argv[0]; progname = argv[0];
@ -247,7 +252,6 @@ int main(int argc, char *argv[])
" and -p options are mutually exclusive, if neither is used then -o should present\n"); " and -p options are mutually exclusive, if neither is used then -o should present\n");
usage(); usage();
} }
iface_num = (opt_dest) ? 1 : 0;
if(!opt_pic && !opt_ecver) { if(!opt_pic && !opt_ecver) {
if(optind != argc - 1) { if(optind != argc - 1) {
ERR("Got %d hexfile names (Need exactly one hexfile)\n", ERR("Got %d hexfile names (Need exactly one hexfile)\n",
@ -270,29 +274,43 @@ int main(int argc, char *argv[])
/* /*
* MPP Interface * MPP Interface
*/ */
struct astribank_device *astribank; struct astribank *astribank;
struct mpp_device *mpp;
if((astribank = mpp_init(devpath, iface_num)) == NULL) { astribank = astribank_new(devpath);
if(!astribank) {
ERR("%s: Opening astribank failed\n", devpath); ERR("%s: Opening astribank failed\n", devpath);
return 1; return 1;
} }
//show_astribank_info(astribank); mpp = astribank_mpp_open(astribank);
if(load_hexfile(astribank, argv[optind], dest) < 0) { 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)); ERR("%s: Loading firmware to %s failed\n", devpath, dev_dest2str(dest));
return 1; return 1;
} }
astribank_close(astribank, 0); astribank_destroy(astribank);
} else if(opt_pic || opt_echo || opt_ecver) { } else if(opt_pic || opt_echo || opt_ecver) {
/* /*
* XPP Interface * XPP Interface
*/ */
struct astribank_device *astribank; struct astribank *astribank;
struct xusb_iface *xpp_iface;
if((astribank = astribank_open(devpath, iface_num)) == NULL) { astribank = astribank_new(devpath);
if (!astribank) {
ERR("%s: Opening astribank failed\n", devpath); ERR("%s: Opening astribank failed\n", devpath);
return 1; return 1;
} }
//show_astribank_info(astribank); 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 HAVE_OCTASIC
if (opt_ecver) { if (opt_ecver) {
if((ret = echo_ver(astribank)) < 0) { if((ret = echo_ver(astribank)) < 0) {
@ -315,7 +333,7 @@ int main(int argc, char *argv[])
} }
#endif #endif
} }
astribank_close(astribank, 0); astribank_destroy(astribank);
} }
return 0; return 0;
} }

2
xpp/astribank_license.c
View File

@ -24,7 +24,7 @@
#include <stdio.h> #include <stdio.h>
#include <ctype.h> #include <ctype.h>
#include <string.h> #include <string.h>
#include <debug.h> #include <xtalk/debug.h>
#include "astribank_license.h" #include "astribank_license.h"
#define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0])) #define ARRAY_SIZE(a) (sizeof(a)/sizeof((a)[0]))

2
xpp/astribank_license.h
View File

@ -1,7 +1,7 @@
#ifndef ASTRIBANK_ALLOW_H #ifndef ASTRIBANK_ALLOW_H
#define ASTRIBANK_ALLOW_H #define ASTRIBANK_ALLOW_H
#include "mpp.h" #include "mpptalk.h"
enum license_markers { enum license_markers {
LICENSE_MARKER_NONE = 0, LICENSE_MARKER_NONE = 0,

119
xpp/astribank_tool.c
View File

@ -28,10 +28,10 @@
#include <getopt.h> #include <getopt.h>
#include <sys/types.h> #include <sys/types.h>
#include <arpa/inet.h> #include <arpa/inet.h>
#include "astribank_usb.h" #include <xtalk/debug.h>
#include <xtalk/xusb.h>
#include "mpptalk.h" #include "mpptalk.h"
#include <debug.h> #include "astribank.h"
#include <xusb.h>
#define DBG_MASK 0x80 #define DBG_MASK 0x80
/* if enabled, adds support for resetting pre-MPP USB firmware - if we /* if enabled, adds support for resetting pre-MPP USB firmware - if we
@ -76,90 +76,11 @@ static int reset_kind(const char *arg)
return -1; return -1;
} }
static int show_hardware(struct astribank_device *astribank)
{
int ret;
struct eeprom_table eeprom_table;
struct capabilities capabilities;
struct extrainfo extrainfo;
ret = mpp_caps_get(astribank, &eeprom_table, &capabilities, NULL);
if(ret < 0)
return ret;
show_eeprom(&eeprom_table, stdout);
show_astribank_status(astribank, stdout);
if(astribank->eeprom_type == EEPROM_TYPE_LARGE) {
show_capabilities(&capabilities, stdout);
if(STATUS_FPGA_LOADED(astribank->status)) {
uint8_t unit;
uint8_t card_status;
uint8_t card_type;
uint8_t fpga_configuration;
uint8_t status;
for(unit = 0; unit < 5; unit++) {
ret = mpps_card_info(astribank, unit, &card_type, &card_status);
if(ret < 0)
return ret;
printf("CARD %d: type=%x.%x %s\n", unit,
((card_type >> 4) & 0xF), (card_type & 0xF),
((card_status & 0x1) ? "PIC" : "NOPIC"));
}
ret = mpps_stat(astribank, unit, &fpga_configuration, &status);
if (ret < 0)
return ret;
printf("FPGA: %-17s: %d\n", "Configuration num", fpga_configuration);
printf("FPGA: %-17s: %s\n", "Watchdog Timer",
(SER_STAT_WATCHDOG_READY(status)) ? "ready" : "expired");
printf("FPGA: %-17s: %s\n", "XPD Alive",
(SER_STAT_XPD_ALIVE(status)) ? "yes" : "no");
}
ret = mpp_extrainfo_get(astribank, &extrainfo);
if(ret < 0)
return ret;
show_extrainfo(&extrainfo, stdout);
if(CAP_EXTRA_TWINSTAR(&capabilities)) {
twinstar_show(astribank, stdout);
}
}
return 0;
}
#ifdef SUPPORT_OLD_RESET
/* Try to reset a device using USB_FW.hex, up to Xorcom rev. 6885 */
int old_reset(const char* devpath)
{
struct astribank_device *astribank;
int ret;
struct {
uint8_t op;
} PACKED header = {0x20}; /* PT_RESET */
char *buf = (char*) &header;
/* Note that the function re-opens the connection to the Astribank
* as any reference to the previous connection was lost when mpp_open
* returned NULL as the astribank reference. */
astribank = astribank_open(devpath, 1);
if (!astribank) {
DBG("Failed re-opening astribank device for old_reset\n");
return -ENODEV;
}
ret = xusb_send(astribank->xusb, buf, 1, 5000);
/* If we just had a reenumeration, we may get -ENODEV */
if(ret < 0 && ret != -ENODEV)
return ret;
/* We don't astribank_close(), as it has likely been
* reenumerated by now. */
return 0;
}
#endif /* SUPPORT_OLD_RESET */
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
char *devpath = NULL; char *devpath = NULL;
struct astribank_device *astribank; struct astribank *astribank;
struct mpp_device *mpp;
const char options[] = "vd:D:nr:p:w:Q"; const char options[] = "vd:D:nr:p:w:Q";
int opt_renumerate = 0; int opt_renumerate = 0;
char *opt_port = NULL; char *opt_port = NULL;
@ -218,20 +139,12 @@ int main(int argc, char *argv[])
usage(); usage();
} }
DBG("Startup %s\n", devpath); DBG("Startup %s\n", devpath);
if((astribank = mpp_init(devpath, 1)) == NULL) { astribank = astribank_new(devpath);
ERR("Failed initializing MPP\n"); if(!astribank) {
#ifdef SUPPORT_OLD_RESET ERR("Failed initializing Astribank\n");
DBG("opt_reset = %s\n", opt_reset);
if (opt_reset) {
DBG("Trying old reset method\n");
if ((ret = old_reset(devpath)) != 0) {
ERR("Old reset method failed as well: %d\n", ret);
}
}
#endif /* SUPPORT_OLD_RESET */
return 1; return 1;
} }
mpp = astribank_mpp_open(astribank);
/* /*
* First process reset options. We want to be able * First process reset options. We want to be able
* to reset minimal USB firmwares even if they don't * to reset minimal USB firmwares even if they don't
@ -245,7 +158,7 @@ int main(int argc, char *argv[])
return 1; return 1;
} }
DBG("Reseting (%s)\n", opt_reset); DBG("Reseting (%s)\n", opt_reset);
if((ret = mpp_reset(astribank, full_reset)) < 0) { if((ret = mpp_reset(mpp, full_reset)) < 0) {
ERR("%s Reseting astribank failed: %d\n", ERR("%s Reseting astribank failed: %d\n",
(full_reset) ? "Full" : "Half", ret); (full_reset) ? "Full" : "Half", ret);
} }
@ -253,10 +166,10 @@ int main(int argc, char *argv[])
} }
show_astribank_info(astribank); show_astribank_info(astribank);
if(opt_query) { if(opt_query) {
show_hardware(astribank); show_hardware(mpp);
} else if(opt_renumerate) { } else if(opt_renumerate) {
DBG("Renumerate\n"); DBG("Renumerate\n");
if((ret = mpp_renumerate(astribank)) < 0) { if((ret = mpp_renumerate(mpp)) < 0) {
ERR("Renumerating astribank failed: %d\n", ret); ERR("Renumerating astribank failed: %d\n", ret);
} }
} else if(opt_watchdog) { } else if(opt_watchdog) {
@ -264,24 +177,24 @@ int main(int argc, char *argv[])
DBG("TWINSTAR: Setting watchdog %s-guard\n", DBG("TWINSTAR: Setting watchdog %s-guard\n",
(watchdogstate) ? "on" : "off"); (watchdogstate) ? "on" : "off");
if((ret = mpp_tws_setwatchdog(astribank, watchdogstate)) < 0) { if((ret = mpp_tws_setwatchdog(mpp, watchdogstate)) < 0) {
ERR("Failed to set watchdog to %d\n", watchdogstate); ERR("Failed to set watchdog to %d\n", watchdogstate);
return 1; return 1;
} }
} else if(opt_port) { } else if(opt_port) {
int new_portnum = strtoul(opt_port, NULL, 0); int new_portnum = strtoul(opt_port, NULL, 0);
int tws_portnum = mpp_tws_portnum(astribank); int tws_portnum = mpp_tws_portnum(mpp);
char *msg = (new_portnum == tws_portnum) char *msg = (new_portnum == tws_portnum)
? " Same same, never mind..." ? " Same same, never mind..."
: ""; : "";
DBG("TWINSTAR: Setting portnum to %d.%s\n", new_portnum, msg); DBG("TWINSTAR: Setting portnum to %d.%s\n", new_portnum, msg);
if((ret = mpp_tws_setportnum(astribank, new_portnum)) < 0) { if((ret = mpp_tws_setportnum(mpp, new_portnum)) < 0) {
ERR("Failed to set USB portnum to %d\n", new_portnum); ERR("Failed to set USB portnum to %d\n", new_portnum);
return 1; return 1;
} }
} }
out: out:
mpp_exit(astribank); astribank_destroy(astribank);
return 0; return 0;
} }

276
xpp/astribank_usb.c
View File

@ -1,276 +0,0 @@
/*
* 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.
*
*/
#define _GNU_SOURCE /* for memrchr() */
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <syslog.h>
#include <arpa/inet.h>
#include <xusb.h>
#include "astribank_usb.h"
#include <debug.h>
static const char rcsid[] = "$Id$";
#define DBG_MASK 0x01
#define TIMEOUT 500
#define TYPE_ENTRY(t,p,ni,n,ne,out,in,...) \
{ \
.my_vendor_id = 0xe4e4, \
.my_product_id = (p), \
.name = #t, \
.num_interfaces = (ni), \
.my_interface_num = (n), \
.num_endpoints = (ne), \
.my_ep_in = (in), \
.my_ep_out = (out), \
}
#define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
static const struct xusb_spec astribank_specs[] = {
/* OLD Firmwares */
TYPE_ENTRY("USB-OLDFXS", 0x1131, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("FPGA-OLDFXS", 0x1132, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("USB-BRI", 0x1141, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("FPGA-BRI", 0x1142, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("USB-OLD", 0x1151, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("FPGA-OLD", 0x1152, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("USB-MULTI", 0x1161, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("FPGA-MULTI", 0x1162, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("BURNED-MULTI", 0x1164, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
TYPE_ENTRY("USB-BURN", 0x1112, 2, 1, 2, MP_EP_OUT, MP_EP_IN),
};
static const struct xusb_spec astribank_pic_specs[] = {
TYPE_ENTRY("USB_PIC", 0x1161, 2, 0, 2, XPP_EP_OUT, XPP_EP_IN),
};
#undef TYPE_ENTRY
//static int verbose = LOG_DEBUG;
/*
* USB handling
*/
struct astribank_device *astribank_open(const char devpath[], int iface_num)
{
struct astribank_device *astribank = NULL;
struct xusb *xusb;
DBG("devpath='%s' iface_num=%d\n", devpath, iface_num);
if((astribank = malloc(sizeof(struct astribank_device))) == NULL) {
ERR("Out of memory\n");
goto fail;
}
memset(astribank, 0, sizeof(*astribank));
if (iface_num) {
xusb = xusb_find_bypath(astribank_specs, ARRAY_SIZE(astribank_specs), devpath);
} else {
xusb = xusb_find_bypath(astribank_pic_specs, ARRAY_SIZE(astribank_pic_specs), devpath);
}
if (!xusb) {
ERR("%s: No device found\n", __func__);
goto fail;
}
astribank->xusb = xusb;
astribank->is_usb2 = (xusb_packet_size(xusb) == 512);
astribank->my_interface_num = iface_num;
if (xusb_claim_interface(astribank->xusb) < 0) {
ERR("xusb_claim_interface failed\n");
goto fail;
}
astribank->tx_sequenceno = 1;
return astribank;
fail:
if (astribank) {
free(astribank);
astribank = NULL;
}
return NULL;
}
/*
* MP device handling
*/
void show_astribank_info(const struct astribank_device *astribank)
{
struct xusb *xusb;
assert(astribank != NULL);
xusb = astribank->xusb;
assert(xusb != NULL);
if(verbose <= LOG_INFO) {
xusb_showinfo(xusb);
} else {
const struct xusb_spec *spec;
spec = xusb_spec(xusb);
printf("USB Bus/Device: [%s]\n", xusb_devpath(xusb));
printf("USB Firmware Type: [%s]\n", spec->name);
printf("USB iSerialNumber: [%s]\n", xusb_serial(xusb));
printf("USB iManufacturer: [%s]\n", xusb_manufacturer(xusb));
printf("USB iProduct: [%s]\n", xusb_product(xusb));
}
}
void astribank_close(struct astribank_device *astribank, int disconnected)
{
assert(astribank != NULL);
if (astribank->xusb) {
xusb_close(astribank->xusb);
astribank->xusb = NULL;
}
astribank->tx_sequenceno = 0;
}
#if 0
int flush_read(struct astribank_device *astribank)
{
char tmpbuf[BUFSIZ];
int ret;
DBG("starting...\n");
memset(tmpbuf, 0, BUFSIZ);
ret = recv_usb(astribank, tmpbuf, BUFSIZ, 1);
if(ret < 0 && ret != -ETIMEDOUT) {
ERR("ret=%d\n", ret);
return ret;
} else if(ret > 0) {
DBG("Got %d bytes:\n", ret);
dump_packet(LOG_DEBUG, DBG_MASK, __FUNCTION__, tmpbuf, ret);
}
return 0;
}
#endif
int release_isvalid(uint16_t release)
{
uint8_t rmajor = (release >> 8) & 0xFF;
uint8_t rminor = release & 0xFF;
return (rmajor > 0) &&
(rmajor < 10) &&
(rminor > 0) &&
(rminor < 10);
}
int label_isvalid(const char *label)
{
int len;
int goodlen;
const char GOOD_CHARS[] =
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789"
"-_.";
len = strlen(label);
goodlen = strspn(label, GOOD_CHARS);
if(len > LABEL_SIZE) {
ERR("Label too long (%d > %d)\n", len, LABEL_SIZE);
return 0;
}
if(goodlen != len) {
ERR("Bad character in label (pos=%d)\n", goodlen);
return 0;
}
return 1;
}
int eeprom_fill(struct eeprom_table *eprm,
const char *vendor,
const char *product,
const char *release,
const char *label)
{
uint16_t val;
eprm->source = 0xC0;
eprm->config_byte = 0;
if(vendor) {
val = strtoul(vendor, NULL, 0);
if(!val) {
ERR("Invalid vendor '%s'\n",
vendor);
return -EINVAL;
}
eprm->vendor = val;
}
if(product) {
val = strtoul(product, NULL, 0);
if(!val) {
ERR("Invalid product '%s'\n",
product);
return -EINVAL;
}
eprm->product = val;
}
if(release) {
int release_major = 0;
int release_minor = 0;
uint16_t value;
if(sscanf(release, "%d.%d", &release_major, &release_minor) != 2) {
ERR("Failed to parse release number '%s'\n", release);
return -EINVAL;
}
value = (release_major << 8) | release_minor;
DBG("Parsed release(%d): major=%d, minor=%d\n",
value, release_major, release_minor);
if(!release_isvalid(value)) {
ERR("Invalid release number 0x%X\n", value);
return -EINVAL;
}
eprm->release = value;
}
if(label) {
/* padding */
if(!label_isvalid(label)) {
ERR("Invalid label '%s'\n", label);
return -EINVAL;
}
memset(eprm->label, 0, LABEL_SIZE);
memcpy(eprm->label, label, strlen(label));
}
return 0;
}
int astribank_has_twinstar(struct astribank_device *astribank)
{
uint16_t product_series;
assert(astribank != NULL);
product_series = xusb_product_id(astribank->xusb);
product_series &= 0xFFF0;
if(product_series == 0x1160) /* New boards */
return 1;
return 0;
}

113
xpp/astribank_usb.h
View File

@ -1,113 +0,0 @@
#ifndef ASTRIBANK_USB_H
#define ASTRIBANK_USB_H
/*
* 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 <stdio.h>
#include <xusb.h>
#include <xtalk.h>
#include "mpp.h"
/*
* Astribank handling
*/
#define PACKET_SIZE 512
/* USB Endpoints */
#define MP_EP_OUT 0x04 /* Managment processor */
#define MP_EP_IN 0x88 /* Managment processor */
#define XPP_EP_OUT 0x02 /* XPP */
#define XPP_EP_IN 0x86 /* XPP */
/* USB firmware types */
#define USB_11xx 0
#define USB_FIRMWARE_II 1
#define USB_PIC 2
struct interface_type {
int type_code;
int num_interfaces;
int my_interface_num;
int num_endpoints;
int my_ep_out;
int my_ep_in;
char *name;
int endpoints[4]; /* for matching */
};
enum eeprom_burn_state {
BURN_STATE_NONE = 0,
BURN_STATE_STARTED = 1,
BURN_STATE_ENDED = 2,
BURN_STATE_FAILED = 3,
};
struct astribank_device {
struct xusb *xusb;
struct xtalk_device *xtalk_dev;
usb_dev_handle *handle;
int my_interface_num;
int my_ep_out;
int my_ep_in;
char iInterface[BUFSIZ];
int is_usb2;
enum eeprom_type eeprom_type;
enum eeprom_burn_state burn_state;
uint8_t status;
uint8_t mpp_proto_version;
struct eeprom_table *eeprom;
struct firmware_versions fw_versions;
uint16_t tx_sequenceno;
};
/*
* Prototypes
*/
struct astribank_device *astribank_open(const char devpath[], int iface_num);
void astribank_close(struct astribank_device *astribank, int disconnected);
void show_astribank_info(const struct astribank_device *astribank);
int send_usb(struct astribank_device *astribank, char *buf, int len, int timeout);
int recv_usb(struct astribank_device *astribank, char *buf, size_t len, int timeout);
int flush_read(struct astribank_device *astribank);
int eeprom_fill(struct eeprom_table *eprm,
const char *vendor,
const char *product,
const char *release,
const char *label);
int astribank_has_twinstar(struct astribank_device *astribank);
int label_isvalid(const char *label);
#define AB_REPORT(report_type, astribank, fmt, ...) \
report_type("%s [%s]: " fmt, \
xusb_devpath((astribank)->xusb), \
xusb_serial((astribank)->xusb), \
## __VA_ARGS__)
#define AB_INFO(astribank, fmt, ...) \
AB_REPORT(INFO, astribank, fmt, ## __VA_ARGS__)
#define AB_ERR(astribank, fmt, ...) \
AB_REPORT(ERR, astribank, fmt, ## __VA_ARGS__)
#endif /* ASTRIBANK_USB_H */

59
xpp/echo_loader.c
View File

@ -28,12 +28,21 @@
#include <limits.h> #include <limits.h>
#include <regex.h> #include <regex.h>
#include <sys/time.h> #include <sys/time.h>
#include "echo_loader.h" #include <unistd.h>
#include "debug.h"
#include <oct6100api/oct6100_api.h> #include <oct6100api/oct6100_api.h>
#include <xtalk/debug.h>
#include <xtalk/xusb.h>
#include <astribank.h>
#include "echo_loader.h"
#include "parse_span_specs.h" #include "parse_span_specs.h"
#define DBG_MASK 0x03 #ifdef __GNUC__
#define PACKED __attribute__((packed))
#else
#define PACKED
#endif
#define DBG_MASK 0x10
#define TIMEOUT 1000 #define TIMEOUT 1000
#define ECHO_MAX_CHANS 128 #define ECHO_MAX_CHANS 128
#define ECHO_RIN_STREAM 0 #define ECHO_RIN_STREAM 0
@ -53,7 +62,7 @@ static float oct_fw_load_timeout = 2.0;
struct echo_mod { struct echo_mod {
tPOCT6100_INSTANCE_API pApiInstance; tPOCT6100_INSTANCE_API pApiInstance;
UINT32 ulEchoChanHndl[256]; UINT32 ulEchoChanHndl[256];
struct astribank_device *astribank; struct astribank *astribank;
int maxchans; int maxchans;
}; };
@ -100,9 +109,9 @@ static struct usb_buffer {
} usb_buffer; } usb_buffer;
static void usb_buffer_init(struct astribank_device *astribank, struct usb_buffer *ub) static void usb_buffer_init(struct astribank *astribank, struct usb_buffer *ub)
{ {
ub->max_len = xusb_packet_size(astribank->xusb); ub->max_len = xusb_packet_size(xusb_dev_of_astribank(astribank));
ub->curr = 0; ub->curr = 0;
ub->min_send = INT_MAX; ub->min_send = INT_MAX;
ub->max_send = 0; ub->max_send = 0;
@ -120,7 +129,7 @@ static long usb_buffer_usec(struct usb_buffer *ub)
(now.tv_usec - ub->start.tv_usec); (now.tv_usec - ub->start.tv_usec);
} }
static void usb_buffer_showstatistics(struct astribank_device *astribank, struct usb_buffer *ub) static void usb_buffer_showstatistics(struct astribank *astribank, struct usb_buffer *ub)
{ {
long usec; long usec;
@ -133,7 +142,7 @@ static void usb_buffer_showstatistics(struct astribank_device *astribank, struct
usec / 1000, usec / ub->num_sends); usec / 1000, usec / ub->num_sends);
} }
static int usb_buffer_flush(struct astribank_device *astribank, struct usb_buffer *ub) static int usb_buffer_flush(struct astribank *astribank, struct usb_buffer *ub)
{ {
int ret; int ret;
long t; long t;
@ -142,7 +151,7 @@ static int usb_buffer_flush(struct astribank_device *astribank, struct usb_buffe
if (ub->curr == 0) if (ub->curr == 0)
return 0; return 0;
ret = xusb_send(astribank->xusb, ub->data, ub->curr, TIMEOUT); ret = astribank_send(astribank, 0, ub->data, ub->curr, TIMEOUT);
if (ret < 0) { if (ret < 0) {
AB_ERR(astribank, "xusb_send failed: %d\n", ret); AB_ERR(astribank, "xusb_send failed: %d\n", ret);
return ret; return ret;
@ -175,7 +184,7 @@ static int usb_buffer_flush(struct astribank_device *astribank, struct usb_buffe
return ret; return ret;
} }
static int usb_buffer_append(struct astribank_device *astribank, struct usb_buffer *ub, static int usb_buffer_append(struct astribank *astribank, struct usb_buffer *ub,
char *buf, int len) char *buf, int len)
{ {
if (ub->curr + len >= ub->max_len) { if (ub->curr + len >= ub->max_len) {
@ -188,7 +197,7 @@ static int usb_buffer_append(struct astribank_device *astribank, struct usb_buff
return len; return len;
} }
static int usb_buffer_send(struct astribank_device *astribank, struct usb_buffer *ub, static int usb_buffer_send(struct astribank *astribank, struct usb_buffer *ub,
char *buf, int len, int timeout, int recv_answer) char *buf, int len, int timeout, int recv_answer)
{ {
int ret = 0; int ret = 0;
@ -209,7 +218,7 @@ static int usb_buffer_send(struct astribank_device *astribank, struct usb_buffer
ret = usb_buffer_flush(astribank, ub); ret = usb_buffer_flush(astribank, ub);
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = xusb_recv(astribank->xusb, buf, PACKET_SIZE, TIMEOUT); ret = astribank_recv(astribank, 0, buf, PACKET_SIZE, TIMEOUT);
if (ret <= 0) { if (ret <= 0) {
AB_ERR(astribank, "No USB packs to read: %s\n", strerror(-ret)); AB_ERR(astribank, "No USB packs to read: %s\n", strerror(-ret));
return -EINVAL; return -EINVAL;
@ -239,7 +248,7 @@ static int usb_buffer_send(struct astribank_device *astribank, struct usb_buffer
return ret; return ret;
} }
int spi_send(struct astribank_device *astribank, uint16_t addr, uint16_t data, int recv_answer, int ver) int spi_send(struct astribank *astribank, uint16_t addr, uint16_t data, int recv_answer, int ver)
{ {
int ret; int ret;
char buf[PACKET_SIZE]; char buf[PACKET_SIZE];
@ -272,7 +281,7 @@ int spi_send(struct astribank_device *astribank, uint16_t addr, uint16_t data, i
return ret; return ret;
} }
int test_send(struct astribank_device *astribank) int test_send(struct astribank *astribank)
{ {
int ret; int ret;
char buf[PACKET_SIZE]; char buf[PACKET_SIZE];
@ -300,7 +309,7 @@ int test_send(struct astribank_device *astribank)
return ret; return ret;
} }
int echo_send_data(struct astribank_device *astribank, const unsigned int addr, const unsigned int data) int echo_send_data(struct astribank *astribank, const unsigned int addr, const unsigned int data)
{ {
int ret; int ret;
/* DBG("SEND: %04X -> [%04X]\n", data, addr); /* DBG("SEND: %04X -> [%04X]\n", data, addr);
@ -330,7 +339,7 @@ failed:
return ret; return ret;
} }
int echo_recv_data(struct astribank_device *astribank, const unsigned int addr) int echo_recv_data(struct astribank *astribank, const unsigned int addr)
{ {
unsigned int data = 0x00; unsigned int data = 0x00;
int ret; int ret;
@ -452,7 +461,7 @@ UINT32 Oct6100UserDriverWriteApi(tPOCT6100_WRITE_PARAMS f_pWriteParams)
const unsigned int addr = f_pWriteParams->ulWriteAddress; const unsigned int addr = f_pWriteParams->ulWriteAddress;
const unsigned int data = f_pWriteParams->usWriteData; const unsigned int data = f_pWriteParams->usWriteData;
const struct echo_mod *echo_mod = (struct echo_mod *)(f_pWriteParams->pProcessContext); const struct echo_mod *echo_mod = (struct echo_mod *)(f_pWriteParams->pProcessContext);
struct astribank_device *astribank = echo_mod->astribank; struct astribank *astribank = echo_mod->astribank;
int ret; int ret;
ret = echo_send_data(astribank, addr, data); ret = echo_send_data(astribank, addr, data);
@ -469,7 +478,7 @@ UINT32 Oct6100UserDriverWriteSmearApi(tPOCT6100_WRITE_SMEAR_PARAMS f_pSmearParam
unsigned int data; unsigned int data;
unsigned int len; unsigned int len;
const struct echo_mod *echo_mod; const struct echo_mod *echo_mod;
struct astribank_device *astribank; struct astribank *astribank;
unsigned int i; unsigned int i;
len = f_pSmearParams->ulWriteLength; len = f_pSmearParams->ulWriteLength;
@ -495,7 +504,7 @@ UINT32 Oct6100UserDriverWriteBurstApi(tPOCT6100_WRITE_BURST_PARAMS f_pBurstParam
unsigned int data; unsigned int data;
unsigned int len = f_pBurstParams->ulWriteLength; unsigned int len = f_pBurstParams->ulWriteLength;
const struct echo_mod *echo_mod = (struct echo_mod *)f_pBurstParams->pProcessContext; const struct echo_mod *echo_mod = (struct echo_mod *)f_pBurstParams->pProcessContext;
struct astribank_device *astribank = echo_mod->astribank; struct astribank *astribank = echo_mod->astribank;
unsigned int i; unsigned int i;
for (i = 0; i < len; i++) { for (i = 0; i < len; i++) {
@ -516,7 +525,7 @@ UINT32 Oct6100UserDriverReadApi(tPOCT6100_READ_PARAMS f_pReadParams)
{ {
const unsigned int addr = f_pReadParams->ulReadAddress; const unsigned int addr = f_pReadParams->ulReadAddress;
const struct echo_mod *echo_mod; const struct echo_mod *echo_mod;
struct astribank_device *astribank; struct astribank *astribank;
int ret; int ret;
echo_mod = (struct echo_mod *)f_pReadParams->pProcessContext; echo_mod = (struct echo_mod *)f_pReadParams->pProcessContext;
@ -535,7 +544,7 @@ UINT32 Oct6100UserDriverReadBurstApi(tPOCT6100_READ_BURST_PARAMS f_pBurstParams)
unsigned int addr; unsigned int addr;
unsigned int len; unsigned int len;
const struct echo_mod *echo_mod; const struct echo_mod *echo_mod;
struct astribank_device *astribank; struct astribank *astribank;
unsigned int i; unsigned int i;
len = f_pBurstParams->ulReadLength; len = f_pBurstParams->ulReadLength;
@ -555,13 +564,13 @@ UINT32 Oct6100UserDriverReadBurstApi(tPOCT6100_READ_BURST_PARAMS f_pBurstParams)
return cOCT6100_ERR_OK; return cOCT6100_ERR_OK;
} }
inline int get_ver(struct astribank_device *astribank) inline int get_ver(struct astribank *astribank)
{ {
return spi_send(astribank, 0, 0, 1, 1); return spi_send(astribank, 0, 0, 1, 1);
} }
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
UINT32 init_octasic(char *filename, struct astribank_device *astribank, struct span_specs *span_specs) UINT32 init_octasic(char *filename, struct astribank *astribank, struct span_specs *span_specs)
{ {
int cpld_ver; int cpld_ver;
struct echo_mod *echo_mod; struct echo_mod *echo_mod;
@ -838,7 +847,7 @@ UINT32 init_octasic(char *filename, struct astribank_device *astribank, struct s
} }
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int load_echo(struct astribank_device *astribank, char *filename, int default_is_alaw, const char *span_spec) int load_echo(struct astribank *astribank, char *filename, int default_is_alaw, const char *span_spec)
{ {
int ret; int ret;
UINT32 octasic_status; UINT32 octasic_status;
@ -868,7 +877,7 @@ int load_echo(struct astribank_device *astribank, char *filename, int default_is
return 0; return 0;
} }
int echo_ver(struct astribank_device *astribank) int echo_ver(struct astribank *astribank)
{ {
usb_buffer_init(astribank, &usb_buffer); usb_buffer_init(astribank, &usb_buffer);
return get_ver(astribank); return get_ver(astribank);

8
xpp/echo_loader.h
View File

@ -23,10 +23,10 @@
*/ */
#include <stdint.h> #include <stdint.h>
#include "astribank_usb.h" #include "astribank.h"
int spi_send(struct astribank_device *astribank, uint16_t addr, uint16_t data, int recv_answer, int ver); int spi_send(struct astribank *astribank, uint16_t addr, uint16_t data, int recv_answer, int ver);
int load_echo(struct astribank_device *astribank, char *filename, int is_alaw, const char *span_spec); int load_echo(struct astribank *astribank, char *filename, int is_alaw, const char *span_spec);
int echo_ver(struct astribank_device *astribank); int echo_ver(struct astribank *astribank);
#endif /* ECHO_LOADER_H */ #endif /* ECHO_LOADER_H */

202
xpp/mpp.h
View File

@ -1,202 +0,0 @@
#ifndef MPP_H
#define MPP_H
/*
* 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.
*
*/
/*
* MPP - Managment Processor Protocol definitions
*/
#include <mpptalk_defs.h>
#include <stdint.h>
#include <xtalk.h>
#ifdef __GNUC__
#define PACKED __attribute__((packed))
#else
#error "We do not know how your compiler packs structures"
#endif
#define MK_PROTO_VERSION(major, minor) (((major) << 4) | (0x0F & (minor)))
#define MPP_PROTOCOL_VERSION MK_PROTO_VERSION(1,4)
#define MPP_SUPPORTED_VERSION(x) ((x) == MK_PROTO_VERSION(1,3) || (x) == MK_PROTO_VERSION(1,4))
/*
* The eeprom_table is common to all eeprom types.
*/
#define LABEL_SIZE 8
struct eeprom_table {
uint8_t source; /* C0 - small eeprom, C2 - large eeprom */
uint16_t vendor;
uint16_t product;
uint16_t release; /* BCD encoded release */
uint8_t config_byte; /* Must be 0 */
uint8_t label[LABEL_SIZE];
} PACKED;
#define VERSION_LEN 6
struct firmware_versions {
char usb[VERSION_LEN];
char fpga[VERSION_LEN];
char eeprom[VERSION_LEN];
} PACKED;
struct capabilities {
uint8_t ports_fxs;
uint8_t ports_fxo;
uint8_t ports_bri;
uint8_t ports_pri;
uint8_t extra_features; /* BIT(0) - TwinStar */
uint8_t ports_echo;
uint8_t reserved[2];
uint32_t timestamp;
} PACKED;
#define CAP_EXTRA_TWINSTAR(c) ((c)->extra_features & 0x01)
#define CAP_EXTRA_TWINSTAR_SET(c) do {(c)->extra_features |= 0x01;} while (0)
#define CAP_EXTRA_TWINSTAR_CLR(c) do {(c)->extra_features &= ~0x01;} while (0)
#define KEYSIZE 16
struct capkey {
uint8_t k[KEYSIZE];
} PACKED;
struct extrainfo {
char text[EXTRAINFO_SIZE];
} PACKED;
struct mpp_header {
uint16_t len;
uint16_t seq;
uint8_t op; /* MSB: 0 - to device, 1 - from device */
} PACKED;
enum mpp_ser_op {
SER_CARD_INFO_GET = 0x1,
SER_STAT_GET = 0x3,
/* Status bits */
#define SER_STAT_WATCHDOG_READY(s) ((s) & 0x01)
#define SER_STAT_XPD_ALIVE(s) ((s) & 0x02)
};
/* Individual commands structure */
CMD_DEF(MPP, STATUS_GET);
CMD_DEF(MPP, STATUS_GET_REPLY,
uint8_t i2cs_data;
#define STATUS_FPGA_LOADED(x) ((x) & 0x01)
uint8_t status; /* BIT(0) - FPGA is loaded */
struct firmware_versions fw_versions;
);
CMD_DEF(MPP, EEPROM_SET,
struct eeprom_table data;
);
CMD_DEF(MPP, CAPS_GET);
CMD_DEF(MPP, CAPS_GET_REPLY,
struct eeprom_table data;
struct capabilities capabilities;
struct capkey key;
);
CMD_DEF(MPP, CAPS_SET,
struct eeprom_table data;
struct capabilities capabilities;
struct capkey key;
);
CMD_DEF(MPP, EXTRAINFO_GET);
CMD_DEF(MPP, EXTRAINFO_GET_REPLY,
struct extrainfo info;
);
CMD_DEF(MPP, EXTRAINFO_SET,
struct extrainfo info;
);
CMD_DEF(MPP, RENUM);
CMD_DEF(MPP, EEPROM_BLK_RD,
uint16_t offset;
uint16_t len;
);
CMD_DEF(MPP, EEPROM_BLK_RD_REPLY,
uint16_t offset;
uint8_t data[0];
);
CMD_DEF(MPP, DEV_SEND_START,
uint8_t dest;
char ihex_version[VERSION_LEN];
);
CMD_DEF(MPP, DEV_SEND_END);
CMD_DEF(MPP, DEV_SEND_SEG,
uint16_t offset;
uint8_t data[0];
);
CMD_DEF(MPP, RESET);
CMD_DEF(MPP, HALF_RESET);
CMD_DEF(MPP, SER_SEND,
uint8_t data[0];
);
CMD_DEF(MPP, SER_RECV,
uint8_t data[0];
);
CMD_DEF(MPP, TWS_WD_MODE_SET,
uint8_t wd_active;
);
CMD_DEF(MPP, TWS_WD_MODE_GET);
CMD_DEF(MPP, TWS_WD_MODE_GET_REPLY,
uint8_t wd_active;
);
CMD_DEF(MPP, TWS_PORT_SET,
uint8_t portnum;
);
CMD_DEF(MPP, TWS_PORT_GET);
CMD_DEF(MPP, TWS_PORT_GET_REPLY,
uint8_t portnum;
);
CMD_DEF(MPP, TWS_PWR_GET);
CMD_DEF(MPP, TWS_PWR_GET_REPLY,
uint8_t power;
);
#endif /* MPP_H */

771
xpp/mpptalk.c
View File

File diff suppressed because it is too large Load Diff

194
xpp/mpptalk.h
View File

@ -1,5 +1,5 @@
#ifndef MPP_FUNCS_H #ifndef MPPTALK_H
#define MPP_FUNCS_H #define MPPTALK_H
/* /*
* Written by Oron Peled <oron@actcom.co.il> * Written by Oron Peled <oron@actcom.co.il>
* Copyright (C) 2008, Xorcom * Copyright (C) 2008, Xorcom
@ -22,64 +22,152 @@
* *
*/ */
#include <stdint.h> #ifdef __cplusplus
#include <stdio.h> extern "C"
{
#include "mpp.h" #endif /* __cplusplus */
#include "astribank_usb.h"
struct astribank_device;
struct eeprom_table;
struct extrainfo;
struct capabilities;
struct capkey;
#define TIMEOUT 6000
/* high-level */
struct astribank_device *mpp_init(const char devpath[], int iface_num);
void mpp_exit(struct astribank_device *astribank);
int mpp_proto_query(struct astribank_device *astribank);
int mpp_status_query(struct astribank_device *astribank);
int mpp_eeprom_set(struct astribank_device *astribank, const struct eeprom_table *et);
int mpp_renumerate(struct astribank_device *astribank);
int mpp_caps_get(struct astribank_device *astribank,
struct eeprom_table *et,
struct capabilities *cap,
struct capkey *key);
int mpp_caps_set(struct astribank_device *astribank,
const struct eeprom_table *eeprom_table,
const struct capabilities *capabilities,
const struct capkey *key);
int mpp_extrainfo_get(struct astribank_device *astribank, struct extrainfo *info);
int mpp_extrainfo_set(struct astribank_device *astribank, const struct extrainfo *info);
int mpp_eeprom_blk_rd(struct astribank_device *astribank, uint8_t *buf, uint16_t offset, uint16_t len);
int mpp_send_start(struct astribank_device *astribank, int dest, const char *ihex_version);
int mpp_send_end(struct astribank_device *astribank);
int mpp_send_seg(struct astribank_device *astribank, const uint8_t *data, uint16_t offset, uint16_t len);
int mpp_reset(struct astribank_device *astribank, int full_reset);
int mpp_serial_cmd(struct astribank_device *astribank, const uint8_t *in, uint8_t *out, uint16_t len);
void show_eeprom(const struct eeprom_table *eprm, FILE *fp);
void show_capabilities(const struct capabilities *capabilities, FILE *fp);
void show_astribank_status(struct astribank_device *astribank, FILE *fp);
void show_extrainfo(const struct extrainfo *extrainfo, FILE *fp);
int twinstar_show(struct astribank_device *astribank, FILE *fp);
/* /*
* Serial commands to FPGA * MPPTALK - Example XTALK dialect
*/ */
int mpps_card_info(struct astribank_device *astribank, int unit, uint8_t *card_type, uint8_t *card_status);
int mpps_stat(struct astribank_device *astribank, int unit, uint8_t *maincard_version, uint8_t *status); #include <xtalk/proto.h>
#include <xtalk/proto_sync.h>
#ifdef __GNUC__
#define PACKED __attribute__((packed))
#else
#define PACKED
#endif
/*---------------- Common types --------------------*/
/*
* The eeprom_table is common to all eeprom types.
*/
#define LABEL_SIZE 8
struct eeprom_table {
uint8_t source; /* C0 - small eeprom, C2 - large eeprom */
uint16_t vendor;
uint16_t product;
uint16_t release; /* BCD encoded release */
uint8_t config_byte; /* Must be 0 */
uint8_t label[LABEL_SIZE];
} PACKED;
#define VERSION_LEN 6
struct firmware_versions {
char usb[VERSION_LEN];
char fpga[VERSION_LEN];
char eeprom[VERSION_LEN];
} PACKED;
struct capabilities {
uint8_t ports_fxs;
uint8_t ports_fxo;
uint8_t ports_bri;
uint8_t ports_pri;
uint8_t extra_features; /* BIT(0) - TwinStar */
uint8_t ports_echo;
uint8_t reserved[2];
uint32_t timestamp;
} PACKED;
#define CAP_EXTRA_TWINSTAR(c) ((c)->extra_features & 0x01)
#define CAP_EXTRA_TWINSTAR_SET(c) do {(c)->extra_features |= 0x01;} while (0)
#define CAP_EXTRA_TWINSTAR_CLR(c) do {(c)->extra_features &= ~0x01;} while (0)
#define KEYSIZE 16
struct capkey {
uint8_t k[KEYSIZE];
} PACKED;
#define EXTRAINFO_SIZE 24
struct extrainfo {
char text[EXTRAINFO_SIZE];
} PACKED;
struct mpp_header {
uint16_t len;
uint16_t seq;
uint8_t op; /* MSB: 0 - to device, 1 - from device */
} PACKED;
enum mpp_ser_op {
SER_CARD_INFO_GET = 0x1,
SER_STAT_GET = 0x3,
/* Status bits */
#define SER_STAT_WATCHDOG_READY(s) ((s) & 0x01)
#define SER_STAT_XPD_ALIVE(s) ((s) & 0x02)
};
/* EEPROM_QUERY: i2cs(ID1, ID0) */
enum eeprom_type {
EEPROM_TYPE_NONE = 0,
EEPROM_TYPE_SMALL = 1,
EEPROM_TYPE_LARGE = 2,
EEPROM_TYPE_UNUSED = 3,
};
enum dev_dest {
DEST_NONE = 0x00,
DEST_FPGA = 0x01,
DEST_EEPROM = 0x02,
};
/*---------------- PROTOCOL ------------------------*/
/* API */
struct mpp_device;
struct mpp_device *mpp_new(struct xusb_iface *iface);
void mpp_delete(struct mpp_device *dev);
struct xusb_iface *xubs_iface_of_mpp(struct mpp_device *mpp);
int mpp_status_query(struct mpp_device *mpp_dev);
enum eeprom_type mpp_eeprom_type(struct mpp_device *mpp_dev);
void show_eeprom(const struct eeprom_table *eprm, FILE *fp);
void show_capabilities(const struct capabilities *capabilities, FILE *fp);
void show_astribank_status(struct mpp_device *mpp_dev, FILE *fp);
void show_extrainfo(const struct extrainfo *extrainfo, FILE *fp);
int twinstar_show(struct mpp_device *mpp, FILE *fp);
int show_hardware(struct mpp_device *mpp_dev);
int mpp_renumerate(struct mpp_device *mpp_dev);
int mpp_send_start(struct mpp_device *mpp_dev, int dest, const char *ihex_version);
int mpp_send_end(struct mpp_device *mpp_dev);
int mpp_send_seg(struct mpp_device *mpp_dev, const uint8_t *data, uint16_t offset, uint16_t len);
int mpp_reset(struct mpp_device *mpp_dev, int full_reset);
int mpp_caps_get(struct mpp_device *mpp_dev,
struct eeprom_table *eeprom_table,
struct capabilities *capabilities,
struct capkey *key);
int mpp_caps_set(struct mpp_device *mpp_dev,
const struct eeprom_table *eeprom_table,
const struct capabilities *capabilities,
const struct capkey *key);
/*
* serial sub-protocol to FPGA
*/
int mpps_card_info(struct mpp_device *mpp, int unit, uint8_t *card_type, uint8_t *card_status);
int mpps_stat(struct mpp_device *mpp, int unit, uint8_t *maincard_version, uint8_t *status);
/* /*
* Twinstar * Twinstar
*/ */
int mpp_tws_watchdog(struct astribank_device *astribank); int mpp_tws_watchdog(struct mpp_device *mpp);
int mpp_tws_setwatchdog(struct astribank_device *astribank, int yes); int mpp_tws_setwatchdog(struct mpp_device *mpp, int yes);
int mpp_tws_powerstate(struct astribank_device *astribank); int mpp_tws_powerstate(struct mpp_device *mpp);
int mpp_tws_portnum(struct astribank_device *astribank); int mpp_tws_portnum(struct mpp_device *mpp);
int mpp_tws_setportnum(struct astribank_device *astribank, uint8_t portnum); int mpp_tws_setportnum(struct mpp_device *mpp, uint8_t portnum);
const char *dev_dest2str(int dest); const char *dev_dest2str(int dest);
#endif /* MPP_FUNCS_H */ #ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* MPPTALK_H */

113
xpp/mpptalk_defs.h
View File

@ -1,113 +0,0 @@
#ifndef MPPTALK_DEFS_H
#define MPPTALK_DEFS_H
/*
* Written by Oron Peled <oron@actcom.co.il>
* Copyright (C) 2008,2009,2010 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 <xtalk_defs.h>
/*
* MPP - Managment Processor Protocol definitions
*/
/*
* OP Codes:
* MSB of op signifies a reply from device
*/
#define MPP_RENUM 0x0B /* Trigger USB renumeration */
#define MPP_EEPROM_SET 0x0D
/* AB capabilities */
#define MPP_CAPS_GET 0x0E
#define MPP_CAPS_GET_REPLY 0x8E
#define MPP_CAPS_SET 0x0F
#define MPP_DEV_SEND_START 0x05
#define MPP_DEV_SEND_SEG 0x07
#define MPP_DEV_SEND_END 0x09
/* Astribank Status */
#define MPP_STATUS_GET 0x11
#define MPP_STATUS_GET_REPLY 0x91
#define MPP_STATUS_GET_REPLY_V13 0x91 /* backward compat */
/* Get extra vendor information */
#define MPP_EXTRAINFO_GET 0x13
#define MPP_EXTRAINFO_GET_REPLY 0x93
#define MPP_EXTRAINFO_SET 0x15 /* Set extra vendor information */
#define MPP_EEPROM_BLK_RD 0x27
#define MPP_EEPROM_BLK_RD_REPLY 0xA7
#define MPP_SER_SEND 0x37
#define MPP_SER_RECV 0xB7
#define MPP_RESET 0x45 /* Reset both FPGA and USB firmwares */
#define MPP_HALF_RESET 0x47 /* Reset only FPGA firmware */
/* Twinstar */
#define MPP_TWS_WD_MODE_SET 0x31 /* Set watchdog off/on guard */
#define MPP_TWS_WD_MODE_GET 0x32 /* Current watchdog mode */
#define MPP_TWS_WD_MODE_GET_REPLY 0xB2 /* Current watchdog mode */
#define MPP_TWS_PORT_SET 0x34 /* USB-[0/1] */
#define MPP_TWS_PORT_GET 0x35 /* USB-[0/1] */
#define MPP_TWS_PORT_GET_REPLY 0xB5 /* USB-[0/1] */
#define MPP_TWS_PWR_GET 0x36 /* Power: bits -> USB ports */
#define MPP_TWS_PWR_GET_REPLY 0xB6 /* Power: bits -> USB ports */
/*
* Statuses
*/
#define STAT_OK 0x00 /* acknowledges previous command */
#define STAT_FAIL 0x01 /* Last command failed */
#define STAT_RESET_FAIL 0x02 /* reset failed */
#define STAT_NODEST 0x03 /* No destination is selected */
#define STAT_MISMATCH 0x04 /* Data mismatch */
#define STAT_NOACCESS 0x05 /* No access */
#define STAT_BAD_CMD 0x06 /* Bad command */
#define STAT_TOO_SHORT 0x07 /* Packet is too short */
#define STAT_ERROFFS 0x08 /* Offset error */
#define STAT_NOCODE 0x09 /* Source was not burned before */
#define STAT_NO_LEEPROM 0x0A /* Large EEPROM was not found */
#define STAT_NO_EEPROM 0x0B /* No EEPROM was found */
#define STAT_WRITE_FAIL 0x0C /* Writing to device failed */
#define STAT_FPGA_ERR 0x0D /* FPGA error */
#define STAT_KEY_ERR 0x0E /* Bad Capabilities Key */
#define STAT_NOCAPS_ERR 0x0F /* No matching capability */
#define STAT_NOPWR_ERR 0x10 /* No power on USB connector */
#define STAT_CAPS_FPGA_ERR 0x11 /* Setting of the capabilities while FPGA is loaded */
/* EEPROM_QUERY: i2cs(ID1, ID0) */
enum eeprom_type {
EEPROM_TYPE_NONE = 0,
EEPROM_TYPE_SMALL = 1,
EEPROM_TYPE_LARGE = 2,
EEPROM_TYPE_UNUSED = 3,
};
enum dev_dest {
DEST_NONE = 0x00,
DEST_FPGA = 0x01,
DEST_EEPROM = 0x02,
};
#define EXTRAINFO_SIZE 24
#endif /* MPPTALK_DEFS_H */

47
xpp/pic_loader.c
View File

@ -25,12 +25,12 @@
#include <stdlib.h> #include <stdlib.h>
#include <errno.h> #include <errno.h>
#include <regex.h> #include <regex.h>
#include <xtalk/debug.h>
#include <xtalk/xusb.h>
#include "hexfile.h" #include "hexfile.h"
#include "pic_loader.h" #include "pic_loader.h"
#include <debug.h>
#include <xusb.h>
#define DBG_MASK 0x03 #define DBG_MASK 0x20
#define MAX_HEX_LINES 10000 #define MAX_HEX_LINES 10000
#define TIMEOUT 500 #define TIMEOUT 500
@ -57,7 +57,7 @@ struct xpp_packet_header {
} d; } d;
} PACKED; } PACKED;
int send_picline(struct astribank_device *astribank, uint8_t card_type, enum pic_command pcmd, int offs, uint8_t *data, int data_len) int send_picline(struct astribank *ab, uint8_t card_type, enum pic_command pcmd, int offs, uint8_t *data, int data_len)
{ {
int recv_answer = 0; int recv_answer = 0;
char buf[PACKET_SIZE]; char buf[PACKET_SIZE];
@ -65,7 +65,7 @@ int send_picline(struct astribank_device *astribank, uint8_t card_type, enum pic
int pack_len; int pack_len;
int ret; int ret;
assert(astribank != NULL); assert(ab != NULL);
pack_len = data_len + sizeof(phead->header) + sizeof(phead->d.pic_packet.pic_header); pack_len = data_len + sizeof(phead->header) + sizeof(phead->d.pic_packet.pic_header);
phead->header.len = pack_len; phead->header.len = pack_len;
phead->header.op = PIC_REQ_XOP; phead->header.op = PIC_REQ_XOP;
@ -90,14 +90,14 @@ int send_picline(struct astribank_device *astribank, uint8_t card_type, enum pic
DBG("PICLINE: pack_len=%d pcmd=%d\n", pack_len, pcmd); DBG("PICLINE: pack_len=%d pcmd=%d\n", pack_len, pcmd);
dump_packet(LOG_DEBUG, DBG_MASK, "dump:picline[W]", (char *)phead, pack_len); dump_packet(LOG_DEBUG, DBG_MASK, "dump:picline[W]", (char *)phead, pack_len);
ret = xusb_send(astribank->xusb, buf, pack_len, TIMEOUT); ret = astribank_send(ab, 0, buf, pack_len, TIMEOUT);
if(ret < 0) { if(ret < 0) {
ERR("xusb_send failed: %d\n", ret); ERR("astribank_send failed: %d\n", ret);
return ret; return ret;
} }
DBG("xusb_send: Written %d bytes\n", ret); DBG("astribank_send: Written %d bytes\n", ret);
if (recv_answer) { if (recv_answer) {
ret = xusb_recv(astribank->xusb, buf, sizeof(buf), TIMEOUT); ret = astribank_recv(ab, 0, buf, sizeof(buf), TIMEOUT);
if(ret <= 0) { if(ret <= 0) {
ERR("No USB packs to read\n"); ERR("No USB packs to read\n");
return ret; return ret;
@ -172,7 +172,7 @@ static const char *pic_basename(const char *fname, uint8_t *card_type)
/* /*
* Returns: true on success, false on failure * Returns: true on success, false on failure
*/ */
static int pic_burn(struct astribank_device *astribank, const struct hexdata *hexdata) static int pic_burn(struct astribank *ab, const struct hexdata *hexdata)
{ {
const char *v = hexdata->version_info; const char *v = hexdata->version_info;
const char *basename; const char *basename;
@ -182,18 +182,21 @@ static int pic_burn(struct astribank_device *astribank, const struct hexdata *he
int ret; int ret;
unsigned int i; unsigned int i;
const char *devstr; const char *devstr;
const struct xusb_device *xusb;
v = (v[0]) ? v : "Unknown"; v = (v[0]) ? v : "Unknown";
assert(astribank != NULL); assert(ab != NULL);
assert(hexdata != NULL); assert(hexdata != NULL);
devstr = xusb_devpath(astribank->xusb); xusb = xusb_dev_of_astribank(ab);
if(!astribank->is_usb2) { devstr = xusb_devpath(xusb);
i = xusb_packet_size(xusb);
if(i != 512) {
ERR("%s: Skip PIC burning (not USB2)\n", devstr); ERR("%s: Skip PIC burning (not USB2)\n", devstr);
return 0; return 0;
} }
INFO("%s [%s]: Loading PIC Firmware: %s (version %s)\n", INFO("%s [%s]: Loading PIC Firmware: %s (version %s)\n",
devstr, devstr,
xusb_serial(astribank->xusb), xusb_serial(xusb),
hexdata->fname, hexdata->fname,
hexdata->version_info); hexdata->version_info);
basename = pic_basename(hexdata->fname, &card_type); basename = pic_basename(hexdata->fname, &card_type);
@ -209,10 +212,10 @@ static int pic_burn(struct astribank_device *astribank, const struct hexdata *he
for(i = 2; i; i--) { for(i = 2; i; i--) {
char buf[PACKET_SIZE]; char buf[PACKET_SIZE];
if(xusb_recv(astribank->xusb, buf, sizeof(buf), 1) <= 0) if (astribank_recv(ab, 0, buf, sizeof(buf), TIMEOUT) <= 0)
break; break;
} }
if((ret = send_picline(astribank, card_type, PIC_START_FLAG, 0, NULL, 0)) != 0) { if((ret = send_picline(ab, card_type, PIC_START_FLAG, 0, NULL, 0)) != 0) {
perror("Failed sending start hexline"); perror("Failed sending start hexline");
return 0; return 0;
} }
@ -233,7 +236,7 @@ static int pic_burn(struct astribank_device *astribank, const struct hexdata *he
} }
data = hexline->d.content.tt_data.data; data = hexline->d.content.tt_data.data;
check_sum ^= data[0] ^ data[1] ^ data[2]; check_sum ^= data[0] ^ data[1] ^ data[2];
ret = send_picline(astribank, card_type, PIC_DATA_FLAG, ret = send_picline(ab, card_type, PIC_DATA_FLAG,
hexline->d.content.header.offset, data, len); hexline->d.content.header.offset, data, len);
if(ret) { if(ret) {
perror("Failed sending data hexline"); perror("Failed sending data hexline");
@ -247,7 +250,7 @@ static int pic_burn(struct astribank_device *astribank, const struct hexdata *he
return 0; return 0;
} }
} }
if((ret = send_picline(astribank, card_type, PIC_END_FLAG, 0, &check_sum, 1)) != 0) { if((ret = send_picline(ab, card_type, PIC_END_FLAG, 0, &check_sum, 1)) != 0) {
perror("Failed sending end hexline"); perror("Failed sending end hexline");
return 0; return 0;
} }
@ -255,12 +258,12 @@ static int pic_burn(struct astribank_device *astribank, const struct hexdata *he
return 1; return 1;
} }
int load_pic(struct astribank_device *astribank, int numfiles, char *filelist[]) int load_pic(struct astribank *ab, int numfiles, char *filelist[])
{ {
int i; int i;
const char *devstr; const char *devstr;
devstr = xusb_devpath(astribank->xusb); devstr = xusb_devpath(xusb_dev_of_astribank(ab));
DBG("%s: Loading %d PIC files...\n", devstr, numfiles); DBG("%s: Loading %d PIC files...\n", devstr, numfiles);
for(i = 0; i < numfiles; i++) { for(i = 0; i < numfiles; i++) {
struct hexdata *picdata; struct hexdata *picdata;
@ -271,13 +274,13 @@ int load_pic(struct astribank_device *astribank, int numfiles, char *filelist[])
perror(curr); perror(curr);
return -errno; return -errno;
} }
if(!pic_burn(astribank, picdata)) { if(!pic_burn(ab, picdata)) {
ERR("%s: PIC %s burning failed\n", devstr, curr); ERR("%s: PIC %s burning failed\n", devstr, curr);
return -ENODEV; return -ENODEV;
} }
free_hexdata(picdata); free_hexdata(picdata);
} }
if((i = send_picline(astribank, 0, PIC_ENDS_FLAG, 0, NULL, 0)) != 0) { if((i = send_picline(ab, 0, PIC_ENDS_FLAG, 0, NULL, 0)) != 0) {
ERR("%s: PIC end burning failed\n", devstr); ERR("%s: PIC end burning failed\n", devstr);
return -ENODEV; return -ENODEV;
} }

6
xpp/pic_loader.h
View File

@ -23,7 +23,7 @@
*/ */
#include <stdint.h> #include <stdint.h>
#include "astribank_usb.h" #include "astribank.h"
/* /*
* Astribank PIC loading * Astribank PIC loading
@ -39,8 +39,8 @@ enum pic_command {
#define PIC_PACK_LEN 0x0B #define PIC_PACK_LEN 0x0B
#define PIC_LINE_LEN 0x03 #define PIC_LINE_LEN 0x03
int send_picline(struct astribank_device *astribank, uint8_t card_type, int send_picline(struct astribank *astribank, uint8_t card_type,
enum pic_command pcmd, int offs, uint8_t *data, int data_len); enum pic_command pcmd, int offs, uint8_t *data, int data_len);
int load_pic(struct astribank_device *astribank, int numfiles, char *filelist[]); int load_pic(struct astribank *astribank, int numfiles, char *filelist[]);
#endif /* PIC_LOADER_H */ #endif /* PIC_LOADER_H */

5
xpp/xtalk/Makefile.am
View File

@ -19,12 +19,7 @@ noinst_PROGRAMS = xlist_test xusb_test xusb_test_bypath xtalk_test xtalk_raw_te
sbin_PROGRAMS = xtalk_send sbin_PROGRAMS = xtalk_send
noinst_LTLIBRARIES = libxtalk.la noinst_LTLIBRARIES = libxtalk.la
dist_noinst_HEADERS = \ dist_noinst_HEADERS = \
debug.h \
xlist.h \
xtalk.h \
xtalk_base.h \ xtalk_base.h \
xtalk_defs.h \
xusb.h \
xusb_common.h \ xusb_common.h \
include/xtalk/proto_raw.h \ include/xtalk/proto_raw.h \
include/xtalk/api_defs.h \ include/xtalk/api_defs.h \

497
xpp/xtalk/xtalk.c
View File

@ -1,497 +0,0 @@
/*
* Written by Oron Peled <oron@actcom.co.il>
* Copyright (C) 2009, 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 <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <arpa/inet.h>
#include <xtalk.h>
#include <debug.h>
#define DBG_MASK 0x02
#define TIMEOUT 6000
/*
* Base XTALK device. A pointer to this struct
* should be included in the struct representing
* the dialect.
*/
struct xtalk_device {
void *transport_priv; /* e.g: struct xusb */
struct xtalk_ops ops;
struct xtalk_protocol xproto;
uint8_t xtalk_proto_version;
uint8_t status;
size_t packet_size;
uint16_t tx_sequenceno;
};
CMD_DEF(XTALK, ACK,
uint8_t stat;
);
CMD_DEF(XTALK, PROTO_GET,
uint8_t proto_version;
uint8_t reserved;
);
CMD_DEF(XTALK, PROTO_GET_REPLY,
uint8_t proto_version;
uint8_t reserved;
);
union XTALK_PDATA(XTALK) {
MEMBER(XTALK, ACK);
MEMBER(XTALK, PROTO_GET);
MEMBER(XTALK, PROTO_GET_REPLY);
} PACKED members;
struct xtalk_protocol xtalk_base = {
.name = "XTALK",
.proto_version = 0,
.commands = {
CMD_RECV(XTALK, ACK, NULL),
CMD_SEND(XTALK, PROTO_GET),
CMD_RECV(XTALK, PROTO_GET_REPLY, NULL),
},
.ack_statuses = {
ACK_STAT(OK, "Acknowledges previous command"),
ACK_STAT(FAIL, "Last command failed"),
ACK_STAT(RESET_FAIL, "reset failed"),
ACK_STAT(NODEST, "No destination is selected"),
ACK_STAT(MISMATCH, "Data mismatch"),
ACK_STAT(NOACCESS, "No access"),
ACK_STAT(BAD_CMD, "Bad command"),
ACK_STAT(TOO_SHORT, "Packet is too short"),
ACK_STAT(ERROFFS, "Offset error (not used)"),
ACK_STAT(NO_LEEPROM, "Large EEPROM was not found"),
ACK_STAT(NO_EEPROM, "No EEPROM was found"),
ACK_STAT(WRITE_FAIL, "Writing to device failed"),
ACK_STAT(NOPWR_ERR, "No power on USB connector"),
}
};
void free_command(struct xtalk_command *cmd)
{
if (!cmd)
return;
memset(cmd, 0, cmd->header.len);
free(cmd);
}
static const struct xtalk_command_desc *get_command_desc(
const struct xtalk_protocol *xproto, uint8_t op)
{
const struct xtalk_command_desc *desc;
if (!xproto)
return NULL;
desc = &xproto->commands[op];
if (!desc->name)
return NULL;
#if 0
DBG("%s version=%d, op=0x%X (%s)\n",
xproto->name, xproto->proto_version,
op, desc->name);
#endif
return desc;
}
static const char *ack_status_msg(const struct xtalk_protocol *xproto,
uint8_t status)
{
const char *ack_status;
if (!xproto)
return NULL;
ack_status = xproto->ack_statuses[status];
DBG("%s status=0x%X (%s)\n", xproto->name, status, ack_status);
return ack_status;
}
int xtalk_set_protocol(struct xtalk_device *xtalk_dev,
const struct xtalk_protocol *xproto)
{
const char *protoname = (xproto) ? xproto->name : "GLOBAL";
int i;
DBG("%s\n", protoname);
memset(&xtalk_dev->xproto, 0, sizeof(xtalk_dev->xproto));
for (i = 0; i < MAX_OPS; i++) {
const struct xtalk_command_desc *desc;
desc = get_command_desc(xproto, i);
if (desc) {
if (!IS_PRIVATE_OP(i)) {
ERR("Bad op=0x%X "
"(should be in the range [0x%X-0x%X]\n",
i, PRIVATE_OP_FIRST, PRIVATE_OP_LAST);
return -EINVAL;
}
xtalk_dev->xproto.commands[i] = *desc;
DBG("private: op=0x%X (%s)\n", i, desc->name);
} else {
if (!IS_PRIVATE_OP(i)) {
const char *name;
xtalk_dev->xproto.commands[i] =
xtalk_base.commands[i];
name = xtalk_dev->xproto.commands[i].name;
if (name)
DBG("global: op=0x%X (%s)\n", i, name);
}
}
}
for (i = 0; i < MAX_STATUS; i++) {
const char *stat_msg;
stat_msg = (xproto) ? xproto->ack_statuses[i] : NULL;
if (stat_msg) {
if (!IS_PRIVATE_OP(i)) {
ERR("Bad status=0x%X "
"(should be in the range [0x%X-0x%X]\n",
i, PRIVATE_OP_FIRST, PRIVATE_OP_LAST);
return -EINVAL;
}
xtalk_dev->xproto.ack_statuses[i] = stat_msg;
DBG("private: status=0x%X (%s)\n", i, stat_msg);
} else {
if (!IS_PRIVATE_OP(i)) {
const char *stat_msg;
xtalk_dev->xproto.ack_statuses[i] =
xtalk_base.ack_statuses[i];
stat_msg = xtalk_dev->xproto.ack_statuses[i];
if (stat_msg)
DBG("global: status=0x%X (%s)\n",
i, stat_msg);
}
}
}
xtalk_dev->xproto.name = protoname;
xtalk_dev->xproto.proto_version = (xproto) ? xproto->proto_version : 0;
return 0;
}
struct xtalk_command *new_command(
const struct xtalk_device *xtalk_dev,
uint8_t op, uint16_t extra_data)
{
const struct xtalk_protocol *xproto;
struct xtalk_command *cmd;
const struct xtalk_command_desc *desc;
uint16_t len;
xproto = &xtalk_dev->xproto;
desc = get_command_desc(xproto, op);
if (!desc) {
ERR("Unknown op=0x%X.\n", op);
return NULL;
}
DBG("OP=0x%X [%s] (extra_data %d)\n", op, desc->name, extra_data);
len = desc->len + extra_data;
cmd = malloc(len);
if (!cmd) {
ERR("Out of memory\n");
return NULL;
}
if (extra_data) {
uint8_t *ptr = (uint8_t *)cmd;
DBG("clear extra_data (%d bytes)\n", extra_data);
memset(ptr + desc->len, 0, extra_data);
}
cmd->header.op = op;
cmd->header.len = len;
cmd->header.seq = 0; /* Overwritten in send_usb() */
return cmd;
}
void xtalk_dump_command(struct xtalk_command *cmd)
{
uint16_t len;
int i;
len = cmd->header.len;
if (len < sizeof(struct xtalk_header)) {
ERR("Command too short (%d)\n", len);
return;
}
INFO("DUMP: OP=0x%X len=%d seq=%d\n",
cmd->header.op, cmd->header.len, cmd->header.seq);
for (i = 0; i < len - sizeof(struct xtalk_header); i++)
INFO(" %2d. 0x%X\n", i, cmd->alt.raw_data[i]);
}
static int send_command(struct xtalk_device *xtalk_dev,
struct xtalk_command *cmd, int timeout)
{
int ret;
int len;
void *priv = xtalk_dev->transport_priv;
len = cmd->header.len;
cmd->header.seq = xtalk_dev->tx_sequenceno;
ret = xtalk_dev->ops.send_func(priv, (char *)cmd, len, timeout);
if (ret < 0)
DBG("send_func failed ret=%d\n", ret);
xtalk_dev->tx_sequenceno++;
return ret;
}
static struct xtalk_command *recv_command(struct xtalk_device *xtalk_dev,
int timeout)
{
struct xtalk_command *reply;
void *priv = xtalk_dev->transport_priv;
size_t psize = xtalk_dev->packet_size;
int ret;
reply = malloc(psize);
if (!reply) {
ERR("Out of memory\n");
goto err;
}
reply->header.len = 0;
ret = xtalk_dev->ops.recv_func(priv, (char *)reply, psize, timeout);
if (ret < 0) {
ERR("Receive from usb failed.\n");
goto err;
} else if (ret == 0) {
goto err; /* No reply */
}
if (ret != reply->header.len) {
ERR("Wrong length received: got %d bytes, "
"but length field says %d bytes%s\n",
ret, reply->header.len,
(ret == 1) ? ". Old USB firmware?" : "");
goto err;
}
/* dump_packet(LOG_DEBUG, DBG_MASK, __func__, (char *)reply, ret); */
return reply;
err:
if (reply) {
memset(reply, 0, psize);
free_command(reply);
}
return NULL;
}
__attribute__((warn_unused_result))
int process_command(
struct xtalk_device *xtalk_dev,
struct xtalk_command *cmd,
struct xtalk_command **reply_ref)
{
const struct xtalk_protocol *xproto;
struct xtalk_command *reply = NULL;
const struct xtalk_command_desc *reply_desc;
const struct xtalk_command_desc *expected;
const struct xtalk_command_desc *cmd_desc;
uint8_t reply_op;
const char *protoname;
int ret;
xproto = &xtalk_dev->xproto;
protoname = (xproto) ? xproto->name : "GLOBAL";
/* So the caller knows if a reply was received */
if (reply_ref)
*reply_ref = NULL;
reply_op = cmd->header.op | XTALK_REPLY_MASK;
cmd_desc = get_command_desc(xproto, cmd->header.op);
expected = get_command_desc(xproto, reply_op);
ret = send_command(xtalk_dev, cmd, TIMEOUT);
if (!reply_ref) {
DBG("No reply requested\n");
goto out;
}
if (ret < 0) {
ERR("send_command failed: %d\n", ret);
goto out;
}
reply = recv_command(xtalk_dev, TIMEOUT);
if (!reply) {
ERR("recv_command failed\n");
ret = -EPROTO;
goto out;
}
*reply_ref = reply;
if ((reply->header.op & 0x80) != 0x80) {
ERR("Unexpected reply op=0x%02X, should have MSB set.\n",
reply->header.op);
ret = -EPROTO;
goto out;
}
DBG("REPLY OP: 0x%X\n", reply->header.op);
reply_desc = get_command_desc(xproto, reply->header.op);
if (!reply_desc) {
ERR("Unknown reply (proto=%s) op=0x%02X\n",
protoname, reply->header.op);
ret = -EPROTO;
goto out;
}
DBG("REPLY NAME: %s\n", reply_desc->name);
if (reply->header.op == XTALK_ACK) {
int status = CMD_FIELD(reply, XTALK, ACK, stat);
if (expected) {
ERR("Expected OP=0x%02X: Got ACK(%d): %s\n",
reply_op,
status,
ack_status_msg(xproto, status));
ret = -EPROTO;
goto out;
} else if (status != STAT_OK) {
ERR("Got ACK (for OP=0x%X [%s]): %d %s\n",
cmd->header.op,
cmd_desc->name,
status, ack_status_msg(xproto, status));
ret = -EPROTO;
goto out;
}
/* Good expected ACK ... */
} else if (reply->header.op != reply_op) {
ERR("Expected OP=0x%02X: Got OP=0x%02X\n",
reply_op, reply->header.op);
ret = -EPROTO;
goto out;
}
if (expected && expected->len > reply->header.len) {
ERR("Expected len=%d: Got len=%d\n",
expected->len, reply->header.len);
ret = -EPROTO;
goto out;
}
if (cmd->header.seq != reply->header.seq) {
ERR("Expected seq=%d: Got seq=%d\n",
cmd->header.seq, reply->header.seq);
ret = -EPROTO;
goto out;
}
ret = reply->header.len; /* All good, return the length */
DBG("returning reply op 0x%X (%d bytes)\n", reply->header.op, ret);
out:
free_command(cmd);
if (!reply_ref && reply)
free_command(reply);
return ret;
}
/*
* Protocol Commands
*/
int xtalk_proto_query(struct xtalk_device *xtalk_dev)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
uint8_t proto_version;
int ret;
DBG("\n");
assert(xtalk_dev != NULL);
proto_version = xtalk_dev->xproto.proto_version;
cmd = new_command(xtalk_dev, XTALK_PROTO_GET, 0);
if (!cmd) {
ERR("new_command failed\n");
return -ENOMEM;
}
/* Protocol Version */
CMD_FIELD(cmd, XTALK, PROTO_GET, proto_version) = proto_version;
ret = process_command(xtalk_dev, cmd, &reply);
if (ret < 0) {
ERR("process_command failed: %d\n", ret);
goto out;
}
xtalk_dev->xtalk_proto_version =
CMD_FIELD(reply, XTALK, PROTO_GET_REPLY, proto_version);
if (xtalk_dev->xtalk_proto_version != proto_version) {
DBG("Got %s protocol version: 0x%02x (expected 0x%02x)\n",
xtalk_dev->xproto.name,
xtalk_dev->xtalk_proto_version,
proto_version);
ret = xtalk_dev->xtalk_proto_version;
goto out;
}
DBG("Protocol version: %02x\n", xtalk_dev->xtalk_proto_version);
ret = xtalk_dev->xtalk_proto_version;
out:
free_command(reply);
return ret;
}
/*
* Wrappers
*/
struct xtalk_device *xtalk_new(const struct xtalk_ops *ops,
size_t packet_size, void *priv)
{
struct xtalk_device *xtalk_dev;
int ret;
DBG("\n");
assert(ops != NULL);
xtalk_dev = malloc(sizeof(*xtalk_dev));
if (!xtalk_dev) {
ERR("Allocating XTALK device memory failed\n");
return NULL;
}
memset(xtalk_dev, 0, sizeof(*xtalk_dev));
memcpy((void *)&xtalk_dev->ops, (const void *)ops,
sizeof(xtalk_dev->ops));
xtalk_dev->transport_priv = priv;
xtalk_dev->packet_size = packet_size;
xtalk_dev->tx_sequenceno = 1;
ret = xtalk_set_protocol(xtalk_dev, NULL);
if (ret < 0) {
ERR("GLOBAL Protocol registration failed: %d\n", ret);
goto err;
}
return xtalk_dev;
err:
if (xtalk_dev)
xtalk_delete(xtalk_dev);
return NULL;
}
void xtalk_delete(struct xtalk_device *xtalk_dev)
{
void *priv;
if (!xtalk_dev)
return;
DBG("\n");
priv = xtalk_dev->transport_priv;
assert(priv);
xtalk_dev->tx_sequenceno = 0;
assert(&xtalk_dev->ops != NULL);
assert(&xtalk_dev->ops.close_func != NULL);
xtalk_dev->ops.close_func(priv);
}

178
xpp/xtalk/xtalk.h
View File

@ -1,178 +0,0 @@
#ifndef XTALK_H
#define XTALK_H
/*
* Written by Oron Peled <oron@actcom.co.il>
* Copyright (C) 2009, 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.
*
*/
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/*
* XTALK - Base protocol for our USB devices
* It is meant to provide a common base for layered
* protocols (dialects)
*/
#include <stdint.h>
#include <stdlib.h>
/* Definitions common to the firmware (in include/ directory) */
#include <xtalk_defs.h>
#ifdef __GNUC__
#define PACKED __attribute__((packed))
#else
#error "We do not know how your compiler packs structures"
#endif
struct xtalk_device;
struct xtalk_command_desc;
typedef int (*xtalk_cmd_callback_t)(
struct xtalk_device *xtalk_dev,
struct xtalk_command_desc *xtalk_cmd);
/* Describe a single xtalk command */
struct xtalk_command_desc {
uint8_t op;
const char *name;
xtalk_cmd_callback_t callback;
uint16_t len; /* Minimal length */
};
/* Define a complete protocol */
struct xtalk_protocol {
const char *name;
uint8_t proto_version;
struct xtalk_command_desc commands[MAX_OPS];
const char *ack_statuses[MAX_STATUS];
};
/*
* The common header of every xtalk command
* in every xtalk dialect.
*/
struct xtalk_header {
uint16_t len;
uint16_t seq;
uint8_t op; /* MSB: 0 - to device, 1 - from device */
} PACKED;
struct xtalk_command {
/* Common part */
struct xtalk_header header;
/* Each dialect has its own data members */
union private_data {
uint8_t raw_data[0];
} PACKED alt;
} PACKED;
/*
* Macros to unify access to protocol packets and fields:
* p - signify the dialect prefix (XTALK for base protocol)
* o - signify command op (e.g: ACK)
* cmd - A pointer to struct xtalk_command
* field - field name (e.g: raw_data)
*/
#define XTALK_STRUCT(p, o) p ## _struct_ ## o
#define XTALK_PDATA(o) xtalk_privdata_ ## o
#define XTALK_CMD_PTR(cmd, p) ((union XTALK_PDATA(p)*)&((cmd)->alt))
#define CMD_FIELD(cmd, p, o, field) \
(XTALK_CMD_PTR(cmd, p)->XTALK_STRUCT(p, o).field)
#define CMD_DEF(p, o, ...) struct XTALK_STRUCT(p, o) { \
__VA_ARGS__ \
} PACKED XTALK_STRUCT(p, o)
#define MEMBER(p, o) struct XTALK_STRUCT(p, o) XTALK_STRUCT(p, o)
/* Wrappers for transport (xusb) functions */
struct xtalk_ops {
int (*send_func)(void *transport_priv, void *data, size_t len,
int timeout);
int (*recv_func)(void *transport_priv, void *data, size_t maxlen,
int timeout);
int (*close_func)(void *transport_priv);
};
/*
* Base XTALK device. A pointer to this struct
* should be included in the struct representing
* the dialect.
*/
struct xtalk_device;
/* high-level */
struct xtalk_device *xtalk_new(const struct xtalk_ops *ops,
size_t packet_size, void *transport_priv);
void xtalk_delete(struct xtalk_device *dev);
int xtalk_set_protocol(struct xtalk_device *xtalk_dev,
const struct xtalk_protocol *xproto);
int xtalk_proto_query(struct xtalk_device *dev);
void xtalk_dump_command(struct xtalk_command *cmd);
/* low-level */
int process_command(
struct xtalk_device *dev,
struct xtalk_command *cmd,
struct xtalk_command **reply_ref);
struct xtalk_command *new_command(
const struct xtalk_device *xtalk_dev,
uint8_t op, uint16_t extra_data);
void free_command(struct xtalk_command *cmd);
/*
* Convenience macros to define entries in a protocol command table:
* p - signify the dialect prefix (XTALK for base protocol)
* o - signify command op (e.g: ACK)
* cb - A callback function (type xtalk_cmd_callback_t)
*/
#define CMD_RECV(p, o, cb) \
[p ## _ ## o | XTALK_REPLY_MASK] = { \
.op = (p ## _ ## o) | XTALK_REPLY_MASK, \
.name = (#o "_reply"), \
.callback = (cb), \
.len = \
sizeof(struct xtalk_header) + \
sizeof(struct XTALK_STRUCT(p, o)), \
}
#define CMD_SEND(p, o) \
[p ## _ ## o] = { \
.op = (p ## _ ## o), \
.name = (#o), \
.callback = NULL, \
.len = \
sizeof(struct xtalk_header) + \
sizeof(struct XTALK_STRUCT(p, o)), \
}
/*
* Convenience macro to define statuses:
* x - status code (e.g: OK)
* m - status message (const char *)
*/
#define ACK_STAT(x, m) [STAT_ ## x] = (m)
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* XTALK_H */

5
xpp/xtalk/xtalk_base.c
View File

@ -351,3 +351,8 @@ void xtalk_base_delete(struct xtalk_base *xtalk_base)
memset(xtalk_base, 0, sizeof(*xtalk_base)); memset(xtalk_base, 0, sizeof(*xtalk_base));
free(xtalk_base); free(xtalk_base);
} }
struct xusb_iface *xusb_iface_of_xtalk_base(const struct xtalk_base *xtalk_base)
{
return xtalk_base->transport_priv;
}

41
xpp/xtalk/xtalk_defs.h
View File

@ -1,41 +0,0 @@
#ifndef XTALK_DEFS_H
#define XTALK_DEFS_H
#define MAX_OPS 256 /* single byte */
#define MAX_STATUS 256 /* single byte */
#define XTALK_REPLY_MASK 0x80 /* Every reply has this bit */
#define PRIVATE_OP_FIRST 0x05
#define PRIVATE_OP_LAST 0x7F
#define IS_PRIVATE_OP(x) ( \
(((x) & ~(XTALK_REPLY_MASK)) >= PRIVATE_OP_FIRST) && \
(((x) & ~(XTALK_REPLY_MASK)) <= PRIVATE_OP_LAST) \
)
#define XTALK_ACK 0x80
#define XTALK_PROTO_GET 0x01
#define XTALK_PROTO_GET_REPLY (XTALK_PROTO_GET | XTALK_REPLY_MASK)
#define XTALK_FWVERS_GET 0x11
#define XTALK_FWVERS_GET_REPLY (XTALK_FWVERS_GET | XTALK_REPLY_MASK)
/* Get EEPROM table contents Product/Vendor Id ... */
#define XTALK_CAPS_GET 0x0E
#define XTALK_CAPS_GET_REPLY (XTALK_CAPS_GET | XTALK_REPLY_MASK)
/*------------- XTALK: statuses in ACK ---------------------------------------*/
#define STAT_OK 0x00 /* OK */
#define STAT_FAIL 0x01 /* last command failed */
#define STAT_RESET_FAIL 0x02 /* reset failed */
#define STAT_NODEST 0x03 /* No destination is selected */
#define STAT_MISMATCH 0x04 /* Data mismatch */
#define STAT_NOACCESS 0x05 /* No access */
#define STAT_BAD_CMD 0x06 /* Bad command */
#define STAT_TOO_SHORT 0x07 /* Packet is too short */
#define STAT_ERROFFS 0x08 /* Offset error (not used) */
#define STAT_NO_LEEPROM 0x0A /* Large EEPROM was not found */
#define STAT_NO_EEPROM 0x0B /* No EEPROM was found */
#define STAT_WRITE_FAIL 0x0C /* Writing to device failed */
#define STAT_NOPWR_ERR 0x10 /* No power on USB connector */
#endif /* XTALK_DEFS_H */

943
xpp/xtalk/xusb.c
View File

@ -1,943 +0,0 @@
/*
* 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.
*
*/
#define _GNU_SOURCE /* for memrchr() */
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <stdarg.h>
#include <syslog.h>
#include <arpa/inet.h>
#include <debug.h>
#include <xusb.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#define DBG_MASK 0x01
#define TIMEOUT 500
#define MAX_RETRIES 10
struct xusb {
struct usb_device *dev;
usb_dev_handle *handle;
const struct xusb_spec *spec;
char iManufacturer[BUFSIZ];
char iProduct[BUFSIZ];
char iSerialNumber[BUFSIZ];
char iInterface[BUFSIZ];
char devpath_tail[PATH_MAX + 1];
int bus_num;
int device_num;
int interface_num;
int ep_out;
int ep_in;
int is_usb2;
int is_claimed;
int is_open;
size_t packet_size;
};
static void xusb_init();
/*
* XTALK_OPTIONS:
* A white-space separated list of options, read from the environment
* variable of that name. Existing options:
*
* - "use-clear-halt" -- force USB "clear_halt" operation during
* device initialization (this is the default)
* - "no-use-clear-halt" -- force no USB "clear_halt" operation during
* device initialization
* - "no-lock" -- prevent using global sempahore to serialize libusb
* initialization. Previously done via "XUSB_NOLOCK"
* environment variable.
*/
int xtalk_parse_options(void);
int xtalk_option_use_clear_halt(void);
int xtalk_option_no_lock(void);
void xusb_init_spec(struct xusb_spec *spec, char *name,
uint16_t vendor_id, uint16_t product_id,
int nifaces, int iface, int nep, int ep_out, int ep_in)
{
DBG("Initialize %s: interfaces=%d using interface num=%d endpoints=%d "
"(OUT=0x%02X, IN=0x%02X)\n",
name, nifaces, iface, nep, ep_out, ep_in);
memset(spec, 0, sizeof(*spec));
spec->name = name;
spec->num_interfaces = nifaces;
spec->my_interface_num = iface;
spec->num_endpoints = nep;
spec->my_vendor_id = vendor_id;
spec->my_product_id = product_id;
spec->my_ep_in = ep_in;
spec->my_ep_out = ep_out;
}
#define EP_OUT(xusb) ((xusb)->spec->my_ep_out)
#define EP_IN(xusb) ((xusb)->spec->my_ep_in)
/*
* USB handling
*/
static int get_usb_string(struct xusb *xusb, uint8_t item, char *buf)
{
char tmp[BUFSIZ];
int ret;
assert(xusb->handle);
if (!item)
return 0;
ret = usb_get_string_simple(xusb->handle, item, tmp, BUFSIZ);
if (ret <= 0)
return ret;
return snprintf(buf, BUFSIZ, "%s", tmp);
}
static const struct usb_interface_descriptor *get_interface(
const struct usb_device *dev,
int my_interface_num,
int num_interfaces)
{
const struct usb_interface *interface;
const struct usb_interface_descriptor *iface_desc;
const struct usb_config_descriptor *config_desc;
int num_altsetting;
config_desc = dev->config;
if (!config_desc) {
ERR("No configuration descriptor: strange USB1 controller?\n");
return NULL;
}
if (num_interfaces && config_desc->bNumInterfaces != num_interfaces) {
DBG("Wrong number of interfaces: have %d need %d\n",
config_desc->bNumInterfaces, num_interfaces);
return NULL;
}
interface = &config_desc->interface[my_interface_num];
assert(interface != NULL);
iface_desc = interface->altsetting;
num_altsetting = interface->num_altsetting;
assert(num_altsetting != 0);
assert(iface_desc != NULL);
return iface_desc;
}
static int match_interface(const struct usb_device *dev,
const struct xusb_spec *spec)
{
const struct usb_device_descriptor *dev_desc;
const struct usb_interface_descriptor *iface_desc;
dev_desc = &dev->descriptor;
assert(dev_desc);
DBG("Checking: %04X:%04X interfaces=%d interface num=%d endpoints=%d: "
"\"%s\"\n",
spec->my_vendor_id,
spec->my_product_id,
spec->num_interfaces,
spec->my_interface_num,
spec->num_endpoints,
spec->name);
if (dev_desc->idVendor != spec->my_vendor_id) {
DBG("Wrong vendor id 0x%X\n", dev_desc->idVendor);
return 0;
}
if (dev_desc->idProduct != spec->my_product_id) {
DBG("Wrong product id 0x%X\n", dev_desc->idProduct);
return 0;
}
iface_desc = get_interface(dev, spec->my_interface_num,
spec->num_interfaces);
if (!iface_desc) {
ERR("Could not get interface descriptor of device: %s\n",
usb_strerror());
return 0;
}
if (iface_desc->bInterfaceClass != 0xFF) {
DBG("Wrong interface class 0x%X\n",
iface_desc->bInterfaceClass);
return 0;
}
if (iface_desc->bInterfaceNumber != spec->my_interface_num) {
DBG("Wrong interface number %d (expected %d)\n",
iface_desc->bInterfaceNumber, spec->my_interface_num);
return 0;
}
if (iface_desc->bNumEndpoints != spec->num_endpoints) {
DBG("Wrong number of endpoints %d\n",
iface_desc->bNumEndpoints);
return 0;
}
return 1;
}
#define GET_USB_STRING(xusb, from, item) \
get_usb_string((xusb), (from)->item, xusb->item)
static int xusb_fill_strings(struct xusb *xusb)
{
const struct usb_device_descriptor *dev_desc;
const struct usb_interface_descriptor *iface_desc;
dev_desc = &xusb->dev->descriptor;
assert(dev_desc);
if (GET_USB_STRING(xusb, dev_desc, iManufacturer) < 0) {
ERR("Failed reading iManufacturer string: %s\n",
usb_strerror());
return 0;
}
if (GET_USB_STRING(xusb, dev_desc, iProduct) < 0) {
ERR("Failed reading iProduct string: %s\n",
usb_strerror());
return 0;
}
if (GET_USB_STRING(xusb, dev_desc, iSerialNumber) < 0) {
ERR("Failed reading iSerialNumber string: %s\n",
usb_strerror());
return 0;
}
iface_desc = get_interface(xusb->dev, xusb->interface_num, 0);
if (!iface_desc) {
ERR("Could not get interface descriptor of device: %s\n",
usb_strerror());
return 0;
}
if (GET_USB_STRING(xusb, iface_desc, iInterface) < 0) {
ERR("Failed reading iInterface string: %s\n", usb_strerror());
return 0;
}
return 1;
}
static int xusb_open(struct xusb *xusb)
{
assert(xusb);
if (xusb->is_open)
return 1;
xusb->handle = usb_open(xusb->dev);
if (!xusb->handle) {
ERR("Failed to open usb device '%s': %s\n",
xusb->devpath_tail, usb_strerror());
return 0;
}
xusb->is_open = 1;
return 1;
}
int xusb_claim_interface(struct xusb *xusb)
{
const struct usb_device_descriptor *dev_desc;
int ret;
assert(xusb);
xusb_open(xusb); /* If it's not open yet... */
if (usb_claim_interface(xusb->handle, xusb->interface_num) != 0) {
ERR("usb_claim_interface %d in '%s': %s\n",
xusb->interface_num,
xusb->devpath_tail,
usb_strerror());
return 0;
}
xusb->is_claimed = 1;
xusb_fill_strings(xusb);
dev_desc = &xusb->dev->descriptor;
DBG("ID=%04X:%04X Manufacturer=[%s] Product=[%s] "
"SerialNumber=[%s] Interface=[%s]\n",
dev_desc->idVendor,
dev_desc->idProduct,
xusb->iManufacturer,
xusb->iProduct,
xusb->iSerialNumber,
xusb->iInterface);
if (xtalk_option_use_clear_halt()) {
DBG("Using clear_halt()\n");
if (usb_clear_halt(xusb->handle, EP_OUT(xusb)) != 0) {
ERR("Clearing output endpoint: %s\n", usb_strerror());
return 0;
}
if (usb_clear_halt(xusb->handle, EP_IN(xusb)) != 0) {
ERR("Clearing input endpoint: %s\n", usb_strerror());
return 0;
}
}
ret = xusb_flushread(xusb);
if (ret < 0) {
ERR("xusb_flushread failed: %d\n", ret);
return 0;
}
return 1;
}
static void xusb_list_dump(struct xlist_node *xusb_list)
{
struct xlist_node *curr;
struct xusb *xusb;
for (curr = xusb_list->next; curr != xusb_list; curr = curr->next) {
struct usb_device *dev;
struct usb_bus *bus;
struct usb_device_descriptor *dev_desc;
xusb = curr->data;
assert(xusb);
dev = xusb->dev;
assert(dev);
bus = dev->bus;
assert(bus);
dev_desc = &dev->descriptor;
assert(dev_desc);
DBG("usb:ID=%04X:%04X [%s / %s / %s], (%s/%s)\n",
dev_desc->idVendor,
dev_desc->idProduct,
xusb->iManufacturer,
xusb->iProduct,
xusb->iSerialNumber,
bus->dirname,
dev->filename
);
}
}
void xusb_destroy(struct xusb *xusb)
{
if (xusb) {
xusb_close(xusb);
memset(xusb, 0, sizeof(*xusb));
free(xusb);
}
}
static struct xusb *xusb_new(struct usb_device *dev,
const struct xusb_spec *spec)
{
struct usb_device_descriptor *dev_desc;
struct usb_config_descriptor *config_desc;
struct usb_interface *interface;
struct usb_interface_descriptor *iface_desc;
struct usb_endpoint_descriptor *endpoint;
size_t max_packet_size;
int i;
struct xusb *xusb = NULL;
/*
* Get information from the usb_device
*/
dev_desc = &dev->descriptor;
if (!dev_desc) {
ERR("usb device without a device descriptor\n");
goto fail;
}
config_desc = dev->config;
if (!config_desc) {
ERR("usb device without a configuration descriptor\n");
goto fail;
}
interface = &config_desc->interface[spec->my_interface_num];
iface_desc = interface->altsetting;
endpoint = iface_desc->endpoint;
/* Calculate max packet size */
max_packet_size = PACKET_SIZE;
for (i = 0; i < iface_desc->bNumEndpoints; i++, endpoint++) {
DBG("Validating endpoint @ %d (interface %d)\n",
i, spec->my_interface_num);
if (endpoint->bEndpointAddress == spec->my_ep_out ||
endpoint->bEndpointAddress == spec->my_ep_in) {
if (endpoint->wMaxPacketSize > PACKET_SIZE) {
ERR("EP #%d wMaxPacketSize too large (%d)\n",
i, endpoint->wMaxPacketSize);
goto fail;
}
if (endpoint->wMaxPacketSize < max_packet_size)
max_packet_size = endpoint->wMaxPacketSize;
}
}
/* Fill xusb */
xusb = malloc(sizeof(*xusb));
if (!xusb) {
ERR("Out of memory");
goto fail;
}
memset(xusb, 0, sizeof(*xusb));
xusb->dev = dev;
xusb->spec = spec;
sscanf(dev->bus->dirname, "%d", &xusb->bus_num);
sscanf(dev->filename, "%d", &xusb->device_num);
snprintf(xusb->devpath_tail, PATH_MAX, "%03d/%03d",
xusb->bus_num, xusb->device_num);
xusb->interface_num = spec->my_interface_num;
xusb->ep_out = spec->my_ep_out;
xusb->ep_in = spec->my_ep_in;
xusb->packet_size = max_packet_size;
xusb->is_usb2 = (max_packet_size == 512);
if (!xusb_open(xusb)) {
ERR("Failed opening device: %04X:%04X - %s\n",
dev_desc->idVendor,
dev_desc->idProduct,
xusb->devpath_tail);
goto fail;
}
DBG("%04X:%04X - %s\n",
dev_desc->idVendor,
dev_desc->idProduct,
xusb->devpath_tail);
return xusb;
fail:
xusb_destroy(xusb);
return NULL;
}
struct xusb *xusb_find_iface(const char *devpath,
int iface_num,
int ep_out,
int ep_in,
struct xusb_spec *dummy_spec)
{
struct usb_bus *bus;
DBG("\n");
xusb_init();
for (bus = usb_get_busses(); bus; bus = bus->next) {
int bus_num;
char tmppath[PATH_MAX + 1];
struct usb_device *dev;
tmppath[0] = '\0';
sscanf(bus->dirname, "%d", &bus_num);
snprintf(tmppath, sizeof(tmppath), "%03d", bus_num);
DBG("Check bus %d: %s ? %s\n", bus_num, tmppath, devpath);
if (strncmp(tmppath, devpath, strlen(tmppath)) != 0)
continue;
DBG("Matched bus %d\n", bus_num);
for (dev = bus->devices; dev; dev = dev->next) {
struct usb_device_descriptor *dev_desc;
struct usb_config_descriptor *config_desc;
struct usb_interface *interface;
struct xusb *xusb;
int device_num;
sscanf(dev->filename, "%d", &device_num);
DBG("Check device %d\n", device_num);
snprintf(tmppath, sizeof(tmppath), "%03d/%03d",
bus_num, device_num);
if (strncmp(tmppath, devpath, strlen(tmppath)) != 0)
continue;
dev_desc = &dev->descriptor;
assert(dev_desc);
config_desc = dev->config;
assert(config_desc);
interface = config_desc->interface;
assert(interface);
DBG("Matched device %s: %X:%X\n", tmppath,
dev_desc->idVendor, dev_desc->idProduct);
assert(dummy_spec);
xusb_init_spec(dummy_spec, "<none>",
dev_desc->idVendor, dev_desc->idProduct,
config_desc->bNumInterfaces,
iface_num,
interface->altsetting->bNumEndpoints,
ep_out, ep_in);
xusb = xusb_new(dev, dummy_spec);
if (!xusb)
ERR("xusb allocation failed\n");
return xusb;
}
}
return NULL;
}
static const char *path_tail(const char *path)
{
const char *p;
assert(path != NULL);
/* Find last '/' */
p = memrchr(path, '/', strlen(path));
if (!p) {
ERR("Missing a '/' in %s\n", path);
return NULL;
}
/* Search for a '/' before that */
p = memrchr(path, '/', p - path);
if (!p)
p = path; /* No more '/' */
else
p++; /* skip '/' */
return p;
}
int xusb_filter_bypath(const struct xusb *xusb, void *data)
{
const char *p;
const char *path = data;
DBG("%s\n", path);
assert(path != NULL);
p = path_tail(path);
if (strcmp(xusb->devpath_tail, p) != 0) {
DBG("device path missmatch: '%s' != '%s'\n",
xusb->devpath_tail, p);
return 0;
}
return 1;
}
struct xusb *xusb_find_bypath(const struct xusb_spec *specs, int numspecs,
const char *path)
{
struct xlist_node *xlist;
struct xlist_node *head;
struct xusb *xusb;
xlist = xusb_find_byproduct(specs, numspecs,
xusb_filter_bypath, (void *)path);
head = xlist_shift(xlist);
if (!head)
return NULL;
if (!xlist_empty(xlist)) {
ERR("Too many matches (extra %zd) to '%s'\n",
xlist_length(xlist), path);
return NULL;
}
xusb = head->data;
xlist_destroy(xlist, NULL);
return xusb;
}
struct xlist_node *xusb_find_byproduct(const struct xusb_spec *specs,
int numspecs, xusb_filter_t filterfunc, void *data)
{
struct xlist_node *xlist;
struct usb_bus *bus;
struct usb_device *dev;
DBG("specs(%d)\n", numspecs);
xlist = xlist_new(NULL);
if (!xlist) {
ERR("Failed allocation new xlist");
goto fail_xlist;
}
xusb_init();
for (bus = usb_get_busses(); bus; bus = bus->next) {
for (dev = bus->devices; dev; dev = dev->next) {
struct usb_device_descriptor *dev_desc;
struct xlist_node *item;
int i;
dev_desc = &dev->descriptor;
assert(dev_desc);
DBG("usb:%s/%s: ID=%04X:%04X\n",
dev->bus->dirname,
dev->filename,
dev_desc->idVendor,
dev_desc->idProduct);
for (i = 0; i < numspecs; i++) {
struct xusb *xusb;
const struct xusb_spec *sp = &specs[i];
if (!match_interface(dev, sp))
continue;
xusb = xusb_new(dev, sp);
if (!xusb) {
ERR("xusb allocation failed\n");
goto fail_malloc;
}
if (filterfunc && !filterfunc(xusb, data)) {
xusb_destroy(xusb);
continue;
}
item = xlist_new(xusb);
xlist_append_item(xlist, item);
break;
}
}
}
xusb_list_dump(xlist);
return xlist;
fail_malloc:
xlist_destroy(xlist, NULL);
fail_xlist:
return NULL;
}
struct xusb *xusb_open_one(const struct xusb_spec *specs, int numspecs,
xusb_filter_t filterfunc, void *data)
{
struct xlist_node *xusb_list;
struct xlist_node *curr;
int num;
struct xusb *xusb = NULL;
xusb_list = xusb_find_byproduct(specs, numspecs, filterfunc, data);
num = xlist_length(xusb_list);
DBG("total %d devices\n", num);
switch (num) {
case 0:
ERR("No matching device.\n");
break;
case 1:
curr = xlist_shift(xusb_list);
xusb = curr->data;
xlist_destroy(curr, NULL);
xlist_destroy(xusb_list, NULL);
if (!xusb_claim_interface(xusb)) {
xusb_destroy(xusb);
return NULL;
}
xusb_showinfo(xusb);
break;
default:
ERR("Too many devices (%d). Aborting.\n", num);
break;
}
return xusb;
}
int xusb_interface(struct xusb *xusb)
{
return xusb->interface_num;
}
size_t xusb_packet_size(const struct xusb *xusb)
{
return xusb->packet_size;
}
/*
* MP device handling
*/
void xusb_showinfo(const struct xusb *xusb)
{
struct usb_device_descriptor *dev_desc;
struct usb_device *dev;
assert(xusb != NULL);
dev = xusb->dev;
dev_desc = &dev->descriptor;
if (verbose <= LOG_INFO) {
INFO("usb:%s/%s: ID=%04X:%04X [%s / %s / %s]\n",
dev->bus->dirname,
dev->filename,
dev_desc->idVendor,
dev_desc->idProduct,
xusb->iManufacturer,
xusb->iProduct,
xusb->iSerialNumber);
} else {
printf("USB Bus/Device: [%s/%s] (%s,%s)\n",
dev->bus->dirname,
dev->filename,
(xusb->is_open) ? "open" : "closed",
(xusb->is_claimed) ? "claimed" : "unused");
printf("USB Spec name: [%s]\n", xusb->spec->name);
printf("USB iManufacturer: [%s]\n", xusb->iManufacturer);
printf("USB iProduct: [%s]\n", xusb->iProduct);
printf("USB iSerialNumber: [%s]\n", xusb->iSerialNumber);
}
}
const char *xusb_serial(const struct xusb *xusb)
{
return xusb->iSerialNumber;
}
const char *xusb_devpath(const struct xusb *xusb)
{
return xusb->devpath_tail;
}
const char *xusb_manufacturer(const struct xusb *xusb)
{
return xusb->iManufacturer;
}
const char *xusb_product(const struct xusb *xusb)
{
return xusb->iProduct;
}
uint16_t xusb_vendor_id(const struct xusb *xusb)
{
return xusb->dev->descriptor.idVendor;
}
uint16_t xusb_product_id(const struct xusb *xusb)
{
return xusb->dev->descriptor.idProduct;
}
const struct xusb_spec *xusb_spec(const struct xusb *xusb)
{
return xusb->spec;
}
int xusb_close(struct xusb *xusb)
{
if (xusb) {
if (xusb->handle) {
assert(xusb->spec);
assert(xusb->spec->name);
DBG("Closing interface \"%s\"\n", xusb->spec->name);
if (xusb->is_claimed) {
if (usb_release_interface(xusb->handle,
xusb->spec->my_interface_num) != 0)
ERR("Releasing interface: usb: %s\n",
usb_strerror());
xusb->is_claimed = 0;
}
if (xusb->is_open) {
if (usb_close(xusb->handle) != 0) {
ERR("Closing device: usb: %s\n",
usb_strerror());
}
xusb->is_open = 0;
}
xusb->handle = NULL;
}
xusb = NULL;
}
return 0;
}
int xusb_send(struct xusb *xusb, char *buf, int len, int timeout)
{
int ret;
int retries = 0;
dump_packet(LOG_DEBUG, DBG_MASK, __func__, buf, len);
if (EP_OUT(xusb) & USB_ENDPOINT_IN) {
ERR("%s called with an input endpoint 0x%x\n",
__func__, EP_OUT(xusb));
return -EINVAL;
}
retry_write:
ret = usb_bulk_write(xusb->handle, EP_OUT(xusb), buf, len, timeout);
if (ret < 0) {
/*
* If the device was gone, it may be the
* result of renumeration. Ignore it.
*/
if (ret != -ENODEV) {
ERR("bulk_write to endpoint 0x%x failed: (%d) %s\n",
EP_OUT(xusb), ret, usb_strerror());
dump_packet(LOG_ERR, DBG_MASK, "xusb_send[ERR]",
buf, len);
/*exit(2);*/
} else {
DBG("bulk_write to endpoint 0x%x got ENODEV\n",
EP_OUT(xusb));
xusb_close(xusb);
}
return ret;
}
if (!ret) {
ERR("bulk_write to endpoint 0x%x short write[%d]: (%d)\n",
EP_OUT(xusb), retries, ret);
if (retries++ > MAX_RETRIES)
return -EFAULT;
usleep(100);
goto retry_write;
}
if (ret != len) {
ERR("bulk_write to endpoint 0x%x short write: (%d) %s\n",
EP_OUT(xusb), ret, usb_strerror());
dump_packet(LOG_ERR, DBG_MASK, "xusb_send[ERR]", buf, len);
return -EFAULT;
}
return ret;
}
int xusb_recv(struct xusb *xusb, char *buf, size_t len, int timeout)
{
int ret;
int retries = 0;
if (EP_IN(xusb) & USB_ENDPOINT_OUT) {
ERR("%s called with an output endpoint 0x%x\n",
__func__, EP_IN(xusb));
return -EINVAL;
}
retry_read:
ret = usb_bulk_read(xusb->handle, EP_IN(xusb), buf, len, timeout);
if (ret < 0) {
DBG("bulk_read from endpoint 0x%x failed: (%d) %s\n",
EP_IN(xusb), ret, usb_strerror());
memset(buf, 0, len);
return ret;
}
if (!ret) {
ERR("bulk_read to endpoint 0x%x short read[%d]: (%d)\n",
EP_IN(xusb), retries, ret);
if (retries++ > MAX_RETRIES)
return -EFAULT;
usleep(100);
goto retry_read;
}
dump_packet(LOG_DEBUG, DBG_MASK, __func__, buf, ret);
return ret;
}
int xusb_flushread(struct xusb *xusb)
{
char tmpbuf[BUFSIZ];
int ret;
DBG("starting...\n");
memset(tmpbuf, 0, BUFSIZ);
ret = xusb_recv(xusb, tmpbuf, BUFSIZ, 1);
if (ret < 0 && ret != -ETIMEDOUT) {
ERR("ret=%d\n", ret);
return ret;
} else if (ret > 0) {
DBG("Got %d bytes:\n", ret);
dump_packet(LOG_DEBUG, DBG_MASK, __func__, tmpbuf, ret);
}
return 0;
}
/*
* Serialize calls to usb_find_busses()/usb_find_devices()
*/
static const key_t SEM_KEY = 0x1a2b3c4d;
static int semid = -1; /* Failure */
static void xusb_lock_usb()
{
struct sembuf sembuf;
while (semid < 0) {
/* Maybe it was already created? */
semid = semget(SEM_KEY, 1, 0);
if (semid < 0) {
/* No, let's create ourselves */
semid = semget(SEM_KEY, 1, IPC_CREAT | IPC_EXCL | 0644);
if (semid < 0) {
/* Someone else won the race to create it */
if (errno != ENOENT)
ERR("%s: semget() failed: %s\n",
__func__, strerror(errno));
/* Retry */
continue;
}
/* Initialize */
if (semctl(semid, 0, SETVAL, 1) < 0)
ERR("%s: SETVAL() failed: %s\n",
__func__, strerror(errno));
}
}
DBG("%d: LOCKING\n", getpid());
sembuf.sem_num = 0;
sembuf.sem_op = -1;
sembuf.sem_flg = SEM_UNDO;
if (semop(semid, &sembuf, 1) < 0)
ERR("%s: semop() failed: %s\n", __func__, strerror(errno));
DBG("%d: LOCKED\n", getpid());
}
static void xusb_unlock_usb()
{
struct sembuf sembuf;
DBG("%d: UNLOCKING\n", getpid());
sembuf.sem_num = 0;
sembuf.sem_op = 1;
sembuf.sem_flg = SEM_UNDO;
if (semop(semid, &sembuf, 1) < 0)
ERR("%s: semop() failed: %s\n", __func__, strerror(errno));
DBG("%d: UNLOCKED\n", getpid());
}
static int initizalized;
static void xusb_init()
{
if (!initizalized) {
xtalk_parse_options();
if (!xtalk_option_no_lock())
xusb_lock_usb();
usb_init();
usb_find_busses();
usb_find_devices();
initizalized = 1;
if (!xtalk_option_no_lock())
xusb_unlock_usb();
}
}
/* XTALK option handling */
static int use_clear_halt = 1;
static int libusb_no_lock = 0;
static int xtalk_one_option(const char *option_string)
{
if (strcmp(option_string, "use-clear-halt") == 0) {
use_clear_halt = 1;
return 0;
}
if (strcmp(option_string, "no-use-clear-halt") == 0) {
use_clear_halt = 0;
return 0;
}
if (strcmp(option_string, "no-lock") == 0) {
libusb_no_lock = 1;
return 0;
}
ERR("Unknown XTALK_OPTIONS content: '%s'\n", option_string);
return -EINVAL;
}
int xtalk_option_use_clear_halt(void)
{
return use_clear_halt;
}
int xtalk_option_no_lock(void)
{
return libusb_no_lock;
}
int xtalk_parse_options(void)
{
char *xtalk_options;
char *saveptr;
char *token;
int ret;
xtalk_options = getenv("XTALK_OPTIONS");
if (!xtalk_options)
return 0;
token = strtok_r(xtalk_options, " \t", &saveptr);
while (token) {
ret = xtalk_one_option(token);
if (ret < 0)
return ret;
token = strtok_r(NULL, " \t", &saveptr);
}
return 0;
}

102
xpp/xtalk/xusb.h
View File

@ -1,102 +0,0 @@
#ifndef XUSB_H
#define XUSB_H
/*
* 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 <stdio.h>
#include <stdint.h>
#include <usb.h>
#include <xlist.h>
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/*
* Xorcom usb handling
*/
#define PACKET_SIZE 512
/*
* Specify the wanted interface
*/
struct xusb_spec {
/* Sanity checks so we know it is our device indeed */
int num_interfaces;
int num_endpoints;
char *name; /* For debug/output purpose */
/* What we will actually use */
uint16_t my_vendor_id;
uint16_t my_product_id;
int my_interface_num;
int my_ep_out;
int my_ep_in;
};
void xusb_init_spec(struct xusb_spec *xusb_spec, char *name,
uint16_t vendor_id, uint16_t product_id,
int nifaces, int iface, int nep, int ep_out, int ep_in);
struct xusb;
/*
* Prototypes
*/
typedef int (*xusb_filter_t)(const struct xusb *xusb, void *data);
struct xlist_node *xusb_find_byproduct(const struct xusb_spec *specs,
int numspecs, xusb_filter_t filterfunc, void *data);
struct xusb *xusb_find_bypath(const struct xusb_spec *specs, int numspecs,
const char *path);
struct xusb *xusb_open_one(const struct xusb_spec *specs, int numspecs,
xusb_filter_t filterfunc, void *data);
struct xusb *xusb_find_iface(const char *devpath, int iface_num,
int ep_out, int ep_in, struct xusb_spec *dummy);
/*
* A convenience filter
*/
int xusb_filter_bypath(const struct xusb *xusb, void *data);
int xusb_interface(struct xusb *xusb);
int xusb_claim_interface(struct xusb *xusb);
void xusb_destroy(struct xusb *xusb);
int xusb_close(struct xusb *xusb);
size_t xusb_packet_size(const struct xusb *xusb);
void xusb_showinfo(const struct xusb *xusb);
const char *xusb_serial(const struct xusb *xusb);
const char *xusb_manufacturer(const struct xusb *xusb);
const char *xusb_product(const struct xusb *xusb);
uint16_t xusb_vendor_id(const struct xusb *xusb);
uint16_t xusb_product_id(const struct xusb *xusb);
const char *xusb_devpath(const struct xusb *xusb);
const struct xusb_spec *xusb_spec(const struct xusb *xusb);
int xusb_send(struct xusb *xusb, char *buf, int len, int timeout);
int xusb_recv(struct xusb *xusb, char *buf, size_t len, int timeout);
int xusb_flushread(struct xusb *xusb);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* XUSB_H */

2
xpp/xtalk/xusb_libusbx.c
View File

@ -566,7 +566,7 @@ struct xusb_device *xusb_find_bypath(const char *path)
ERR("usb device without a device descriptor\n"); ERR("usb device without a device descriptor\n");
continue; continue;
} }
INFO("Found: %04x:%04x %s\n", DBG("Found: %04x:%04x %s\n",
dev_desc.idVendor, dev_desc.idProduct, devpath_tail); dev_desc.idVendor, dev_desc.idProduct, devpath_tail);
xusb_init_spec(spec, "<BYPATH>", xusb_init_spec(spec, "<BYPATH>",
dev_desc.idVendor, dev_desc.idProduct); dev_desc.idVendor, dev_desc.idProduct);