51 #include <sys/types.h> 52 #include <netinet/in.h> 53 #include <netinet/tcp.h> 54 #include <arpa/inet.h> 55 #include <sys/socket.h> 64 #include "avrmalloc.h" 76 #if defined(USE_EEPROM_SPACE) 77 MEM_SPACE_MASK = 0x00ff0000,
79 FLASH_OFFSET = 0x00000000,
80 SRAM_OFFSET = 0x00800000,
81 EEPROM_OFFSET = 0x00810000,
83 MEM_SPACE_MASK = 0x00f00000,
85 FLASH_OFFSET = 0x00000000,
86 SRAM_OFFSET = 0x00800000,
94 GDB_RET_KILL_REQUEST = -1,
106 static char HEX_DIGIT[] =
"0123456789abcdef";
110 static int global_server_quit = 0;
113 static int global_debug_on;
117 static int gdb_pre_parse_packet (GdbComm_T *comm,
int fd,
int blocking);
123 gdb_read_byte (
int fd)
127 int cnt = MAX_READ_RETRY;
131 res = read (fd, &c, 1);
138 avr_error (
"read failed: %s", strerror (errno));
149 avr_error (
"Maximum read reties reached");
159 if ((hex >=
'A') && (hex <=
'F'))
160 return (10 + (hex -
'A'));
162 else if ((hex >=
'a') && (hex <=
'f'))
163 return (10 + (hex -
'a'));
165 else if ((hex >=
'0') && (hex <=
'9'))
169 avr_error (
"Invalid hexidecimal digit: 0x%02x", hex);
178 gdb_write (
int fd,
const void *buf,
size_t count)
182 res = write (fd, buf, count);
187 avr_error (
"write failed: %s", strerror (errno));
193 avr_error (
"write only wrote %d of %d bytes", res, count);
201 gdb_last_reply (
char *reply)
203 static char *last_reply = NULL;
207 if (last_reply == NULL)
222 gdb_send_ack (
int fd)
225 fprintf (stderr,
" Ack -> gdb\n");
227 gdb_write (fd,
"+", 1);
233 gdb_send_reply (
int fd,
char *reply)
238 static char buf[MAX_BUF];
241 gdb_last_reply (reply);
244 fprintf (stderr,
"Sent: $%s#", reply);
248 gdb_write (fd,
"$#00", 4);
251 fprintf (stderr,
"%02x\n", cksum & 0xff);
255 memset (buf,
'\0',
sizeof (buf));
262 cksum += (
unsigned char)*reply;
268 if (bytes == (MAX_BUF - 3))
276 fprintf (stderr,
"%02x\n", cksum & 0xff);
279 buf[bytes++] = HEX_DIGIT[(cksum >> 4) & 0xf];
280 buf[bytes++] = HEX_DIGIT[cksum & 0xf];
282 gdb_write (fd, buf, bytes);
293 gdb_read_registers (GdbComm_T *comm,
int fd)
299 size_t buf_sz = (32 + 1 + 2 + 4) * 2 + 1;
305 for (i = 0; i < 32; i++)
307 val = comm->read_reg (comm->user_data, i);
308 buf[i * 2] = HEX_DIGIT[(val >> 4) & 0xf];
309 buf[i * 2 + 1] = HEX_DIGIT[val & 0xf];
313 val = comm->read_sreg (comm->user_data);
314 buf[i * 2] = HEX_DIGIT[(val >> 4) & 0xf];
315 buf[i * 2 + 1] = HEX_DIGIT[val & 0xf];
319 val = comm->read_sram (comm->user_data, SPL_ADDR);
320 buf[i * 2] = HEX_DIGIT[(val >> 4) & 0xf];
321 buf[i * 2 + 1] = HEX_DIGIT[val & 0xf];
324 val = comm->read_sram (comm->user_data, SPH_ADDR);
325 buf[i * 2] = HEX_DIGIT[(val >> 4) & 0xf];
326 buf[i * 2 + 1] = HEX_DIGIT[val & 0xf];
333 val = comm->read_pc (comm->user_data) * 2;
334 buf[i * 2] = HEX_DIGIT[(val >> 4) & 0xf];
335 buf[i * 2 + 1] = HEX_DIGIT[val & 0xf];
338 buf[i * 2 + 2] = HEX_DIGIT[(val >> 4) & 0xf];
339 buf[i * 2 + 3] = HEX_DIGIT[val & 0xf];
342 buf[i * 2 + 4] = HEX_DIGIT[(val >> 4) & 0xf];
343 buf[i * 2 + 5] = HEX_DIGIT[val & 0xf];
346 buf[i * 2 + 6] = HEX_DIGIT[(val >> 4) & 0xf];
347 buf[i * 2 + 7] = HEX_DIGIT[val & 0xf];
349 gdb_send_reply (fd, buf);
357 gdb_write_registers (GdbComm_T *comm,
int fd,
char *pkt)
364 for (i = 0; i < 32; i++)
366 bval = hex2nib (*pkt++) << 4;
367 bval += hex2nib (*pkt++);
368 comm->write_reg (comm->user_data, i, bval);
372 bval = hex2nib (*pkt++) << 4;
373 bval += hex2nib (*pkt++);
374 comm->write_sreg (comm->user_data, bval);
377 bval = hex2nib (*pkt++) << 4;
378 bval += hex2nib (*pkt++);
379 comm->write_sram (comm->user_data, SPL_ADDR, bval);
381 bval = hex2nib (*pkt++) << 4;
382 bval += hex2nib (*pkt++);
383 comm->write_sram (comm->user_data, SPH_ADDR, bval);
391 val = ((uint32_t) hex2nib (*pkt++)) << 4;
392 val += ((uint32_t) hex2nib (*pkt++));
394 val += ((uint32_t) hex2nib (*pkt++)) << 12;
395 val += ((uint32_t) hex2nib (*pkt++)) << 8;
397 val += ((uint32_t) hex2nib (*pkt++)) << 20;
398 val += ((uint32_t) hex2nib (*pkt++)) << 16;
400 val += ((uint32_t) hex2nib (*pkt++)) << 28;
401 val += ((uint32_t) hex2nib (*pkt++)) << 24;
402 comm->write_pc (comm->user_data, val / 2);
404 gdb_send_reply (fd,
"OK");
416 gdb_extract_hex_num (
char **pkt,
char stop)
421 int max_shifts =
sizeof (int) * 2 - 1;
424 while ((*p != stop) && (*p !=
'\0'))
429 num = (num << 4) | hex2nib (*p);
442 gdb_read_register (GdbComm_T *comm,
int fd,
char *pkt)
448 memset (reply,
'\0',
sizeof (reply));
450 reg = gdb_extract_hex_num (&pkt,
'\0');
452 if ((reg >= 0) && (reg < 32))
454 uint8_t val = comm->read_reg (comm->user_data, reg);
455 snprintf (reply,
sizeof (reply) - 1,
"%02x", val);
459 uint8_t val = comm->read_sreg (comm->user_data);
460 snprintf (reply,
sizeof (reply) - 1,
"%02x", val);
465 spl = comm->read_sram (comm->user_data, SPL_ADDR);
466 sph = comm->read_sram (comm->user_data, SPH_ADDR);
467 snprintf (reply,
sizeof (reply) - 1,
"%02x%02x", spl, sph);
471 int val = comm->read_pc (comm->user_data) * 2;
472 snprintf (reply,
sizeof (reply) - 1,
"%02x%02x" "%02x%02x",
473 val & 0xff, (val >> 8) & 0xff, (val >> 16) & 0xff,
479 gdb_send_reply (fd,
"E00");
482 gdb_send_reply (fd, reply);
490 gdb_write_register (GdbComm_T *comm,
int fd,
char *pkt)
495 reg = gdb_extract_hex_num (&pkt,
'=');
499 dval = hex2nib (*pkt++) << 4;
500 dval += hex2nib (*pkt++);
502 if ((reg >= 0) && (reg < 33))
507 comm->write_sreg (comm->user_data, dval & 0xff);
511 comm->write_reg (comm->user_data, reg, dval & 0xff);
517 hval = hex2nib (*pkt++) << 4;
518 hval += hex2nib (*pkt++);
520 comm->write_sram (comm->user_data, SPL_ADDR, dval & 0xff);
521 comm->write_sram (comm->user_data, SPH_ADDR, hval & 0xff);
533 dval += ((uint32_t) hex2nib (*pkt++)) << 12;
534 dval += ((uint32_t) hex2nib (*pkt++)) << 8;
536 dval += ((uint32_t) hex2nib (*pkt++)) << 20;
537 dval += ((uint32_t) hex2nib (*pkt++)) << 16;
539 dval += ((uint32_t) hex2nib (*pkt++)) << 28;
540 dval += ((uint32_t) hex2nib (*pkt++)) << 24;
541 comm->write_pc (comm->user_data, dval / 2);
546 gdb_send_reply (fd,
"E00");
550 gdb_send_reply (fd,
"OK");
559 gdb_get_addr_len (
char *pkt,
char a_end,
char l_end,
int *addr,
int *len)
561 char *orig_pkt = pkt;
567 while (*pkt != a_end)
568 *addr = (*addr << 4) + hex2nib (*pkt++);
572 while (*pkt != l_end)
573 *len = (*len << 4) + hex2nib (*pkt++);
579 return (pkt - orig_pkt);
583 gdb_read_memory (GdbComm_T *comm,
int fd,
char *pkt)
593 pkt += gdb_get_addr_len (pkt,
',',
'\0', &addr, &len);
595 buf =
avr_new0 (uint8_t, (len * 2) + 1);
597 if ((addr & MEM_SPACE_MASK) == SRAM_OFFSET)
601 addr = addr & ~MEM_SPACE_MASK;
613 snprintf ((
char*)buf, len * 2,
"E%02x", EIO);
617 for (i = 0; i < len; i++)
619 bval = comm->read_sram (comm->user_data, addr + i);
620 buf[i * 2] = HEX_DIGIT[bval >> 4];
621 buf[i * 2 + 1] = HEX_DIGIT[bval & 0xf];
625 else if ((addr & MEM_SPACE_MASK) == FLASH_OFFSET)
629 addr = addr & ~MEM_SPACE_MASK;
631 is_odd_addr = addr % 2;
636 bval = comm->read_flash (comm->user_data, addr / 2) >> 8;
637 buf[i++] = HEX_DIGIT[bval >> 4];
638 buf[i++] = HEX_DIGIT[bval & 0xf];
645 wval = comm->read_flash (comm->user_data, addr / 2);
648 buf[i++] = HEX_DIGIT[bval >> 4];
649 buf[i++] = HEX_DIGIT[bval & 0xf];
652 buf[i++] = HEX_DIGIT[bval >> 4];
653 buf[i++] = HEX_DIGIT[bval & 0xf];
661 bval = comm->read_flash (comm->user_data, addr / 2) & 0xff;
662 buf[i++] = HEX_DIGIT[bval >> 4];
663 buf[i++] = HEX_DIGIT[bval & 0xf];
666 #if defined(USE_EEPROM_SPACE) 667 else if ((addr & MEM_SPACE_MASK) == EEPROM_OFFSET)
671 addr = addr & ~MEM_SPACE_MASK;
673 avr_warning (
"reading of eeprom not yet implemented: 0x%x.\n", addr);
674 snprintf (buf, len * 2,
"E%02x", EIO);
680 avr_warning (
"Invalid memory address: 0x%x.\n", addr);
681 snprintf ((
char*)buf, len * 2,
"E%02x", EIO);
684 gdb_send_reply (fd, (
char*)buf);
690 gdb_write_memory (GdbComm_T *comm,
int fd,
char *pkt)
701 strncpy (reply,
"OK",
sizeof (reply));
703 pkt += gdb_get_addr_len (pkt,
',',
':', &addr, &len);
705 if ((addr & MEM_SPACE_MASK) == SRAM_OFFSET)
709 addr = addr & ~MEM_SPACE_MASK;
717 snprintf (reply,
sizeof (reply),
"E%02x", EIO);
721 for (i = addr; i < addr + len; i++)
723 bval = hex2nib (*pkt++) << 4;
724 bval += hex2nib (*pkt++);
725 comm->write_sram (comm->user_data, i, bval);
729 else if ((addr & MEM_SPACE_MASK) == FLASH_OFFSET)
735 if (comm->write_flash && comm->write_flash_lo8
736 && comm->write_flash_hi8)
738 addr = addr & ~MEM_SPACE_MASK;
740 is_odd_addr = addr % 2;
744 bval = hex2nib (*pkt++) << 4;
745 bval += hex2nib (*pkt++);
746 comm->write_flash_hi8 (comm->user_data, addr / 2, bval);
753 wval = hex2nib (*pkt++) << 4;
754 wval += hex2nib (*pkt++);
755 wval += hex2nib (*pkt++) << 12;
756 wval += hex2nib (*pkt++) << 8;
757 comm->write_flash (comm->user_data, addr / 2, wval);
765 bval = hex2nib (*pkt++) << 4;
766 bval += hex2nib (*pkt++);
767 comm->write_flash_lo8 (comm->user_data, addr / 2, bval);
773 avr_warning (
"Gdb asked to write to flash and target can't.\n");
774 snprintf (reply,
sizeof (reply),
"E%02x", EIO);
777 #if defined (USE_EEPROM_SPACE) 778 else if ((addr & MEM_SPACE_MASK) == EEPROM_OFFSET)
782 addr = addr & ~MEM_SPACE_MASK;
784 avr_warning (
"writing of eeprom not yet implemented: 0x%x.\n", addr);
785 snprintf (reply,
sizeof (reply),
"E%02x", EIO);
791 avr_warning (
"Invalid memory address: 0x%x.\n", addr);
792 snprintf (reply,
sizeof (reply),
"E%02x", EIO);
795 gdb_send_reply (fd, reply);
819 gdb_break_point (GdbComm_T *comm,
int fd,
char *pkt)
828 gdb_get_addr_len (pkt,
',',
'\0', &addr, &len);
835 && ((addr / 2) >= comm->max_pc (comm->user_data)))
837 avr_warning (
"Attempt to set break at invalid addr\n");
838 gdb_send_reply (fd,
"E01");
843 comm->remove_break (comm->user_data, addr / 2);
845 comm->insert_break (comm->user_data, addr / 2);
852 gdb_send_reply (fd,
"");
856 gdb_send_reply (fd,
"OK");
869 gdb_fetch_io_registers (GdbComm_T *comm,
int fd,
char *pkt)
883 gdb_send_reply (fd,
"40");
886 else if (pkt[0] ==
':')
890 gdb_get_addr_len (pkt + 1,
',',
'\0', &addr, &len);
892 memset (reply,
'\0',
sizeof (reply));
894 for (i = 0; i < len; i++)
896 comm->io_fetch (comm->user_data, addr + i, &val, reg_name,
899 snprintf (reply + pos,
sizeof (reply) - pos,
"%s,%x;",
903 gdb_send_reply (fd, reply);
907 gdb_send_reply (fd,
"E01");
912 gdb_send_reply (fd,
"");
920 gdb_query_request (GdbComm_T *comm,
int fd,
char *pkt)
927 len = strlen (
"avr.io_reg");
928 if (strncmp (pkt,
"avr.io_reg", len) == 0)
930 gdb_fetch_io_registers (comm, fd, pkt + len);
935 gdb_send_reply (fd,
"");
944 gdb_continue (GdbComm_T *comm,
int fd,
char *pkt)
946 char reply[MAX_BUF + 1];
949 char step = *(pkt - 1);
952 static int is_running = 0;
961 memset (reply, 0,
sizeof (reply));
970 avr_error (
"attempt to resume at other than current");
977 global_server_quit = 1;
981 res = comm->step (comm->user_data);
983 if (res == BREAK_POINT)
985 if (comm->disable_breakpts)
986 comm->disable_breakpts (comm->user_data);
991 res = gdb_pre_parse_packet (comm, fd, GDB_BLOCKING_OFF);
994 if (res == GDB_RET_CTRL_C)
1002 if ((step ==
's') || (step ==
'S'))
1007 if (reply[0] ==
'\0')
1012 pc = comm->read_pc (comm->user_data) * 2;
1014 bytes = snprintf (reply, MAX_BUF,
"T%02x", signo);
1017 snprintf (reply + bytes, MAX_BUF - bytes,
1018 "20:%02x;" "21:%02x%02x;" "22:%02x%02x%02x%02x;",
1019 comm->read_sreg (comm->user_data),
1020 comm->read_sram (comm->user_data, SPL_ADDR),
1021 comm->read_sram (comm->user_data, SPH_ADDR), pc & 0xff,
1022 (pc >> 8) & 0xff, (pc >> 16) & 0xff, (pc >> 24) & 0xff);
1025 gdb_send_reply (fd, reply);
1038 gdb_continue_with_signal (GdbComm_T *comm,
int fd,
char *pkt)
1041 char step = *(pkt - 1);
1045 signo = (hex2nib (*pkt++) << 4);
1046 signo += (hex2nib (*pkt++) & 0xf);
1048 if (global_debug_on)
1049 fprintf (stderr,
"GDB sent signal: %d\n", signo);
1061 comm->reset (comm->user_data);
1062 gdb_send_reply (fd,
"S05");
1071 if (comm->irq_raise)
1073 comm->irq_raise (comm->user_data, signo - 94);
1085 else if (*pkt ==
';')
1092 gdb_send_reply (fd,
"");
1096 gdb_continue (comm, fd, pkt);
1104 gdb_parse_packet (GdbComm_T *comm,
int fd,
char *pkt)
1109 gdb_send_reply (fd,
"S05");
1113 gdb_read_registers (comm, fd);
1117 gdb_write_registers (comm, fd, pkt);
1121 gdb_read_register (comm, fd, pkt);
1125 gdb_write_register (comm, fd, pkt);
1129 gdb_read_memory (comm, fd, pkt);
1133 gdb_write_memory (comm, fd, pkt);
1141 comm->reset (comm->user_data);
1142 gdb_send_reply (fd,
"OK");
1143 return GDB_RET_KILL_REQUEST;
1147 gdb_continue_with_signal (comm, fd, pkt);
1152 gdb_continue (comm, fd, pkt);
1157 gdb_break_point (comm, fd, pkt);
1161 gdb_query_request (comm, fd, pkt);
1165 gdb_send_reply (fd,
"");
1172 gdb_set_blocking_mode (
int fd,
int mode)
1177 if (fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) & ~O_NONBLOCK) < 0)
1178 avr_warning (
"fcntl failed: %s\n", strerror (errno));
1183 if (fcntl (fd, F_SETFL, fcntl (fd, F_GETFL, 0) | O_NONBLOCK) < 0)
1184 avr_warning (
"fcntl failed: %s\n", strerror (errno));
1195 gdb_pre_parse_packet (GdbComm_T *comm,
int fd,
int blocking)
1199 char pkt_buf[MAX_BUF + 1];
1200 int cksum, pkt_cksum;
1201 static int block_on = 1;
1203 if (block_on != blocking)
1205 gdb_set_blocking_mode (fd, blocking);
1206 block_on = blocking;
1209 c = gdb_read_byte (fd);
1215 memset (pkt_buf, 0,
sizeof (pkt_buf));
1218 gdb_set_blocking_mode (fd, GDB_BLOCKING_ON);
1221 c = gdb_read_byte (fd);
1222 while ((c !=
'#') && (i < MAX_BUF))
1225 pkt_cksum += (
unsigned char)c;
1226 c = gdb_read_byte (fd);
1229 cksum = hex2nib (gdb_read_byte (fd)) << 4;
1230 cksum |= hex2nib (gdb_read_byte (fd));
1238 if ((pkt_cksum & 0xff) != cksum)
1239 avr_error (
"Bad checksum: sent 0x%x <--> computed 0x%x",
1242 if (global_debug_on)
1243 fprintf (stderr,
"Recv: \"$%s#%02x\"\n", pkt_buf, cksum);
1248 res = gdb_parse_packet (comm, fd, pkt_buf);
1255 if (global_debug_on)
1256 fprintf (stderr,
" gdb -> Nak\n");
1257 gdb_send_reply (fd, gdb_last_reply (NULL));
1261 if (global_debug_on)
1262 fprintf (stderr,
" gdb -> Ack\n");
1269 return GDB_RET_CTRL_C;
1276 avr_warning (
"Unknown request from gdb: %c (0x%02x)\n", c, c);
1283 gdb_main_loop (GdbComm_T *comm,
int fd)
1286 char reply[MAX_BUF];
1290 res = gdb_pre_parse_packet (comm, fd, GDB_BLOCKING_ON);
1293 case GDB_RET_KILL_REQUEST:
1296 case GDB_RET_CTRL_C:
1298 snprintf (reply, MAX_BUF,
"S%02x", SIGINT);
1299 gdb_send_reply (fd, reply);
1322 struct sockaddr_in address[1];
1324 socklen_t addrLength[1];
1326 global_debug_on = debug_on;
1328 if ((sock = socket (PF_INET, SOCK_STREAM, 0)) < 0)
1329 avr_error (
"Can't create socket: %s", strerror (errno));
1335 setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, &i,
sizeof (i));
1337 address->sin_family = AF_INET;
1338 address->sin_port = htons (port);
1339 memset (&address->sin_addr, 0, sizeof (address->sin_addr));
1341 if (bind (sock, (
struct sockaddr *)address,
sizeof (address)))
1342 avr_error (
"Can not bind socket: %s", strerror (errno));
1346 while (global_server_quit == 0)
1348 if (listen (sock, 1))
1350 int saved_errno = errno;
1357 avr_error (
"Can not listen on socket: %s",
1358 strerror (saved_errno));
1361 fprintf (stderr,
"Waiting on port %d for gdb client to connect...\n",
1365 addrLength[0] =
sizeof (
struct sockaddr);
1369 conn = accept (sock, (
struct sockaddr *)address, addrLength);
1372 int saved_errno = errno;
1379 avr_error (
"Accept connection failed: %s",
1380 strerror (saved_errno));
1391 setsockopt (conn, IPPROTO_TCP, TCP_NODELAY, &i,
sizeof (i));
1396 fprintf (stderr,
"Connection opened by host %s, port %hd.\n",
1397 inet_ntoa (address->sin_addr), ntohs (address->sin_port));
1399 gdb_main_loop (comm, conn);
1401 comm->reset (comm->user_data);
void signal_watch_start(int signo)
Start watching for the occurrance of the given signal.
#define avr_new0(type, count)
Macro for allocating memory and initializing it to zero.
void gdb_interact(GdbComm_T *comm, int port, int debug_on)
Start interacting with gdb.
void avr_free(void *ptr)
Free malloc'd memory.
char * avr_strdup(const char *s)
Wrapper for strdup().
#define avr_warning(fmt, args...)
Print a warning message to stderr.
void signal_watch_stop(int signo)
Stop watching signal.
#define avr_error(fmt, args...)
Print an error message to stderr and terminate program.
int signal_has_occurred(int signo)
Check to see if a signal has occurred.