esirisc: support eSi-RISC targets
[fw/openocd] / src / target / esirisc_jtag.c
1 /***************************************************************************
2  *   Copyright (C) 2018 by Square, Inc.                                    *
3  *   Steven Stallion <stallion@squareup.com>                               *
4  *   James Zhao <hjz@squareup.com>                                         *
5  *                                                                         *
6  *   This program is free software; you can redistribute it and/or modify  *
7  *   it under the terms of the GNU General Public License as published by  *
8  *   the Free Software Foundation; either version 2 of the License, or     *
9  *   (at your option) any later version.                                   *
10  *                                                                         *
11  *   This program is distributed in the hope that it will be useful,       *
12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
14  *   GNU General Public License for more details.                          *
15  *                                                                         *
16  *   You should have received a copy of the GNU General Public License     *
17  *   along with this program.  If not, see <http://www.gnu.org/licenses/>. *
18  ***************************************************************************/
19
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include <helper/binarybuffer.h>
25 #include <helper/log.h>
26 #include <helper/types.h>
27 #include <jtag/jtag.h>
28 #include <jtag/commands.h>
29 #include <jtag/interface.h>
30
31 #include "esirisc_jtag.h"
32
33 static void esirisc_jtag_set_instr(struct esirisc_jtag *jtag_info, uint32_t new_instr)
34 {
35         struct jtag_tap *tap = jtag_info->tap;
36
37         if (buf_get_u32(tap->cur_instr, 0, tap->ir_length) != new_instr) {
38                 struct scan_field field;
39                 uint8_t t[4];
40
41                 field.num_bits = tap->ir_length;
42                 field.out_value = t;
43                 buf_set_u32(t, 0, field.num_bits, new_instr);
44                 field.in_value = NULL;
45
46                 jtag_add_ir_scan(tap, &field, TAP_IDLE);
47         }
48 }
49
50 /*
51  * The data register is latched every 8 bits while in the Shift-DR state
52  * (Update-DR is not supported). This necessitates prepending padding
53  * bits to ensure data is aligned when multiple TAPs are present.
54  */
55 static int esirisc_jtag_get_padding(void)
56 {
57         int padding = 0;
58         int bypass_devices = 0;
59
60         for (struct jtag_tap *tap = jtag_tap_next_enabled(NULL); tap != NULL;
61                         tap = jtag_tap_next_enabled(tap))
62                 if (tap->bypass)
63                         bypass_devices++;
64
65         int num_bits = bypass_devices % 8;
66         if (num_bits > 0)
67                 padding = 8 - num_bits;
68
69         return padding;
70 }
71
72 static int esirisc_jtag_count_bits(int num_fields, struct scan_field *fields)
73 {
74         int bit_count = 0;
75
76         for (int i = 0; i < num_fields; ++i)
77                 bit_count += fields[i].num_bits;
78
79         return bit_count;
80 }
81
82 /*
83  * Data received from the target will be byte-stuffed if it contains
84  * either the pad byte (0xAA) or stuffing marker (0x55). Buffers should
85  * be sized twice the expected length to account for stuffing overhead.
86  */
87 static void esirisc_jtag_unstuff(uint8_t *data, size_t len)
88 {
89         uint8_t *r, *w;
90         uint8_t *end;
91
92         r = w = data;
93         end = data + len;
94         while (r < end) {
95                 if (*r == STUFF_MARKER) {
96                         r++; /* skip stuffing marker */
97                         assert(r < end);
98                         *w++ = *r++ ^ STUFF_MARKER;
99                 } else
100                         *w++ = *r++;
101         }
102 }
103
104 /*
105  * The eSi-Debug protocol defines a byte-oriented command/response
106  * channel that operates over serial or JTAG. While not strictly
107  * required, separate DR scans are used for sending and receiving data.
108  * This allows the TAP to recover gracefully if the byte stream is
109  * corrupted at the expense of sending additional padding bits.
110  */
111
112 static int esirisc_jtag_send(struct esirisc_jtag *jtag_info, uint8_t command,
113                 int num_out_fields, struct scan_field *out_fields)
114 {
115         int num_fields = 2 + num_out_fields;
116         struct scan_field *fields = cmd_queue_alloc(num_fields * sizeof(struct scan_field));
117
118         esirisc_jtag_set_instr(jtag_info, INSTR_DEBUG);
119
120         fields[0].num_bits = esirisc_jtag_get_padding();
121         fields[0].out_value = NULL;
122         fields[0].in_value = NULL;
123
124         fields[1].num_bits = 8;
125         fields[1].out_value = &command;
126         fields[1].in_value = NULL;
127
128         /* append command data */
129         for (int i = 0; i < num_out_fields; ++i)
130                 jtag_scan_field_clone(&fields[2+i], &out_fields[i]);
131
132         jtag_add_dr_scan(jtag_info->tap, num_fields, fields, TAP_IDLE);
133
134         return jtag_execute_queue();
135 }
136
137 static int esirisc_jtag_recv(struct esirisc_jtag *jtag_info,
138                 int num_in_fields, struct scan_field *in_fields)
139 {
140         int num_in_bits = esirisc_jtag_count_bits(num_in_fields, in_fields);
141         int num_in_bytes = DIV_ROUND_UP(num_in_bits, 8);
142
143         struct scan_field fields[3];
144         uint8_t r[num_in_bytes * 2];
145
146         esirisc_jtag_set_instr(jtag_info, INSTR_DEBUG);
147
148         fields[0].num_bits = esirisc_jtag_get_padding() + 1;
149         fields[0].out_value = NULL;
150         fields[0].in_value = NULL;
151
152         fields[1].num_bits = 8;
153         fields[1].out_value = NULL;
154         fields[1].in_value = &jtag_info->status;
155
156         fields[2].num_bits = num_in_bits * 2;
157         fields[2].out_value = NULL;
158         fields[2].in_value = r;
159
160         jtag_add_dr_scan(jtag_info->tap, ARRAY_SIZE(fields), fields, TAP_IDLE);
161
162         int retval = jtag_execute_queue();
163         if (retval != ERROR_OK)
164                 return retval;
165
166         /* unstuff response data and write back to caller */
167         if (num_in_fields > 0) {
168                 esirisc_jtag_unstuff(r, ARRAY_SIZE(r));
169
170                 int bit_count = 0;
171                 for (int i = 0; i < num_in_fields; ++i) {
172                         buf_set_buf(r, bit_count, in_fields[i].in_value, 0, in_fields[i].num_bits);
173                         bit_count += in_fields[i].num_bits;
174                 }
175         }
176
177         return ERROR_OK;
178 }
179
180 static int esirisc_jtag_check_status(struct esirisc_jtag *jtag_info)
181 {
182         uint8_t eid = esirisc_jtag_get_eid(jtag_info);
183         if (eid != EID_NONE) {
184                 LOG_ERROR("esirisc_jtag: bad status: 0x%02" PRIx32 " (DA: %" PRId32 ", "
185                                 "S: %" PRId32 ", EID: 0x%02" PRIx32 ")",
186                                 jtag_info->status, esirisc_jtag_is_debug_active(jtag_info),
187                                 esirisc_jtag_is_stopped(jtag_info), eid);
188                 return ERROR_FAIL;
189         }
190
191         return ERROR_OK;
192 }
193
194 static int esirisc_jtag_send_and_recv(struct esirisc_jtag *jtag_info, uint8_t command,
195                 int num_out_fields, struct scan_field *out_fields,
196                 int num_in_fields, struct scan_field *in_fields)
197 {
198         int retval;
199
200         jtag_info->status = 0;  /* clear status */
201
202         retval = esirisc_jtag_send(jtag_info, command, num_out_fields, out_fields);
203         if (retval != ERROR_OK) {
204                 LOG_ERROR("esirisc_jtag: send failed (command: 0x%02" PRIx32 ")", command);
205                 return ERROR_FAIL;
206         }
207
208         retval = esirisc_jtag_recv(jtag_info, num_in_fields, in_fields);
209         if (retval != ERROR_OK) {
210                 LOG_ERROR("esirisc_jtag: recv failed (command: 0x%02" PRIx32 ")", command);
211                 return ERROR_FAIL;
212         }
213
214         return esirisc_jtag_check_status(jtag_info);
215 }
216
217 /*
218  * Status is automatically updated after each command completes;
219  * these functions make each field available to the caller.
220  */
221
222 bool esirisc_jtag_is_debug_active(struct esirisc_jtag *jtag_info)
223 {
224         return !!(jtag_info->status & 1<<7);    /* DA */
225 }
226
227 bool esirisc_jtag_is_stopped(struct esirisc_jtag *jtag_info)
228 {
229         return !!(jtag_info->status & 1<<6);    /* S */
230 }
231
232 uint8_t esirisc_jtag_get_eid(struct esirisc_jtag *jtag_info)
233 {
234         return jtag_info->status & 0x3f;                /* EID */
235 }
236
237 /*
238  * Most commands manipulate target data (eg. memory and registers); each
239  * command returns a status byte that indicates success. Commands must
240  * transmit multibyte values in big-endian order, however response
241  * values are in little-endian order. Target endianness does not have an
242  * effect on this ordering.
243  */
244
245 int esirisc_jtag_read_byte(struct esirisc_jtag *jtag_info, uint32_t address, uint8_t *data)
246 {
247         struct scan_field out_fields[1];
248         uint8_t a[4];
249
250         out_fields[0].num_bits = 32;
251         out_fields[0].out_value = a;
252         h_u32_to_be(a, address);
253         out_fields[0].in_value = NULL;
254
255         struct scan_field in_fields[1];
256         uint8_t d[1];
257
258         in_fields[0].num_bits = 8;
259         in_fields[0].out_value = NULL;
260         in_fields[0].in_value = d;
261
262         int retval = esirisc_jtag_send_and_recv(jtag_info, DEBUG_READ_BYTE,
263                         ARRAY_SIZE(out_fields), out_fields, ARRAY_SIZE(in_fields), in_fields);
264         if (retval != ERROR_OK)
265                 return retval;
266
267         *data = *d;
268
269         return ERROR_OK;
270 }
271
272 int esirisc_jtag_read_hword(struct esirisc_jtag *jtag_info, uint32_t address, uint16_t *data)
273 {
274         struct scan_field out_fields[1];
275         uint8_t a[4];
276
277         out_fields[0].num_bits = 32;
278         out_fields[0].out_value = a;
279         h_u32_to_be(a, address);
280         out_fields[0].in_value = NULL;
281
282         struct scan_field in_fields[1];
283         uint8_t d[2];
284
285         in_fields[0].num_bits = 16;
286         in_fields[0].out_value = NULL;
287         in_fields[0].in_value = d;
288
289         int retval = esirisc_jtag_send_and_recv(jtag_info, DEBUG_READ_HWORD,
290                         ARRAY_SIZE(out_fields), out_fields, ARRAY_SIZE(in_fields), in_fields);
291         if (retval != ERROR_OK)
292                 return retval;
293
294         *data = le_to_h_u16(d);
295
296         return ERROR_OK;
297 }
298
299 int esirisc_jtag_read_word(struct esirisc_jtag *jtag_info, uint32_t address, uint32_t *data)
300 {
301         struct scan_field out_fields[1];
302         uint8_t a[4];
303
304         out_fields[0].num_bits = 32;
305         out_fields[0].out_value = a;
306         h_u32_to_be(a, address);
307         out_fields[0].in_value = NULL;
308
309         struct scan_field in_fields[1];
310         uint8_t d[4];
311
312         in_fields[0].num_bits = 32;
313         in_fields[0].out_value = NULL;
314         in_fields[0].in_value = d;
315
316         int retval = esirisc_jtag_send_and_recv(jtag_info, DEBUG_READ_WORD,
317                         ARRAY_SIZE(out_fields), out_fields, ARRAY_SIZE(in_fields), in_fields);
318         if (retval != ERROR_OK)
319                 return retval;
320
321         *data = le_to_h_u32(d);
322
323         return ERROR_OK;
324 }
325
326 int esirisc_jtag_write_byte(struct esirisc_jtag *jtag_info, uint32_t address, uint8_t data)
327 {
328         struct scan_field out_fields[2];
329         uint8_t a[4];
330
331         out_fields[0].num_bits = 32;
332         out_fields[0].out_value = a;
333         h_u32_to_be(a, address);
334         out_fields[0].in_value = NULL;
335
336         out_fields[1].num_bits = 8;
337         out_fields[1].out_value = &data;
338         out_fields[1].in_value = NULL;
339
340         return esirisc_jtag_send_and_recv(jtag_info, DEBUG_WRITE_BYTE,
341                         ARRAY_SIZE(out_fields), out_fields, 0, NULL);
342 }
343
344 int esirisc_jtag_write_hword(struct esirisc_jtag *jtag_info, uint32_t address, uint16_t data)
345 {
346         struct scan_field out_fields[2];
347         uint8_t a[4], d[2];
348
349         out_fields[0].num_bits = 32;
350         out_fields[0].out_value = a;
351         h_u32_to_be(a, address);
352         out_fields[0].in_value = NULL;
353
354         out_fields[1].num_bits = 16;
355         out_fields[1].out_value = d;
356         h_u16_to_be(d, data);
357         out_fields[1].in_value = NULL;
358
359         return esirisc_jtag_send_and_recv(jtag_info, DEBUG_WRITE_HWORD,
360                         ARRAY_SIZE(out_fields), out_fields, 0, NULL);
361 }
362
363 int esirisc_jtag_write_word(struct esirisc_jtag *jtag_info, uint32_t address, uint32_t data)
364 {
365         struct scan_field out_fields[2];
366         uint8_t a[4], d[4];
367
368         out_fields[0].num_bits = 32;
369         out_fields[0].out_value = a;
370         h_u32_to_be(a, address);
371         out_fields[0].in_value = NULL;
372
373         out_fields[1].num_bits = 32;
374         out_fields[1].out_value = d;
375         h_u32_to_be(d, data);
376         out_fields[1].in_value = NULL;
377
378         return esirisc_jtag_send_and_recv(jtag_info, DEBUG_WRITE_WORD,
379                         ARRAY_SIZE(out_fields), out_fields, 0, NULL);
380 }
381
382 int esirisc_jtag_read_reg(struct esirisc_jtag *jtag_info, uint8_t reg, uint32_t *data)
383 {
384         struct scan_field out_fields[1];
385
386         out_fields[0].num_bits = 8;
387         out_fields[0].out_value = &reg;
388         out_fields[0].in_value = NULL;
389
390         struct scan_field in_fields[1];
391         uint8_t d[4];
392
393         in_fields[0].num_bits = 32;
394         in_fields[0].out_value = NULL;
395         in_fields[0].in_value = d;
396
397         int retval = esirisc_jtag_send_and_recv(jtag_info, DEBUG_READ_REG,
398                         ARRAY_SIZE(out_fields), out_fields, ARRAY_SIZE(in_fields), in_fields);
399         if (retval != ERROR_OK)
400                 return retval;
401
402         *data = le_to_h_u32(d);
403
404         return ERROR_OK;
405 }
406
407 int esirisc_jtag_write_reg(struct esirisc_jtag *jtag_info, uint8_t reg, uint32_t data)
408 {
409         struct scan_field out_fields[2];
410         uint8_t d[4];
411
412         out_fields[0].num_bits = 8;
413         out_fields[0].out_value = &reg;
414         out_fields[0].in_value = NULL;
415
416         out_fields[1].num_bits = 32;
417         out_fields[1].out_value = d;
418         h_u32_to_be(d, data);
419         out_fields[1].in_value = NULL;
420
421         return esirisc_jtag_send_and_recv(jtag_info, DEBUG_WRITE_REG,
422                         ARRAY_SIZE(out_fields), out_fields, 0, NULL);
423 }
424
425 int esirisc_jtag_read_csr(struct esirisc_jtag *jtag_info, uint8_t bank, uint8_t csr, uint32_t *data)
426 {
427         struct scan_field out_fields[1];
428         uint8_t c[2];
429
430         out_fields[0].num_bits = 16;
431         out_fields[0].out_value = c;
432         h_u16_to_be(c, (csr << 5) | bank);
433         out_fields[0].in_value = NULL;
434
435         struct scan_field in_fields[1];
436         uint8_t d[4];
437
438         in_fields[0].num_bits = 32;
439         in_fields[0].out_value = NULL;
440         in_fields[0].in_value = d;
441
442         int retval = esirisc_jtag_send_and_recv(jtag_info, DEBUG_READ_CSR,
443                         ARRAY_SIZE(out_fields), out_fields, ARRAY_SIZE(in_fields), in_fields);
444         if (retval != ERROR_OK)
445                 return retval;
446
447         *data = le_to_h_u32(d);
448
449         return ERROR_OK;
450 }
451
452 int esirisc_jtag_write_csr(struct esirisc_jtag *jtag_info, uint8_t bank, uint8_t csr, uint32_t data)
453 {
454         struct scan_field out_fields[2];
455         uint8_t c[2], d[4];
456
457         out_fields[0].num_bits = 16;
458         out_fields[0].out_value = c;
459         h_u16_to_be(c, (csr << 5) | bank);
460         out_fields[0].in_value = NULL;
461
462         out_fields[1].num_bits = 32;
463         out_fields[1].out_value = d;
464         h_u32_to_be(d, data);
465         out_fields[1].in_value = NULL;
466
467         return esirisc_jtag_send_and_recv(jtag_info, DEBUG_WRITE_CSR,
468                         ARRAY_SIZE(out_fields), out_fields, 0, NULL);
469 }
470
471 /*
472  * Control commands affect CPU operation; these commands send no data
473  * and return a status byte.
474  */
475
476 static inline int esirisc_jtag_send_ctrl(struct esirisc_jtag *jtag_info, uint8_t command)
477 {
478         return esirisc_jtag_send_and_recv(jtag_info, command, 0, NULL, 0, NULL);
479 }
480
481 int esirisc_jtag_enable_debug(struct esirisc_jtag *jtag_info)
482 {
483         return esirisc_jtag_send_ctrl(jtag_info, DEBUG_ENABLE_DEBUG);
484 }
485
486 int esirisc_jtag_disable_debug(struct esirisc_jtag *jtag_info)
487 {
488         return esirisc_jtag_send_ctrl(jtag_info, DEBUG_DISABLE_DEBUG);
489 }
490
491 int esirisc_jtag_assert_reset(struct esirisc_jtag *jtag_info)
492 {
493         return esirisc_jtag_send_ctrl(jtag_info, DEBUG_ASSERT_RESET);
494 }
495
496 int esirisc_jtag_deassert_reset(struct esirisc_jtag *jtag_info)
497 {
498         return esirisc_jtag_send_ctrl(jtag_info, DEBUG_DEASSERT_RESET);
499 }
500
501 int esirisc_jtag_break(struct esirisc_jtag *jtag_info)
502 {
503         return esirisc_jtag_send_ctrl(jtag_info, DEBUG_BREAK);
504 }
505
506 int esirisc_jtag_continue(struct esirisc_jtag *jtag_info)
507 {
508         return esirisc_jtag_send_ctrl(jtag_info, DEBUG_CONTINUE);
509 }
510
511 int esirisc_jtag_flush_caches(struct esirisc_jtag *jtag_info)
512 {
513         return esirisc_jtag_send_ctrl(jtag_info, DEBUG_FLUSH_CACHES);
514 }