From 3e0f736e1d78eb6b4c590f4b434cf75941969d01 Mon Sep 17 00:00:00 2001 From: Daniel Beer Date: Tue, 17 Nov 2009 15:11:46 +1300 Subject: [PATCH] Implemented UIF support (untested). RF2500 support is tested and still working. --- Makefile | 2 +- fet.c | 157 +++++++++++++++++++++++++++++++++++-------------------- fet.h | 1 + main.c | 60 ++++++++++++++++----- rf2500.c | 5 +- uif.c | 125 +++++++++++++++++++++++++++++++++++++++++++ uif.h | 28 ++++++++++ 7 files changed, 306 insertions(+), 72 deletions(-) create mode 100644 uif.c create mode 100644 uif.h diff --git a/Makefile b/Makefile index ec9db24..c814f84 100644 --- a/Makefile +++ b/Makefile @@ -25,7 +25,7 @@ clean: .SUFFIXES: .c .o -mspdebug: main.o fet.o rf2500.o dis.o +mspdebug: main.o fet.o rf2500.o dis.o uif.o $(CC) $(CFLAGS) -o $@ $^ -lusb .c.o: diff --git a/fet.c b/fet.c index a79ab4d..9ad7cc6 100644 --- a/fet.c +++ b/fet.c @@ -24,6 +24,7 @@ #include "fet.h" static const struct fet_transport *fet_transport; +static int fet_is_rf2500; /********************************************************************* * Checksum calculation @@ -88,7 +89,7 @@ static u_int16_t calc_checksum(const char *data, int len) * * No checksums are included. */ -static int fet_send_data(const char *data, int len) +static int send_rf2500_data(const char *data, int len) { int offset = 0; @@ -119,7 +120,7 @@ static int fet_len; #define BUFFER_BYTE(b, x) ((int)((u_int8_t *)(b))[x]) #define BUFFER_WORD(b, x) ((BUFFER_BYTE(b, x + 1) << 8) | BUFFER_BYTE(b, x)) -static const char *fet_recv_packet(int *pktlen) +static const char *recv_packet(int *pktlen) { int plen = BUFFER_WORD(fet_buf, 0); @@ -144,7 +145,7 @@ static const char *fet_recv_packet(int *pktlen) *pktlen = plen - 2; if (c != r) { - fprintf(stderr, "fet_fecv_packet: checksum " + fprintf(stderr, "recv_packet: checksum " "error (calc %04x, recv %04x)\n", c, r); return NULL; @@ -163,22 +164,36 @@ static const char *fet_recv_packet(int *pktlen) return NULL; } -static int fet_send_command(const char *data, int len) +static int send_command(const char *data, int datalen, + const char *extra, int exlen) { char datapkt[256]; + int len = 0; + char buf[256]; - u_int16_t cksum = calc_checksum(data, len); + u_int16_t cksum; int i = 0; int j; - assert (len + 4 <= sizeof(buf)); - assert (len + 2 <= sizeof(datapkt)); + assert (len + exlen + 2 <= sizeof(datapkt)); assert (fet_transport != NULL); - memcpy(datapkt, data, len); + /* Assemble the unescaped undelimeted packet into datapkt. */ + memcpy(datapkt, data, datalen); + len += datalen; + + if (extra) { + memcpy(datapkt + len, extra, exlen); + len += exlen; + } + + cksum = calc_checksum(datapkt, len); datapkt[len++] = cksum & 0xff; datapkt[len++] = cksum >> 8; + /* Copy into buf, escaping special characters and adding + * delimeters. + */ buf[i++] = 0x7e; for (j = 0; j < len; j++) { char c = datapkt[j]; @@ -197,19 +212,26 @@ static int fet_send_command(const char *data, int len) return fet_transport->send(buf, i); } -static const char *fet_send_recv(const char *data, int len, int *recvlen) +static const char *xfer(const char *command, int len, + const char *data, int datalen, + int *recvlen) { const char *buf; - if (fet_send_command(data, len) < 0) + if (data && fet_is_rf2500) { + if (send_rf2500_data(data, datalen) < 0) + return NULL; + if (send_command(command, len, NULL, 0) < 0) + return NULL; + } else if (send_command(command, len, data, datalen) < 0) return NULL; - buf = fet_recv_packet(recvlen); + buf = recv_packet(recvlen); if (!buf) return NULL; - if (data[0] != buf[0]) { - fprintf(stderr, "fet_send_recv: reply type mismatch\n"); + if (command[0] != buf[0]) { + fprintf(stderr, "xfer: reply type mismatch\n"); return NULL; } @@ -232,56 +254,58 @@ int fet_open(const struct fet_transport *tr, int proto_flags, int vcc_mv) }; fet_transport = tr; + fet_is_rf2500 = proto_flags & FET_PROTO_RF2500; init_codes(); /* open */ - if (!fet_send_recv("\x01\x01", 2, NULL)) { - fprintf(stderr, "fet_startup: open failed\n"); + if (!xfer("\x01\x01", 2, NULL, 0, NULL)) { + fprintf(stderr, "fet_open: open failed\n"); return -1; } /* init */ - if (!fet_send_recv("\x27\x02\x01\x00\x04\x00\x00\x00\x00", 8, NULL)) { - fprintf(stderr, "fet_startup: init failed\n"); + if (!xfer("\x27\x02\x01\x00\x04\x00\x00\x00\x00", 8, NULL, 0, NULL)) { + fprintf(stderr, "fet_open: init failed\n"); return -1; } /* configure: Spy-Bi-Wire or JTAG */ config[8] = (proto_flags & FET_PROTO_SPYBIWIRE) ? 1 : 0; - if (!fet_send_recv(config, 12, NULL)) { - fprintf(stderr, "fet_startup: configure failed\n"); + if (!xfer(config, 12, NULL, 0, NULL)) { + fprintf(stderr, "fet_open: configure failed\n"); return -1; } /* I don't know what this is. It's RF2500-specific. It may have * something to do with flash -- 0x1d is sent before an erase. */ - if (!fet_send_recv("\x1e\x01", 2, NULL)) { - fprintf(stderr, "fet_startup: command 0x1e failed\n"); + if (fet_is_rf2500 && !xfer("\x1e\x01", 2, NULL, 0, NULL)) { + fprintf(stderr, "fet_open: command 0x1e failed\n"); return -1; } /* set VCC */ vcc[4] = vcc_mv & 0xff; vcc[5] = vcc_mv >> 8; - if (!fet_send_recv(vcc, 8, NULL)) { - fprintf(stderr, "fet_startup: set VCC failed\n"); + if (!xfer(vcc, 8, NULL, 0, NULL)) { + fprintf(stderr, "fet_open: set VCC failed\n"); return -1; } /* I don't know what this is, but it appears to halt the MSP. Without * it, memory reads return garbage. This is RF2500-specific. */ - if (!fet_send_recv("\x28\x02\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00", - 12, NULL)) { - fprintf(stderr, "fet_startup: command 0x28 failed\n"); + if (fet_is_rf2500 && + !xfer("\x28\x02\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00", + 12, NULL, 0, NULL)) { + fprintf(stderr, "fet_open: command 0x28 failed\n"); return -1; } /* Who knows what this is. Without it, register reads don't work. * This is RF2500-specific. */ - { + if (fet_is_rf2500) { static char data[] = { 0x00, 0x80, 0xff, 0xff, 0x00, 0x00, 0x00, 0x10, 0xff, 0x10, 0x40, 0x00, 0x00, 0x02, 0xff, 0x05, @@ -295,11 +319,10 @@ int fet_open(const struct fet_transport *tr, int proto_flags, int vcc_mv) 0xff, 0xff, }; - if (fet_send_data(data, sizeof(data)) < 0 || - !fet_send_recv("\x29\x02\x04\x00\x00\x00\x00\x00" - "\x39\x00\x00\x00\x31\x00\x00\x00" - "\x4a\x00\x00\x00", 20, NULL)) { - fprintf(stderr, "fet_startup: command 0x29 failed\n"); + if (!xfer("\x29\x02\x04\x00\x00\x00\x00\x00" + "\x39\x00\x00\x00\x31\x00\x00\x00" + "\x4a\x00\x00\x00", 20, data, sizeof(data), NULL)) { + fprintf(stderr, "fet_open: command 0x29 failed\n"); return -1; } } @@ -326,7 +349,7 @@ int fet_reset(int flags) reset[12] = 1; } - if (!fet_send_recv(reset, 16, NULL)) { + if (!xfer(reset, 16, NULL, 0, NULL)) { fprintf(stderr, "fet_reset: reset failed\n"); return -1; } @@ -336,7 +359,7 @@ int fet_reset(int flags) int fet_close(void) { - if (!fet_send_recv("\x02\x02\x01\x00", 4, NULL)) { + if (!xfer("\x02\x02\x01\x00", 4, NULL, 0, NULL)) { fprintf(stderr, "fet_shutdown: close command failed\n"); return -1; } @@ -353,7 +376,7 @@ int fet_get_context(u_int16_t *regs) int i; const char *buf; - buf = fet_send_recv("\x08\x01", 2, &len); + buf = xfer("\x08\x01", 2, NULL, 0, &len); if (len < 72) { fprintf(stderr, "fet_get_context: short reply (%d bytes)\n", len); @@ -378,9 +401,21 @@ int fet_set_context(u_int16_t *regs) buf[i * 4 + 1] = regs[i] >> 8; } - if (fet_send_data(buf, sizeof(buf)) < 0 || - !fet_send_recv("\x09\x02\x02\x00\xff\xff\x00\x00" - "\x40\x00\x00\x00", 12, NULL)) { + static char cmd[] = { + 0x09, 0x00, 0x00, 0x00, + 0xff, 0xff, 0x00, 0x00, + 0x40, 0x00, 0x00, 0x00 + }; + + if (fet_is_rf2500) { + cmd[1] = 0x02; + cmd[2] = 0x02; + } else { + cmd[1] = 0x04; + cmd[2] = 0x01; + } + + if (!xfer(cmd, 12, buf, sizeof(buf), NULL)) { fprintf(stderr, "fet_set_context: context set failed\n"); return -1; } @@ -404,7 +439,7 @@ int fet_read_mem(u_int16_t addr, char *buffer, int count) readmem[5] = addr >> 8; readmem[8] = plen; - buf = fet_send_recv(readmem, 12, &len); + buf = xfer(readmem, 12, NULL, 0, &len); if (!buf) { fprintf(stderr, "fet_read_mem: failed to read " "from 0x%04x\n", addr); @@ -432,16 +467,23 @@ int fet_write_mem(u_int16_t addr, char *buffer, int count) int plen = count > 128 ? 128 : count; static char writemem[] = { - 0x0e, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + if (fet_is_rf2500) { + writemem[1] = 0x02; + writemem[2] = 0x02; + } else { + writemem[1] = 0x04; + writemem[2] = 0x01; + } + writemem[4] = addr & 0xff; writemem[5] = addr >> 8; writemem[8] = plen; - if (fet_send_data(buffer, plen) < 0 || - !fet_send_recv(writemem, 12, NULL)) { + if (!xfer(writemem, 12, buffer, plen, NULL)) { fprintf(stderr, "fet_write_mem: failed to write " "to 0x%04x\n", addr); return -1; @@ -489,24 +531,24 @@ int fet_erase(int type, u_int16_t addr) break; } - if (!fet_send_recv("\x1d\x01", 2, NULL)) { + if (!xfer("\x1d\x01", 2, NULL, 0, NULL)) { fprintf(stderr, "fet_erase: command 1d failed\n"); return -1; } - if (!fet_send_recv("\x05\x02\x02\x00\x02\x00\x00\x00\x26\x00\x00\x00", - 12, NULL)) { + if (!xfer("\x05\x02\x02\x00\x02\x00\x00\x00\x26\x00\x00\x00", + 12, NULL, 0, NULL)) { fprintf(stderr, "fet_erase: config (1) failed\n"); return -1; } - if (!fet_send_recv("\x05\x02\x02\x00\x05\x00\x00\x00\x00\x00\x00\x00", - 12, NULL)) { + if (!xfer("\x05\x02\x02\x00\x05\x00\x00\x00\x00\x00\x00\x00", + 12, NULL, 0, NULL)) { fprintf(stderr, "fet_erase: config (2) failed\n"); return -1; } - if (!fet_send_recv(erase, 16, NULL)) { + if (!xfer(erase, 16, NULL, 0, NULL)) { fprintf(stderr, "fet_erase: erase command failed\n"); return -1; } @@ -523,7 +565,7 @@ int fet_poll(void) if (usleep(500000) < 0) return -1; - reply = fet_send_recv("\x12\x02\x01\x00\x00\x00\x00\x00", 8, &len); + reply = xfer("\x12\x02\x01\x00\x00\x00\x00\x00", 8, NULL, 0, &len); if (!reply) { fprintf(stderr, "fet_poll: polling failed\n"); return -1; @@ -534,8 +576,8 @@ int fet_poll(void) int fet_step(void) { - if (!fet_send_recv("\x11\x02\x02\x00\x02\x00\x00\x00\x00\x00\x00\x00", - 12, NULL)) { + if (!xfer("\x11\x02\x02\x00\x02\x00\x00\x00\x00\x00\x00\x00", + 12, NULL, 0, NULL)) { fprintf(stderr, "fet_step: failed to single-step\n"); return -1; } @@ -545,8 +587,8 @@ int fet_step(void) int fet_run(void) { - if (!fet_send_recv("\x11\x02\x02\x00\x03\x00\x00\x00\x00\x00\x00\x00", - 12, NULL)) { + if (!xfer("\x11\x02\x02\x00\x03\x00\x00\x00\x00\x00\x00\x00", + 12, NULL, 0, NULL)) { fprintf(stderr, "fet_run: run failed\n"); return -1; } @@ -556,7 +598,7 @@ int fet_run(void) int fet_stop(void) { - if (!fet_send_recv("\x12\x02\x01\x00\x01\x00\x00\x00", 8, NULL)) { + if (!xfer("\x12\x02\x01\x00\x01\x00\x00\x00", 8, NULL, 0, NULL)) { fprintf(stderr, "fet_stop: stop failed\n"); return -1; } @@ -593,13 +635,12 @@ int fet_break(int enable, u_int16_t addr) buf[52] = 1; } - if (fet_send_data(buf, sizeof(buf)) < 0 || - !fet_send_recv("\x2a\x02\x04\x00\x08\x00\x00\x00\xb0\x00\x00\x00" - "\x00\x00\x00\x00\x40\x00\x00\x00", 20, NULL)) { + if (!xfer("\x2a\x02\x04\x00\x08\x00\x00\x00\xb0\x00\x00\x00" + "\x00\x00\x00\x00\x40\x00\x00\x00", 20, + buf, sizeof(buf), NULL)) { fprintf(stderr, "fet_break: set breakpoint failed\n"); return -1; } return 0; } - diff --git a/fet.h b/fet.h index 9c737ee..191c5d9 100644 --- a/fet.h +++ b/fet.h @@ -36,6 +36,7 @@ struct fet_transport { * millivolts and a set of protocol mode flags. */ #define FET_PROTO_SPYBIWIRE 0x01 +#define FET_PROTO_RF2500 0x02 int fet_open(const struct fet_transport *transport, int proto_flags, int vcc_mv); diff --git a/main.c b/main.c index 921c10d..48ae715 100644 --- a/main.c +++ b/main.c @@ -22,12 +22,14 @@ #include #include #include +#include #include "dis.h" #include "fet.h" #include "rf2500.h" +#include "uif.h" -static void hexdump(int addr, const char *data, int len) +void hexdump(int addr, const char *data, int len) { int offset = 0; @@ -542,24 +544,15 @@ static void sigint_handler(int signum) { } -int main(void) +static void reader_loop(void) { const static struct sigaction siga = { .sa_handler = sigint_handler, .sa_flags = 0 }; - puts( -"MSPDebug version 0.1+ - debugging tool for the eZ430\n" -"Copyright (C) 2009 Daniel Beer \n" -"This is free software; see the source for copying conditions. There is NO\n" -"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"); - - if (rf2500_open() < 0) - return -1; - - sigaction(SIGINT, &siga, NULL); cmd_help(NULL); + sigaction(SIGINT, &siga, NULL); for (;;) { char buf[128]; @@ -595,6 +588,49 @@ int main(void) } printf("\n"); +} + +static void usage(const char *progname) +{ + fprintf(stderr, "Usage: %s [-u device]\n" +"By default, the first RF2500 device on the USB bus is opened. If -u is\n" +"given, then a UIF device attached to the specified serial port is\n" +"opened.\n", progname); +} + +int main(int argc, char **argv) +{ + const char *uif_device = NULL; + int opt; + int result; + + puts( +"MSPDebug version 0.1+ - debugging tool for the eZ430\n" +"Copyright (C) 2009 Daniel Beer \n" +"This is free software; see the source for copying conditions. There is NO\n" +"warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"); + + while ((opt = getopt(argc, argv, "u:")) >= 0) + switch (opt) { + case 'u': + uif_device = optarg; + break; + + default: + usage(argv[0]); + return -1; + } + + /* Open the appropriate device */ + if (uif_device) + result = uif_open(uif_device); + else + result = rf2500_open(); + + if (result < 0) + return -1; + + reader_loop(); fet_run(); fet_close(); diff --git a/rf2500.c b/rf2500.c index 8153d0c..d5934a7 100644 --- a/rf2500.c +++ b/rf2500.c @@ -22,6 +22,8 @@ #include "fet.h" +void hexdump(int addr, const char *data, int len); + /********************************************************************* * USB transport * @@ -195,7 +197,8 @@ int rf2500_open(void) usbtr_flush(); if (fet_open(&usbtr_transport, - FET_PROTO_SPYBIWIRE, 3000) < 0) { + FET_PROTO_SPYBIWIRE | + FET_PROTO_RF2500, 3000) < 0) { usbtr_close(); return -1; } diff --git a/uif.c b/uif.c new file mode 100644 index 0000000..73186b6 --- /dev/null +++ b/uif.c @@ -0,0 +1,125 @@ +/* MSPDebug - debugging tool for the eZ430 + * Copyright (C) 2009 Daniel Beer + * + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "uif.h" +#include "fet.h" + +void hexdump(int addr, const char *data, int len); + +static int serial_fd = -1; + +static int serial_send(const char *data, int len) +{ + int result; + + assert (serial_fd >= 0); + +#ifdef DEBUG_SERIAL + puts("Serial transfer out:"); + hexdump(0, data, len); +#endif + + while (len) { + result = write(serial_fd, data, len); + if (result < 0) { + if (errno == EINTR) + continue; + + perror("serial_send"); + return -1; + } + + data += result; + len -= result; + } + + return 0; +} + +static int serial_recv(char *data, int max_len) +{ + int len; + + assert (serial_fd >= 0); + + len = read(serial_fd, data, max_len); + + if (len < 0) { + perror("serial_recv"); + return -1; + } + +#ifdef DEBUG_SERIAL + puts("Serial transfer in:"); + hexdump(0, data, len); +#endif + return len; +} + +static void serial_close(void) +{ + assert (serial_fd >= 0); + + close(serial_fd); +} + +static const struct fet_transport serial_transport = { + .send = serial_send, + .recv = serial_recv, + .close = serial_close +}; + +int uif_open(const char *device) +{ + struct termios attr; + + printf("Trying to open UIF on %s...\n", device); + + serial_fd = open(device, O_RDWR | O_NOCTTY); + if (serial_fd < 0) { + fprintf(stderr, "uif_open: open: %s: %s\n", + device, strerror(errno)); + return -1; + } + + tcgetattr(serial_fd, &attr); + cfmakeraw(&attr); + cfsetspeed(&attr, B460800); + if (tcsetattr(serial_fd, TCSAFLUSH, &attr) < 0) { + fprintf(stderr, "uif_open: tcsetattr: %s: %s\n", + device, strerror(errno)); + return -1; + } + + if (fet_open(&serial_transport, FET_PROTO_SPYBIWIRE, 3000) < 0) { + close(serial_fd); + return -1; + } + + return 0; +} diff --git a/uif.h b/uif.h new file mode 100644 index 0000000..e143b4b --- /dev/null +++ b/uif.h @@ -0,0 +1,28 @@ +/* MSPDebug - debugging tool for the eZ430 + * Copyright (C) 2009 Daniel Beer + * + * 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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#ifndef UIF_H_ +#define UIF_H_ + +/* This function is for opening an eZ430-F2013 or FET430UIF device via + * a kernel-supported serial interface. The argument given should be the + * filename of the relevant tty device. + */ +int uif_open(const char *device); + +#endif