mspdebug/drivers/goodfet.c

681 lines
14 KiB
C

/* MSPDebug - debugging tool for MSP430 MCUs
* Copyright (C) 2009-2012 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 <stdlib.h>
#include <string.h>
#include "util.h"
#include "sport.h"
#include "output.h"
#include "goodfet.h"
#include "ctrlc.h"
/* GoodFET protocol definitions */
#define APP_JTAG430 0x11
#define APP_DEBUG 0xFF
#define GLOBAL_READ 0x00
#define GLOBAL_WRITE 0x01
#define GLOBAL_PEEK 0x02
#define GLOBAL_POKE 0x03
#define GLOBAL_SETUP 0x10
#define GLOBAL_START 0x20
#define GLOBAL_STOP 0x21
#define GLOBAL_CALL 0x30
#define GLOBAL_EXEC 0x31
#define GLOBAL_LIMIT 0x7B
#define GLOBAL_EXIST 0x7C
#define GLOBAL_NMEM 0x7D
#define GLOBAL_NOK 0x7E
#define GLOBAL_OK 0x7F
#define GLOBAL_DEBUG 0xFF
#define JTAG430_HALTCPU 0xA0
#define JTAG430_RELEASECPU 0xA1
#define JTAG430_SETINSTRFETCH 0xC1
#define JTAG430_SETPC 0xC2
#define JTAG430_SETREG 0xD2
#define JTAG430_GETREG 0xD3
#define JTAG430_WRITEMEM 0xE0
#define JTAG430_WRITEFLASH 0xE1
#define JTAG430_READMEM 0xE2
#define JTAG430_ERASEFLASH 0xE3
#define JTAG430_ERASECHECK 0xE4
#define JTAG430_VERIFYMEM 0xE5
#define JTAG430_BLOWFUSE 0xE6
#define JTAG430_ISFUSEBLOWN 0xE7
#define JTAG430_ERASEINFO 0xE8
#define JTAG430_COREIP_ID 0xF0
#define JTAG430_DEVICE_ID 0xF1
/* GoodFET packet transfer */
#define MAX_LEN 1024
#define MAX_MEM_BLOCK 128
/************************************************************************
* GoodFET protocol handling
*/
struct packet {
uint8_t app;
uint8_t verb;
uint16_t len;
uint8_t data[MAX_LEN];
};
static int reset_sequence(sport_t fd)
{
static const int states[] = {
SPORT_MC_RTS,
SPORT_MC_RTS | SPORT_MC_DTR,
SPORT_MC_DTR
};
int i;
printc_dbg("Resetting GoodFET...\n");
for (i = 0; i < 3; i++) {
if (sport_set_modem(fd, states[i]) < 0) {
printc_err("goodfet: failed at step %d: %s\n",
i, last_error());
return -1;
}
delay_ms(20);
}
return 0;
}
static int send_packet(sport_t fd,
uint8_t app, uint8_t verb, uint16_t len,
const uint8_t *data)
{
uint8_t raw[MAX_LEN + 4];
if (len > MAX_LEN) {
printc_err("goodfet: send_packet: maximum length "
"exceeded (%d)\n", len);
return -1;
}
#ifdef DEBUG_GOODFET
printc_dbg("SEND: %02x/%02x\n", app, verb);
if (len)
debug_hexdump("Data", data, len);
#endif
raw[0] = app;
raw[1] = verb;
raw[2] = len & 0xff;
raw[3] = len >> 8;
memcpy(raw + 4, data, len);
if (sport_write_all(fd, raw, len + 4) < 0) {
printc_err("goodfet: send_packet: %s\n", last_error());
return -1;
}
return 0;
}
static int recv_packet(sport_t fd, struct packet *pkt)
{
uint8_t header[4];
if (sport_read_all(fd, header, 4) < 0) {
printc_err("goodfet: recv_packet (header): %s\n",
last_error());
return -1;
}
pkt->app = header[0];
pkt->verb = header[1];
pkt->len = ((uint16_t)header[2]) | (((uint16_t)header[3]) << 8);
if (pkt->len > MAX_LEN) {
printc_err("goodfet: recv_packet: maximum length "
"exceeded (%d)\n", pkt->len);
return -1;
}
if (sport_read_all(fd, pkt->data, pkt->len) < 0) {
printc_err("goodfet: recv_packet (data): %s\n",
last_error());
return -1;
}
#ifdef DEBUG_GOODFET
printc_dbg("RECV: %02x/%02x\n", pkt->app, pkt->verb);
if (pkt->len)
debug_hexdump("Data", pkt->data, pkt->len);
#endif
return 0;
}
static int xfer(sport_t fd,
uint8_t app, uint8_t verb, uint16_t len,
const uint8_t *data, struct packet *pkt)
{
if (send_packet(fd, app, verb, len, data) < 0)
goto fail;
while (recv_packet(fd, pkt) >= 0) {
if (pkt->app == APP_DEBUG && pkt->verb == GLOBAL_DEBUG) {
char text[MAX_LEN + 1];
memcpy(text, pkt->data, pkt->len);
text[pkt->len] = 0;
printc_dbg("[GoodFET debug] %s\n", text);
}
if (pkt->app == app && pkt->verb == verb)
return 0;
}
fail:
printc_err("goodfet: command 0x%02x/0x%02x "
"failed\n", app, verb);
return -1;
}
/************************************************************************
* GoodFET MSP430 JTAG operations
*/
/* Read a word-aligned block from any kind of memory. */
static int read_words(sport_t fd, address_t addr,
address_t len, uint8_t *data)
{
struct packet pkt;
uint8_t req[6];
req[0] = addr;
req[1] = addr >> 8;
req[2] = addr >> 16;
req[3] = addr >> 24;
req[4] = len;
req[5] = len >> 8;
if (xfer(fd, APP_JTAG430, GLOBAL_PEEK, sizeof(req), req, &pkt) < 0) {
printc_err("goodfet: read %d bytes from 0x%x failed\n",
len, addr);
return -1;
}
if (pkt.len != len) {
printc_err("goodfet: short memory read (got %d, "
"expected %d)\n", pkt.len, len);
return -1;
}
memcpy(data, pkt.data, pkt.len);
return 0;
}
/* Write a word to RAM. */
static int write_ram_word(sport_t fd, address_t addr, uint16_t value)
{
uint8_t req[6];
struct packet pkt;
req[0] = addr;
req[1] = addr >> 8;
req[2] = 0;
req[3] = 0;
req[4] = value;
req[5] = value >> 8;
if (xfer(fd, APP_JTAG430, GLOBAL_POKE, sizeof(req), req, &pkt) < 0) {
printc_err("goodfet: failed to write word at 0x%x\n", addr);
return -1;
}
return 0;
}
/* Write a word-aligned flash block. The starting address must be within
* the flash memory range.
*/
static int write_flash_block(sport_t fd, address_t addr,
address_t len, const uint8_t *data)
{
uint8_t req[MAX_MEM_BLOCK + 4];
struct packet pkt;
req[0] = addr >> 0;
req[1] = addr >> 8;
req[2] = addr >> 16;
req[3] = addr >> 24;
memcpy(req + 4, data, len);
if (xfer(fd, APP_JTAG430, JTAG430_WRITEFLASH,
len + 4, req, &pkt) < 0) {
printc_err("goodfet: failed to write "
"flash block of size %d at 0x%x\n",
len, addr);
return -1;
}
return 0;
}
/* Write a single byte by reading and rewriting a word. */
static int write_byte(sport_t fd, address_t addr, uint8_t value)
{
address_t aligned = addr & ~1;
uint8_t data[2];
int r;
if (read_words(fd, aligned, 2, data) < 0)
goto fail;
data[addr & 1] = value;
if (addr < 0x8000)
r = write_ram_word(fd, aligned,
((uint16_t)data[0]) |
(((uint16_t)data[1]) << 8));
else
r = write_flash_block(fd, aligned, 2, data);
if (r < 0)
goto fail;
return 0;
fail:
printc_err("good_fet: write_byte at address 0x%x failed\n", addr);
return -1;
}
static int init_device(sport_t fd)
{
struct packet pkt;
uint8_t chip_id[2];
printc_dbg("Initializing...\n");
if (xfer(fd, APP_JTAG430, GLOBAL_NOK, 0, NULL, &pkt) < 0) {
printc_err("goodfet: comms test failed\n");
return -1;
}
printc_dbg("Setting up JTAG pins\n");
if (xfer(fd, APP_JTAG430, GLOBAL_SETUP, 0, NULL, &pkt) < 0) {
printc_err("goodfet: SETUP command failed\n");
return -1;
}
printc_dbg("Starting JTAG\n");
if (xfer(fd, APP_JTAG430, GLOBAL_START, 0, NULL, &pkt) < 0) {
printc_err("goodfet: START command failed\n");
return -1;
}
if (pkt.len < 1) {
printc_err("goodfet: bad response to JTAG START\n");
return -1;
}
printc("JTAG ID: 0x%02x\n", pkt.data[0]);
if (pkt.data[0] != 0x89 && pkt.data[0] != 0x91) {
printc_err("goodfet: unexpected JTAG ID: 0x%02x\n",
pkt.data[0]);
xfer(fd, APP_JTAG430, GLOBAL_STOP, 0, NULL, &pkt);
return -1;
}
printc_dbg("Halting CPU\n");
if (xfer(fd, APP_JTAG430, JTAG430_HALTCPU, 0, NULL, &pkt) < 0) {
printc_err("goodfet: HALTCPU command failed\n");
xfer(fd, APP_JTAG430, GLOBAL_STOP, 0, NULL, &pkt);
return -1;
}
if (read_words(fd, 0xff0, 2, chip_id) < 0) {
printc_err("goodfet: failed to read chip ID\n");
xfer(fd, APP_JTAG430, GLOBAL_STOP, 0, NULL, &pkt);
return -1;
}
printc_dbg("Chip ID: 0x%02x%02x\n", chip_id[0], chip_id[1]);
return 0;
}
/************************************************************************
* MSPDebug Device interface
*/
struct goodfet {
struct device base;
sport_t serial_fd;
};
static int goodfet_readmem(device_t dev_base, address_t addr,
uint8_t *mem, address_t len)
{
struct goodfet *gc = (struct goodfet *)dev_base;
if (!len)
return 0;
/* Handle unaligned start */
if (addr & 1) {
uint8_t data[2];
if (read_words(gc->serial_fd, addr ^ 1, 2, data) < 0)
goto fail;
mem[0] = data[1];
addr++;
mem++;
len--;
}
/* Read aligned blocks */
while (len >= 2) {
int plen = MAX_MEM_BLOCK;
if (plen > len)
plen = len;
plen &= ~1;
if (read_words(gc->serial_fd, addr, plen, mem) < 0)
goto fail;
addr += plen;
mem += plen;
len -= plen;
}
/* Handle unaligned end */
if (len) {
uint8_t data[2];
if (read_words(gc->serial_fd, addr, 2, data) < 0)
goto fail;
mem[0] = data[0];
}
return 0;
fail:
printc_err("goodfet: readmem failed at 0x%x\n", addr);
return -1;
}
static int goodfet_writemem(device_t dev_base, address_t addr,
const uint8_t *mem, address_t len)
{
struct goodfet *gc = (struct goodfet *)dev_base;
if (!len)
return 0;
/* Handle unaligned start */
if (addr & 1) {
if (write_byte(gc->serial_fd, addr, mem[0]) < 0)
goto fail;
addr++;
mem++;
len--;
}
while (len >= 2) {
if (addr < 0x8000) {
if (write_ram_word(gc->serial_fd, addr,
((uint16_t)mem[0]) |
(((uint16_t)mem[1]) << 8)) < 0)
goto fail;
addr += 2;
mem += 2;
len -= 2;
} else {
int plen = MAX_MEM_BLOCK;
if (plen > len)
plen = len;
plen &= ~1;
if (write_flash_block(gc->serial_fd, addr,
plen, mem) < 0)
goto fail;
addr += plen;
mem += plen;
len -= plen;
}
}
/* Handle unaligned end */
if (len && (write_byte(gc->serial_fd, addr, mem[0]) < 0))
goto fail;
return 0;
fail:
printc_err("goodfet: writemem failed at 0x%x\n", addr);
return -1;
}
static int goodfet_setregs(device_t dev_base, const address_t *regs)
{
(void)dev_base;
(void)regs;
printc_err("goodfet: register write not implemented\n");
return -1;
}
static int goodfet_getregs(device_t dev_base, address_t *regs)
{
(void)dev_base;
(void)regs;
printc_err("goodfet: register read not implemented\n");
return -1;
}
static int goodfet_reset(struct goodfet *gc)
{
static const uint8_t cmd_seq[] = {
JTAG430_RELEASECPU,
GLOBAL_STOP,
GLOBAL_START,
JTAG430_HALTCPU
};
int i;
/* We don't have a POR request, so just restart JTAG */
for (i = 0; i < 4; i++) {
struct packet pkt;
if (xfer(gc->serial_fd, APP_JTAG430, cmd_seq[i],
0, NULL, &pkt) < 0) {
printc_err("goodfet: reset: command 0x%02x failed\n",
cmd_seq[i]);
return -1;
}
}
return 0;
}
static int goodfet_run(struct goodfet *gc)
{
struct packet pkt;
if (xfer(gc->serial_fd, APP_JTAG430, JTAG430_RELEASECPU,
0, NULL, &pkt) < 0) {
printc_err("goodfet: failed to release CPU\n");
return -1;
}
return 0;
}
static int goodfet_halt(struct goodfet *gc)
{
struct packet pkt;
if (xfer(gc->serial_fd, APP_JTAG430, JTAG430_HALTCPU,
0, NULL, &pkt) < 0) {
printc_err("goodfet: failed to release CPU\n");
return -1;
}
return 0;
}
static int goodfet_ctl(device_t dev_base, device_ctl_t type)
{
struct goodfet *gc = (struct goodfet *)dev_base;
switch (type) {
case DEVICE_CTL_RESET:
return goodfet_reset(gc);
case DEVICE_CTL_RUN:
return goodfet_run(gc);
case DEVICE_CTL_HALT:
return goodfet_halt(gc);
case DEVICE_CTL_STEP:
printc_err("goodfet: single-stepping not implemented\n");
return -1;
}
return 0;
}
static device_status_t goodfet_poll(device_t dev_base)
{
(void)dev_base;
if (delay_ms(100) < 0 || ctrlc_check())
return DEVICE_STATUS_INTR;
return DEVICE_STATUS_RUNNING;
}
static int goodfet_erase(device_t dev_base, device_erase_type_t type,
address_t addr)
{
struct goodfet *gc = (struct goodfet *)dev_base;
struct packet pkt;
if (type != DEVICE_ERASE_MAIN) {
printc_err("goodfet: only main memory erase is supported\n");
return -1;
}
if (xfer(gc->serial_fd, APP_JTAG430, JTAG430_ERASEFLASH,
0, NULL, &pkt) < 0) {
printc_err("goodfet: erase failed\n");
return -1;
}
return 0;
}
static device_t goodfet_open(const struct device_args *args)
{
struct goodfet *gc;
if (!(args->flags & DEVICE_FLAG_TTY)) {
printc_err("goodfet: this driver does not support raw "
"USB access\n");
return NULL;
}
if (!(args->flags & DEVICE_FLAG_JTAG)) {
printc_err("goodfet: this driver does not support "
"Spy-Bi-Wire\n");
return NULL;
}
gc = malloc(sizeof(*gc));
if (!gc) {
printc_err("goodfet: malloc: %s\n", last_error());
return NULL;
}
gc->base.type = &device_goodfet;
gc->base.max_breakpoints = 0;
gc->serial_fd = sport_open(args->path, 115200, 0);
if (SPORT_ISERR(gc->serial_fd)) {
printc_err("goodfet: sport_open: %s: %s\n",
args->path, last_error());
free(gc);
return NULL;
}
if ((args->flags & DEVICE_FLAG_FORCE_RESET) &&
reset_sequence(gc->serial_fd) < 0)
printc_err("warning: goodfet: reset failed\n");
if (sport_flush(gc->serial_fd) < 0)
printc_err("warning: goodfet: sport_flush: %s\n",
last_error());
if (init_device(gc->serial_fd) < 0) {
printc_err("goodfet: initialization failed\n");
free(gc);
return NULL;
}
return &gc->base;
}
static void goodfet_destroy(device_t dev_base)
{
struct goodfet *gc = (struct goodfet *)dev_base;
struct packet pkt;
xfer(gc->serial_fd, APP_JTAG430, JTAG430_RELEASECPU, 0, NULL, &pkt);
xfer(gc->serial_fd, APP_JTAG430, GLOBAL_STOP, 0, NULL, &pkt);
sport_close(gc->serial_fd);
free(gc);
}
const struct device_class device_goodfet = {
.name = "goodfet",
.help = "GoodFET MSP430 JTAG",
.open = goodfet_open,
.destroy = goodfet_destroy,
.readmem = goodfet_readmem,
.writemem = goodfet_writemem,
.getregs = goodfet_getregs,
.setregs = goodfet_setregs,
.ctl = goodfet_ctl,
.poll = goodfet_poll,
.erase = goodfet_erase
};