4 Copyright 2008, 2009 Michel Pollet <buserror@gmail.com>
6 This file is part of simavr.
8 simavr is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 simavr is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with simavr. If not, see <http://www.gnu.org/licenses/>.
22 #include <netinet/in.h>
23 #include <netinet/tcp.h>
24 #include <arpa/inet.h>
25 #include <sys/socket.h>
36 #include "avr_eeprom.h"
41 typedef struct avr_gdb_t {
43 int listen; // listen socket
44 int s; // current gdb connection
55 static void gdb_send_reply(avr_gdb_t * g, char * cmd)
58 uint8_t * dst = reply;
65 sprintf((char*)dst, "#%02x", check);
66 DBG(printf("%s '%s'\n", __FUNCTION__, reply);)
67 send(g->s, reply, dst - reply + 3, 0);
70 static void gdb_send_quick_status(avr_gdb_t * g, uint8_t signal)
74 sprintf(cmd, "T%02x20:%02x;21:%02x%02x;22:%02x%02x%02x00;",
75 signal ? signal : 5, g->avr->data[R_SREG],
76 g->avr->data[R_SPL], g->avr->data[R_SPH],
77 g->avr->pc & 0xff, (g->avr->pc>>8)&0xff, (g->avr->pc>>16)&0xff);
78 gdb_send_reply(g, cmd);
81 static int gdb_change_breakpoint(avr_gdb_t * g, int set, int kind, avr_flashaddr_t addr, uint32_t len)
83 DBG(printf("set %d kind %d addr %08x len %d (map %08x)\n", set, kind, addr, len, g->watchmap);)
85 if (g->watchmap == 0xffffffff)
86 return -1; // map full
88 // check to see if it exists
89 for (int i = 0; i < 32; i++)
90 if ((g->watchmap & (1 << i)) && g->watch[i].pc == addr) {
91 g->watch[i].len = len;
94 for (int i = 0; i < 32; i++)
95 if (!(g->watchmap & (1 << i))) {
96 g->watchmap |= (1 << i);
97 g->watch[i].len = len;
98 g->watch[i].pc = addr;
99 g->watch[i].kind = kind;
103 for (int i = 0; i < 32; i++)
104 if ((g->watchmap & (1 << i)) && g->watch[i].pc == addr) {
105 g->watchmap &= ~(1 << i);
108 g->watch[i].kind = 0;
115 static int gdb_write_register(avr_gdb_t * g, int regi, uint8_t * src)
119 g->avr->data[regi] = *src;
122 g->avr->data[R_SREG] = *src;
125 g->avr->data[R_SPL] = src[0];
126 g->avr->data[R_SPH] = src[1];
129 g->avr->pc = src[0] | (src[1] << 8) | (src[2] << 16) | (src[3] << 24);
135 static int gdb_read_register(avr_gdb_t * g, int regi, char * rep)
139 sprintf(rep, "%02x", g->avr->data[regi]);
142 sprintf(rep, "%02x", g->avr->data[R_SREG]);
145 sprintf(rep, "%02x%02x", g->avr->data[R_SPL], g->avr->data[R_SPH]);
148 sprintf(rep, "%02x%02x%02x00",
149 g->avr->pc & 0xff, (g->avr->pc>>8)&0xff, (g->avr->pc>>16)&0xff);
155 static void gdb_handle_command(avr_gdb_t * g, char * cmd)
157 avr_t * avr = g->avr;
159 uint8_t command = *cmd++;
162 gdb_send_quick_status(g, 0);
164 case 'G': { // set all general purpose registers
165 // get their binary form
166 read_hex_string(cmd, (uint8_t*)rep, strlen(cmd));
167 uint8_t *src = (uint8_t*)rep;
168 for (int i = 0; i < 35; i++)
169 src += gdb_write_register(g, i, src);
170 gdb_send_reply(g, "OK");
172 case 'g': { // read all general purpose registers
174 for (int i = 0; i < 35; i++)
175 dst += gdb_read_register(g, i, dst);
176 gdb_send_reply(g, rep);
178 case 'p': { // read register
179 unsigned int regi = 0;
180 sscanf(cmd, "%x", ®i);
181 gdb_read_register(g, regi, rep);
182 gdb_send_reply(g, rep);
184 case 'P': { // write register
185 unsigned int regi = 0;
186 char * val = strchr(cmd, '=');
190 sscanf(cmd, "%x", ®i);
191 read_hex_string(val, (uint8_t*)rep, strlen(val));
192 gdb_write_register(g, regi, (uint8_t*)rep);
193 gdb_send_reply(g, "OK");
195 case 'm': { // read memory
196 avr_flashaddr_t addr;
198 sscanf(cmd, "%x,%x", &addr, &len);
199 uint8_t * src = NULL;
200 if (addr < avr->flashend) {
201 src = avr->flash + addr;
202 } else if (addr >= 0x800000 && (addr - 0x800000) <= avr->ramend) {
203 src = avr->data + addr - 0x800000;
204 } else if (addr >= 0x810000 && (addr - 0x810000) <= avr->e2end) {
205 avr_eeprom_desc_t ee = {.offset = (addr - 0x810000)};
206 avr_ioctl(avr, AVR_IOCTL_EEPROM_GET, &ee);
210 gdb_send_reply(g, "E01");
213 } else if (addr >= 0x800000 && (addr - 0x800000) == avr->ramend+1 && len == 2) {
214 // Allow GDB to read a value just after end of stack.
215 // This is necessary to make instruction stepping work when stack is empty
216 printf("GDB read just past end of stack %08x, %08x; returning zero\n", addr, len);
217 gdb_send_reply(g, "0000");
220 printf("read memory error %08x, %08x (ramend %04x)\n", addr, len, avr->ramend+1);
221 gdb_send_reply(g, "E01");
226 sprintf(dst, "%02x", *src++);
230 gdb_send_reply(g, rep);
232 case 'M': { // write memory
234 sscanf(cmd, "%x,%x", &addr, &len);
235 char * start = strchr(cmd, ':');
237 gdb_send_reply(g, "E01");
241 read_hex_string(start + 1, avr->flash + addr, strlen(start+1));
242 gdb_send_reply(g, "OK");
243 } else if (addr >= 0x800000 && (addr - 0x800000) <= avr->ramend) {
244 read_hex_string(start + 1, avr->data + addr - 0x800000, strlen(start+1));
245 gdb_send_reply(g, "OK");
246 } else if (addr >= 0x810000 && (addr - 0x810000) <= avr->e2end) {
247 read_hex_string(start + 1, (uint8_t*)rep, strlen(start+1));
248 avr_eeprom_desc_t ee = {.offset = (addr - 0x810000), .size = len, .ee = (uint8_t*)rep };
249 avr_ioctl(avr, AVR_IOCTL_EEPROM_SET, &ee);
250 gdb_send_reply(g, "OK");
252 printf("write memory error %08x, %08x\n", addr, len);
253 gdb_send_reply(g, "E01");
256 case 'c': { // continue
257 avr->state = cpu_Running;
260 avr->state = cpu_Step;
262 case 'r': { // deprecated, suggested for AVRStudio compatibility
263 avr->state = cpu_StepDone;
266 case 'Z': // set clear break/watchpoint
268 uint32_t kind, addr, len;
269 sscanf(cmd, "%d,%x,%x", &kind, &addr, &len);
270 // printf("breakbpoint %d, %08x, %08x\n", kind, addr, len);
272 case 0: // software breakpoint
273 case 1: // hardware breakpoint
274 if (addr <= avr->flashend) {
275 if (gdb_change_breakpoint(g, command == 'Z', kind, addr, len))
276 gdb_send_reply(g, "E01");
278 gdb_send_reply(g, "OK");
280 gdb_send_reply(g, "E01"); // out of flash address
283 case 2: // write watchpoint
284 case 3: // read watchpoint
285 case 4: // access watchpoint
287 gdb_send_reply(g, "");
291 gdb_send_reply(g, "");
295 static int gdb_network_handler(avr_gdb_t * g, uint32_t dosleep)
302 FD_SET(g->s, &read_set);
305 FD_SET(g->listen, &read_set);
308 struct timeval timo = { 0, dosleep }; // short, but not too short interval
309 int ret = select(max, &read_set, NULL, NULL, &timo);
314 if (FD_ISSET(g->listen, &read_set)) {
315 g->s = accept(g->listen, NULL, NULL);
318 perror("gdb_network_handler accept");
323 setsockopt (g->s, IPPROTO_TCP, TCP_NODELAY, &i, sizeof (i));
324 g->avr->state = cpu_Stopped;
325 printf("%s connection opened\n", __FUNCTION__);
328 if (g->s != -1 && FD_ISSET(g->s, &read_set)) {
329 uint8_t buffer[1024];
331 ssize_t r = recv(g->s, buffer, sizeof(buffer)-1, 0);
334 printf("%s connection closed\n", __FUNCTION__);
336 g->watchmap = 0; // clear breakpoints
337 g->avr->state = cpu_Running; // resume
342 perror("gdb_network_handler recv");
347 // printf("%s: received %d bytes\n'%s'\n", __FUNCTION__, r, buffer);
348 // hdump("gdb", buffer, r);
350 uint8_t * src = buffer;
351 while (*src == '+' || *src == '-')
353 // control C -- lets send the guy a nice status packet
356 g->avr->state = cpu_StepDone;
357 printf("GDB hit control-c\n");
361 uint8_t * end = buffer + r - 1;
362 while (end > src && *end != '#')
366 DBG(printf("GDB command = '%s'\n", src);)
368 send(g->s, "+", 1, 0);
370 gdb_handle_command(g, (char*)src);
376 int avr_gdb_processor(avr_t * avr, int sleep)
378 if (!avr || !avr->gdb)
380 avr_gdb_t * g = avr->gdb;
382 if (g->watchmap && avr->state == cpu_Running) {
383 for (int i = 0; i < 32; i++)
384 if ((g->watchmap & (1 << i)) && g->watch[i].pc == avr->pc) {
385 DBG(printf("avr_gdb_processor hit breakpoint at %08x\n", avr->pc);)
386 gdb_send_quick_status(g, 0);
387 avr->state = cpu_Stopped;
390 if (avr->state == cpu_StepDone) {
391 gdb_send_quick_status(g, 0);
392 avr->state = cpu_Stopped;
394 // this also sleeps for a bit
395 return gdb_network_handler(g, sleep);
399 int avr_gdb_init(avr_t * avr)
401 avr_gdb_t * g = malloc(sizeof(avr_gdb_t));
402 memset(g, 0, sizeof(avr_gdb_t));
406 if ((g->listen = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
407 fprintf(stderr, "Can't create socket: %s", strerror(errno));
412 setsockopt(g->listen, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i));
414 struct sockaddr_in address = { 0 };
415 address.sin_family = AF_INET;
416 address.sin_port = htons (avr->gdb_port);
418 if (bind(g->listen, (struct sockaddr *) &address, sizeof(address))) {
419 fprintf(stderr, "Can not bind socket: %s", strerror(errno));
422 if (listen(g->listen, 1)) {
426 printf("avr_gdb_init listening on port %d\n", avr->gdb_port);
430 // change default run behaviour to use the slightly slower versions
431 avr->run = avr_callback_run_gdb;
432 avr->sleep = avr_callback_sleep_gdb;