sys64738
/
mspdebug
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Use stdint.h instead of sys/types.h.

This commit is contained in:
Daniel Beer 2010-05-13 12:57:21 +12:00
parent f4fcd0c909
commit b8a3ef41c7
27 changed files with 214 additions and 214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
binfile.h
View File

@ -20,13 +20,13 @@
#define BINFILE_H_
#include <stdio.h>
#include <sys/types.h>
#include <stdint.h>
#include "stab.h"
/* Callback for binary image data */
typedef int (*imgfunc_t)(void *user_data,
u_int16_t addr, const u_int8_t *data, int len);
uint16_t addr, const uint8_t *data, int len);
/* Intel HEX file support */
int ihex_check(FILE *in);

42
bsl.c
View File

@ -20,7 +20,7 @@
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <stdint.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
@ -33,7 +33,7 @@ struct bsl_device {
struct device base;
int serial_fd;
u_int8_t reply_buf[256];
uint8_t reply_buf[256];
int reply_len;
};
@ -43,7 +43,7 @@ struct bsl_device {
static int bsl_ack(struct bsl_device *dev)
{
u_int8_t reply;
uint8_t reply;
if (read_with_timeout(dev->serial_fd, &reply, 1) < 0) {
fprintf(stderr, "bsl: failed to receive reply\n");
@ -65,7 +65,7 @@ static int bsl_ack(struct bsl_device *dev)
static int bsl_sync(struct bsl_device *dev)
{
static const u_int8_t c = DATA_HDR;
static const uint8_t c = DATA_HDR;
int tries = 2;
if (tcflush(dev->serial_fd, TCIFLUSH) < 0) {
@ -82,12 +82,12 @@ static int bsl_sync(struct bsl_device *dev)
}
static int send_command(struct bsl_device *dev,
int code, u_int16_t addr,
const u_int8_t *data, int len)
int code, uint16_t addr,
const uint8_t *data, int len)
{
u_int8_t pktbuf[256];
u_int8_t cklow = 0xff;
u_int8_t ckhigh = 0xff;
uint8_t pktbuf[256];
uint8_t cklow = 0xff;
uint8_t ckhigh = 0xff;
int pktlen = data ? len + 4 : 4;
int i;
@ -121,8 +121,8 @@ static int send_command(struct bsl_device *dev,
static int verify_checksum(struct bsl_device *dev)
{
u_int8_t cklow = 0xff;
u_int8_t ckhigh = 0xff;
uint8_t cklow = 0xff;
uint8_t ckhigh = 0xff;
int i;
for (i = 0; i < dev->reply_len; i += 2)
@ -177,7 +177,7 @@ static int fetch_reply(struct bsl_device *dev)
}
static int bsl_xfer(struct bsl_device *dev,
int command_code, u_int16_t addr, const u_int8_t *txdata,
int command_code, uint16_t addr, const uint8_t *txdata,
int len)
{
if (bsl_sync(dev) < 0 ||
@ -217,33 +217,33 @@ static device_status_t bsl_poll(device_t dev_base)
return DEVICE_STATUS_HALTED;
}
static int bsl_breakpoint(device_t dev_base, int enabled, u_int16_t addr)
static int bsl_breakpoint(device_t dev_base, int enabled, uint16_t addr)
{
fprintf(stderr, "bsl: breakpoints are not implemented\n");
return -1;
}
static int bsl_getregs(device_t dev_base, u_int16_t *regs)
static int bsl_getregs(device_t dev_base, uint16_t *regs)
{
fprintf(stderr, "bsl: register fetch is not implemented\n");
return -1;
}
static int bsl_setregs(device_t dev_base, const u_int16_t *regs)
static int bsl_setregs(device_t dev_base, const uint16_t *regs)
{
fprintf(stderr, "bsl: register store is not implemented\n");
return -1;
}
static int bsl_writemem(device_t dev_base,
u_int16_t addr, const u_int8_t *mem, int len)
uint16_t addr, const uint8_t *mem, int len)
{
fprintf(stderr, "bsl: memory write is not implemented\n");
return -1;
}
static int bsl_readmem(device_t dev_base,
u_int16_t addr, u_int8_t *mem, int len)
uint16_t addr, uint8_t *mem, int len)
{
struct bsl_device *dev = (struct bsl_device *)dev_base;
@ -271,13 +271,13 @@ static int bsl_readmem(device_t dev_base,
static int enter_via_fet(struct bsl_device *dev)
{
u_int8_t buf[16];
u_int8_t *data = buf;
uint8_t buf[16];
uint8_t *data = buf;
int len = 8;
/* Enter bootloader command */
if (write_all(dev->serial_fd,
(u_int8_t *)"\x7e\x24\x01\x9d\x5a\x7e", 6)) {
(uint8_t *)"\x7e\x24\x01\x9d\x5a\x7e", 6)) {
fprintf(stderr, "bsl: couldn't write bootloader transition "
"command\n");
return -1;
@ -311,7 +311,7 @@ device_t bsl_open(const char *device)
{
struct bsl_device *dev = malloc(sizeof(*dev));
char idtext[64];
u_int16_t id;
uint16_t id;
if (!dev) {
perror("bsl: can't allocate memory");

14
cproc_util.c
View File

@ -25,10 +25,10 @@
#include "util.h"
static int format_addr(stab_t stab, char *buf, int max_len,
msp430_amode_t amode, u_int16_t addr)
msp430_amode_t amode, uint16_t addr)
{
char name[64];
u_int16_t offset;
uint16_t offset;
int numeric = 0;
const char *prefix = "";
@ -109,7 +109,7 @@ static int format_reg(char *buf, int max_len,
* Returns the number of characters printed.
*/
static int format_operand(stab_t stab, char *buf, int max_len,
msp430_amode_t amode, u_int16_t addr,
msp430_amode_t amode, uint16_t addr,
msp430_reg_t reg)
{
int len = 0;
@ -183,7 +183,7 @@ static int dis_format(stab_t stab, char *buf, int max_len,
}
void cproc_disassemble(cproc_t cp,
u_int16_t offset, const u_int8_t *data, int length)
uint16_t offset, const uint8_t *data, int length)
{
stab_t stab = cproc_stab(cp);
int first_line = 1;
@ -193,7 +193,7 @@ void cproc_disassemble(cproc_t cp,
int retval;
int count;
int i;
u_int16_t oboff;
uint16_t oboff;
char obname[64];
char buf[256];
int len = 0;
@ -238,7 +238,7 @@ void cproc_disassemble(cproc_t cp,
}
}
void cproc_hexdump(cproc_t cp, u_int16_t addr, const u_int8_t *data, int data_len)
void cproc_hexdump(cproc_t cp, uint16_t addr, const uint8_t *data, int data_len)
{
int offset = 0;
@ -279,7 +279,7 @@ void cproc_hexdump(cproc_t cp, u_int16_t addr, const u_int8_t *data, int data_le
}
}
void cproc_regs(cproc_t cp, const u_int16_t *regs)
void cproc_regs(cproc_t cp, const uint16_t *regs)
{
int i;

12
cproc_util.h
View File

@ -19,18 +19,18 @@
#ifndef CPROC_UTIL_H_
#define CPROC_UTIL_H_
#include <sys/types.h>
#include <stdint.h>
#include "cproc.h"
/* Print colorized disassembly on command processor standard output */
void cproc_disassemble(cproc_t cp, u_int16_t addr,
const u_int8_t *buf, int len);
void cproc_disassemble(cproc_t cp, uint16_t addr,
const uint8_t *buf, int len);
/* Print colorized hexdump on standard output */
void cproc_hexdump(cproc_t cp, u_int16_t addr,
const u_int8_t *buf, int len);
void cproc_hexdump(cproc_t cp, uint16_t addr,
const uint8_t *buf, int len);
/* Colorized register dump */
void cproc_regs(cproc_t cp, const u_int16_t *regs);
void cproc_regs(cproc_t cp, const uint16_t *regs);
#endif

30
devcmd.c
View File

@ -34,8 +34,8 @@
static int cmd_regs(cproc_t cp, char **arg)
{
device_t dev = cproc_device(cp);
u_int16_t regs[DEVICE_NUM_REGS];
u_int8_t code[16];
uint16_t regs[DEVICE_NUM_REGS];
uint8_t code[16];
if (dev->getregs(dev, regs) < 0)
return -1;
@ -45,7 +45,7 @@ static int cmd_regs(cproc_t cp, char **arg)
if (dev->readmem(dev, regs[0], code, sizeof(code)) < 0)
return 0;
cproc_disassemble(cp, regs[0], (u_int8_t *)code, sizeof(code));
cproc_disassemble(cp, regs[0], (uint8_t *)code, sizeof(code));
return 0;
}
@ -84,7 +84,7 @@ static int cmd_md(cproc_t cp, char **arg)
}
while (length) {
u_int8_t buf[128];
uint8_t buf[128];
int blen = length > sizeof(buf) ? sizeof(buf) : length;
if (dev->readmem(dev, offset, buf, blen) < 0)
@ -106,7 +106,7 @@ static int cmd_mw(cproc_t cp, char **arg)
char *byte_text;
int offset = 0;
int length = 0;
u_int8_t buf[1024];
uint8_t buf[1024];
if (!off_text) {
fprintf(stderr, "md: offset must be specified\n");
@ -230,7 +230,7 @@ static int cmd_set(cproc_t cp, char **arg)
char *val_text = get_arg(arg);
int reg;
int value = 0;
u_int16_t regs[DEVICE_NUM_REGS];
uint16_t regs[DEVICE_NUM_REGS];
if (!(reg_text && val_text)) {
fprintf(stderr, "set: must specify a register and a value\n");
@ -269,7 +269,7 @@ static int cmd_dis(cproc_t cp, char **arg)
char *len_text = get_arg(arg);
int offset = 0;
int length = 0x40;
u_int8_t buf[4096];
uint8_t buf[4096];
if (!off_text) {
fprintf(stderr, "dis: offset must be specified\n");
@ -300,14 +300,14 @@ static int cmd_dis(cproc_t cp, char **arg)
if (dev->readmem(dev, offset, buf, length) < 0)
return -1;
cproc_disassemble(cp, offset, (u_int8_t *)buf, length);
cproc_disassemble(cp, offset, (uint8_t *)buf, length);
return 0;
}
struct hexout_data {
FILE *file;
u_int16_t addr;
u_int8_t buf[16];
uint16_t addr;
uint8_t buf[16];
int len;
};
@ -358,7 +358,7 @@ fail:
}
static int hexout_feed(struct hexout_data *hexout,
u_int16_t addr, const u_int8_t *buf, int len)
uint16_t addr, const uint8_t *buf, int len)
{
while (len) {
int count;
@ -410,7 +410,7 @@ static int cmd_hexout(cproc_t cp, char **arg)
return -1;
while (length) {
u_int8_t buf[128];
uint8_t buf[128];
int count = length;
if (count > sizeof(buf))
@ -447,8 +447,8 @@ fail:
struct prog_data {
device_t dev;
u_int8_t buf[128];
u_int16_t addr;
uint8_t buf[128];
uint16_t addr;
int len;
int have_erased;
};
@ -490,7 +490,7 @@ static int prog_flush(struct prog_data *prog)
}
static int prog_feed(void *user_data,
u_int16_t addr, const u_int8_t *data, int len)
uint16_t addr, const uint8_t *data, int len)
{
struct prog_data *prog = (struct prog_data *)user_data;

4
device.c
View File

@ -28,7 +28,7 @@
*/
static struct {
u_int16_t id;
uint16_t id;
const char *id_text;
} id_table[] = {
{0x1132, "F1122"},
@ -64,7 +64,7 @@ static struct {
{0xF46F, "F471xx"}
};
int device_id_text(u_int16_t id, char *out, int max_len)
int device_id_text(uint16_t id, char *out, int max_len)
{
int i = 0;
int len;

18
device.h
View File

@ -19,7 +19,7 @@
#ifndef DEVICE_H_
#define DEVICE_H_
#include <sys/types.h>
#include <stdint.h>
struct device;
typedef struct device *device_t;
@ -46,17 +46,17 @@ struct device {
void (*destroy)(device_t dev);
/* Read/write memory */
int (*readmem)(device_t dev, u_int16_t addr,
u_int8_t *mem, int len);
int (*writemem)(device_t dev, u_int16_t addr,
const u_int8_t *mem, int len);
int (*readmem)(device_t dev, uint16_t addr,
uint8_t *mem, int len);
int (*writemem)(device_t dev, uint16_t addr,
const uint8_t *mem, int len);
/* Read/write registers */
int (*getregs)(device_t dev, u_int16_t *regs);
int (*setregs)(device_t dev, const u_int16_t *regs);
int (*getregs)(device_t dev, uint16_t *regs);
int (*setregs)(device_t dev, const uint16_t *regs);
/* Breakpoint control */
int (*breakpoint)(device_t dev, int enabled, u_int16_t addr);
int (*breakpoint)(device_t dev, int enabled, uint16_t addr);
/* CPU control */
int (*ctl)(device_t dev, device_ctl_t op);
@ -66,6 +66,6 @@ struct device {
};
/* Look up a device ID. Returns 0 on success or -1 if none found */
int device_id_text(u_int16_t id, char *out, int max_len);
int device_id_text(uint16_t id, char *out, int max_len);
#endif

22
dis.c
View File

@ -34,10 +34,10 @@
* Returns the number of bytes consumed in decoding, or -1 if the a
* valid single-operand instruction could not be found.
*/
static int decode_single(const u_int8_t *code, u_int16_t offset,
u_int16_t size, struct msp430_instruction *insn)
static int decode_single(const uint8_t *code, uint16_t offset,
uint16_t size, struct msp430_instruction *insn)
{
u_int16_t op = (code[1] << 8) | code[0];
uint16_t op = (code[1] << 8) | code[0];
int need_arg = 0;
insn->op = op & 0xff80;
@ -86,10 +86,10 @@ static int decode_single(const u_int8_t *code, u_int16_t offset,
* Returns the number of bytes consumed or -1 if a valid instruction
* could not be found.
*/
static int decode_double(const u_int8_t *code, u_int16_t offset,
u_int16_t size, struct msp430_instruction *insn)
static int decode_double(const uint8_t *code, uint16_t offset,
uint16_t size, struct msp430_instruction *insn)
{
u_int16_t op = (code[1] << 8) | code[0];
uint16_t op = (code[1] << 8) | code[0];
int need_src = 0;
int need_dst = 0;
int ret = 2;
@ -175,10 +175,10 @@ static int decode_double(const u_int8_t *code, u_int16_t offset,
* All jump instructions are one word in length, so this function
* always returns 2 (to indicate the consumption of 2 bytes).
*/
static int decode_jump(const u_int8_t *code, u_int16_t offset, u_int16_t len,
static int decode_jump(const uint8_t *code, uint16_t offset, uint16_t len,
struct msp430_instruction *insn)
{
u_int16_t op = (code[1] << 8) | code[0];
uint16_t op = (code[1] << 8) | code[0];
int tgtrel = op & 0x3ff;
if (tgtrel & 0x200)
@ -193,7 +193,7 @@ static int decode_jump(const u_int8_t *code, u_int16_t offset, u_int16_t len,
}
static void remap_cgen(msp430_amode_t *mode,
u_int16_t *addr,
uint16_t *addr,
msp430_reg_t *reg)
{
if (*reg == MSP430_REG_SR) {
@ -396,10 +396,10 @@ static void find_emulated_ops(struct msp430_instruction *insn)
* successful, the decoded instruction is written into the structure
* pointed to by insn.
*/
int dis_decode(const u_int8_t *code, u_int16_t offset, u_int16_t len,
int dis_decode(const uint8_t *code, uint16_t offset, uint16_t len,
struct msp430_instruction *insn)
{
u_int16_t op;
uint16_t op;
int ret;
memset(insn, 0, sizeof(*insn));

12
dis.h
View File

@ -18,7 +18,7 @@
#ifndef DIS_H_
#include <sys/types.h>
#include <stdint.h>
/* Addressing modes.
*
@ -177,7 +177,7 @@ typedef enum {
* For jump instructions, the target address is stored in dst_operand.
*/
struct msp430_instruction {
u_int16_t offset;
uint16_t offset;
int len;
msp430_op_t op;
@ -185,11 +185,11 @@ struct msp430_instruction {
int is_byte_op;
msp430_amode_t src_mode;
u_int16_t src_addr;
uint16_t src_addr;
msp430_reg_t src_reg;
msp430_amode_t dst_mode;
u_int16_t dst_addr;
uint16_t dst_addr;
msp430_reg_t dst_reg;
};
@ -202,8 +202,8 @@ struct msp430_instruction {
* successful, the decoded instruction is written into the structure
* pointed to by insn.
*/
int dis_decode(const u_int8_t *code,
u_int16_t offset, u_int16_t len,
int dis_decode(const uint8_t *code,
uint16_t offset, uint16_t len,
struct msp430_instruction *insn);
/* Look up names for registers and opcodes */

8
elf32.c
View File

@ -30,7 +30,7 @@
#define EM_MSP430 0x69
#endif
static const u_int8_t elf32_id[] = {
static const uint8_t elf32_id[] = {
ELFMAG0, ELFMAG1, ELFMAG2, ELFMAG3, ELFCLASS32
};
@ -121,7 +121,7 @@ static int read_shdr(struct elf32_info *info, FILE *in)
return 0;
}
static u_int32_t file_to_phys(struct elf32_info *info, u_int32_t v)
static uint32_t file_to_phys(struct elf32_info *info, uint32_t v)
{
int i;
@ -139,8 +139,8 @@ static int feed_section(struct elf32_info *info,
FILE *in, int offset, int size, imgfunc_t cb,
void *user_data)
{
u_int8_t buf[1024];
u_int16_t addr = file_to_phys(info, offset);
uint8_t buf[1024];
uint16_t addr = file_to_phys(info, offset);
if (fseek(in, offset, SEEK_SET) < 0) {
perror("elf32: can't seek to section");

2
expr.c
View File

@ -20,7 +20,7 @@
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <stdint.h>
#include <regex.h>
#include <errno.h>
#include <assert.h>

2
expr.h
View File

@ -19,7 +19,7 @@
#ifndef EXPR_H_
#define EXPR_H_
#include <sys/types.h>
#include <stdint.h>
#include "stab.h"
/* Parse an address expression, storing the result in the integer

68
fet.c
View File

@ -40,9 +40,9 @@ struct fet_device {
int version;
int have_breakpoint;
u_int16_t code_left[65536];
uint16_t code_left[65536];
u_int8_t fet_buf[65538];
uint8_t fet_buf[65538];
int fet_len;
/* Recieved packet is parsed into this struct */
@ -51,9 +51,9 @@ struct fet_device {
int state;
int argc;
u_int32_t argv[MAX_PARAMS];
uint32_t argv[MAX_PARAMS];
u_int8_t *data;
uint8_t *data;
int datalen;
} fet_reply;
};
@ -132,7 +132,7 @@ static void init_codes(struct fet_device *dev)
int i;
for (i = 0; i < 65536; i++) {
u_int16_t right = i << 1;
uint16_t right = i << 1;
if (i & 0x8000)
right ^= 0x0811;
@ -145,19 +145,19 @@ static void init_codes(struct fet_device *dev)
* needs to be stored in little-endian format at the end of the payload.
*/
static u_int16_t calc_checksum(struct fet_device *dev,
const u_int8_t *data, int len)
static uint16_t calc_checksum(struct fet_device *dev,
const uint8_t *data, int len)
{
int i;
u_int16_t cksum = 0xffff;
u_int16_t code = 0x8408;
uint16_t cksum = 0xffff;
uint16_t code = 0x8408;
for (i = len * 8; i; i--)
cksum = dev->code_left[cksum];
for (i = len - 1; i >= 0; i--) {
int j;
u_int8_t c = data[i];
uint8_t c = data[i];
for (j = 0; j < 8; j++) {
if (c & 0x80)
@ -182,12 +182,12 @@ static u_int16_t calc_checksum(struct fet_device *dev,
* No checksums are included.
*/
static int send_rf2500_data(struct fet_device *dev,
const u_int8_t *data, int len)
const uint8_t *data, int len)
{
int offset = 0;
while (len) {
u_int8_t pbuf[63];
uint8_t pbuf[63];
int plen = len > 59 ? 59 : len;
pbuf[0] = 0x83;
@ -206,7 +206,7 @@ static int send_rf2500_data(struct fet_device *dev,
return 0;
}
#define BUFFER_BYTE(b, x) ((int)((u_int8_t *)(b))[x])
#define BUFFER_BYTE(b, x) ((int)((uint8_t *)(b))[x])
#define BUFFER_WORD(b, x) ((BUFFER_BYTE(b, x + 1) << 8) | BUFFER_BYTE(b, x))
#define BUFFER_LONG(b, x) ((BUFFER_WORD(b, x + 2) << 16) | BUFFER_WORD(b, x))
@ -284,8 +284,8 @@ static const char *error_strings[] =
static int parse_packet(struct fet_device *dev, int plen)
{
u_int16_t c = calc_checksum(dev, dev->fet_buf + 2, plen - 2);
u_int16_t r = BUFFER_WORD(dev->fet_buf, plen);
uint16_t c = calc_checksum(dev, dev->fet_buf + 2, plen - 2);
uint16_t r = BUFFER_WORD(dev->fet_buf, plen);
int i = 2;
int type;
int error;
@ -401,14 +401,14 @@ static int recv_packet(struct fet_device *dev)
}
static int send_command(struct fet_device *dev, int command_code,
const u_int32_t *params, int nparams,
const u_int8_t *extra, int exlen)
const uint32_t *params, int nparams,
const uint8_t *extra, int exlen)
{
u_int8_t datapkt[256];
uint8_t datapkt[256];
int len = 0;
u_int8_t buf[512];
u_int16_t cksum;
uint8_t buf[512];
uint16_t cksum;
int i = 0;
int j;
@ -424,7 +424,7 @@ static int send_command(struct fet_device *dev, int command_code,
datapkt[len++] = nparams >> 8;
for (j = 0; j < nparams; j++) {
u_int32_t p = params[j];
uint32_t p = params[j];
datapkt[len++] = p & 0xff;
p >>= 8;
@ -479,10 +479,10 @@ static int send_command(struct fet_device *dev, int command_code,
}
static int xfer(struct fet_device *dev,
int command_code, const u_int8_t *data, int datalen,
int command_code, const uint8_t *data, int datalen,
int nparams, ...)
{
u_int32_t params[MAX_PARAMS];
uint32_t params[MAX_PARAMS];
int i;
va_list ap;
@ -537,7 +537,7 @@ static int do_identify(struct fet_device *dev)
memcpy(idtext, dev->fet_reply.data + 4, 32);
idtext[32] = 0;
} else {
u_int16_t id;
uint16_t id;
if (xfer(dev, 0x28, NULL, 0, 2, 0, 0) < 0) {
fprintf(stderr, "fet: command 0x28 failed\n");
@ -674,7 +674,7 @@ static void fet_destroy(device_t dev_base)
free(dev);
}
int fet_readmem(device_t dev_base, u_int16_t addr, u_int8_t *buffer, int count)
int fet_readmem(device_t dev_base, uint16_t addr, uint8_t *buffer, int count)
{
struct fet_device *dev = (struct fet_device *)dev_base;
@ -702,8 +702,8 @@ int fet_readmem(device_t dev_base, u_int16_t addr, u_int8_t *buffer, int count)
return 0;
}
int fet_writemem(device_t dev_base, u_int16_t addr,
const u_int8_t *buffer, int count)
int fet_writemem(device_t dev_base, uint16_t addr,
const uint8_t *buffer, int count)
{
struct fet_device *dev = (struct fet_device *)dev_base;
@ -727,7 +727,7 @@ int fet_writemem(device_t dev_base, u_int16_t addr,
return 0;
}
static int fet_getregs(device_t dev_base, u_int16_t *regs)
static int fet_getregs(device_t dev_base, uint16_t *regs)
{
struct fet_device *dev = (struct fet_device *)dev_base;
int i;
@ -747,10 +747,10 @@ static int fet_getregs(device_t dev_base, u_int16_t *regs)
return 0;
}
static int fet_setregs(device_t dev_base, const u_int16_t *regs)
static int fet_setregs(device_t dev_base, const uint16_t *regs)
{
struct fet_device *dev = (struct fet_device *)dev_base;
u_int8_t buf[DEVICE_NUM_REGS * 4];;
uint8_t buf[DEVICE_NUM_REGS * 4];;
int i;
int ret;
@ -771,7 +771,7 @@ static int fet_setregs(device_t dev_base, const u_int16_t *regs)
return 0;
}
static int fet_breakpoint(device_t dev_base, int enabled, u_int16_t addr)
static int fet_breakpoint(device_t dev_base, int enabled, uint16_t addr)
{
struct fet_device *dev = (struct fet_device *)dev_base;
@ -798,9 +798,9 @@ static int fet_breakpoint(device_t dev_base, int enabled, u_int16_t addr)
struct magic_record {
int min_version;
int flags;
u_int32_t param_29[MAGIC_PARAM_COUNT];
const u_int8_t data_29[MAGIC_DATA_SIZE];
const u_int8_t data_2b[MAGIC_DATA_SIZE];
uint32_t param_29[MAGIC_PARAM_COUNT];
const uint8_t data_29[MAGIC_DATA_SIZE];
const uint8_t data_2b[MAGIC_DATA_SIZE];
};
/* The first entry in this table whose version exceeds the version

14
gdb.c
View File

@ -23,7 +23,7 @@
#include <unistd.h>
#include <ctype.h>
#include <stdarg.h>
#include <sys/types.h>
#include <stdint.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
@ -217,7 +217,7 @@ static int gdb_send(struct gdb_data *data, const char *msg)
static int read_registers(struct gdb_data *data)
{
u_int16_t regs[DEVICE_NUM_REGS];
uint16_t regs[DEVICE_NUM_REGS];
int i;
printf("Reading registers\n");
@ -262,7 +262,7 @@ static int monitor_command(struct gdb_data *data, char *buf)
static int write_registers(struct gdb_data *data, char *buf)
{
u_int16_t regs[DEVICE_NUM_REGS];
uint16_t regs[DEVICE_NUM_REGS];
int i;
if (strlen(buf) < DEVICE_NUM_REGS * 4)
@ -287,7 +287,7 @@ static int read_memory(struct gdb_data *data, char *text)
{
char *length_text = strchr(text, ',');
int length, addr;
u_int8_t buf[128];
uint8_t buf[128];
int i;
if (!length_text) {
@ -321,7 +321,7 @@ static int write_memory(struct gdb_data *data, char *text)
char *data_text = strchr(text, ':');
char *length_text = strchr(text, ',');
int length, addr;
u_int8_t buf[128];
uint8_t buf[128];
int buflen = 0;
if (!(data_text && length_text)) {
@ -356,7 +356,7 @@ static int write_memory(struct gdb_data *data, char *text)
static int run_set_pc(struct gdb_data *data, char *buf)
{
u_int16_t regs[DEVICE_NUM_REGS];
uint16_t regs[DEVICE_NUM_REGS];
if (!*buf)
return 0;
@ -370,7 +370,7 @@ static int run_set_pc(struct gdb_data *data, char *buf)
static int run_final_status(struct gdb_data *data)
{
u_int16_t regs[DEVICE_NUM_REGS];
uint16_t regs[DEVICE_NUM_REGS];
int i;
if (data->device->getregs(data->device, regs) < 0)

8
ihex.c
View File

@ -27,10 +27,10 @@ int ihex_check(FILE *in)
return fgetc(in) == ':';
}
static int feed_line(FILE *in, u_int8_t *data, int nbytes, imgfunc_t cb,
static int feed_line(FILE *in, uint8_t *data, int nbytes, imgfunc_t cb,
void *user_data)
{
u_int8_t cksum = 0;
uint8_t cksum = 0;
int i;
if (nbytes < 5 || data[3])
@ -48,7 +48,7 @@ static int feed_line(FILE *in, u_int8_t *data, int nbytes, imgfunc_t cb,
}
return cb(user_data,
((u_int16_t)data[1]) << 8 | ((u_int16_t)data[2]),
((uint16_t)data[1]) << 8 | ((uint16_t)data[2]),
data + 4, nbytes - 5);
}
@ -61,7 +61,7 @@ int ihex_extract(FILE *in, imgfunc_t cb, void *user_data)
while (fgets(buf, sizeof(buf), in)) {
int len = strlen(buf);
int i;
u_int8_t data[64];
uint8_t data[64];
int nbytes;
lno++;

12
main.c
View File

@ -42,8 +42,8 @@
#include "rf2500.h"
static void io_prefix(stab_t stab,
const char *prefix, u_int16_t pc,
u_int16_t addr, int is_byte)
const char *prefix, uint16_t pc,
uint16_t addr, int is_byte)
{
char name[64];
@ -64,8 +64,8 @@ static void io_prefix(stab_t stab,
}
}
static int fetch_io(void *user_data, u_int16_t pc,
u_int16_t addr, int is_byte, u_int16_t *data_ret)
static int fetch_io(void *user_data, uint16_t pc,
uint16_t addr, int is_byte, uint16_t *data_ret)
{
stab_t stab = (stab_t)user_data;
@ -101,8 +101,8 @@ static int fetch_io(void *user_data, u_int16_t pc,
return 0;
}
static void store_io(void *user_data, u_int16_t pc,
u_int16_t addr, int is_byte, u_int16_t data)
static void store_io(void *user_data, uint16_t pc,
uint16_t addr, int is_byte, uint16_t data)
{
stab_t stab = (stab_t)user_data;

8
rf2500.c
View File

@ -29,7 +29,7 @@ struct rf2500_transport {
int int_number;
struct usb_dev_handle *handle;
u_int8_t buf[64];
uint8_t buf[64];
int len;
int offset;
};
@ -98,12 +98,12 @@ static int open_device(struct rf2500_transport *tr,
return -1;
}
static int usbtr_send(transport_t tr_base, const u_int8_t *data, int len)
static int usbtr_send(transport_t tr_base, const uint8_t *data, int len)
{
struct rf2500_transport *tr = (struct rf2500_transport *)tr_base;
while (len) {
u_int8_t pbuf[256];
uint8_t pbuf[256];
int plen = len > 255 ? 255 : len;
int txlen = plen + 1;
@ -136,7 +136,7 @@ static int usbtr_send(transport_t tr_base, const u_int8_t *data, int len)
return 0;
}
static int usbtr_recv(transport_t tr_base, u_int8_t *databuf, int max_len)
static int usbtr_recv(transport_t tr_base, uint8_t *databuf, int max_len)
{
struct rf2500_transport *tr = (struct rf2500_transport *)tr_base;
int rlen;

2
rtools.c
View File

@ -320,7 +320,7 @@ static int isearch_match(const struct msp430_instruction *insn,
static int do_isearch(cproc_t cp,
int addr, int len, const struct isearch_query *q)
{
u_int8_t *mbuf;
uint8_t *mbuf;
device_t dev = cproc_device(cp);
int i;

72
sim.c
View File

@ -35,13 +35,13 @@ struct sim_device {
sim_store_func_t store_func;
void *user_data;
u_int8_t memory[MEM_SIZE];
u_int16_t regs[DEVICE_NUM_REGS];
uint8_t memory[MEM_SIZE];
uint16_t regs[DEVICE_NUM_REGS];
int running;
u_int16_t current_insn;
uint16_t current_insn;
int have_breakpoint;
u_int16_t breakpoint_addr;
uint16_t breakpoint_addr;
};
#define MEM_GETB(dev, offset) ((dev)->memory[offset])
@ -57,10 +57,10 @@ struct sim_device {
static int fetch_operand(struct sim_device *dev,
int amode, int reg, int is_byte,
u_int16_t *addr_ret, u_int32_t *data_ret)
uint16_t *addr_ret, uint32_t *data_ret)
{
u_int16_t addr = 0;
u_int32_t mask = is_byte ? 0xff : 0xffff;
uint16_t addr = 0;
uint32_t mask = is_byte ? 0xff : 0xffff;
switch (amode) {
case MSP430_AMODE_REGISTER:
@ -125,7 +125,7 @@ static int fetch_operand(struct sim_device *dev,
*data_ret = MEM_GETW(dev, addr) & mask;
if (addr < MEM_IO_END && dev->fetch_func) {
u_int16_t data16 = *data_ret;
uint16_t data16 = *data_ret;
int ret;
ret = dev->fetch_func(dev->user_data,
@ -141,7 +141,7 @@ static int fetch_operand(struct sim_device *dev,
static void store_operand(struct sim_device *dev,
int amode, int reg, int is_byte,
u_int16_t addr, u_int16_t data)
uint16_t addr, uint16_t data)
{
if (is_byte)
MEM_SETB(dev, addr, data);
@ -157,20 +157,20 @@ static void store_operand(struct sim_device *dev,
#define ARITH_BITS (MSP430_SR_V | MSP430_SR_N | MSP430_SR_Z | MSP430_SR_C)
static int step_double(struct sim_device *dev, u_int16_t ins)
static int step_double(struct sim_device *dev, uint16_t ins)
{
u_int16_t opcode = ins & 0xf000;
uint16_t opcode = ins & 0xf000;
int sreg = (ins >> 8) & 0xf;
int amode_dst = (ins >> 7) & 1;
int is_byte = ins & 0x0040;
int amode_src = (ins >> 4) & 0x3;
int dreg = ins & 0x000f;
u_int32_t src_data;
u_int16_t dst_addr = 0;
u_int32_t dst_data;
u_int32_t res_data;
u_int32_t msb = is_byte ? 0x80 : 0x8000;
u_int32_t mask = is_byte ? 0xff : 0xffff;
uint32_t src_data;
uint16_t dst_addr = 0;
uint32_t dst_data;
uint32_t res_data;
uint32_t msb = is_byte ? 0x80 : 0x8000;
uint32_t mask = is_byte ? 0xff : 0xffff;
if (fetch_operand(dev, amode_src, sreg, is_byte, NULL, &src_data) < 0)
return -1;
@ -271,17 +271,17 @@ static int step_double(struct sim_device *dev, u_int16_t ins)
return 0;
}
static int step_single(struct sim_device *dev, u_int16_t ins)
static int step_single(struct sim_device *dev, uint16_t ins)
{
u_int16_t opcode = ins & 0xff80;
uint16_t opcode = ins & 0xff80;
int is_byte = ins & 0x0040;
int amode = (ins >> 4) & 0x3;
int reg = ins & 0x000f;
u_int16_t msb = is_byte ? 0x80 : 0x8000;
u_int32_t mask = is_byte ? 0xff : 0xffff;
u_int16_t src_addr = 0;
u_int32_t src_data;
u_int32_t res_data;
uint16_t msb = is_byte ? 0x80 : 0x8000;
uint32_t mask = is_byte ? 0xff : 0xffff;
uint16_t src_addr = 0;
uint32_t src_data;
uint32_t res_data;
if (fetch_operand(dev, amode, reg, is_byte, &src_addr, &src_data) < 0)
return -1;
@ -357,11 +357,11 @@ static int step_single(struct sim_device *dev, u_int16_t ins)
return 0;
}
static int step_jump(struct sim_device *dev, u_int16_t ins)
static int step_jump(struct sim_device *dev, uint16_t ins)
{
u_int16_t opcode = ins & 0xfc00;
u_int16_t pc_offset = (ins & 0x03ff) << 1;
u_int16_t sr = dev->regs[MSP430_REG_SR];
uint16_t opcode = ins & 0xfc00;
uint16_t pc_offset = (ins & 0x03ff) << 1;
uint16_t sr = dev->regs[MSP430_REG_SR];
if (pc_offset & 0x0400)
pc_offset |= 0xff800;
@ -410,7 +410,7 @@ static int step_jump(struct sim_device *dev, u_int16_t ins)
static int step_cpu(struct sim_device *dev)
{
u_int16_t ins;
uint16_t ins;
int ret;
/* Fetch the instruction */
@ -442,8 +442,8 @@ static void sim_destroy(device_t dev_base)
free(dev_base);
}
static int sim_readmem(device_t dev_base, u_int16_t addr,
u_int8_t *mem, int len)
static int sim_readmem(device_t dev_base, uint16_t addr,
uint8_t *mem, int len)
{
struct sim_device *dev = (struct sim_device *)dev_base;
@ -454,8 +454,8 @@ static int sim_readmem(device_t dev_base, u_int16_t addr,
return 0;
}
static int sim_writemem(device_t dev_base, u_int16_t addr,
const u_int8_t *mem, int len)
static int sim_writemem(device_t dev_base, uint16_t addr,
const uint8_t *mem, int len)
{
struct sim_device *dev = (struct sim_device *)dev_base;
@ -466,7 +466,7 @@ static int sim_writemem(device_t dev_base, u_int16_t addr,
return 0;
}
static int sim_getregs(device_t dev_base, u_int16_t *regs)
static int sim_getregs(device_t dev_base, uint16_t *regs)
{
struct sim_device *dev = (struct sim_device *)dev_base;
@ -474,7 +474,7 @@ static int sim_getregs(device_t dev_base, u_int16_t *regs)
return 0;
}
static int sim_setregs(device_t dev_base, const u_int16_t *regs)
static int sim_setregs(device_t dev_base, const uint16_t *regs)
{
struct sim_device *dev = (struct sim_device *)dev_base;
@ -482,7 +482,7 @@ static int sim_setregs(device_t dev_base, const u_int16_t *regs)
return 0;
}
static int sim_breakpoint(device_t dev_base, int enabled, u_int16_t addr)
static int sim_breakpoint(device_t dev_base, int enabled, uint16_t addr)
{
struct sim_device *dev = (struct sim_device *)dev_base;

8
sim.h
View File

@ -26,12 +26,12 @@
* addresses just map to RAM.
*/
typedef int (*sim_fetch_func_t)(void *user_data,
u_int16_t pc, u_int16_t addr,
int is_byte, u_int16_t *data);
uint16_t pc, uint16_t addr,
int is_byte, uint16_t *data);
typedef void (*sim_store_func_t)(void *user_data,
u_int16_t pc, u_int16_t addr,
int is_byte, u_int16_t data);
uint16_t pc, uint16_t addr,
int is_byte, uint16_t data);
/* Dummy/simulation implementation. */
device_t sim_open(sim_fetch_func_t fetch, sim_store_func_t store,

20
stab.c
View File

@ -20,7 +20,7 @@
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <stdint.h>
#include <regex.h>
#include <errno.h>
#include <assert.h>
@ -58,7 +58,7 @@ static void sym_key_init(struct sym_key *key, const char *text)
}
struct addr_key {
u_int16_t addr;
uint16_t addr;
char name[64];
};
@ -80,7 +80,7 @@ static int addr_key_compare(const void *left, const void *right)
return strcmp(kl->name, kr->name);
}
static void addr_key_init(struct addr_key *key, u_int16_t addr,
static void addr_key_init(struct addr_key *key, uint16_t addr,
const char *text)
{
int len = strlen(text);
@ -98,7 +98,7 @@ static const struct btree_def sym_table_def = {
.zero = &sym_key_zero,
.branches = 32,
.key_size = sizeof(struct sym_key),
.data_size = sizeof(u_int16_t)
.data_size = sizeof(uint16_t)
};
static const struct btree_def addr_table_def = {
@ -128,8 +128,8 @@ int stab_set(stab_t st, const char *name, int value)
{
struct sym_key skey;
struct addr_key akey;
u_int16_t addr = value;
u_int16_t old_addr;
uint16_t addr = value;
uint16_t old_addr;
sym_key_init(&skey, name);
@ -152,8 +152,8 @@ int stab_set(stab_t st, const char *name, int value)
return 0;
}
int stab_nearest(stab_t st, u_int16_t addr, char *ret_name, int max_len,
u_int16_t *ret_offset)
int stab_nearest(stab_t st, uint16_t addr, char *ret_name, int max_len,
uint16_t *ret_offset)
{
struct addr_key akey;
int i;
@ -176,7 +176,7 @@ int stab_nearest(stab_t st, u_int16_t addr, char *ret_name, int max_len,
int stab_get(stab_t st, const char *name, int *value)
{
struct sym_key skey;
u_int16_t addr;
uint16_t addr;
sym_key_init(&skey, name);
if (btree_get(st->sym, &skey, &addr))
@ -189,7 +189,7 @@ int stab_get(stab_t st, const char *name, int *value)
int stab_del(stab_t st, const char *name)
{
struct sym_key skey;
u_int16_t value;
uint16_t value;
struct addr_key akey;
sym_key_init(&skey, name);

8
stab.h
View File

@ -19,7 +19,7 @@
#ifndef STAB_H_
#define STAB_H_
#include <sys/types.h>
#include <stdint.h>
struct stab;
typedef struct stab *stab_t;
@ -41,8 +41,8 @@ int stab_set(stab_t st, const char *name, int value);
*
* Returns 0 if found, 1 otherwise.
*/
int stab_nearest(stab_t st, u_int16_t addr, char *ret_name, int max_len,
u_int16_t *ret_offset);
int stab_nearest(stab_t st, uint16_t addr, char *ret_name, int max_len,
uint16_t *ret_offset);
/* Retrieve the value of a symbol. Returns 0 on success or -1 if the symbol
* doesn't exist.
@ -56,7 +56,7 @@ int stab_del(stab_t st, const char *name);
/* Enumerate all symbols in the table */
typedef int (*stab_callback_t)(void *user_data,
const char *name, u_int16_t value);
const char *name, uint16_t value);
int stab_enum(stab_t st, stab_callback_t cb, void *user_data);

12
sym.c
View File

@ -20,7 +20,7 @@
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sys/types.h>
#include <stdint.h>
#include <regex.h>
#include <errno.h>
#include "stab.h"
@ -34,7 +34,7 @@ static int cmd_eval(cproc_t cp, char **arg)
{
stab_t stab = cproc_stab(cp);
int addr;
u_int16_t offset;
uint16_t offset;
char name[64];
if (expr_eval(stab, *arg, &addr) < 0) {
@ -88,7 +88,7 @@ static int cmd_sym_load_add(cproc_t cp, int clear, char **arg)
return result;
}
static int savemap_cb(void *user_data, const char *name, u_int16_t value)
static int savemap_cb(void *user_data, const char *name, uint16_t value)
{
FILE *savemap_out = (FILE *)user_data;
@ -132,13 +132,13 @@ static int cmd_sym_savemap(cproc_t cp, char **arg)
return 0;
}
static int print_sym(void *user_data, const char *name, u_int16_t value)
static int print_sym(void *user_data, const char *name, uint16_t value)
{
printf("0x%04x: %s\n", value, name);
return 0;
}
static int find_sym(void *user_data, const char *name, u_int16_t value)
static int find_sym(void *user_data, const char *name, uint16_t value)
{
regex_t *find_preg = (regex_t *)user_data;
@ -222,7 +222,7 @@ static int renames_do(stab_t stab,
return 0;
}
static int find_renames(void *user_data, const char *name, u_int16_t value)
static int find_renames(void *user_data, const char *name, uint16_t value)
{
struct rename_data *rename = (struct rename_data *)user_data;
regmatch_t pmatch;

6
transport.h
View File

@ -19,7 +19,7 @@
#ifndef TRANSPORT_H_
#define TRANSPORT_H_
#include <sys/types.h>
#include <stdint.h>
/* This structure is used to provide an interface to a lower-level
* transport. The transport mechanism is viewed as a stream by the FET
@ -31,8 +31,8 @@ typedef struct transport *transport_t;
struct transport {
void (*destroy)(transport_t tr);
int (*send)(transport_t tr, const u_int8_t *data, int len);
int (*recv)(transport_t tr, u_int8_t *data, int max_len);
int (*send)(transport_t tr, const uint8_t *data, int len);
int (*recv)(transport_t tr, uint8_t *data, int max_len);
};
#endif

6
uif.c
View File

@ -21,7 +21,7 @@
#include <string.h>
#include <errno.h>
#include <assert.h>
#include <sys/types.h>
#include <stdint.h>
#include <unistd.h>
#include <termios.h>
@ -34,7 +34,7 @@ struct uif_transport {
int serial_fd;
};
static int serial_send(transport_t tr_base, const u_int8_t *data, int len)
static int serial_send(transport_t tr_base, const uint8_t *data, int len)
{
struct uif_transport *tr = (struct uif_transport *)tr_base;
@ -50,7 +50,7 @@ static int serial_send(transport_t tr_base, const u_int8_t *data, int len)
return 0;
}
static int serial_recv(transport_t tr_base, u_int8_t *data, int max_len)
static int serial_recv(transport_t tr_base, uint8_t *data, int max_len)
{
struct uif_transport *tr = (struct uif_transport *)tr_base;
int r;

6
util.c
View File

@ -58,7 +58,7 @@ int ctrlc_check(void)
return ctrlc_flag;
}
int read_with_timeout(int fd, u_int8_t *data, int max_len)
int read_with_timeout(int fd, uint8_t *data, int max_len)
{
int r;
@ -86,7 +86,7 @@ int read_with_timeout(int fd, u_int8_t *data, int max_len)
return r;
}
int write_all(int fd, const u_int8_t *data, int len)
int write_all(int fd, const uint8_t *data, int len)
{
while (len) {
int result = write(fd, data, len);
@ -225,7 +225,7 @@ char *get_arg(char **text)
return start;
}
void debug_hexdump(const char *label, const u_int8_t *data, int len)
void debug_hexdump(const char *label, const uint8_t *data, int len)
{
int offset = 0;

8
util.h
View File

@ -19,14 +19,14 @@
#ifndef UTIL_H_
#define UTIL_H_
#include <sys/types.h>
#include <stdint.h>
#define ARRAY_LEN(a) (sizeof(a) / sizeof((a)[0]))
/* Various utility functions for IO */
int open_serial(const char *device, int rate);
int read_with_timeout(int fd, u_int8_t *data, int len);
int write_all(int fd, const u_int8_t *data, int len);
int read_with_timeout(int fd, uint8_t *data, int len);
int write_all(int fd, const uint8_t *data, int len);
/* Check and catch ^C from the user */
void ctrlc_init(void);
@ -40,7 +40,7 @@ char *get_arg(char **text);
/* Display hex output for debug purposes */
void debug_hexdump(const char *label,
const u_int8_t *data, int len);
const uint8_t *data, int len);
/* Get text length, not including ANSI codes */
int textlen(const char *text);