arm_adi_v5.h 14 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/***************************************************************************
 *   Copyright (C) 2006 by Magnus Lundin                                   *
 *   lundin@mlu.mine.nu                                                    *
 *                                                                         *
 *   Copyright (C) 2008 by Spencer Oliver                                  *
 *   spen@spen-soft.co.uk                                                  *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef ARM_ADI_V5_H
#define ARM_ADI_V5_H

26
27
28
29
30
31
32
/**
 * @file
 * This defines formats and data structures used to talk to ADIv5 entities.
 * Those include a DAP, different types of Debug Port (DP), and memory mapped
 * resources accessed through a MEM-AP.
 */

33
#include "arm_jtag.h"
34

35
36
37
38
39
/* JTAG instructions/registers for JTAG-DP and SWJ-DP */
#define JTAG_DP_ABORT		0x8
#define JTAG_DP_DPACC		0xA
#define JTAG_DP_APACC		0xB
#define JTAG_DP_IDCODE		0xE
40

41
42
43
44
/* three-bit ACK values for DPACC and APACC reads */
#define JTAG_ACK_OK_FAULT	0x2
#define JTAG_ACK_WAIT		0x1

45
46
47
48
49
/* three-bit ACK values for SWD access (sent LSB first) */
#define SWD_ACK_OK		0x4
#define SWD_ACK_WAIT		0x2
#define SWD_ACK_FAULT		0x1

50
51
#define DPAP_WRITE		0
#define DPAP_READ		1
52

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
/* A[3:0] for DP registers; A[1:0] are always zero.
 * - JTAG accesses all of these via JTAG_DP_DPACC, except for
 *   IDCODE (JTAG_DP_IDCODE) and ABORT (JTAG_DP_ABORT).
 * - SWD accesses these directly, sometimes needing SELECT.CTRLSEL
 */
#define DP_IDCODE		0		/* SWD: read */
#define DP_ABORT		0		/* SWD: write */
#define DP_CTRL_STAT		0x4		/* r/w */
#define DP_WCR			0x4		/* SWD: r/w (mux CTRLSEL) */
#define DP_RESEND		0x8		/* SWD: read */
#define DP_SELECT		0x8		/* JTAG: r/w; SWD: write */
#define DP_RDBUFF		0xC		/* read-only */

/* Fields of the DP's AP ABORT register */
#define DAPABORT		(1 << 0)
#define STKCMPCLR		(1 << 1)	/* SWD-only */
#define STKERRCLR		(1 << 2)	/* SWD-only */
#define WDERRCLR		(1 << 3)	/* SWD-only */
#define ORUNERRCLR		(1 << 4)	/* SWD-only */
72

73
/* Fields of the DP's CTRL/STAT register */
zwelch's avatar
zwelch committed
74
75
#define CORUNDETECT		(1 << 0)
#define SSTICKYORUN		(1 << 1)
76
/* 3:2 - transaction mode (e.g. pushed compare) */
77
#define SSTICKYCMP		(1 << 4)
zwelch's avatar
zwelch committed
78
#define SSTICKYERR		(1 << 5)
79
80
#define READOK			(1 << 6)	/* SWD-only */
#define WDATAERR		(1 << 7)	/* SWD-only */
81
82
/* 11:8 - mask lanes for pushed compare or verify ops */
/* 21:12 - transaction counter */
zwelch's avatar
zwelch committed
83
84
85
86
87
88
#define CDBGRSTREQ		(1 << 26)
#define CDBGRSTACK		(1 << 27)
#define CDBGPWRUPREQ	(1 << 28)
#define CDBGPWRUPACK	(1 << 29)
#define CSYSPWRUPREQ	(1 << 30)
#define CSYSPWRUPACK	(1 << 31)
89

90
91
92
/* MEM-AP register addresses */
/* TODO: rename as MEM_AP_REG_* */
#define AP_REG_CSW		0x00
93
94
95
96
97
98
#define AP_REG_TAR		0x04
#define AP_REG_DRW		0x0C
#define AP_REG_BD0		0x10
#define AP_REG_BD1		0x14
#define AP_REG_BD2		0x18
#define AP_REG_BD3		0x1C
99
100
101
102
#define AP_REG_CFG		0xF4		/* big endian? */
#define AP_REG_BASE		0xF8

/* Generic AP register address */
103
104
#define AP_REG_IDR		0xFC

105
/* Fields of the MEM-AP's CSW register */
106
107
108
#define CSW_8BIT		0
#define CSW_16BIT		1
#define CSW_32BIT		2
zwelch's avatar
zwelch committed
109
#define CSW_ADDRINC_MASK	(3 << 4)
110
#define CSW_ADDRINC_OFF		0
zwelch's avatar
zwelch committed
111
112
#define CSW_ADDRINC_SINGLE	(1 << 4)
#define CSW_ADDRINC_PACKED	(2 << 4)
113
114
115
116
117
118
#define CSW_DEVICE_EN		(1 << 6)
#define CSW_TRIN_PROG		(1 << 7)
#define CSW_SPIDEN			(1 << 23)
/* 30:24 - implementation-defined! */
#define CSW_HPROT			(1 << 25)		/* ? */
#define CSW_MASTER_DEBUG	(1 << 29)		/* ? */
zwelch's avatar
zwelch committed
119
#define CSW_DBGSWENABLE		(1 << 31)
120

121
122
123
124
125
126
/**
 * This represents an ARM Debug Interface (v5) Debug Access Port (DAP).
 * A DAP has two types of component:  one Debug Port (DP), which is a
 * transport agent; and at least one Access Port (AP), controlling
 * resource access.  Most common is a MEM-AP, for memory access.
 *
127
128
129
130
131
132
133
134
135
136
 * There are two basic DP transports: JTAG, and ARM's low pin-count SWD.
 * Accordingly, this interface is responsible for hiding the transport
 * differences so upper layer code can largely ignore them.
 *
 * When the chip is implemented with JTAG-DP or SW-DP, the transport is
 * fixed as JTAG or SWD, respectively.  Chips incorporating SWJ-DP permit
 * a choice made at board design time (by only using the SWD pins), or
 * as part of setting up a debug session (if all the dual-role JTAG/SWD
 * signals are available).
 *
137
138
 * @todo Rename "swjdp_common" as "dap".  Use of SWJ-DP is optional!
 */
139
struct swjdp_common
140
{
141
142
	const struct dap_ops *ops;

143
	struct arm_jtag *jtag_info;
144
	/* Control config */
145
	uint32_t dp_ctrl_stat;
146
147
148
149
150
151
152

	/**
	 * Cache for DP_SELECT bits identifying the current AP.  A DAP may
	 * connect to multiple APs, such as one MEM-AP for general access,
	 * another reserved for accessing debug modules, and a JTAG-DP.
	 * "-1" indicates no cached value.
	 */
153
	uint32_t apsel;
154
155
156
157
158
159
160
161
162
163
164
165
166
167

	/**
	 * Cache for DP_SELECT bits identifying the current four-word AP
	 * register bank.  This caches AP register addresss bits 7:4; JTAG
	 * and SWD access primitves pass address bits 3:2; bits 1:0 are zero.
	 * "-1" indicates no cached value.
	 */
	uint32_t ap_bank_value;

	/**
	 * Cache for (MEM-AP) AP_REG_CSW register value.  This is written to
	 * configure an access mode, such as autoincrementing AP_REG_TAR during
	 * word access.  "-1" indicates no cached value.
	 */
168
	uint32_t ap_csw_value;
169
170
171
172
173
174

	/**
	 * Cache for (MEM-AP) AP_REG_TAR register value This is written to
	 * configure the address being read or written
	 * "-1" indicates no cached value.
	 */
175
	uint32_t ap_tar_value;
176

177
	/* information about current pending SWjDP-AHBAP transaction */
178
	uint8_t  ack;
179

180
181
182
183
	/**
	 * Configures how many extra tck clocks are added after starting a
	 * MEM-AP access before we try to read its status (and/or result).
	 */
184
	uint32_t	memaccess_tck;
185
	/* Size of TAR autoincrement block, ARM ADI Specification requires at least 10 bits */
186
	uint32_t tar_autoincr_block;
187

188
};
189

190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
/**
 * Transport-neutral representation of queued DAP transactions, supporting
 * both JTAG and SWD transports.  All submitted transactions are logically
 * queued, until the queue is executed by run().  Some implementations might
 * execute transactions as soon as they're submitted, but no status is made
 * availablue until run().
 */
struct dap_ops {
	/** If the DAP transport isn't SWD, it must be JTAG.  Upper level
	 * code may need to care about the difference in some cases.
	 */
	bool	is_swd;

	/** Reads the DAP's IDCODe register. */
	int (*queue_idcode_read)(struct swjdp_common *dap,
			uint8_t *ack, uint32_t *data);

	/** DP register read. */
	int (*queue_dp_read)(struct swjdp_common *dap, unsigned reg,
			uint32_t *data);
	/** DP register write. */
	int (*queue_dp_write)(struct swjdp_common *dap, unsigned reg,
			uint32_t data);

	/** AP register read. */
	int (*queue_ap_read)(struct swjdp_common *dap, unsigned reg,
			uint32_t *data);
	/** AP register write. */
	int (*queue_ap_write)(struct swjdp_common *dap, unsigned reg,
			uint32_t data);
	/** AP operation abort. */
	int (*queue_ap_abort)(struct swjdp_common *dap, uint8_t *ack);

	/** Executes all queued DAP operations. */
	int (*run)(struct swjdp_common *dap);
};

/**
 * Queue an IDCODE register read.  This is primarily useful for SWD
 * transports, where it is required as part of link initialization.
 * (For JTAG, this register is read as part of scan chain setup.)
 *
 * @param dap The DAP used for reading.
 * @param ack Pointer to where transaction status will be stored.
 * @param data Pointer saying where to store the IDCODE value.
 *
 * @return ERROR_OK for success, else a fault code.
 */
static inline int dap_queue_idcode_read(struct swjdp_common *dap,
		uint8_t *ack, uint32_t *data)
{
	return dap->ops->queue_idcode_read(dap, ack, data);
}

/**
 * Queue a DP register read.
 * Note that not all DP registers are readable; also, that JTAG and SWD
 * have slight differences in DP register support.
 *
 * @param dap The DAP used for reading.
 * @param reg The two-bit number of the DP register being read.
 * @param data Pointer saying where to store the register's value
 * 	(in host endianness).
 *
 * @return ERROR_OK for success, else a fault code.
 */
static inline int dap_queue_dp_read(struct swjdp_common *dap,
		unsigned reg, uint32_t *data)
{
	return dap->ops->queue_dp_read(dap, reg, data);
}

/**
 * Queue a DP register write.
 * Note that not all DP registers are writable; also, that JTAG and SWD
 * have slight differences in DP register support.
 *
 * @param dap The DAP used for writing.
 * @param reg The two-bit number of the DP register being written.
 * @param data Value being written (host endianness)
 *
 * @return ERROR_OK for success, else a fault code.
 */
static inline int dap_queue_dp_write(struct swjdp_common *dap,
		unsigned reg, uint32_t data)
{
	return dap->ops->queue_dp_write(dap, reg, data);
}

/**
 * Queue an AP register read.
 *
 * @param dap The DAP used for reading.
 * @param reg The number of the AP register being read.
 * @param data Pointer saying where to store the register's value
 * 	(in host endianness).
 *
 * @return ERROR_OK for success, else a fault code.
 */
static inline int dap_queue_ap_read(struct swjdp_common *dap,
		unsigned reg, uint32_t *data)
{
	return dap->ops->queue_ap_read(dap, reg, data);
}

/**
 * Queue an AP register write.
 *
 * @param dap The DAP used for writing.
 * @param reg The number of the AP register being written.
 * @param data Value being written (host endianness)
 *
 * @return ERROR_OK for success, else a fault code.
 */
static inline int dap_queue_ap_write(struct swjdp_common *dap,
		unsigned reg, uint32_t data)
{
	return dap->ops->queue_ap_write(dap, reg, data);
}

/**
 * Queue an AP abort operation.  The current AP transaction is aborted,
 * including any update of the transaction counter.  The AP is left in
 * an unknown state (so it must be re-initialized).  For use only after
 * the AP has reported WAIT status for an extended period.
 *
 * @param dap The DAP used for writing.
 * @param ack Pointer to where transaction status will be stored.
 *
 * @return ERROR_OK for success, else a fault code.
 */
static inline int dap_queue_ap_abort(struct swjdp_common *dap, uint8_t *ack)
{
	return dap->ops->queue_ap_abort(dap, ack);
}

/**
 * Perform all queued DAP operations, and clear any errors posted in the
 * CTRL_STAT register when they are done.  Note that if more than one AP
 * operation will be queued, one of the first operations in the queue
 * should probably enable CORUNDETECT in the CTRL/STAT register.
 *
 * @param dap The DAP used.
 *
 * @return ERROR_OK for success, else a fault code.
 */
static inline int dap_run(struct swjdp_common *dap)
{
	return dap->ops->run(dap);
}

David Brownell's avatar
David Brownell committed
341
/** Accessor for currently selected DAP-AP number (0..255) */
342
static inline uint8_t dap_ap_get_select(struct swjdp_common *swjdp)
343
{
344
	return (uint8_t)(swjdp ->apsel >> 24);
345
346
}

David Brownell's avatar
David Brownell committed
347
348
349
/* AP selection applies to future AP transactions */
void dap_ap_select(struct swjdp_common *dap,uint8_t apsel);

350
/* Queued AP transactions */
David Brownell's avatar
David Brownell committed
351
352
353
354
355
356
int dap_setup_accessport(struct swjdp_common *swjdp,
		uint32_t csw, uint32_t tar);
int dap_ap_write_reg_u32(struct swjdp_common *swjdp,
		uint32_t addr, uint32_t value);
int dap_ap_read_reg_u32(struct swjdp_common *swjdp,
		uint32_t addr, uint32_t *value);
357

358
359
/* Queued JTAG ops must be completed with jtagdp_transaction_endcheck() */
int jtagdp_transaction_endcheck(struct swjdp_common *swjdp);
360

David Brownell's avatar
David Brownell committed
361
/* Queued MEM-AP memory mapped single word transfers */
362
363
int mem_ap_read_u32(struct swjdp_common *swjdp, uint32_t address, uint32_t *value);
int mem_ap_write_u32(struct swjdp_common *swjdp, uint32_t address, uint32_t value);
364

David Brownell's avatar
David Brownell committed
365
/* Synchronous MEM-AP memory mapped single word transfers */
366
int mem_ap_read_atomic_u32(struct swjdp_common *swjdp,
367
		uint32_t address, uint32_t *value);
368
int mem_ap_write_atomic_u32(struct swjdp_common *swjdp,
369
		uint32_t address, uint32_t value);
370
371

/* MEM-AP memory mapped bus block transfers */
372
int mem_ap_read_buf_u8(struct swjdp_common *swjdp,
373
		uint8_t *buffer, int count, uint32_t address);
374
int mem_ap_read_buf_u16(struct swjdp_common *swjdp,
375
		uint8_t *buffer, int count, uint32_t address);
376
int mem_ap_read_buf_u32(struct swjdp_common *swjdp,
377
378
		uint8_t *buffer, int count, uint32_t address);

379
int mem_ap_write_buf_u8(struct swjdp_common *swjdp,
380
		uint8_t *buffer, int count, uint32_t address);
381
int mem_ap_write_buf_u16(struct swjdp_common *swjdp,
382
		uint8_t *buffer, int count, uint32_t address);
383
int mem_ap_write_buf_u32(struct swjdp_common *swjdp,
384
		uint8_t *buffer, int count, uint32_t address);
385
386

/* Initialisation of the debug system, power domains and registers */
387
int ahbap_debugport_init(struct swjdp_common *swjdp);
388

389

390
/* Commands for user dap access */
391
int dap_info_command(struct command_context *cmd_ctx,
392
		struct swjdp_common *swjdp, int apsel);
393
394

#define DAP_COMMAND_HANDLER(name) \
395
		COMMAND_HELPER(name, struct swjdp_common *swjdp)
396
397
398
399
DAP_COMMAND_HANDLER(dap_baseaddr_command);
DAP_COMMAND_HANDLER(dap_memaccess_command);
DAP_COMMAND_HANDLER(dap_apsel_command);
DAP_COMMAND_HANDLER(dap_apid_command);
400

401
402
403
404
405
406
407
408
struct target;

/* Put debug link into SWD mode */
int dap_to_swd(struct target *target);

/* Put debug link into JTAG mode */
int dap_to_jtag(struct target *target);

409
#endif