Add option parsing and help

Supports setting the gdb listen port
Supports setting which version of stlink to use
Supports setting the device to use (in case autoprobing doesn't work)

diff --git a/doc/tutorial/tutorial.pdf b/doc/tutorial/tutorial.pdf
index 9202ed4dc33c1bcafdcf4db30807103a22c846c8..4ffcc3e563b3df294e331eb3fae97f9843f31817 100644 (file)
Binary files a/doc/tutorial/tutorial.pdf and b/doc/tutorial/tutorial.pdf differ

diff --git a/doc/tutorial/tutorial.tex b/doc/tutorial/tutorial.tex
index d1ba4fdbdf57cd442feb99d9c333441a9b8c37f6..a5548058fe18d70e53727fda8bae7492527fa83c 100644 (file)
--- a/doc/tutorial/tutorial.tex
+++ b/doc/tutorial/tutorial.tex
@@ -106,12 +106,14 @@ A GDB server must be start to interact with the STM32. Depending on the discover
 are using, you must run one of the 2 commands:\\
 \begin{small}
 \begin{lstlisting}[frame=tb]
-# STM32VL discovery kit
-$> sudo ./st-util /dev/sg2
+# STM32VL discovery kit (onboard ST-link)
+$> sudo ./st-util --stlinkv1 [-d /dev/sg2]
 
-# STM32L discovery kit
-# 2 dummy command line arguments needed, will be fixed soon
-$> sudo ./st-util fu bar
+# STM32L discovery kit (onboard ST-link/V2)
+$> sudo ./st-util 
+
+# Full help for other options (listen port, version)
+$> ./st-util --help
 \end{lstlisting}
 \end{small}
 

diff --git a/gdbserver/gdb-server.c b/gdbserver/gdb-server.c
index 67f0be0e61d4edd42992b72865b393c0ff3c186a..30ee01483554b85afd8783fb01b050c279cb5628 100644 (file)
--- a/gdbserver/gdb-server.c
+++ b/gdbserver/gdb-server.c
@@ -6,6 +6,7 @@
  license that can be found in the LICENSE file.
 */
 
+#include <getopt.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
@@ -20,6 +21,12 @@
 
 #include "gdb-remote.h"
 
+#define DEFAULT_LOGGING_LEVEL 10
+#define DEFAULT_GDB_LISTEN_PORT 4242
+
+#define STRINGIFY_inner(name) #name
+#define STRINGIFY(name) STRINGIFY_inner(name)
+
 #define FLASH_BASE 0x08000000
 #define FLASH_PAGE (sl->flash_pgsz)
 #define FLASH_PAGE_MASK (~((1 << 10) - 1))
@@ -77,79 +84,168 @@ struct chip_params {
        { 0 }
 };
 
+typedef struct _st_state_t {
+    // things from command line, bleh
+    int stlink_version;
+    // "/dev/serial/by-id/usb-FTDI_TTL232R-3V3_FTE531X6-if00-port0" is only 58 chars
+    char devicename[100];
+    int logging_level;
+       int listen_port;
+} st_state_t;
+
+
 int serve(stlink_t *sl, int port);
 char* make_memory_map(const struct chip_params *params, uint32_t flash_size);
 
-int main(int argc, char** argv) {
-
-       stlink_t *sl = NULL;
 
-       const char * HelpStr =  "Usage:\n"
-                                                               "\t st-util port [/dev/sgX]\n"
-                                                               "\t st-util [port]\n"
-                                                               "\t st-util --help\n";
+int parse_options(int argc, char** argv, st_state_t *st) {
+    static struct option long_options[] = {
+        {"help", no_argument, NULL, 'h'},
+        {"verbose", optional_argument, NULL, 'v'},
+        {"device", required_argument, NULL, 'd'},
+        {"stlink_version", required_argument, NULL, 's'},
+        {"stlinkv1", no_argument, NULL, '1'},
+               {"listen_port", required_argument, NULL, 'p'},
+        {0, 0, 0, 0},
+    };
+       const char * help_str = "%s - usage:\n\n"
+       "  -h, --help\t\tPrint this help\n"
+       "  -vXX, --verbose=XX\tspecify a specific verbosity level (0..99)\n"
+       "  -v, --verbose\tspecify generally verbose logging\n"
+       "  -d <device>, --device=/dev/stlink2_1\n"
+       "\t\t\tWhere is your stlink device connected?\n"
+       "  -s X, --stlink_version=X\n"
+       "\t\t\tChoose what version of stlink to use, (defaults to 2)\n"
+       "  -1, --stlinkv1\tForce stlink version 1\n"
+       "  -p 4242, --listen_port=1234\n"
+       "\t\t\tSet the gdb server listen port. "
+       "(default port: " STRINGIFY(DEFAULT_GDB_LISTEN_PORT) ")\n"
+       ;
+
+
+    int option_index = 0;
+    int c;
+    int q;
+    while ((c = getopt_long(argc, argv, "hv::d:s:1p:", 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");
+            printf("option %s", long_options[option_index].name);
+            if (optarg) {
+                printf(" with arg %s", optarg);
+            }
+            printf("\n");
+            break;
+        case 'h':
+            printf(help_str, argv[0]);
+            exit(EXIT_SUCCESS);
+            break;
+        case 'v':
+            if (optarg) {
+                st->logging_level = atoi(optarg);
+            } else {
+                st->logging_level = DEFAULT_LOGGING_LEVEL;
+            }
+            break;
+        case 'd':
+            if (strlen(optarg) > sizeof (st->devicename)) {
+                fprintf(stderr, "device name too long: %ld\n", strlen(optarg));
+            } else {
+                strcpy(st->devicename, optarg);
+            }
+            break;
+               case '1':
+                       st->stlink_version = 1;
+                       break;
+               case 's':
+                       sscanf(optarg, "%i", &q);
+                       if (q < 0 || q > 2) {
+                               fprintf(stderr, "stlink version %d unknown!\n", q);
+                               exit(EXIT_FAILURE);
+                       }
+                       st->stlink_version = q;
+                       break;
+               case 'p':
+                       sscanf(optarg, "%i", &q);
+                       if (q < 0) {
+                               fprintf(stderr, "Can't use a negative port to listen on: %d\n", q);
+                               exit(EXIT_FAILURE);
+                       }
+                       st->listen_port = q;
+                       break;
+        }
+    }
+
+    if (optind < argc) {
+        printf("non-option ARGV-elements: ");
+        while (optind < argc)
+            printf("%s ", argv[optind++]);
+        printf("\n");
+    }
+    return 0;
+}
 
-       switch(argc) {
 
-               case 3 : {
-                       //sl = stlink_quirk_open(argv[2], 0);
-                       // FIXME - hardcoded to usb....
-                       sl = stlink_open_usb(10);
-                       if(sl == NULL) return 1;
-                       break;
-               }
+int main(int argc, char** argv) {
 
-               case 2 : {
-                       if (strcmp(argv[1], "--help") == 0) {
-                               fprintf(stdout, HelpStr, NULL);
-                               return 1;
-                       }
-               }
+       stlink_t *sl = NULL;
 
-#if CONFIG_USE_LIBSG
-               case 1 : { // Search ST-LINK (from /dev/sg0 to /dev/sg99)
+       st_state_t state;
+       memset(&state, 0, sizeof(state));
+       // set defaults...
+       state.stlink_version = 2;
+       state.logging_level = 10;
+       state.listen_port = DEFAULT_GDB_LISTEN_PORT;
+       parse_options(argc, argv, &state);
+       switch (state.stlink_version) {
+       case 2:
+               sl = stlink_open_usb(state.logging_level);
+               if(sl == NULL) return 1;
+               break;
+       case 1:
+#if (CONFIG_USE_LIBSG == 1)
+               if (strlen(state.devicename) == 0) {
                        const int DevNumMax = 99;
                        int ExistDevCount = 0;
 
-                       for(int DevNum = 0; DevNum <= DevNumMax; DevNum++)
-                       {
-                               if(DevNum < 10) {
+                       for (int DevNum = 0; DevNum <= DevNumMax; DevNum++) {
+                               if (DevNum < 10) {
                                        char DevName[] = "/dev/sgX";
                                        const int X_index = 7;
                                        DevName[X_index] = DevNum + '0';
-                                       if ( !access(DevName, F_OK) ) {
+                                       if (!access(DevName, F_OK)) {
                                                sl = stlink_quirk_open(DevName, 0);
                                                ExistDevCount++;
                                        }
-                               }
-                               else if(DevNum < 100) {
+                               } else if (DevNum < 100) {
                                        char DevName[] = "/dev/sgXY";
                                        const int X_index = 7;
                                        const int Y_index = 8;
-                                       DevName[X_index] = DevNum/10 + '0';
-                                       DevName[Y_index] = DevNum%10 + '0';
-                                       if ( !access(DevName, F_OK) ) {
+                                       DevName[X_index] = DevNum / 10 + '0';
+                                       DevName[Y_index] = DevNum % 10 + '0';
+                                       if (!access(DevName, F_OK)) {
                                                sl = stlink_quirk_open(DevName, 0);
                                                ExistDevCount++;
                                        }
                                }
-                               if(sl != NULL) break;
+                               if (sl != NULL) break;
                        }
 
-                       if(sl == NULL) {
+                       if (sl == NULL) {
                                fprintf(stdout, "\nNumber of /dev/sgX devices found: %i \n",
-                                               ExistDevCount);
+                                       ExistDevCount);
                                fprintf(stderr, "ST-LINK not found\n");
                                return 1;
                        }
-                       break;
+               } else {
+                       sl = stlink_quirk_open(state.devicename, state.logging_level);
                }
+               break;
+#else
+               fprintf(stderr, "Support for stlink v1 disabled at build time...\n");
+               fprintf(stderr, "Perhaps you're on OSX, and we haven't finished removing the libsg deps?\n");
+               exit(EXIT_FAILURE);
 #endif
-
-               default: {
-                       fprintf(stderr, HelpStr, NULL);
-                       return 1;
-               }
        }
 
        if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE) {
@@ -200,9 +296,7 @@ int main(int argc, char** argv) {
        // memory map is in 1k blocks.
        current_memory_map = make_memory_map(params, flash_size * 0x400);
 
-       int port = 4242;
-
-       while(serve(sl, port) == 0);
+       while(serve(sl, state.listen_port) == 0);
 
        /* Switch back to mass storage mode before closing. */
        stlink_run(sl);