1332 lines
42 KiB
C++
1332 lines
42 KiB
C++
/*
|
|
* ebusd - daemon for communication with eBUS heating systems.
|
|
* Copyright (C) 2020-2022 John Baier <ebusd@ebusd.eu>
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <fcntl.h>
|
|
#include <poll.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/file.h>
|
|
#include <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <arpa/inet.h>
|
|
#include <netdb.h>
|
|
#include <dirent.h>
|
|
#include <time.h>
|
|
#include <termios.h>
|
|
#include <unistd.h>
|
|
#include <argp.h>
|
|
#include <iostream>
|
|
#include <fstream>
|
|
#include <cstdlib>
|
|
#include <iomanip>
|
|
#include <string>
|
|
#include <cstring>
|
|
#include "intelhex/intelhexclass.h"
|
|
#include "lib/utils/tcpsocket.h"
|
|
|
|
using ebusd::socketConnect;
|
|
|
|
/** the version string of the program. */
|
|
const char *argp_program_version = "eBUS adapter PIC firmware loader";
|
|
|
|
/** the documentation of the program. */
|
|
static const char argpdoc[] =
|
|
"A tool for loading firmware to the eBUS adapter PIC and configure some adjustable settings."
|
|
"\vPORT is either the serial port to use (e.g./dev/ttyUSB0) that also supports a trailing wildcard '*' for testing"
|
|
" multiple ports, or a network port as \"ip:port\" for use with e.g. socat or ebusd-esp.";
|
|
|
|
static const char argpargsdoc[] = "PORT";
|
|
|
|
/** the definition of the known program arguments. */
|
|
static const struct argp_option argpoptions[] = {
|
|
{"verbose", 'v', nullptr, 0, "enable verbose output", 0 },
|
|
{"dhcp", 'd', nullptr, 0, "set dynamic IP address via DHCP (default)", 0 },
|
|
{"ip", 'i', "IP", 0, "set fix IP address (e.g. 192.168.0.10)", 0 },
|
|
{"mask", 'm', "MASK", 0, "set fix IP mask (e.g. 24)", 0 },
|
|
{"gateway", 'g', "GW", 0, "set fix IP gateway to GW (if necessary and other than net address + 1)", 0 },
|
|
{"macip", 'M', nullptr, 0, "set the MAC address suffix from the IP address", 0 },
|
|
{"macid", 'I', nullptr, 0, "set the MAC address suffix from internal ID (default)", 0 },
|
|
{"arbdel", 'a', "US", 0, "set arbitration delay to US microseconds (0-620 in steps of 10, default 200"
|
|
", since firmware 20211128)", 0 },
|
|
{"pingon", 'p', nullptr, 0, "enable visual ping (default)", 0 },
|
|
{"pingoff", 'o', nullptr, 0, "disable visual ping", 0 },
|
|
{"softvar", -3, "VARIANT", 0, "set the soft jumpers VARIANT to U=USB/RPI (default), W=WIFI, E=Ethernet,"
|
|
" N=non-enhanced USB/RPI/WIFI, F=non-enhanced Ethernet"
|
|
" (prefer hard jumpers in lowercase, ignore hard jumpers in uppercase"
|
|
", since firmware 20221206)", 0 },
|
|
{"hardvar", -4, nullptr, 0, "set the variant from hard jumpers only (ignore soft jumpers)", 0 },
|
|
{"flash", 'f', "FILE", 0, "flash the FILE to the device", 0 },
|
|
{"reset", 'r', nullptr, 0, "reset the device at the end on success", 0 },
|
|
{"slow", 's', nullptr, 0, "use low speed for transfer", 0 },
|
|
{nullptr, 0, nullptr, 0, nullptr, 0 },
|
|
};
|
|
|
|
static bool verbose = false;
|
|
static bool setDhcp = false;
|
|
static bool setIp = false;
|
|
static uint8_t setIpAddress[] = {0, 0, 0, 0};
|
|
static bool setMacFromIp = false;
|
|
static bool setMacFromIpValue = true;
|
|
static bool setMask = false;
|
|
static uint8_t setMaskLen = 0x1f;
|
|
static bool setGateway = false;
|
|
uint32_t setGatewayBits = 0;
|
|
static bool setArbitrationDelay = false;
|
|
static uint16_t setArbitrationDelayMicros = 0;
|
|
static bool setVisualPing = false;
|
|
static bool setVisualPingOn = false;
|
|
static bool setSoftVariant = false;
|
|
static uint8_t setSoftVariantValue = 0;
|
|
static bool setSoftVariantForced = false;
|
|
static bool setHardVariant = false;
|
|
static char* flashFile = nullptr;
|
|
static bool reset = false;
|
|
static bool lowSpeed = false;
|
|
|
|
bool parseByte(const char *arg, uint8_t minValue, uint8_t maxValue, uint8_t *result) {
|
|
char* strEnd = nullptr;
|
|
unsigned long value = 0;
|
|
strEnd = nullptr;
|
|
value = strtoul(arg, &strEnd, 10);
|
|
if (strEnd == nullptr || strEnd == arg || *strEnd != 0) {
|
|
return false;
|
|
}
|
|
if (value<minValue || value>maxValue) {
|
|
return false;
|
|
}
|
|
*result = (uint8_t)value;
|
|
return true;
|
|
}
|
|
|
|
bool parseShort(const char *arg, uint16_t minValue, uint16_t maxValue, uint16_t *result) {
|
|
char* strEnd = nullptr;
|
|
unsigned long value = 0;
|
|
strEnd = nullptr;
|
|
value = strtoul(arg, &strEnd, 10);
|
|
if (strEnd == nullptr || strEnd == arg || *strEnd != 0) {
|
|
return false;
|
|
}
|
|
if (value<minValue || value>maxValue) {
|
|
return false;
|
|
}
|
|
*result = (uint16_t)value;
|
|
return true;
|
|
}
|
|
|
|
error_t parse_opt(int key, char *arg, struct argp_state *state) {
|
|
char *ip = nullptr, *part = nullptr;
|
|
int pos = 0, sum = 0;
|
|
struct stat st;
|
|
uint32_t hostBits = 0;
|
|
switch (key) {
|
|
case 'v': // --verbose
|
|
verbose = true;
|
|
break;
|
|
case 'd': // --dhcp
|
|
if (setIp || setMask || setGateway) {
|
|
argp_error(state, "either DHCP or IP address is needed");
|
|
return EINVAL;
|
|
}
|
|
setDhcp = true;
|
|
break;
|
|
case 'i': // --ip=192.168.0.10
|
|
if (arg == nullptr || arg[0] == 0) {
|
|
argp_error(state, "invalid IP address");
|
|
return EINVAL;
|
|
}
|
|
if (setDhcp) {
|
|
argp_error(state, "either DHCP or IP address is needed");
|
|
return EINVAL;
|
|
}
|
|
if (setIp) {
|
|
argp_error(state, "IP address was specified twice");
|
|
return EINVAL;
|
|
}
|
|
ip = strdup(arg);
|
|
part = strtok(ip, ".");
|
|
|
|
for (pos=0; part && pos < 4; pos++) {
|
|
if (!parseByte(part, 0, 255, setIpAddress+pos)) {
|
|
break;
|
|
}
|
|
sum += setIpAddress[pos];
|
|
part = strtok(nullptr, ".");
|
|
}
|
|
free(ip);
|
|
if (pos != 4 || part || sum == 0) {
|
|
argp_error(state, "invalid IP address");
|
|
return EINVAL;
|
|
}
|
|
setIp = true;
|
|
break;
|
|
case 'm': // --mask=24
|
|
if (arg == nullptr || arg[0] == 0) {
|
|
argp_error(state, "invalid IP mask");
|
|
return EINVAL;
|
|
}
|
|
if (setDhcp) {
|
|
argp_error(state, "either DHCP or IP address is needed");
|
|
return EINVAL;
|
|
}
|
|
if (setMask) {
|
|
argp_error(state, "mask was specified twice");
|
|
return EINVAL;
|
|
}
|
|
if (!parseByte(arg, 1, 0x1e, &setMaskLen)) {
|
|
argp_error(state, "invalid IP mask");
|
|
return EINVAL;
|
|
}
|
|
setMask = true;
|
|
break;
|
|
case 'g': // --gateway=192.168.0.11
|
|
if (arg == nullptr || arg[0] == 0) {
|
|
argp_error(state, "invalid gateway");
|
|
return EINVAL;
|
|
}
|
|
if (setDhcp) {
|
|
argp_error(state, "either DHCP or IP address is needed");
|
|
return EINVAL;
|
|
}
|
|
if (!setIp || !setMask) {
|
|
argp_error(state, "IP and mask need to be specified before gateway");
|
|
return EINVAL;
|
|
}
|
|
ip = strdup(arg);
|
|
part = strtok(ip, ".");
|
|
setGatewayBits = 0;
|
|
hostBits = 0;
|
|
for (pos=0; part && pos < 4; pos++) {
|
|
uint8_t address = 0;
|
|
if (!parseByte(part, 0, 255, &address)) {
|
|
break;
|
|
}
|
|
sum += address;
|
|
part = strtok(nullptr, ".");
|
|
uint8_t maskRemain = setMaskLen-pos*8;
|
|
uint8_t mask = maskRemain >= 8 ? 255 : maskRemain == 0 ? 0 : (255^((1 << (8 - maskRemain)) - 1));
|
|
if ((address & mask) != (setIpAddress[pos] & mask)) {
|
|
argp_error(state, "invalid gateway (different network)");
|
|
free(ip);
|
|
return EINVAL;
|
|
}
|
|
setGatewayBits = (setGatewayBits << 8) | (address & ~mask);
|
|
hostBits = (hostBits << 8) | (setIpAddress[pos] & ~mask);
|
|
}
|
|
free(ip);
|
|
if (pos != 4 || part || sum == 0 || setGatewayBits == 0) {
|
|
argp_error(state, "invalid gateway");
|
|
return EINVAL;
|
|
}
|
|
if (setGatewayBits == hostBits) {
|
|
argp_error(state, "invalid gateway (same as address)");
|
|
return EINVAL;
|
|
}
|
|
if (!setGatewayBits || setGatewayBits == ((1 << (32 - setMaskLen)) - 1)) {
|
|
argp_error(state, "invalid gateway (net or broadcast address)");
|
|
return EINVAL;
|
|
}
|
|
if (setGatewayBits == 1) { // default
|
|
setGatewayBits = 0x3f;
|
|
setGateway = true;
|
|
break;
|
|
}
|
|
if (setMaskLen >= 27) {
|
|
// fine: all bits are available
|
|
setGateway = true;
|
|
break;
|
|
}
|
|
if (!(setGatewayBits >> 5)) {
|
|
if (!(setGatewayBits & 0x1f)) {
|
|
argp_error(state, "invalid gateway (net address)");
|
|
return EINVAL;
|
|
}
|
|
// fine: host part above max gateway adjustable bits is the same and remainder non-zero
|
|
setGatewayBits &= 0x1f;
|
|
setGateway = true;
|
|
break;
|
|
}
|
|
if ((setGatewayBits >> 5) == ((1<<((32-setMaskLen)-5))-1)) {
|
|
// fine: host part above max gateway adjustable bits is all 1
|
|
setGatewayBits = 0x20 | (setGatewayBits & 0x1f);
|
|
setGateway = true;
|
|
break;
|
|
}
|
|
argp_error(state, "invalid gateway (out of possible range of first/last 31 hosts in subnet)");
|
|
return EINVAL;
|
|
case 'M': // --macip
|
|
setMacFromIp = true;
|
|
setMacFromIpValue = true;
|
|
break;
|
|
case 'I': // --macid
|
|
setMacFromIp = true;
|
|
setMacFromIpValue = false;
|
|
break;
|
|
case 'a': // --arbdel=1000
|
|
if (arg == nullptr || arg[0] == 0) {
|
|
argp_error(state, "invalid arbitration delay");
|
|
return EINVAL;
|
|
}
|
|
if (!parseShort(arg, 0, 620, &setArbitrationDelayMicros)) {
|
|
argp_error(state, "invalid arbitration delay");
|
|
return EINVAL;
|
|
}
|
|
setArbitrationDelay = true;
|
|
break;
|
|
case 'p': // --pingon
|
|
setVisualPing = true;
|
|
setVisualPingOn = true;
|
|
break;
|
|
case 'o': // --pingoff
|
|
setVisualPing = true;
|
|
setVisualPingOn = false;
|
|
break;
|
|
case -3: // --softvar=U|W|E|F|N|u|w|e|f|n
|
|
if (setHardVariant) {
|
|
argp_error(state, "can't set hard and soft jumpers");
|
|
return EINVAL;
|
|
}
|
|
if (arg == nullptr || arg[0] == 0) {
|
|
argp_error(state, "invalid variant");
|
|
return EINVAL;
|
|
}
|
|
if (arg[0] == 'u' || arg[0] == 'U') {
|
|
setSoftVariantValue = 3;
|
|
} else if (arg[0] == 'w' || arg[0] == 'W') {
|
|
setSoftVariantValue = 2;
|
|
} else if (arg[0] == 'e' || arg[0] == 'E') {
|
|
setSoftVariantValue = 1;
|
|
} else if (arg[0] == 'f' || arg[0] == 'F') {
|
|
setSoftVariantValue = 4;
|
|
} else if (arg[0] == 'n' || arg[0] == 'N') {
|
|
setSoftVariantValue = 0;
|
|
} else {
|
|
argp_error(state, "invalid variant");
|
|
return EINVAL;
|
|
}
|
|
setSoftVariantForced = arg[0]<'a';
|
|
setSoftVariant = true;
|
|
break;
|
|
case -4: // --hardvar
|
|
if (setSoftVariant) {
|
|
argp_error(state, "can't set hard and soft jumpers");
|
|
return EINVAL;
|
|
}
|
|
setSoftVariantValue = 3;
|
|
setSoftVariantForced = false;
|
|
setHardVariant = true;
|
|
break;
|
|
case 'f': // --flash=firmware.hex
|
|
if (arg == nullptr || arg[0] == 0 || stat(arg, &st) != 0 || !S_ISREG(st.st_mode)) {
|
|
argp_error(state, "invalid flash file");
|
|
return EINVAL;
|
|
}
|
|
flashFile = arg;
|
|
break;
|
|
case 'r': // --reset
|
|
reset = true;
|
|
break;
|
|
case 's': // --slow
|
|
lowSpeed = true;
|
|
break;
|
|
default:
|
|
return ARGP_ERR_UNKNOWN;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// START: copy from generated bootloader
|
|
|
|
#define WRITE_FLASH_BLOCKSIZE 32
|
|
#define ERASE_FLASH_BLOCKSIZE 32
|
|
#define END_FLASH 0x4000
|
|
|
|
// Frame Format
|
|
//
|
|
// [<COMMAND><DATALEN><ADDRL><ADDRH><ADDRU><...DATA...>]
|
|
// These values are negative because the FSR is set to PACKET_DATA to minimize FSR reloads.
|
|
typedef union
|
|
{
|
|
struct __attribute__((__packed__))
|
|
{
|
|
uint8_t command;
|
|
uint16_t data_length;
|
|
uint8_t EE_key_1;
|
|
uint8_t EE_key_2;
|
|
uint8_t address_L;
|
|
uint8_t address_H;
|
|
uint8_t address_U;
|
|
uint8_t address_unused;
|
|
uint8_t data[2*WRITE_FLASH_BLOCKSIZE];
|
|
};
|
|
uint8_t buffer[2*WRITE_FLASH_BLOCKSIZE+9];
|
|
}frame_t;
|
|
|
|
#define STX 0x55
|
|
|
|
#define READ_VERSION 0
|
|
#define READ_FLASH 1
|
|
#define WRITE_FLASH 2
|
|
#define ERASE_FLASH 3
|
|
#define READ_EE_DATA 4
|
|
#define WRITE_EE_DATA 5
|
|
#define READ_CONFIG 6
|
|
#define WRITE_CONFIG 7
|
|
#define CALC_CHECKSUM 8
|
|
#define RESET_DEVICE 9
|
|
#define CALC_CRC 10
|
|
|
|
#define MINOR_VERSION 0x08 // Version
|
|
#define MAJOR_VERSION 0x00
|
|
//#define STX 0x55 // Actually code 0x55 is 'U' But this is what the autobaud feature of the PIC16F1 EUSART is looking for
|
|
#define ERROR_ADDRESS_OUT_OF_RANGE 0xFE
|
|
#define ERROR_INVALID_COMMAND 0xFF
|
|
#define COMMAND_SUCCESS 0x01
|
|
|
|
// END: copy from generated bootloader
|
|
|
|
#define FRAME_HEADER_LEN 9
|
|
#define FRAME_MAX_LEN (FRAME_HEADER_LEN+2*WRITE_FLASH_BLOCKSIZE)
|
|
#define BAUDRATE_LOW B115200
|
|
#define BAUDRATE_HIGH B921600
|
|
#define WAIT_BYTE_TRANSFERRED_MILLIS 200
|
|
#define WAIT_BITRATE_DETECTION_MICROS 100
|
|
#define WAIT_RESPONSE_TIMEOUT_MILLIS 100
|
|
// size of flash in bytes
|
|
#define END_FLASH_BYTES (END_FLASH*2)
|
|
// size of boot block in words
|
|
#define END_BOOT 0x0400
|
|
// size of boot block in bytes
|
|
#define END_BOOT_BYTES (END_BOOT*2)
|
|
|
|
static bool isSerial = true;
|
|
static int timeoutFactor = 1;
|
|
static int timeoutAddend = 0;
|
|
|
|
ssize_t waitWrite(int fd, uint8_t *data, size_t len, int timeoutMillis) {
|
|
int ret;
|
|
struct pollfd pfd;
|
|
pfd.fd = fd;
|
|
pfd.events = POLLOUT | POLLERR | POLLHUP;
|
|
ret = poll(&pfd, 1, timeoutMillis*timeoutFactor + timeoutAddend);
|
|
if (ret >= 0 && pfd.revents & (POLLERR | POLLHUP)) {
|
|
return -1;
|
|
}
|
|
if (ret <= 0) {
|
|
return ret;
|
|
}
|
|
ret = write(fd, data, len);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
#ifdef DEBUG_RAW
|
|
std::cout << "> " << std::dec << static_cast<unsigned>(ret) << "/" << static_cast<unsigned>(len) << ":" << std::hex;
|
|
for (int pos = 0; pos < ret; pos++) {
|
|
std::cout << " " << std::setw(2) << std::setfill('0') << static_cast<unsigned>(data[pos]);
|
|
}
|
|
std::cout << std::endl;
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
ssize_t waitRead(int fd, uint8_t *data, size_t len, int timeoutMillis) {
|
|
int ret;
|
|
struct pollfd pfd;
|
|
pfd.fd = fd;
|
|
pfd.events = POLLIN | POLLERR | POLLHUP;
|
|
ret = poll(&pfd, 1, timeoutMillis*timeoutFactor + timeoutAddend);
|
|
if (ret >= 0 && pfd.revents & (POLLERR | POLLHUP)) {
|
|
return -1;
|
|
}
|
|
if (ret <= 0) {
|
|
return ret;
|
|
}
|
|
ret = read(fd, data, len);
|
|
if (ret < 0) {
|
|
return ret;
|
|
}
|
|
#ifdef DEBUG_RAW
|
|
std::cout << "< " << std::dec << static_cast<unsigned>(ret) << "/" << static_cast<unsigned>(len) << ":" << std::hex;
|
|
for (int pos = 0; pos < ret; pos++) {
|
|
std::cout << " " << std::setw(2) << std::setfill('0') << static_cast<unsigned>(data[pos]);
|
|
}
|
|
std::cout << std::endl;
|
|
#endif
|
|
return ret;
|
|
}
|
|
|
|
ssize_t sendReceiveFrame(int fd, frame_t& frame, size_t sendDataLen, ssize_t fixReceiveDataLen,
|
|
int responseTimeoutExtraMillis = 0, bool hideErrors = false) {
|
|
// send 0x55 for auto baud detection in PIC
|
|
unsigned char ch = STX;
|
|
ssize_t cnt = waitWrite(fd, &ch, 1, WAIT_BYTE_TRANSFERRED_MILLIS);
|
|
if (cnt < 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "write sync failed" << std::endl;
|
|
}
|
|
return cnt;
|
|
}
|
|
if (cnt == 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "write sync timed out" << std::endl;
|
|
}
|
|
return cnt;
|
|
}
|
|
// wait for bitrate detection to finish in PIC
|
|
usleep(WAIT_BITRATE_DETECTION_MICROS);
|
|
uint8_t writeCommand = frame.command;
|
|
size_t len = FRAME_HEADER_LEN+sendDataLen;
|
|
for (size_t pos=0; pos < len; ) {
|
|
cnt = waitWrite(fd, frame.buffer+pos, len-pos, WAIT_BYTE_TRANSFERRED_MILLIS);
|
|
if (cnt < 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "write data failed" << std::endl;
|
|
}
|
|
return cnt;
|
|
}
|
|
if (cnt == 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "write data timed out" << std::endl;
|
|
}
|
|
return -1;
|
|
}
|
|
pos += cnt;
|
|
}
|
|
cnt = waitRead(fd, &ch, 1, WAIT_RESPONSE_TIMEOUT_MILLIS + responseTimeoutExtraMillis);
|
|
if (cnt < 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "read sync failed" << std::endl;
|
|
}
|
|
return cnt;
|
|
}
|
|
if (cnt == 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "read sync timed out" << std::endl;
|
|
}
|
|
return -1;
|
|
}
|
|
if (ch != STX) {
|
|
if (!hideErrors) {
|
|
std::cerr << "did not receive sync: 0x" << std::setfill('0') << std::setw(2) << std::hex
|
|
<< static_cast<unsigned>(ch) << std::endl;
|
|
}
|
|
return -1;
|
|
}
|
|
// read the answer from the device
|
|
len = FRAME_HEADER_LEN; // start with the header itself
|
|
for (size_t pos=0; pos < len; ) {
|
|
cnt = waitRead(fd, frame.buffer+pos, len-pos, WAIT_BYTE_TRANSFERRED_MILLIS);
|
|
if (cnt < 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "read data failed" << std::endl;
|
|
}
|
|
return cnt;
|
|
}
|
|
if (cnt == 0) {
|
|
if (!hideErrors) {
|
|
std::cerr << "read data timed out" << std::endl;
|
|
}
|
|
return -1;
|
|
}
|
|
pos += cnt;
|
|
if (pos == FRAME_HEADER_LEN) {
|
|
if (fixReceiveDataLen < 0) {
|
|
len += frame.data_length;
|
|
} else {
|
|
len += fixReceiveDataLen;
|
|
}
|
|
fixReceiveDataLen = 0;
|
|
}
|
|
}
|
|
uint8_t dummy[4];
|
|
waitRead(fd, dummy, 4, WAIT_BYTE_TRANSFERRED_MILLIS); // read away potential nonsense tail
|
|
if (frame.command != writeCommand) {
|
|
if (!hideErrors) {
|
|
std::cerr << "unexpected answer" << std::endl;
|
|
}
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int readVersion(int fd, bool verbose = true) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = READ_VERSION;
|
|
ssize_t ret = sendReceiveFrame(fd, frame, 0, 16);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (frame.data[0] != MINOR_VERSION || frame.data[1] != MAJOR_VERSION) {
|
|
std::cerr << "unexpected version" << std::endl;
|
|
return -1;
|
|
}
|
|
if (verbose) {
|
|
std::cout << "Max packet size: " << static_cast<unsigned>(frame.data[2] | (frame.data[3] << 8)) << std::endl;
|
|
}
|
|
std::cout << "Device ID: " << std::setfill('0') << std::setw(4) << std::hex
|
|
<< static_cast<unsigned>(frame.data[6] | (frame.data[7] << 8));
|
|
if (frame.data[6] == 0xb0 && frame.data[7] == 0x30) {
|
|
std::cout << " (PIC16F15356)";
|
|
}
|
|
std::cout << std::endl;
|
|
if (verbose) {
|
|
std::cout << "Blocksize erase: " << std::dec << static_cast<unsigned>(frame.data[10]) << std::endl;
|
|
std::cout << "Blocksize write: " << std::dec << static_cast<unsigned>(frame.data[11]) << std::endl;
|
|
std::cout << "User ID 1: " << std::setfill('0') << std::setw(2) << std::hex
|
|
<< static_cast<unsigned>(frame.data[12]) << std::endl;
|
|
std::cout << "User ID 2: " << std::setfill('0') << std::setw(2) << std::hex
|
|
<< static_cast<unsigned>(frame.data[13]) << std::endl;
|
|
std::cout << "User ID 3: " << std::setfill('0') << std::setw(2) << std::hex
|
|
<< static_cast<unsigned>(frame.data[14]) << std::endl;
|
|
std::cout << "User ID 4: " << std::setfill('0') << std::setw(2) << std::hex
|
|
<< static_cast<unsigned>(frame.data[15]) << std::endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int printFrameData(frame_t frame, bool skipHigh) {
|
|
uint16_t address = (frame.address_H << 8)|frame.address_L;
|
|
int pos;
|
|
std::cout << std::hex;
|
|
for (pos = 0; pos < frame.data_length;) {
|
|
if ((pos%16) == 0) {
|
|
std::cout << std::setw(4) << static_cast<unsigned>(address) << ":";
|
|
}
|
|
std::cout << " " << std::setw(2) << static_cast<unsigned>(frame.data[pos++]);
|
|
if (skipHigh) {
|
|
pos++;
|
|
} else if (pos < frame.data_length) {
|
|
std::cout << " " << std::setw(2) << static_cast<unsigned>(frame.data[pos++]);
|
|
}
|
|
address++;
|
|
if ((pos%16) == 0) {
|
|
std::cout << std::endl;
|
|
}
|
|
}
|
|
if ((pos%16) != 0) {
|
|
std::cout << std::endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int printFrame(frame_t frame) {
|
|
std::cout << "command: 0x" << std::setfill('0') << std::setw(2) << std::hex
|
|
<< static_cast<unsigned>(frame.command) << std::endl;
|
|
std::cout << "data_length: " << std::dec << static_cast<unsigned>(frame.data_length) << std::endl;
|
|
std::cout << "address: 0x" << std::setw(2) << std::hex << static_cast<unsigned>(frame.address_H) << std::setw(2)
|
|
<< std::hex << static_cast<unsigned>(frame.address_L);
|
|
for (int pos = 0; pos < frame.data_length; ) {
|
|
if ((pos%16) == 0) {
|
|
std::cout << std::endl << std::setw(4) << static_cast<unsigned>(pos) << ":" << std::endl;
|
|
}
|
|
std::cout << " " << std::setw(2) << static_cast<unsigned>(frame.data[pos++]);
|
|
pos++;
|
|
}
|
|
std::cout << std::endl;
|
|
return 0;
|
|
}
|
|
|
|
int readConfig(int fd, uint16_t address, uint16_t len, bool skipHigh = false, bool print = true,
|
|
uint8_t* storeData = nullptr) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = READ_CONFIG;
|
|
frame.data_length = len;
|
|
frame.address_L = address&0xff;
|
|
frame.address_H = (address>>8)&0xff;
|
|
ssize_t ret = sendReceiveFrame(fd, frame, 0, len);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (print) {
|
|
printFrameData(frame, skipHigh);
|
|
}
|
|
if (storeData) {
|
|
memcpy(storeData, frame.data, len);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int writeConfig(int fd, uint16_t address, uint16_t len, uint8_t* data) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = WRITE_CONFIG;
|
|
frame.data_length = len;
|
|
frame.EE_key_1 = 0x55;
|
|
frame.EE_key_2 = 0xaa;
|
|
frame.address_L = address&0xff;
|
|
frame.address_H = (address>>8)&0xff;
|
|
memcpy(frame.data, data, len);
|
|
ssize_t ret = sendReceiveFrame(fd, frame, len, 1, 50);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (frame.data[0] != COMMAND_SUCCESS) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int readFlash(int fd, uint16_t address, bool skipHigh = false, bool print = true, uint8_t* storeData = nullptr) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = READ_FLASH;
|
|
frame.data_length = 0x10;
|
|
frame.address_L = address&0xff;
|
|
frame.address_H = (address>>8)&0xff;
|
|
ssize_t ret = sendReceiveFrame(fd, frame, 0, -1);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (print) {
|
|
printFrameData(frame, skipHigh);
|
|
}
|
|
if (storeData) {
|
|
memcpy(storeData, frame.data, 0x10);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int writeFlash(int fd, uint16_t address, uint16_t len, uint8_t* data, bool hideErrors = false) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = WRITE_FLASH;
|
|
frame.data_length = len;
|
|
frame.EE_key_1 = 0x55;
|
|
frame.EE_key_2 = 0xaa;
|
|
frame.address_L = address&0xff;
|
|
frame.address_H = (address>>8)&0xff;
|
|
memcpy(frame.data, data, len);
|
|
ssize_t ret = sendReceiveFrame(fd, frame, len, 1, len*30, hideErrors);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (frame.data[0] != COMMAND_SUCCESS) {
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int eraseFlash(int fd, uint16_t address, uint16_t len) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = ERASE_FLASH;
|
|
frame.data_length = (len+ERASE_FLASH_BLOCKSIZE-1)/ERASE_FLASH_BLOCKSIZE;
|
|
frame.EE_key_1 = 0x55;
|
|
frame.EE_key_2 = 0xaa;
|
|
frame.address_L = address&0xff;
|
|
frame.address_H = (address>>8)&0xff;
|
|
ssize_t ret = sendReceiveFrame(fd, frame, 0, 1, frame.data_length*5);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (frame.data[0] != COMMAND_SUCCESS) {
|
|
return -frame.data[0]-1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int calcChecksum(int fd, uint16_t address, uint16_t len) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = CALC_CHECKSUM;
|
|
frame.data_length = len;
|
|
frame.address_L = address&0xff;
|
|
frame.address_H = (address>>8)&0xff;
|
|
ssize_t ret = sendReceiveFrame(fd, frame, 0, 2, len*30);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
return frame.data[0] | (frame.data[1] << 8);
|
|
}
|
|
|
|
int resetDevice(int fd) {
|
|
frame_t frame;
|
|
memset(frame.buffer, 0, FRAME_MAX_LEN);
|
|
frame.command = RESET_DEVICE;
|
|
ssize_t ret = sendReceiveFrame(fd, frame, 0, 1);
|
|
if (ret != 0) {
|
|
return ret;
|
|
}
|
|
if (frame.data[0] != COMMAND_SUCCESS) {
|
|
return -frame.data[0]-1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
struct termios termios_original;
|
|
|
|
int openSerial(std::string port) {
|
|
// open serial port
|
|
int fd = open(port.c_str(), O_RDWR | O_NOCTTY | O_NDELAY); // non-blocking IO
|
|
if (fd == -1) {
|
|
std::cerr << "unable to open " << port << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
if (flock(fd, LOCK_EX|LOCK_NB)) {
|
|
close(fd);
|
|
std::cerr << "unable to lock " << port << std::endl;
|
|
return -1;
|
|
}
|
|
|
|
// backup terminal settings
|
|
tcgetattr(fd, &termios_original);
|
|
|
|
// configure terminal settings
|
|
struct termios termios;
|
|
memset(&termios, 0, sizeof(termios));
|
|
|
|
if (cfsetspeed(&termios, lowSpeed ? BAUDRATE_LOW : BAUDRATE_HIGH) != 0) {
|
|
std::cerr << "unable to set speed " << std::endl;
|
|
close(fd);
|
|
return -1;
|
|
}
|
|
termios.c_iflag |= 0;
|
|
termios.c_oflag |= 0;
|
|
termios.c_cflag |= CS8 | CREAD | CLOCAL;
|
|
termios.c_lflag |= 0;
|
|
termios.c_cc[VMIN] = 1;
|
|
termios.c_cc[VTIME] = 0;
|
|
if (tcsetattr(fd, TCSANOW, &termios) != 0) {
|
|
std::cerr << "unable to set serial " << std::endl;
|
|
close(fd);
|
|
return -1;
|
|
}
|
|
std::cout << "opened " << port << std::endl;
|
|
return fd;
|
|
}
|
|
|
|
int openNet(std::string host, uint16_t port) {
|
|
// open network port
|
|
int fd = socketConnect(host.c_str(), port, false, nullptr, 5);
|
|
if (fd < 0) {
|
|
std::cerr << "unable to open " << host << std::endl;
|
|
return -1;
|
|
}
|
|
fcntl(fd, F_SETFL, O_NONBLOCK); // set non-blocking
|
|
std::cout << "opened " << host << ":" << static_cast<unsigned>(port) << std::endl;
|
|
return fd;
|
|
}
|
|
|
|
void closeConnection(int fd) {
|
|
if (isSerial) {
|
|
tcsetattr(fd, TCSANOW, &termios_original);
|
|
}
|
|
close(fd);
|
|
}
|
|
|
|
int calcFileChecksum(uint8_t* storeFirstBlock = nullptr) {
|
|
std::ifstream inStream;
|
|
inStream.open(flashFile, ifstream::in);
|
|
if (!inStream.good()) {
|
|
std::cerr << "unable to open file" << std::endl;
|
|
return -1;
|
|
}
|
|
intelhex ih;
|
|
inStream >> ih;
|
|
if (ih.getNoErrors() > 0 || ih.getNoWarnings() > 0) {
|
|
std::cerr << "unable to read file" << std::endl;
|
|
return -1;
|
|
}
|
|
unsigned long startAddr = 0, endAddr = 0;
|
|
if (!ih.startAddress(&startAddr) || !ih.endAddress(&endAddr)) {
|
|
std::cerr << "unable to read file" << std::endl;
|
|
return -1;
|
|
}
|
|
if (startAddr < END_BOOT_BYTES || endAddr >= END_FLASH_BYTES || endAddr < startAddr || (startAddr&0xf) != 0) {
|
|
std::cerr << "invalid address range" << std::endl;
|
|
return -1;
|
|
}
|
|
ih.begin();
|
|
unsigned long nextAddr = ih.currentAddress();
|
|
if (nextAddr != END_BOOT_BYTES) {
|
|
std::cerr << "unexpected start address in file." << std::endl;
|
|
return -1;
|
|
}
|
|
unsigned long blockStart = END_BOOT_BYTES;
|
|
uint16_t checkSum = 0;
|
|
uint16_t skipped = 0;
|
|
while (blockStart < END_FLASH_BYTES && nextAddr < END_FLASH_BYTES) {
|
|
for (int pos = 0; pos < WRITE_FLASH_BLOCKSIZE; pos++, nextAddr++) {
|
|
unsigned long addr = ih.currentAddress();
|
|
uint8_t value = (pos&0x1) == 1 ? 0x3f : 0xff;
|
|
if (addr == nextAddr && ih.getData(&value)) {
|
|
ih.incrementAddress();
|
|
} else {
|
|
skipped++;
|
|
}
|
|
if (storeFirstBlock && nextAddr < END_BOOT_BYTES+0x10) {
|
|
storeFirstBlock[pos] = value;
|
|
}
|
|
checkSum += ((uint16_t)value) << ((pos&0x1)*8);
|
|
}
|
|
blockStart += WRITE_FLASH_BLOCKSIZE;
|
|
}
|
|
if (nextAddr-END_BOOT_BYTES != ih.size()+skipped) {
|
|
std::cout << "unable to fully read file." << std::endl;
|
|
return -1;
|
|
}
|
|
return checkSum;
|
|
}
|
|
|
|
void printFileChecksum() {
|
|
uint8_t data[0x10];
|
|
int checkSum = calcFileChecksum(data);
|
|
if (checkSum < 0) {
|
|
return;
|
|
}
|
|
int newFirmwareVersion = -1;
|
|
if (data[0x2*2] == 0xae && data[0x2*2+1] == 0x34 && data[0x3*2+1] == 0x34) {
|
|
newFirmwareVersion = data[0x3*2];
|
|
}
|
|
std::cout
|
|
<< "New firmware version: " << static_cast<unsigned>(newFirmwareVersion)
|
|
<< " [" << std::hex << std::setw(4) << std::setfill('0') << static_cast<signed>(checkSum) << "]" << std::endl;
|
|
}
|
|
|
|
bool flashPic(int fd) {
|
|
std::ifstream inStream;
|
|
inStream.open(flashFile, ifstream::in);
|
|
if (!inStream.good()) {
|
|
std::cerr << "unable to open file" << std::endl;
|
|
return false;
|
|
}
|
|
intelhex ih;
|
|
// if (verbose) {
|
|
// ih.verboseOn();
|
|
// }
|
|
inStream >> ih;
|
|
if (ih.getNoErrors() > 0 || ih.getNoWarnings() > 0) {
|
|
std::cerr << "errors or warnings while reading the file:" << std::endl;
|
|
string str;
|
|
while (ih.popNextWarning(str)) {
|
|
std::cerr << "warning: " << str << std::endl;
|
|
}
|
|
while (ih.popNextError(str)) {
|
|
std::cerr << "error: " << str << std::endl;
|
|
}
|
|
return false;
|
|
}
|
|
unsigned long startAddr = 0, endAddr = 0;
|
|
if (!ih.startAddress(&startAddr) || !ih.endAddress(&endAddr)) {
|
|
std::cerr << "unable to read file" << std::endl;
|
|
return false;
|
|
}
|
|
if (verbose) {
|
|
std::cout << "flashing bytes 0x"
|
|
<< std::hex << std::setfill('0') << std::setw(4) << static_cast<unsigned>(startAddr)
|
|
<< " - 0x"
|
|
<< std::hex << std::setfill('0') << std::setw(4) << static_cast<unsigned>(endAddr)
|
|
<< std::endl;
|
|
}
|
|
if (startAddr < END_BOOT_BYTES || endAddr >= END_FLASH_BYTES || endAddr < startAddr || (startAddr&0xf) != 0) {
|
|
std::cerr << "invalid address range" << std::endl;
|
|
return false;
|
|
}
|
|
ih.begin();
|
|
uint8_t buf[WRITE_FLASH_BLOCKSIZE];
|
|
unsigned long nextAddr = ih.currentAddress();
|
|
if (nextAddr != END_BOOT_BYTES) {
|
|
std::cerr << "unexpected start address in file: 0x" << std::hex << std::setfill('0') << std::setw(4)
|
|
<< static_cast<unsigned>(nextAddr) << std::endl;
|
|
return false;
|
|
}
|
|
unsigned long blockStart = END_BOOT_BYTES;
|
|
uint16_t checkSum = 0;
|
|
uint16_t skipped = 0;
|
|
int eraseRes = eraseFlash(fd, blockStart/2, (endAddr-blockStart)/2);
|
|
if (eraseRes != 0) {
|
|
std::cerr << "erasing flash failed: " << static_cast<signed>(-eraseRes-1) << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "erasing flash: done." << std::endl;
|
|
std::cout << "flashing: 0x" << std::hex << std::setfill('0') << std::setw(4) << static_cast<unsigned>(nextAddr/2)
|
|
<< " - 0x" << static_cast<unsigned>(endAddr/2) << std::endl;
|
|
size_t blocks = 0;
|
|
while (blockStart < endAddr) {
|
|
bool blank = true;
|
|
for (int pos = 0; pos < WRITE_FLASH_BLOCKSIZE; pos++, nextAddr++) {
|
|
unsigned long addr = ih.currentAddress();
|
|
uint8_t value = (pos&0x1) == 1 ? 0x3f : 0xff;
|
|
if (addr == nextAddr && ih.getData(&value)) {
|
|
ih.incrementAddress();
|
|
blank = false;
|
|
} else {
|
|
skipped++;
|
|
}
|
|
buf[pos] = value;
|
|
checkSum += ((uint16_t)value) << ((pos&0x1)*8);
|
|
}
|
|
if (!blank) {
|
|
if (blocks == 0) {
|
|
std::cout << std::endl << "0x" << std::hex << std::setfill('0') << std::setw(4)
|
|
<< static_cast<unsigned>(blockStart/2) << " ";
|
|
}
|
|
if (writeFlash(fd, blockStart/2, WRITE_FLASH_BLOCKSIZE, buf, true) != 0) {
|
|
// repeat once silently:
|
|
if (writeFlash(fd, blockStart/2, WRITE_FLASH_BLOCKSIZE, buf) != 0) {
|
|
std::cerr << "unable to write flash at 0x" << std::hex << std::setfill('0') << std::setw(4)
|
|
<< static_cast<unsigned>(blockStart/2) << std::endl;
|
|
return false;
|
|
}
|
|
}
|
|
std::cout << ".";
|
|
if (++blocks >= 64) {
|
|
blocks = 0;
|
|
}
|
|
std::cout.flush();
|
|
}
|
|
blockStart += WRITE_FLASH_BLOCKSIZE;
|
|
}
|
|
std::cout << std::endl << "flashing finished." << std::endl;
|
|
if (nextAddr-END_BOOT_BYTES != ih.size()+skipped) {
|
|
std::cout << "unable to fully read file." << std::endl;
|
|
}
|
|
int picSum = calcChecksum(fd, startAddr/2, blockStart-startAddr);
|
|
if (picSum < 0) {
|
|
std::cout << "unable to read checksum." << std::endl;
|
|
return false;
|
|
}
|
|
if (picSum != checkSum) {
|
|
std::cout << "unexpected checksum." << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "flashing succeeded." << std::endl;
|
|
return true;
|
|
}
|
|
|
|
int readSettings(int fd, uint8_t* currentData = nullptr) {
|
|
uint8_t mac[] = {0xae, 0xb0, 0x53, 0xef, 0xfe, 0xef}; // "Adapter-eBUS3" + (UserID or MUI)
|
|
uint8_t ip[4] = {0, 0, 0, 0};
|
|
bool useMUI = true;
|
|
uint8_t maskLen = 0;
|
|
uint8_t configData[8];
|
|
if (readConfig(fd, 0x0000, 8, false, false, configData) != 0) { // User ID
|
|
return -1;
|
|
}
|
|
if (currentData) {
|
|
memcpy(currentData, configData, sizeof(configData));
|
|
}
|
|
useMUI = (configData[1]&0x20) != 0; // if highest bit is set, then use MUI. if cleared, use User ID
|
|
maskLen = configData[1]&0x1f;
|
|
uint8_t gw = configData[7]&0x3f;
|
|
for (int i=0; i < 4; i++) {
|
|
ip[i] = configData[i*2];
|
|
if (!useMUI && i > 0) {
|
|
mac[2+i] = configData[i*2];
|
|
}
|
|
}
|
|
if (useMUI) {
|
|
// read MUI to build uniqueMAC address
|
|
// start with MUI6, end with MUI8 (MUI9 is reserved)
|
|
uint8_t mui[8];
|
|
readConfig(fd, 0x0106, 8, true, false, mui); // MUI
|
|
for (int i=0; i < 3; i++) {
|
|
mac[3+i] = mui[i*2];
|
|
}
|
|
}
|
|
std::cout << "MAC address:";
|
|
for (int i=0; i < 6; i++) {
|
|
std::cout << (i == 0?' ':':') << std::hex << std::setw(2) << std::setfill('0') << static_cast<unsigned>(mac[i]);
|
|
}
|
|
std::cout << std::endl;
|
|
if (maskLen == 0x1f || (ip[0]|ip[1]|ip[2]|ip[3]) == 0) {
|
|
std::cout << "IP address: DHCP (default)" << std::endl;
|
|
} else {
|
|
std::cout << "IP address:";
|
|
for (uint8_t pos = 0, maskRemain = maskLen; pos < 4; pos++, maskRemain -= maskRemain >= 8 ? 8 : maskRemain) {
|
|
std::cout << (pos == 0?' ':'.') << std::dec << static_cast<unsigned>(ip[pos]);
|
|
uint8_t mask = maskRemain >= 8 ? 255 : maskRemain == 0 ? 0 : (255 ^ ((1 << (8 - maskRemain)) - 1));
|
|
ip[pos] &= mask; // prepare for gateway
|
|
}
|
|
std::cout << "/" << std::dec << static_cast<unsigned>(maskLen) << ", gateway:";
|
|
// build gateway
|
|
if (gw == 0x3f) {
|
|
// default: first address in network is used as gateway
|
|
ip[3] |= 1;
|
|
} else if (gw & 0x20) {
|
|
// end of subnet
|
|
// non-mask bits outside of |gw reach
|
|
uint8_t mask = maskLen <= 24 ? 0 : (255^((1 << (8 - (maskLen-24))) - 1));
|
|
ip[3] |= ((~mask)^0x1f) | (gw&0x1f);
|
|
if (maskLen<24) {
|
|
// more than just the last IP byte are affected: set non-mask bits to 1 as well in bytes 0-2
|
|
for (uint8_t pos = 0, maskRemain = maskLen; pos < 3; pos++, maskRemain -= maskRemain >= 8 ? 8 : maskRemain) {
|
|
mask = maskRemain >= 8 ? 255 : maskRemain == 0 ? 0 : (255^((1 << (8 - maskRemain)) - 1));
|
|
ip[pos] |= ~mask;
|
|
}
|
|
}
|
|
} else {
|
|
// start of subnet
|
|
ip[3] |= gw&0x1f;
|
|
}
|
|
for (int i=0; i < 4; i++) {
|
|
std::cout << (i == 0?' ':'.') << std::dec << static_cast<unsigned>(ip[i]);
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
uint16_t arbitrationDelay = configData[3]&0x3f;
|
|
std::cout << "Arbitration delay: ";
|
|
if (arbitrationDelay == 0x3f) {
|
|
std::cout << "200 us (default)" << std::endl;
|
|
} else {
|
|
arbitrationDelay *= 10; // steps of 10us
|
|
std::cout << std::dec << static_cast<unsigned>(arbitrationDelay) << " us" << std::endl;
|
|
}
|
|
std::cout << "Visual ping: ";
|
|
if (configData[5]&0x20) {
|
|
std::cout << "on (default)" << std::endl;
|
|
} else {
|
|
std::cout << "off" << std::endl;
|
|
}
|
|
std::cout << "Variant: "; // since firmware 20221206
|
|
if ((configData[5]&0x07)==0x07) {
|
|
std::cout << "hard jumpers only (includes USB/RPI enhanced when no jumpers are set)" << std::endl;
|
|
} else {
|
|
switch (configData[5]&0x03) {
|
|
case 3:
|
|
std::cout << "USB/RPI";
|
|
break;
|
|
case 2:
|
|
std::cout << "WIFI";
|
|
break;
|
|
case 1:
|
|
std::cout << "Ethernet";
|
|
break;
|
|
default:
|
|
std::cout << "non-enhanced ";
|
|
if (maskLen) {
|
|
std::cout << "Ethernet";
|
|
} else {
|
|
std::cout << "USB/RPI/WIFI";
|
|
}
|
|
}
|
|
if (configData[5]&0x04) {
|
|
std::cout << ", prefer hard jumpers";
|
|
} else {
|
|
std::cout << ", ignore hard jumpers";
|
|
}
|
|
std::cout << std::endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
bool writeSettings(int fd, uint8_t* currentData = nullptr) {
|
|
std::cout << "Writing settings: ";
|
|
uint8_t configData[] = {0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f, 0xff, 0x3f};
|
|
if (currentData) {
|
|
memcpy(configData, currentData, sizeof(configData));
|
|
}
|
|
if (setMacFromIp) {
|
|
configData[1] = (configData[1]&~0x20) | (setMacFromIpValue ? 0 : 0x20); // set useMUI
|
|
}
|
|
if (setDhcp) {
|
|
configData[1] |= 0x1f;
|
|
} else if (setIp) {
|
|
if (setMask) {
|
|
configData[1] = (configData[1]&~0x1f) | (setMaskLen&0x1f);
|
|
}
|
|
for (int i = 0; i < 4; i++) {
|
|
configData[i * 2] = setIpAddress[i];
|
|
}
|
|
if (setGateway) {
|
|
configData[7] = setGatewayBits;
|
|
}
|
|
}
|
|
if (setArbitrationDelay) {
|
|
configData[3] = setArbitrationDelayMicros/10;
|
|
}
|
|
if (setVisualPing) {
|
|
configData[5] = (configData[5]&0x1f) | (setVisualPingOn?0x20:0);
|
|
}
|
|
if (setSoftVariant) {
|
|
configData[5] = (configData[5]&0x38) | (setSoftVariantForced?0:0x04) | (setSoftVariantValue&0x03);
|
|
if (setSoftVariantValue==0) {
|
|
configData[1] = (configData[1]&~0x1f); // set mask=0 to disable Ethernet
|
|
}
|
|
} else if (setHardVariant) {
|
|
configData[5] = (configData[5]&0x38) | 0x07;
|
|
}
|
|
if (writeConfig(fd, 0x0000, 8, configData) != 0) {
|
|
std::cerr << "failed" << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "done." << std::endl;
|
|
return true;
|
|
}
|
|
|
|
int run(int fd);
|
|
|
|
int main(int argc, char* argv[]) {
|
|
struct argp aargp = { argpoptions, parse_opt, argpargsdoc, argpdoc, nullptr, nullptr, nullptr };
|
|
int arg_index = -1;
|
|
setenv("ARGP_HELP_FMT", "no-dup-args-note", 0);
|
|
|
|
if (argp_parse(&aargp, argc, argv, ARGP_IN_ORDER, &arg_index, nullptr) != 0) {
|
|
std::cerr << "invalid arguments" << std::endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
if (setIp != setMask || (setMacFromIp && !setIp)) {
|
|
std::cerr << "incomplete IP arguments" << std::endl;
|
|
arg_index = argc; // force help output
|
|
}
|
|
if (argc-arg_index < 1) {
|
|
if (flashFile) {
|
|
printFileChecksum();
|
|
exit(EXIT_SUCCESS);
|
|
} else {
|
|
argp_help(&aargp, stderr, ARGP_HELP_STD_ERR, const_cast<char*>("ebuspicloader"));
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
}
|
|
std::string port = argv[arg_index];
|
|
std::string::size_type pos = port.find('*');
|
|
if (pos == std::string::npos || pos != port.length()-1) {
|
|
int fd;
|
|
pos = port.find(':');
|
|
if (pos != std::string::npos) {
|
|
string host = port.substr(0, pos);
|
|
uint16_t portNum = 0;
|
|
if (!parseShort(port.substr(pos+1).c_str(), 1, 65535, &portNum)) {
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
isSerial = false;
|
|
timeoutFactor = 2;
|
|
timeoutAddend = 100;
|
|
fd = openNet(host, portNum);
|
|
} else {
|
|
fd = openSerial(port);
|
|
}
|
|
if (fd < 0) {
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
return run(fd);
|
|
}
|
|
|
|
std::string::size_type sep = port.find_last_of('/');
|
|
std::string base = sep == std::string::npos ? "" : port.substr(0, sep);
|
|
DIR* dir = opendir(base.c_str());
|
|
if (!dir) {
|
|
std::cerr << "Unable to open directory " << base << std::endl;
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
std::string prefix = sep == std::string::npos ? port.substr(0, pos) : port.substr(sep + 1, pos - 1 - sep);
|
|
struct dirent* ent;
|
|
while ((ent = readdir(dir))) {
|
|
if (std::string(ent->d_name).substr(0, prefix.length()) != prefix) {
|
|
continue;
|
|
}
|
|
std::string name = base + "/" + ent->d_name;
|
|
std::cout << "Trying " << name << "..." << std::endl;
|
|
int fd = openSerial(name);
|
|
if (fd < 0) {
|
|
std::cerr << "Unable to open " << name << std::endl;
|
|
continue;
|
|
}
|
|
run(fd);
|
|
std::cout << std::endl;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int run(int fd) {
|
|
// read version
|
|
if (readVersion(fd, verbose) != 0) {
|
|
closeConnection(fd);
|
|
return EXIT_FAILURE;
|
|
}
|
|
uint8_t data[0x10];
|
|
if (verbose) {
|
|
std::cout << "User ID:" << std::endl;
|
|
readConfig(fd, 0x0000, 8); // User ID
|
|
std::cout << "Rev ID, Device ID:" << std::endl;
|
|
}
|
|
readConfig(fd, 0x0005, 4, false, verbose, data); // Rev ID and Device ID
|
|
std::cout << "Device revision: " << static_cast<unsigned>(((data[1]&0xf) << 2) | ((data[0]&0xc0)>>6))
|
|
<< "." << static_cast<unsigned>(data[0]&0x3f) << std::endl;
|
|
if (verbose) {
|
|
std::cout << "Configuration words:" << std::endl;
|
|
readConfig(fd, 0x0007, 5*2); // Configuration Words
|
|
std::cout << "MUI:" << std::endl;
|
|
readConfig(fd, 0x0100, 9*2, true); // MUI
|
|
std::cout << "EUI:"<< std::endl;
|
|
readConfig(fd, 0x010a, 8*2); // EUI
|
|
readConfig(fd, 0x0116, 14, false, false, data); // TSHR2...FVRC2X
|
|
std::cout << "TSHR2: " << std::dec << static_cast<unsigned>(((data[1]&0xff) << 8) | (data[0]&0xff)) << std::endl;
|
|
std::cout << "FVRA2X: " << static_cast<unsigned>(((data[7]&0xff) << 8) | (data[6]&0xff)) << std::endl;
|
|
std::cout << "FVRC2X: " << static_cast<unsigned>(((data[13]&0xff) << 8) | (data[12]&0xff)) << std::endl;
|
|
}
|
|
if (verbose) {
|
|
std::cout << "Flash:" << std::endl;
|
|
}
|
|
readFlash(fd, 0x0000, false, false, data);
|
|
int bootloaderVersion = -1;
|
|
if (data[0x2*2] == 0xab && data[0x2*2+1] == 0x34 && data[0x3*2+1] == 0x34) {
|
|
bootloaderVersion = data[0x3*2];
|
|
int picSum = calcChecksum(fd, 0x0000, END_BOOT_BYTES);
|
|
std::cout
|
|
<< "Bootloader version: " << static_cast<unsigned>(bootloaderVersion)
|
|
<< " [" << std::hex << std::setw(4) << std::setfill('0') << static_cast<signed>(picSum) << "]" << std::endl;
|
|
} else {
|
|
std::cerr << "Bootloader version not found" << std::endl;
|
|
}
|
|
readFlash(fd, END_BOOT, false, false, data);
|
|
int firmwareVersion = -1;
|
|
if (data[0x2*2] == 0xae && data[0x2*2+1] == 0x34 && data[0x3*2+1] == 0x34) {
|
|
firmwareVersion = data[0x3*2];
|
|
int picSum = calcChecksum(fd, END_BOOT, END_FLASH_BYTES-END_BOOT_BYTES);
|
|
std::cout
|
|
<< "Firmware version: " << static_cast<unsigned>(firmwareVersion)
|
|
<< " [" << std::hex << std::setw(4) << std::setfill('0') << static_cast<signed>(picSum) << "]" << std::endl;
|
|
} else {
|
|
std::cout << "Firmware version not found" << std::endl;
|
|
}
|
|
uint8_t currentConfigData[8];
|
|
bool useCurrentConfigData = true;
|
|
if (readSettings(fd, currentConfigData) != 0) {
|
|
std::cerr << "Settings could not be retrieved" << std::endl;
|
|
useCurrentConfigData = false;
|
|
}
|
|
std::cout << std::endl;
|
|
bool success = true;
|
|
if (flashFile) {
|
|
printFileChecksum();
|
|
if (!flashPic(fd)) {
|
|
success = false;
|
|
}
|
|
}
|
|
if (setMacFromIp || setIp || setDhcp || setArbitrationDelay || setVisualPing || setSoftVariant || setHardVariant) {
|
|
if (writeSettings(fd, useCurrentConfigData ? currentConfigData : nullptr)) {
|
|
std::cout << "Settings changed to:" << std::endl;
|
|
readSettings(fd);
|
|
} else {
|
|
success = false;
|
|
}
|
|
}
|
|
if (reset && success) {
|
|
std::cout << "resetting device." << std::endl;
|
|
resetDevice(fd);
|
|
}
|
|
|
|
closeConnection(fd);
|
|
return 0;
|
|
}
|