projects / fw / stlink / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Merge pull request #132 from prattmic/master
[fw/stlink] / gdbserver / gdb-server.c
diff --git a/gdbserver/gdb-server.c b/gdbserver/gdb-server.c
index 789b609e1b1fd6d80008f20b1d22469507b214b3..414ad8a7b477016ddf46a845042ab96c1d1b1a97 100644 (file)
--- a/gdbserver/gdb-server.c
+++ b/gdbserver/gdb-server.c
@@ -40,6 +40,11 @@ static const char hex[] = "0123456789abcdef";
 
 static const char* current_memory_map = NULL;
 
+/* Persistent mode flag.
+ * In persistent mode, server starts listening again
+ * on GDB disconnect. */
+int persistent = 0;
+
 typedef struct _st_state_t {
     // things from command line, bleh
     int stlink_version;
@@ -62,6 +67,7 @@ int parse_options(int argc, char** argv, st_state_t *st) {
         {"stlink_version", required_argument, NULL, 's'},
         {"stlinkv1", no_argument, NULL, '1'},
                {"listen_port", required_argument, NULL, 'p'},
+               {"multi", optional_argument, NULL, 'm'},
         {0, 0, 0, 0},
     };
        const char * help_str = "%s - usage:\n\n"
@@ -76,13 +82,16 @@ int parse_options(int argc, char** argv, st_state_t *st) {
        "  -p 4242, --listen_port=1234\n"
        "\t\t\tSet the gdb server listen port. "
        "(default port: " STRINGIFY(DEFAULT_GDB_LISTEN_PORT) ")\n"
+    "  -m, --multi\n"
+    "\t\t\tSet gdb server to extended mode.\n"
+    "\t\t\tst-util will continue listening for connections after disconnect.\n"
        ;
 
 
     int option_index = 0;
     int c;
     int q;
-    while ((c = getopt_long(argc, argv, "hv::d:s:1p:", long_options, &option_index)) != -1) {
+    while ((c = getopt_long(argc, argv, "hv::d:s:1p:m", long_options, &option_index)) != -1) {
         switch (c) {
         case 0:
             printf("XXXXX Shouldn't really normally come here, only if there's no corresponding option\n");
@@ -129,6 +138,9 @@ int parse_options(int argc, char** argv, st_state_t *st) {
                        }
                        st->listen_port = q;
                        break;
+               case 'm':
+                       persistent = 1;
+                       break;
         }
     }
 
@@ -177,7 +189,9 @@ int main(int argc, char** argv) {
        }
 #endif
 
-       while(serve(sl, state.listen_port) == 0);
+       do {
+               serve(sl, state.listen_port);
+       } while (persistent);
 
 #ifdef __MINGW32__
 winsock_error:
@@ -784,6 +798,16 @@ int serve(stlink_t *sl, int port) {
 
 #ifdef DEBUG
                                        printf("Rcmd: halt\n");
+#endif
+                } else if (!strncmp(params,"6a7461675f7265736574",20)) { //jtag_reset
+                                       reply = strdup("OK");
+
+                                       stlink_jtag_reset(sl, 1);
+                                       stlink_jtag_reset(sl, 0);
+                                       stlink_force_debug(sl);
+
+#ifdef DEBUG
+                                       printf("Rcmd: jtag_reset\n");
 #endif
                 } else if (!strncmp(params,"7265736574",10)) { //reset
                                        reply = strdup("OK");
@@ -999,6 +1023,22 @@ int serve(stlink_t *sl, int port) {
                                stlink_write_reg(sl, ntohl(value), reg);
                        } else if(reg == 0x19) {
                                stlink_write_reg(sl, ntohl(value), 16);
+                       } else if(reg == 0x1A) {
+                               stlink_write_reg(sl, ntohl(value), 17);
+                       } else if(reg == 0x1B) {
+                               stlink_write_reg(sl, ntohl(value), 18);
+                       } else if(reg == 0x1C) {
+                               stlink_write_unsupported_reg(sl, ntohl(value), reg, &regp);
+                       } else if(reg == 0x1D) {
+                               stlink_write_unsupported_reg(sl, ntohl(value), reg, &regp);
+                       } else if(reg == 0x1E) {
+                               stlink_write_unsupported_reg(sl, ntohl(value), reg, &regp);
+                       } else if(reg == 0x1F) {
+                               stlink_write_unsupported_reg(sl, ntohl(value), reg, &regp);
+            } else if(reg >= 0x20 && reg < 0x40) {
+                stlink_write_unsupported_reg(sl, ntohl(value), reg, &regp);
+                       } else if(reg == 0x40) {
+                stlink_write_unsupported_reg(sl, ntohl(value), reg, &regp);
                        } else {
                                reply = strdup("E00");
                        }
@@ -1029,9 +1069,9 @@ int serve(stlink_t *sl, int port) {
                        unsigned     count = strtoul(s_count, NULL, 16);
 
                        unsigned adj_start = start % 4;
+                       unsigned count_rnd = (count + adj_start + 4 - 1) / 4 * 4;
 
-                       stlink_read_mem32(sl, start - adj_start, (count % 4 == 0) ?
-                                               count : count + 4 - (count % 4));
+                       stlink_read_mem32(sl, start - adj_start, count_rnd);
 
                        reply = calloc(count * 2 + 1, 1);
                        for(unsigned int i = 0; i < count; i++) {
@@ -1050,20 +1090,43 @@ int serve(stlink_t *sl, int port) {
                        stm32_addr_t start = strtoul(s_start, NULL, 16);
                        unsigned     count = strtoul(s_count, NULL, 16);
 
-                       for(unsigned int i = 0; i < count; i ++) {
+                       if(start % 4) {
+                         unsigned align_count = 4 - start % 4;
+                         if (align_count > count) align_count = count;
+                         for(unsigned int i = 0; i < align_count; i ++) {
                                char hex[3] = { hexdata[i*2], hexdata[i*2+1], 0 };
                                uint8_t byte = strtoul(hex, NULL, 16);
                                sl->q_buf[i] = byte;
+                         }
+                         stlink_write_mem8(sl, start, align_count);
+                         start += align_count;
+                         count -= align_count;
+                         hexdata += 2*align_count;
                        }
 
-                       if((count % 4) == 0 && (start % 4) == 0) {
-                               stlink_write_mem32(sl, start, count);
-                       } else {
-                               stlink_write_mem8(sl, start, count);
+                       if(count - count % 4) {
+                         unsigned aligned_count = count - count % 4;
+
+                         for(unsigned int i = 0; i < aligned_count; i ++) {
+                           char hex[3] = { hexdata[i*2], hexdata[i*2+1], 0 };
+                           uint8_t byte = strtoul(hex, NULL, 16);
+                           sl->q_buf[i] = byte;
+                         }
+                         stlink_write_mem32(sl, start, aligned_count);
+                         count -= aligned_count;
+                         start += aligned_count;
+                         hexdata += 2*aligned_count;
                        }
 
+                       if(count) {
+                         for(unsigned int i = 0; i < count; i ++) {
+                           char hex[3] = { hexdata[i*2], hexdata[i*2+1], 0 };
+                           uint8_t byte = strtoul(hex, NULL, 16);
+                           sl->q_buf[i] = byte;
+                         }
+                         stlink_write_mem8(sl, start, count);
+                       }
                        reply = strdup("OK");
-
                        break;
                }
 
@@ -1092,13 +1155,14 @@ int serve(stlink_t *sl, int port) {
                                                wf = WATCHREAD;
                                        } else {
                                                wf = WATCHACCESS;
-                                               if(add_data_watchpoint(sl, wf, addr, len) < 0) {
-                                                       reply = strdup("E00");
-                                               } else {
-                                                       reply = strdup("OK");
-                                                       break;
-                                               }
                                        }
+
+                    if(add_data_watchpoint(sl, wf, addr, len) < 0) {
+                        reply = strdup("E00");
+                    } else {
+                        reply = strdup("OK");
+                        break;
+                    }
                                }
 
                                default:
@@ -1139,6 +1203,12 @@ int serve(stlink_t *sl, int port) {
                         * We do support that always.
                         */
 
+                       /*
+                        * Also, set to persistent mode
+                        * to allow GDB disconnect.
+                        */
+                       persistent = 1;
+
                        reply = strdup("OK");
 
                        break;
@@ -1170,6 +1240,8 @@ int serve(stlink_t *sl, int port) {
                        int result = gdb_send_packet(client, reply);
                        if(result != 0) {
                                fprintf(stderr, "cannot send: %d\n", result);
+                               free(reply);
+                               free(packet);
                                return 1;
                        }
 
STM tools with support for Altus Metrum targets