]> git.gag.com Git - fw/altos/blob - ao-tools/ao-stmload/ao-stmload.c
altoslib: Make AltosReplayReader start synchronously enough to track states
[fw/altos] / ao-tools / ao-stmload / ao-stmload.c
1 /*
2  * Copyright © 2012 Keith Packard <keithp@keithp.com>
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License along
15  * with this program; if not, write to the Free Software Foundation, Inc.,
16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
17  */
18
19 #include <err.h>
20 #include <fcntl.h>
21 #include <gelf.h>
22 #include <stdio.h>
23 #include <stdint.h>
24 #include <stdlib.h>
25 #include <sysexits.h>
26 #include <unistd.h>
27 #include <getopt.h>
28 #include <string.h>
29 #include <stdbool.h>
30 #include "stlink-common.h"
31 #include "ao-elf.h"
32 #include "ccdbg.h"
33 #include "cc.h"
34 #include "ao-stmload.h"
35 #include "ao-selfload.h"
36 #include "ao-verbose.h"
37 #include "ao-editaltos.h"
38
39
40 /*
41  * Read a 16-bit value from the target device with arbitrary
42  * alignment
43  */
44 static uint16_t
45 get_uint16_sl(stlink_t *sl, uint32_t addr)
46 {
47         const           uint8_t *data = sl->q_buf;
48         uint32_t        actual_addr;
49         int             off;
50         uint16_t        result;
51
52         sl->q_len = 0;
53
54
55         actual_addr = addr & ~3;
56         
57         stlink_read_mem32(sl, actual_addr, 8);
58
59         if (sl->q_len != 8)
60                 abort();
61
62         off = addr & 3;
63         result = data[off] | (data[off + 1] << 8);
64         return result;
65 }
66
67 static uint16_t
68 get_uint16(stlink_t *sl, uint32_t addr)
69 {
70         uint16_t        result;
71         result = get_uint16_sl(sl, addr);
72         printf ("read 0x%08x = 0x%04x\n", addr, result);
73         return result;
74 }
75
76 /*
77  * Read a 32-bit value from the target device with arbitrary
78  * alignment
79  */
80 static uint32_t
81 get_uint32_sl(stlink_t *sl, uint32_t addr)
82 {
83         const           uint8_t *data = sl->q_buf;
84         uint32_t        actual_addr;
85         int             off;
86         uint32_t        result;
87
88         sl->q_len = 0;
89
90         printf ("read 0x%x\n", addr);
91
92         actual_addr = addr & ~3;
93         
94         stlink_read_mem32(sl, actual_addr, 8);
95
96         if (sl->q_len != 8)
97                 abort();
98
99         off = addr & 3;
100         result = data[off] | (data[off + 1] << 8) | (data[off+2] << 16) | (data[off+3] << 24);
101         return result;
102 }
103
104 /*
105  * Read a 32-bit value from the target device with arbitrary
106  * alignment
107  */
108 static uint32_t
109 get_uint32(stlink_t *sl, uint32_t addr)
110 {
111         uint32_t        result;
112
113         result = get_uint32_sl(sl, addr);
114         printf ("read 0x%08x = 0x%08x\n", addr, result);
115         return result;
116 }
117
118 /*
119  * Check to see if the target device has been
120  * flashed with a similar firmware image before
121  *
122  * This is done by looking for the same romconfig version,
123  * which should be at the same location as the linker script
124  * places this at 0x100 from the start of the rom section
125  */
126 static int
127 check_flashed(stlink_t *sl)
128 {
129         uint16_t        romconfig_version = get_uint16(sl, AO_ROMCONFIG_VERSION);
130         uint16_t        romconfig_check = get_uint16(sl, AO_ROMCONFIG_CHECK);
131
132         if (romconfig_version != (uint16_t) ~romconfig_check) {
133                 fprintf (stderr, "Device has not been flashed before\n");
134                 return 0;
135         }
136         return 1;
137 }
138
139 static const struct option options[] = {
140         { .name = "v1", .has_arg = 0, .val = '1' },
141         { .name = "raw", .has_arg = 0, .val = 'r' },
142         { .name = "cal", .has_arg = 1, .val = 'c' },
143         { .name = "serial", .has_arg = 1, .val = 's' },
144         { .name = "verbose", .has_arg = 1, .val = 'v' },
145         { 0, 0, 0, 0},
146 };
147
148 static void usage(char *program)
149 {
150         fprintf(stderr, "usage: %s [--v1] [--raw] [--verbose=<verbose>] [--cal=<radio-cal>] [--serial=<serial>] file.{elf,ihx}\n", program);
151         exit(1);
152 }
153
154 void
155 done(stlink_t *sl, int code)
156 {
157         stlink_reset(sl);
158         stlink_run(sl);
159         stlink_exit_debug_mode(sl);
160         stlink_close(sl);
161         exit (code);
162 }
163
164 static int
165 ends_with(char *whole, char *suffix)
166 {
167         int whole_len = strlen(whole);
168         int suffix_len = strlen(suffix);
169
170         if (suffix_len > whole_len)
171                 return 0;
172         return strcmp(whole + whole_len - suffix_len, suffix) == 0;
173 }
174
175 int
176 main (int argc, char **argv)
177 {
178         int                     stlink_v1 = 0;
179         int                     raw = 0;
180         char                    *filename;
181         Elf                     *e;
182         char                    *serial_end;
183         unsigned int            serial = 0;
184         char                    *serial_ucs2;
185         int                     serial_ucs2_len;
186         char                    serial_int[2];
187         unsigned int            s;
188         int                     i;
189         int                     string_num;
190         uint32_t                cal = 0;
191         char                    cal_int[4];
192         char                    *cal_end;
193         int                     c;
194         stlink_t                *sl = NULL;
195         int                     was_flashed = 0;
196         struct ao_hex_image     *load;
197         int                     tries;
198         int                     success;
199         int                     verbose = 0;
200         struct ao_sym           *file_symbols;
201         int                     num_file_symbols;
202
203         while ((c = getopt_long(argc, argv, "1rc:s:v:", options, NULL)) != -1) {
204                 switch (c) {
205                 case '1':
206                         stlink_v1 = 1;
207                         break;
208                 case 'r':
209                         raw = 1;
210                         break;
211                 case 'c':
212                         cal = strtoul(optarg, &cal_end, 10);
213                         if (cal_end == optarg || *cal_end != '\0')
214                                 usage(argv[0]);
215                         break;
216                 case 's':
217                         serial = strtoul(optarg, &serial_end, 10);
218                         if (serial_end == optarg || *serial_end != '\0')
219                                 usage(argv[0]);
220                         break;
221                 case 'v':
222                         verbose++;
223                         break;
224                 default:
225                         usage(argv[0]);
226                         break;
227                 }
228         }
229
230         ao_verbose = verbose;
231
232         if (verbose > 1)
233                 ccdbg_add_debug(CC_DEBUG_BITBANG);
234
235         filename = argv[optind];
236         if (filename == NULL)
237                 usage(argv[0]);
238
239         if (ends_with (filename, ".elf")) {
240                 load = ao_load_elf(filename, &file_symbols, &num_file_symbols);
241         } else if (ends_with (filename, ".ihx")) {
242                 load = ao_hex_load(filename, &file_symbols, &num_file_symbols);
243         } else
244                 usage(argv[0]);
245
246         if (!raw) {
247                 if (!ao_editaltos_find_symbols(file_symbols, num_file_symbols, ao_symbols, ao_num_symbols)) {
248                         fprintf(stderr, "Cannot find required symbols\n");
249                         usage(argv[0]);
250                 }
251         }
252
253         /* Connect to the programming dongle
254          */
255         
256         for (tries = 0; tries < 3; tries++) {
257                 if (stlink_v1) {
258                         sl = stlink_v1_open(50);
259                 } else {
260                         sl = stlink_open_usb(50);
261                 
262                 }
263                 if (!sl) {
264                         fprintf (stderr, "No STLink devices present\n");
265                         done (sl, 1);
266                 }
267
268                 if (sl->chip_id != 0)
269                         break;
270                 stlink_reset(sl);
271                 stlink_close(sl);
272                 sl = NULL;
273         }
274         if (!sl) {
275                 fprintf (stderr, "Debugger connection failed\n");
276                 exit(1);
277         }
278
279         /* Verify that the loaded image fits entirely within device flash
280          */
281         if (load->address < sl->flash_base ||
282             sl->flash_base + sl->flash_size < load->address + load->length) {
283                 fprintf (stderr, "\%s\": Invalid memory range 0x%08x - 0x%08x\n", filename,
284                          load->address, load->address + load->length);
285                 done(sl, 1);
286         }
287
288         /* Enter debugging mode
289          */
290         if (stlink_current_mode(sl) == STLINK_DEV_DFU_MODE)
291                 stlink_exit_dfu_mode(sl);
292
293         if (stlink_current_mode(sl) != STLINK_DEV_DEBUG_MODE)
294                 stlink_enter_swd_mode(sl);
295
296
297         if (!raw) {
298                 /* Go fetch existing config values
299                  * if available
300                  */
301                 was_flashed = check_flashed(sl);
302
303                 if (!serial) {
304                         if (!was_flashed) {
305                                 fprintf (stderr, "Must provide serial number\n");
306                                 done(sl, 1);
307                         }
308                         serial = get_uint16(sl, AO_SERIAL_NUMBER);
309                         if (!serial || serial == 0xffff) {
310                                 fprintf (stderr, "Invalid existing serial %d\n", serial);
311                                 done(sl, 1);
312                         }
313                 }
314
315                 if (!cal && AO_RADIO_CAL && was_flashed) {
316                         cal = get_uint32(sl, AO_RADIO_CAL);
317                         if (!cal || cal == 0xffffffff) {
318                                 fprintf (stderr, "Invalid existing rf cal %d\n", cal);
319                                 done(sl, 1);
320                         }
321                 }
322
323                 if (!ao_editaltos(load, serial, cal))
324                         done(sl, 1);
325         }
326
327         /* And flash the resulting image to the device
328          */
329
330         success = (stlink_write_flash(sl, load->address, load->data, load->length) >= 0);
331                 
332         if (!success) {
333                 fprintf (stderr, "\"%s\": Write failed\n", filename);
334                 done(sl, 1);
335         }
336
337         done(sl, 0);
338 }