dahdi-tools/xpp/mpptalk.c

1190 lines
31 KiB
C
Raw Normal View History

/*
* 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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <errno.h>
#include <arpa/inet.h>
#include <xtalk/debug.h>
#include <xtalk/proto.h>
#include "hexfile.h"
#include "mpptalk.h"
#define DBG_MASK 0x04
enum eeprom_burn_state {
BURN_STATE_NONE = 0,
BURN_STATE_STARTED = 1,
BURN_STATE_ENDED = 2,
BURN_STATE_FAILED = 3,
};
const char *eeprom_type2str(int et)
{
const static char *msgs[] = {
[EEPROM_TYPE_NONE] = "NONE",
[EEPROM_TYPE_SMALL] = "SMALL",
[EEPROM_TYPE_LARGE] = "LARGE",
[EEPROM_TYPE_UNUSED] = "UNUSED",
};
if(et > sizeof(msgs)/sizeof(msgs[0]))
return NULL;
return msgs[et];
};
const char *dev_dest2str(int dest)
{
const static char *msgs[] = {
[DEST_NONE] = "NONE",
[DEST_FPGA] = "FPGA",
[DEST_EEPROM] = "EEPROM",
};
if(dest > sizeof(msgs)/sizeof(msgs[0]))
return NULL;
return msgs[dest];
};
/*
* 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 */
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;
);
union XTALK_PDATA(MPP) {
MEMBER(MPP, STATUS_GET);
MEMBER(MPP, STATUS_GET_REPLY);
MEMBER(MPP, EEPROM_SET);
MEMBER(MPP, CAPS_GET);
MEMBER(MPP, CAPS_GET_REPLY);
MEMBER(MPP, CAPS_SET);
MEMBER(MPP, EXTRAINFO_GET);
MEMBER(MPP, EXTRAINFO_GET_REPLY);
MEMBER(MPP, EXTRAINFO_SET);
MEMBER(MPP, RENUM);
MEMBER(MPP, EEPROM_BLK_RD);
MEMBER(MPP, EEPROM_BLK_RD_REPLY);
MEMBER(MPP, DEV_SEND_SEG);
MEMBER(MPP, DEV_SEND_START);
MEMBER(MPP, DEV_SEND_END);
MEMBER(MPP, RESET);
MEMBER(MPP, HALF_RESET);
MEMBER(MPP, SER_SEND);
MEMBER(MPP, SER_RECV);
/* Twinstar */
MEMBER(MPP, TWS_WD_MODE_SET);
MEMBER(MPP, TWS_WD_MODE_GET);
MEMBER(MPP, TWS_WD_MODE_GET_REPLY);
MEMBER(MPP, TWS_PORT_SET);
MEMBER(MPP, TWS_PORT_GET);
MEMBER(MPP, TWS_PORT_GET_REPLY);
MEMBER(MPP, TWS_PWR_GET);
MEMBER(MPP, TWS_PWR_GET_REPLY);
} PACKED members;
/*
* 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 */
struct xtalk_protocol mpp_proto = {
.name = "MPP",
.proto_version = 0x14,
.commands = {
CMD_SEND(MPP, STATUS_GET),
CMD_RECV(MPP, STATUS_GET_REPLY),
CMD_SEND(MPP, EEPROM_SET),
CMD_SEND(MPP, CAPS_GET),
CMD_RECV(MPP, CAPS_GET_REPLY),
CMD_SEND(MPP, CAPS_SET),
CMD_SEND(MPP, EXTRAINFO_GET),
CMD_RECV(MPP, EXTRAINFO_GET_REPLY),
CMD_SEND(MPP, EXTRAINFO_SET),
CMD_SEND(MPP, RENUM),
CMD_SEND(MPP, EEPROM_BLK_RD),
CMD_RECV(MPP, EEPROM_BLK_RD_REPLY),
CMD_SEND(MPP, DEV_SEND_SEG),
CMD_SEND(MPP, DEV_SEND_START),
CMD_SEND(MPP, DEV_SEND_END),
CMD_SEND(MPP, RESET),
CMD_SEND(MPP, HALF_RESET),
CMD_SEND(MPP, SER_SEND),
CMD_SEND(MPP, SER_RECV),
/* Twinstar */
CMD_SEND(MPP, TWS_WD_MODE_SET),
CMD_SEND(MPP, TWS_WD_MODE_GET),
CMD_RECV(MPP, TWS_WD_MODE_GET_REPLY),
CMD_SEND(MPP, TWS_PORT_SET),
CMD_SEND(MPP, TWS_PORT_GET),
CMD_RECV(MPP, TWS_PORT_GET_REPLY),
CMD_SEND(MPP, TWS_PWR_GET),
CMD_RECV(MPP, TWS_PWR_GET_REPLY),
},
.ack_statuses = {
[STAT_OK] = "Acknowledges previous command",
[STAT_FAIL] = "Last command failed",
[STAT_RESET_FAIL] = "Reset failed",
[STAT_NODEST] = "No destination is selected",
[STAT_MISMATCH] = "Data mismatch",
[STAT_NOACCESS] = "No access",
[STAT_BAD_CMD] = "Bad command",
[STAT_TOO_SHORT] = "Packet is too short",
[STAT_ERROFFS] = "Offset error",
[STAT_NOCODE] = "Source was not burned before",
[STAT_NO_LEEPROM] = "Large EEPROM was not found",
[STAT_NO_EEPROM] = "No EEPROM was found",
[STAT_WRITE_FAIL] = "Writing to device failed",
[STAT_FPGA_ERR] = "FPGA error",
[STAT_KEY_ERR] = "Bad Capabilities Key",
[STAT_NOCAPS_ERR] = "No matching capability",
[STAT_NOPWR_ERR] = "No power on USB connector",
[STAT_CAPS_FPGA_ERR] = "Setting of the capabilities while FPGA is loaded",
}
};
struct mpp_device {
struct xtalk_base *xtalk_base;
struct xtalk_sync *xtalk_sync;
enum eeprom_burn_state burn_state;
int eeprom_type;
int status;
struct firmware_versions fw_versions;
};
struct xusb_iface *xubs_iface_of_mpp(struct mpp_device *mpp)
{
return xusb_iface_of_xtalk_base(mpp->xtalk_base);
}
struct mpp_device *mpp_new(struct xusb_iface *iface)
{
struct mpp_device *mpp_dev;
int ret;
mpp_dev = calloc(sizeof(*mpp_dev), 1);
if (!mpp_dev) {
ERR("Out of memory\n");
goto err;
}
mpp_dev->xtalk_base = xtalk_base_new_on_xusb(iface);
mpp_dev->xtalk_sync = xtalk_sync_new(mpp_dev->xtalk_base);
ret = xtalk_sync_set_protocol(mpp_dev->xtalk_sync, &mpp_proto);
if(ret < 0) {
ERR("MPP Protocol registration failed: %d\n", ret);
goto err;
}
return mpp_dev;
err:
if (mpp_dev)
free(mpp_dev);
return NULL;
}
void mpp_delete(struct mpp_device *dev)
{
xtalk_sync_delete(dev->xtalk_sync);
dev->xtalk_base = NULL;
free(dev);
}
struct xtalk_sync *xtalk_of_mpp(const struct mpp_device *dev)
{
return dev->xtalk_sync;
}
struct cmd_queue {
struct cmd_queue *next;
struct cmd_queue *prev;
struct xtalk_command *cmd;
};
static struct cmd_queue output_queue = {
.next = &output_queue,
.prev = &output_queue,
.cmd = NULL
};
void dump_command(struct xtalk_command *cmd)
{
uint16_t len;
int i;
len = cmd->header.len;
if(len < sizeof(struct mpp_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 mpp_header); i++) {
INFO(" %2d. 0x%X\n", i, cmd->alt.raw_data[i]);
}
}
static int set_ihex_version(char *dst, const char *src)
{
memcpy(dst, src, VERSION_LEN);
return 0;
}
enum eeprom_type mpp_eeprom_type(struct mpp_device *mpp_dev)
{
return mpp_dev->eeprom_type;
}
/*
* Protocol Commands
*/
int mpp_status_query(struct mpp_device *mpp_dev)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, XTALK_OP(MPP, STATUS_GET), 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
mpp_dev->eeprom_type = 0x3 & (CMD_FIELD(reply, MPP, STATUS_GET_REPLY, i2cs_data) >> 3);
mpp_dev->status = CMD_FIELD(reply, MPP, STATUS_GET_REPLY, status);
mpp_dev->fw_versions = CMD_FIELD(reply, MPP, STATUS_GET_REPLY, fw_versions);
DBG("EEPROM TYPE: %02x\n", mpp_dev->eeprom_type);
DBG("FPGA Firmware: %s\n", (mpp_dev->status & 0x1) ? "Loaded" : "Empty");
DBG("Firmware Versions: USB='%s' FPGA='%s' EEPROM='%s'\n",
mpp_dev->fw_versions.usb,
mpp_dev->fw_versions.fpga,
mpp_dev->fw_versions.eeprom);
free_command(reply);
return ret;
}
int mpp_eeprom_set(struct mpp_device *mpp_dev, const struct eeprom_table *et)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_EEPROM_SET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
memcpy(&CMD_FIELD(cmd, MPP, EEPROM_SET, data), et, sizeof(*et));
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
free_command(reply);
return 0;
}
int mpp_renumerate(struct mpp_device *mpp_dev)
{
struct xtalk_command *cmd;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_RENUM, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, NULL, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
return 0;
}
int mpp_caps_get(struct mpp_device *mpp_dev,
struct eeprom_table *eeprom_table,
struct capabilities *capabilities,
struct capkey *key)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_CAPS_GET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
assert(reply->header.op == MPP_CAPS_GET_REPLY);
if(eeprom_table) {
memcpy(eeprom_table, (void *)&CMD_FIELD(reply, MPP, CAPS_GET_REPLY, data), sizeof(*eeprom_table));
}
if(capabilities) {
const struct capabilities *cap = &CMD_FIELD(reply, MPP, CAPS_GET_REPLY, capabilities);
memcpy(capabilities, cap, sizeof(*capabilities));
}
if(key) {
const struct capkey *k = &CMD_FIELD(reply, MPP, CAPS_GET_REPLY, key);
memcpy(key, k, sizeof(*key));
}
free_command(reply);
return 0;
}
int mpp_caps_set(struct mpp_device *mpp_dev,
const struct eeprom_table *eeprom_table,
const struct capabilities *capabilities,
const struct capkey *key)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_CAPS_SET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
memcpy(&CMD_FIELD(cmd, MPP, CAPS_SET, data), eeprom_table, sizeof(*eeprom_table));
memcpy(&CMD_FIELD(cmd, MPP, CAPS_SET, capabilities), capabilities, sizeof(*capabilities));
memcpy(&CMD_FIELD(cmd, MPP, CAPS_SET, key), key, sizeof(*key));
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
free_command(reply);
return 0;
}
int mpp_extrainfo_get(struct mpp_device *mpp_dev, struct extrainfo *info)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_EXTRAINFO_GET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
assert(reply->header.op == MPP_EXTRAINFO_GET_REPLY);
if(info) {
int i;
memcpy(info, (void *)&CMD_FIELD(reply, MPP, EXTRAINFO_GET_REPLY, info), sizeof(*info));
/*
* clean non-printing characters
*/
for (i = sizeof(*info) - 1; i >= 0; i--) {
if (info->text[i] != (char)0xFF)
break;
info->text[i] = '\0';
}
}
free_command(reply);
return 0;
}
int mpp_extrainfo_set(struct mpp_device *mpp_dev, const struct extrainfo *info)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_EXTRAINFO_SET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
memcpy(&CMD_FIELD(cmd, MPP, EXTRAINFO_SET, info), info, sizeof(*info));
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
free_command(reply);
return 0;
}
int mpp_eeprom_blk_rd(struct mpp_device *mpp_dev, uint8_t *buf, uint16_t offset, uint16_t len)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
int size;
DBG("len = %d, offset = %d\n", len, offset);
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_EEPROM_BLK_RD, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
CMD_FIELD(cmd, MPP, EEPROM_BLK_RD, len) = len;
CMD_FIELD(cmd, MPP, EEPROM_BLK_RD, offset) = offset;
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
size = ret;
goto out;
}
size = reply->header.len - sizeof(struct mpp_header) - sizeof(XTALK_STRUCT(MPP, EEPROM_BLK_RD_REPLY));
INFO("size=%d offset=0x%X\n", size, CMD_FIELD(reply, MPP, EEPROM_BLK_RD_REPLY, offset));
dump_packet(LOG_DEBUG, DBG_MASK, "BLK_RD", (char *)reply, ret);
if(size > len) {
ERR("Truncating reply (was %d, now %d)\n", size, len);
size = len;
}
memcpy(buf, CMD_FIELD(reply, MPP, EEPROM_BLK_RD_REPLY, data), size);
out:
free_command(reply);
return size;
}
int mpp_send_start(struct mpp_device *mpp_dev, int dest, const char *ihex_version)
{
struct xtalk_command *cmd;
struct xtalk_command *reply = NULL;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret = 0;
DBG("dest = %s ihex_version = '%s'\n", dev_dest2str(dest), ihex_version);
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_DEV_SEND_START, 0)) == NULL) {
ERR("new_command failed\n");
ret = -ENOMEM;
goto out;
}
CMD_FIELD(cmd, MPP, DEV_SEND_START, dest) = dest;
set_ihex_version(CMD_FIELD(cmd, MPP, DEV_SEND_START, ihex_version), ihex_version);
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
goto out;
}
out:
if(reply)
free_command(reply);
mpp_dev->burn_state = (ret > 0)
? BURN_STATE_STARTED
: BURN_STATE_FAILED;
return ret;
}
int mpp_send_end(struct mpp_device *mpp_dev)
{
struct xtalk_command *cmd;
struct xtalk_command *reply = NULL;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret = 0;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_DEV_SEND_END, 0)) == NULL) {
ERR("new_command failed\n");
ret = -ENOMEM;
goto out;
}
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
goto out;
}
out:
if(reply)
free_command(reply);
mpp_dev->burn_state = (ret > 0)
? BURN_STATE_ENDED
: BURN_STATE_FAILED;
return ret;
}
int mpp_send_seg(struct mpp_device *mpp_dev, const uint8_t *data, uint16_t offset, uint16_t len)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if(mpp_dev->burn_state != BURN_STATE_STARTED) {
ERR("Tried to send a segment while burn_state=%d\n",
mpp_dev->burn_state);
return -EINVAL;
}
DBG("len = %d, offset = %d (0x%02X, 0x%02X)\n", len, offset, *data, *(data + 1));
if((cmd = new_command(xtalk_base, MPP_DEV_SEND_SEG, len)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
CMD_FIELD(cmd, MPP, DEV_SEND_SEG, offset) = offset;
memcpy(CMD_FIELD(cmd, MPP, DEV_SEND_SEG, data), data, len);
#if 0
{
FILE *fp;
if((fp = fopen("seg_data.bin", "a")) == NULL) {
perror("seg_data.bin");
exit(1);
}
if(fwrite(CMD_FIELD(cmd, MPP, DEV_SEND_SEG, data), len, 1, fp) != 1) {
perror("fwrite");
exit(1);
}
fclose(fp);
}
#endif
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
free_command(reply);
return 0;
}
int mpp_reset(struct mpp_device *mpp_dev, int full_reset)
{
struct xtalk_command *cmd;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
int op = (full_reset) ? MPP_RESET: MPP_HALF_RESET;
DBG("full = %s\n", (full_reset) ? "YES" : "NO");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, op, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, NULL, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
return 0;
}
int mpp_serial_cmd(struct mpp_device *mpp_dev, const uint8_t *in, uint8_t *out, uint16_t len)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
uint8_t *data;
DBG("len=%d\n", len);
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_SER_SEND, len)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
data = CMD_FIELD(cmd, MPP, SER_SEND, data);
memcpy(data, in, len);
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
assert(reply->header.op == MPP_SER_RECV);
data = CMD_FIELD(reply, MPP, SER_RECV, data);
memcpy(out, data, len);
free_command(reply);
return 0;
}
int mpps_card_info(struct mpp_device *mpp_dev, int unit, uint8_t *card_type, uint8_t *card_status)
{
/*
* Serial commands must have equal send/receive size
*/
struct card_info_command {
uint8_t ser_op;
uint8_t addr;
uint8_t card_full_type; /* (type << 4 | subtype) */
uint8_t card_status; /* BIT(0) - PIC burned */
} PACKED;
struct card_info_command ci_send;
struct card_info_command ci_recv;
int ret;
memset(&ci_send, 0, sizeof(ci_send));
memset(&ci_recv, 0, sizeof(ci_recv));
ci_send.ser_op = SER_CARD_INFO_GET;
ci_send.addr = (unit << 4); /* low nibble is subunit */
ret = mpp_serial_cmd(mpp_dev,
(uint8_t *)&ci_send,
(uint8_t *)&ci_recv,
sizeof(struct card_info_command));
if (ret < 0)
return ret;
*card_type = ci_recv.card_full_type;
*card_status = ci_recv.card_status;
return 0;
}
int mpps_stat(struct mpp_device *mpp_dev, int unit, uint8_t *fpga_configuration, uint8_t *status)
{
/*
* Serial commands must have equal send/receive size
*/
struct fpga_stat_command {
uint8_t ser_op;
uint8_t fpga_configuration;
uint8_t status; /* BIT(0) - Watchdog timer status */
} PACKED;
struct fpga_stat_command fs_send;
struct fpga_stat_command fs_recv;
int ret;
memset(&fs_send, 0, sizeof(fs_send));
memset(&fs_recv, 0, sizeof(fs_recv));
fs_send.ser_op = SER_STAT_GET;
ret = mpp_serial_cmd(mpp_dev,
(uint8_t *)&fs_send,
(uint8_t *)&fs_recv,
sizeof(struct fpga_stat_command));
if(ret < 0)
return ret;
*fpga_configuration = fs_recv.fpga_configuration;
*status = fs_recv.status;
return 0;
}
int mpp_tws_watchdog(struct mpp_device *mpp_dev)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_TWS_WD_MODE_GET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
ret = CMD_FIELD(reply, MPP, TWS_WD_MODE_GET_REPLY, wd_active);
DBG("wd_active=0x%X\n", ret);
free_command(reply);
return ret == 1;
}
int mpp_tws_setwatchdog(struct mpp_device *mpp_dev, int yes)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("%s\n", (yes) ? "YES" : "NO");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_TWS_WD_MODE_SET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
CMD_FIELD(cmd, MPP, TWS_WD_MODE_SET, wd_active) = (yes) ? 1 : 0;
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
free_command(reply);
return 0;
}
int mpp_tws_powerstate(struct mpp_device *mpp_dev)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_TWS_PWR_GET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
ret = CMD_FIELD(reply, MPP, TWS_PWR_GET_REPLY, power);
DBG("power=0x%X\n", ret);
free_command(reply);
return ret;
}
int mpp_tws_portnum(struct mpp_device *mpp_dev)
{
struct xtalk_command *cmd;
struct xtalk_command *reply;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if((cmd = new_command(xtalk_base, MPP_TWS_PORT_GET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
ret = process_command(xtalk_sync, cmd, &reply, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
ret = CMD_FIELD(reply, MPP, TWS_PORT_GET_REPLY, portnum);
DBG("portnum=0x%X\n", ret);
free_command(reply);
return ret;
}
int mpp_tws_setportnum(struct mpp_device *mpp_dev, uint8_t portnum)
{
struct xtalk_command *cmd;
struct xtalk_sync *xtalk_sync;
struct xtalk_base *xtalk_base;
uint16_t tx_seq;
int ret;
DBG("\n");
assert(mpp_dev != NULL);
xtalk_sync = mpp_dev->xtalk_sync;
xtalk_base = mpp_dev->xtalk_base;
if(portnum >= 2) {
ERR("Invalid portnum (%d)\n", portnum);
return -EINVAL;
}
if((cmd = new_command(xtalk_base, MPP_TWS_PORT_SET, 0)) == NULL) {
ERR("new_command failed\n");
return -ENOMEM;
}
CMD_FIELD(cmd, MPP, TWS_PORT_SET, portnum) = portnum;
ret = process_command(xtalk_sync, cmd, NULL, &tx_seq);
if(ret < 0) {
ERR("process_command failed: %d\n", ret);
return ret;
}
return 0;
}
/*
* data structures
*/
void show_eeprom(const struct eeprom_table *eprm, FILE *fp)
{
int rmajor;
int rminor;
char buf[BUFSIZ];
rmajor = (eprm->release >> 8) & 0xFF;
rminor = eprm->release & 0xFF;;
memset(buf, 0, LABEL_SIZE + 1);
memcpy(buf, eprm->label, LABEL_SIZE);
fprintf(fp, "EEPROM: %-15s: 0x%02X\n", "Source", eprm->source);
fprintf(fp, "EEPROM: %-15s: 0x%04X\n", "Vendor", eprm->vendor);
fprintf(fp, "EEPROM: %-15s: 0x%04X\n", "Product", eprm->product);
fprintf(fp, "EEPROM: %-15s: %d.%d\n", "Release", rmajor, rminor);
fprintf(fp, "EEPROM: %-15s: 0x%02X\n", "Config", eprm->config_byte);
fprintf(fp, "EEPROM: %-15s: '%s'\n", "Label", buf);
}
void show_capabilities(const struct capabilities *capabilities, FILE *fp)
{
fprintf(fp, "Capabilities: FXS ports: %2d\n", capabilities->ports_fxs);
fprintf(fp, "Capabilities: FXO ports: %2d\n", capabilities->ports_fxo);
fprintf(fp, "Capabilities: BRI ports: %2d\n", capabilities->ports_bri);
fprintf(fp, "Capabilities: PRI ports: %2d\n", capabilities->ports_pri);
fprintf(fp, "Capabilities: ECHO ports: %2d\n", capabilities->ports_echo);
fprintf(fp, "Capabilities: TwinStar : %s\n",
(CAP_EXTRA_TWINSTAR(capabilities)) ? "Yes" : "No");
}
void show_astribank_status(struct mpp_device *mpp_dev, FILE *fp)
{
char version_buf[BUFSIZ];
int is_loaded = STATUS_FPGA_LOADED(mpp_dev->status);
fprintf(fp, "Astribank: EEPROM : %s\n",
eeprom_type2str(mpp_dev->eeprom_type));
fprintf(fp, "Astribank: FPGA status : %s\n",
is_loaded ? "Loaded" : "Empty");
if(is_loaded) {
memset(version_buf, 0, sizeof(version_buf));
memcpy(version_buf, mpp_dev->fw_versions.fpga, VERSION_LEN);
fprintf(fp, "Astribank: FPGA version: %s\n",
version_buf);
}
}
void show_extrainfo(const struct extrainfo *extrainfo, FILE *fp)
{
char buf[EXTRAINFO_SIZE + 1];
memcpy(buf, extrainfo->text, EXTRAINFO_SIZE);
buf[EXTRAINFO_SIZE] = '\0'; /* assure null termination */
fprintf(fp, "Extrainfo: : '%s'\n", buf);
}
int twinstar_show(struct mpp_device *mpp, FILE *fp)
{
int watchdog;
int powerstate;
int portnum;
int i;
if((watchdog = mpp_tws_watchdog(mpp)) < 0) {
ERR("Failed getting TwinStar information\n");
return watchdog;
}
if((powerstate = mpp_tws_powerstate(mpp)) < 0) {
ERR("Failed getting TwinStar powerstate\n");
return powerstate;
}
if((portnum = mpp_tws_portnum(mpp)) < 0) {
ERR("Failed getting TwinStar portnum\n");
return portnum;
}
fprintf(fp, "TwinStar: Connected to : USB-%1d\n", portnum);
fprintf(fp, "TwinStar: Watchdog : %s\n",
(watchdog) ? "on-guard" : "off-guard");
for(i = 0; i < 2; i++) {
int pw = (1 << i) & powerstate;
fprintf(fp, "TwinStar: USB-%1d POWER : %s\n",
i, (pw) ? "ON" : "OFF");
}
return 0;
}
int show_hardware(struct mpp_device *mpp_dev)
{
int ret;
struct eeprom_table eeprom_table;
struct capabilities capabilities;
struct extrainfo extrainfo;
ret = mpp_caps_get(mpp_dev, &eeprom_table, &capabilities, NULL);
if(ret < 0)
return ret;
show_eeprom(&eeprom_table, stdout);
show_astribank_status(mpp_dev, stdout);
if(mpp_dev->eeprom_type == EEPROM_TYPE_LARGE) {
show_capabilities(&capabilities, stdout);
if(STATUS_FPGA_LOADED(mpp_dev->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(mpp_dev, 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(mpp_dev, 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(mpp_dev, &extrainfo);
if(ret < 0)
return ret;
show_extrainfo(&extrainfo, stdout);
if(CAP_EXTRA_TWINSTAR(&capabilities)) {
if ((eeprom_table.product & 0xFFF0) != 0x1160)
printf("TwinStar: NO\n");
else
twinstar_show(mpp_dev, stdout);
}
}
return 0;
}