19 #define SAMD_NUM_PROT_BLOCKS 16
20 #define SAMD_PAGE_SIZE_MAX 1024
22 #define SAMD_FLASH ((uint32_t)0x00000000)
23 #define SAMD_USER_ROW ((uint32_t)0x00804000)
24 #define SAMD_PAC1 0x41000000
25 #define SAMD_DSU 0x41002000
26 #define SAMD_NVMCTRL 0x41004000
28 #define SAMD_DSU_STATUSA 1
29 #define SAMD_DSU_DID 0x18
30 #define SAMD_DSU_CTRL_EXT 0x100
32 #define SAMD_NVMCTRL_CTRLA 0x00
33 #define SAMD_NVMCTRL_CTRLB 0x04
34 #define SAMD_NVMCTRL_PARAM 0x08
35 #define SAMD_NVMCTRL_INTFLAG 0x14
36 #define SAMD_NVMCTRL_STATUS 0x18
37 #define SAMD_NVMCTRL_ADDR 0x1C
38 #define SAMD_NVMCTRL_LOCK 0x20
40 #define SAMD_CMDEX_KEY 0xA5UL
41 #define SAMD_NVM_CMD(n) ((SAMD_CMDEX_KEY << 8) | (n & 0x7F))
44 #define SAMD_NVM_CMD_ER 0x02
45 #define SAMD_NVM_CMD_WP 0x04
46 #define SAMD_NVM_CMD_EAR 0x05
47 #define SAMD_NVM_CMD_WAP 0x06
48 #define SAMD_NVM_CMD_LR 0x40
49 #define SAMD_NVM_CMD_UR 0x41
50 #define SAMD_NVM_CMD_SPRM 0x42
51 #define SAMD_NVM_CMD_CPRM 0x43
52 #define SAMD_NVM_CMD_PBC 0x44
53 #define SAMD_NVM_CMD_SSB 0x45
54 #define SAMD_NVM_CMD_INVALL 0x46
57 #define SAMD_NVM_CTRLB_MANW 0x80
60 #define SAMD_NVM_INTFLAG_READY 0x01
63 #define SAMD_PROCESSOR_M0 0x01
64 #define SAMD_FAMILY_D 0x00
65 #define SAMD_FAMILY_L 0x01
66 #define SAMD_FAMILY_C 0x02
67 #define SAMD_SERIES_20 0x00
68 #define SAMD_SERIES_21 0x01
69 #define SAMD_SERIES_22 0x02
70 #define SAMD_SERIES_10 0x02
71 #define SAMD_SERIES_11 0x03
72 #define SAMD_SERIES_09 0x04
75 #define SAMD_GET_PROCESSOR(id) (id >> 28)
76 #define SAMD_GET_FAMILY(id) (((id >> 23) & 0x1F))
77 #define SAMD_GET_SERIES(id) (((id >> 16) & 0x3F))
78 #define SAMD_GET_DEVSEL(id) (id & 0xFF)
81 #define NVMUSERROW_LOCKBIT_MASK ((uint64_t)0x0000FFFFFFFFFFFF)
93 { 0x0,
"SAMD09D14A", 16, 4 },
94 { 0x7,
"SAMD09C13A", 8, 4 },
99 { 0x0,
"SAMD10D14AMU", 16, 4 },
100 { 0x1,
"SAMD10D13AMU", 8, 4 },
101 { 0x2,
"SAMD10D12AMU", 4, 4 },
102 { 0x3,
"SAMD10D14ASU", 16, 4 },
103 { 0x4,
"SAMD10D13ASU", 8, 4 },
104 { 0x5,
"SAMD10D12ASU", 4, 4 },
105 { 0x6,
"SAMD10C14A", 16, 4 },
106 { 0x7,
"SAMD10C13A", 8, 4 },
107 { 0x8,
"SAMD10C12A", 4, 4 },
112 { 0x0,
"SAMD11D14AM", 16, 4 },
113 { 0x1,
"SAMD11D13AMU", 8, 4 },
114 { 0x2,
"SAMD11D12AMU", 4, 4 },
115 { 0x3,
"SAMD11D14ASS", 16, 4 },
116 { 0x4,
"SAMD11D13ASU", 8, 4 },
117 { 0x5,
"SAMD11D12ASU", 4, 4 },
118 { 0x6,
"SAMD11C14A", 16, 4 },
119 { 0x7,
"SAMD11C13A", 8, 4 },
120 { 0x8,
"SAMD11C12A", 4, 4 },
121 { 0x9,
"SAMD11D14AU", 16, 4 },
126 { 0x0,
"SAMD20J18A", 256, 32 },
127 { 0x1,
"SAMD20J17A", 128, 16 },
128 { 0x2,
"SAMD20J16A", 64, 8 },
129 { 0x3,
"SAMD20J15A", 32, 4 },
130 { 0x4,
"SAMD20J14A", 16, 2 },
131 { 0x5,
"SAMD20G18A", 256, 32 },
132 { 0x6,
"SAMD20G17A", 128, 16 },
133 { 0x7,
"SAMD20G16A", 64, 8 },
134 { 0x8,
"SAMD20G15A", 32, 4 },
135 { 0x9,
"SAMD20G14A", 16, 2 },
136 { 0xA,
"SAMD20E18A", 256, 32 },
137 { 0xB,
"SAMD20E17A", 128, 16 },
138 { 0xC,
"SAMD20E16A", 64, 8 },
139 { 0xD,
"SAMD20E15A", 32, 4 },
140 { 0xE,
"SAMD20E14A", 16, 2 },
145 { 0x0,
"SAMD21J18A", 256, 32 },
146 { 0x1,
"SAMD21J17A", 128, 16 },
147 { 0x2,
"SAMD21J16A", 64, 8 },
148 { 0x3,
"SAMD21J15A", 32, 4 },
149 { 0x4,
"SAMD21J14A", 16, 2 },
150 { 0x5,
"SAMD21G18A", 256, 32 },
151 { 0x6,
"SAMD21G17A", 128, 16 },
152 { 0x7,
"SAMD21G16A", 64, 8 },
153 { 0x8,
"SAMD21G15A", 32, 4 },
154 { 0x9,
"SAMD21G14A", 16, 2 },
155 { 0xA,
"SAMD21E18A", 256, 32 },
156 { 0xB,
"SAMD21E17A", 128, 16 },
157 { 0xC,
"SAMD21E16A", 64, 8 },
158 { 0xD,
"SAMD21E15A", 32, 4 },
159 { 0xE,
"SAMD21E14A", 16, 2 },
162 { 0x18,
"SAMR21G19A", 256, 32 },
163 { 0x19,
"SAMR21G18A", 256, 32 },
164 { 0x1A,
"SAMR21G17A", 128, 32 },
165 { 0x1B,
"SAMR21G16A", 64, 16 },
166 { 0x1C,
"SAMR21E18A", 256, 32 },
167 { 0x1D,
"SAMR21E17A", 128, 32 },
168 { 0x1E,
"SAMR21E16A", 64, 16 },
171 { 0x20,
"SAMD21J16B", 64, 8 },
172 { 0x21,
"SAMD21J15B", 32, 4 },
173 { 0x23,
"SAMD21G16B", 64, 8 },
174 { 0x24,
"SAMD21G15B", 32, 4 },
175 { 0x26,
"SAMD21E16B", 64, 8 },
176 { 0x27,
"SAMD21E15B", 32, 4 },
181 { 0x55,
"SAMD21E16BU", 64, 8 },
182 { 0x56,
"SAMD21E15BU", 32, 4 },
183 { 0x57,
"SAMD21G16L", 64, 8 },
184 { 0x3E,
"SAMD21E16L", 64, 8 },
185 { 0x3F,
"SAMD21E15L", 32, 4 },
186 { 0x62,
"SAMD21E16CU", 64, 8 },
187 { 0x63,
"SAMD21E15CU", 32, 4 },
188 { 0x92,
"SAMD21J17D", 128, 16 },
189 { 0x93,
"SAMD21G17D", 128, 16 },
190 { 0x94,
"SAMD21E17D", 128, 16 },
191 { 0x95,
"SAMD21E17DU", 128, 16 },
192 { 0x96,
"SAMD21G17L", 128, 16 },
193 { 0x97,
"SAMD21E17L", 128, 16 },
198 { 0x29,
"SAMDA1J16A", 64, 8 },
199 { 0x2A,
"SAMDA1J15A", 32, 4 },
200 { 0x2B,
"SAMDA1J14A", 16, 4 },
201 { 0x2C,
"SAMDA1G16A", 64, 8 },
202 { 0x2D,
"SAMDA1G15A", 32, 4 },
203 { 0x2E,
"SAMDA1G14A", 16, 4 },
204 { 0x2F,
"SAMDA1E16A", 64, 8 },
205 { 0x30,
"SAMDA1E15A", 32, 4 },
206 { 0x31,
"SAMDA1E14A", 16, 4 },
207 { 0x64,
"SAMDA1J16B", 64, 8 },
208 { 0x65,
"SAMDA1J15B", 32, 4 },
209 { 0x66,
"SAMDA1J14B", 16, 4 },
210 { 0x67,
"SAMDA1G16B", 64, 8 },
211 { 0x68,
"SAMDA1G15B", 32, 4 },
212 { 0x69,
"SAMDA1G14B", 16, 4 },
213 { 0x6A,
"SAMDA1E16B", 64, 8 },
214 { 0x6B,
"SAMDA1E15B", 32, 4 },
215 { 0x6C,
"SAMDA1E14B", 16, 4 },
220 { 0x00,
"SAML21J18A", 256, 32 },
221 { 0x01,
"SAML21J17A", 128, 16 },
222 { 0x02,
"SAML21J16A", 64, 8 },
223 { 0x05,
"SAML21G18A", 256, 32 },
224 { 0x06,
"SAML21G17A", 128, 16 },
225 { 0x07,
"SAML21G16A", 64, 8 },
226 { 0x0A,
"SAML21E18A", 256, 32 },
227 { 0x0B,
"SAML21E17A", 128, 16 },
228 { 0x0C,
"SAML21E16A", 64, 8 },
229 { 0x0D,
"SAML21E15A", 32, 4 },
230 { 0x0F,
"SAML21J18B", 256, 32 },
231 { 0x10,
"SAML21J17B", 128, 16 },
232 { 0x11,
"SAML21J16B", 64, 8 },
233 { 0x14,
"SAML21G18B", 256, 32 },
234 { 0x15,
"SAML21G17B", 128, 16 },
235 { 0x16,
"SAML21G16B", 64, 8 },
236 { 0x19,
"SAML21E18B", 256, 32 },
237 { 0x1A,
"SAML21E17B", 128, 16 },
238 { 0x1B,
"SAML21E16B", 64, 8 },
239 { 0x1C,
"SAML21E15B", 32, 4 },
242 { 0x1E,
"SAMR30G18A", 256, 32 },
243 { 0x1F,
"SAMR30E18A", 256, 32 },
246 { 0x28,
"SAMR34J18", 256, 32 },
247 { 0x2B,
"SAMR35J18", 256, 32 },
252 { 0x00,
"SAML22N18A", 256, 32 },
253 { 0x01,
"SAML22N17A", 128, 16 },
254 { 0x02,
"SAML22N16A", 64, 8 },
255 { 0x05,
"SAML22J18A", 256, 32 },
256 { 0x06,
"SAML22J17A", 128, 16 },
257 { 0x07,
"SAML22J16A", 64, 8 },
258 { 0x0A,
"SAML22G18A", 256, 32 },
259 { 0x0B,
"SAML22G17A", 128, 16 },
260 { 0x0C,
"SAML22G16A", 64, 8 },
265 { 0x00,
"SAMC20J18A", 256, 32 },
266 { 0x01,
"SAMC20J17A", 128, 16 },
267 { 0x02,
"SAMC20J16A", 64, 8 },
268 { 0x03,
"SAMC20J15A", 32, 4 },
269 { 0x05,
"SAMC20G18A", 256, 32 },
270 { 0x06,
"SAMC20G17A", 128, 16 },
271 { 0x07,
"SAMC20G16A", 64, 8 },
272 { 0x08,
"SAMC20G15A", 32, 4 },
273 { 0x0A,
"SAMC20E18A", 256, 32 },
274 { 0x0B,
"SAMC20E17A", 128, 16 },
275 { 0x0C,
"SAMC20E16A", 64, 8 },
276 { 0x0D,
"SAMC20E15A", 32, 4 },
277 { 0x20,
"SAMC20N18A", 256, 32 },
278 { 0x21,
"SAMC20N17A", 128, 16 },
283 { 0x00,
"SAMC21J18A", 256, 32 },
284 { 0x01,
"SAMC21J17A", 128, 16 },
285 { 0x02,
"SAMC21J16A", 64, 8 },
286 { 0x03,
"SAMC21J15A", 32, 4 },
287 { 0x05,
"SAMC21G18A", 256, 32 },
288 { 0x06,
"SAMC21G17A", 128, 16 },
289 { 0x07,
"SAMC21G16A", 64, 8 },
290 { 0x08,
"SAMC21G15A", 32, 4 },
291 { 0x0A,
"SAMC21E18A", 256, 32 },
292 { 0x0B,
"SAMC21E17A", 128, 16 },
293 { 0x0C,
"SAMC21E16A", 64, 8 },
294 { 0x0D,
"SAMC21E15A", 32, 4 },
295 { 0x20,
"SAMC21N18A", 256, 32 },
296 { 0x21,
"SAMC21N17A", 128, 16 },
315 (uint64_t)0xFFFF01FFFE01FF77 },
318 (uint64_t)0xFFFF01FFFE01FF77 },
321 (uint64_t)0xFFFF01FFFE01FF77 },
324 (uint64_t)0xFFFF01FFFE01FF77 },
327 (uint64_t)0xFFFF01FFFE01FF77 },
330 (uint64_t)0xFFFF03FFFC01FF77 },
333 (uint64_t)0xFFFF03FFFC01FF77 },
336 (uint64_t)0xFFFF03FFFC01FF77 },
339 (uint64_t)0xFFFF03FFFC01FF77 },
386 for (
unsigned i = 0; i <
family->num_parts; i++) {
387 if (
family->parts[i].id == devsel)
405 for (
unsigned int prot_block = 0; prot_block <
bank->num_prot_blocks; prot_block++)
406 bank->prot_blocks[prot_block].is_protected = !(lock & (1u<<prot_block));
412 uint32_t *sizep,
int *nump)
422 *sizep = (8 << ((
param >> 16) & 0x7));
425 *nump =
param & 0xFFFF;
427 LOG_ERROR(
"Couldn't read NVM Parameters register");
445 LOG_ERROR(
"Couldn't read Device ID register");
451 LOG_ERROR(
"Couldn't find part corresponding to DID %08" PRIx32,
id);
455 bank->size = part->flash_kb * 1024;
460 LOG_ERROR(
"Couldn't determine Flash page size");
467 LOG_WARNING(
"SAMD: bank size doesn't match NVM parameters. "
468 "Identified %" PRIu32
"KB Flash but NVMCTRL reports %u %" PRIu32
"B pages",
487 if (!
bank->prot_blocks)
495 LOG_INFO(
"SAMD MCU: %s (%" PRIu32
"KB Flash, %" PRIu32
"KB RAM)", part->name,
496 part->flash_kb, part->ram_kb);
506 int timeout_ms = 1000;
519 }
while (
timeval_ms() - ts_start < timeout_ms);
522 LOG_ERROR(
"SAMD: NVM programming timed out");
533 if ((
status & 0x001C) == 0)
547 LOG_ERROR(
"SAMD: NVM programming error");
555 LOG_ERROR(
"Can't clear NVM error conditions");
600 LOG_ERROR(
"Failed to erase row containing %08" PRIx32, address);
620 LOG_ERROR(
"Couldn't read Device ID register");
626 LOG_ERROR(
"Couldn't determine device family");
657 uint64_t value_input, uint64_t value_mask)
661 bool manual_wp =
true;
668 LOG_ERROR(
"Couldn't determine Flash page size");
674 page_size >=
sizeof(value_input));
682 uint64_t value_device;
686 uint64_t value_new = (value_input & value_mask) | (value_device & ~value_mask);
691 if ((~value_device) & value_new) {
712 LOG_ERROR(
"Read of NVM register CTRKB failed.");
734 uint8_t startb, uint8_t endb)
738 for (i = startb ; i <= endb ; i++)
739 mask |= ((uint64_t)1) << i;
745 unsigned int first,
unsigned int last)
757 for (
unsigned int prot_block = first; prot_block <= last; prot_block++) {
758 if (set !=
bank->prot_blocks[prot_block].is_protected) {
762 bank->prot_blocks[prot_block].offset >> 1);
781 set ? (uint64_t)0 : (uint64_t)UINT64_MAX,
782 48 + first, 48 + last);
784 LOG_WARNING(
"SAMD: protect settings were not made persistent!");
812 for (
unsigned int s = first; s <= last; s++) {
815 LOG_ERROR(
"SAMD: failed to erase sector %d at 0x%08" PRIx32, s,
bank->sectors[s].offset);
882 memcpy(pb + pg_offset,
buffer, nb);
887 assert(pg_offset % 4 == 0);
890 nw = (nb +
offset % 4 + 3) / 4;
891 assert(pg_offset + 4 * nw <= chip->
page_size);
899 assert(pg_offset + 4 * nw <= chip->
page_size);
913 if (manual_wp || pg_offset + 4 * nw < chip->
page_size) {
923 LOG_ERROR(
"%s: write failed at address 0x%08" PRIx32, __func__, address);
942 " invalid bank address (try 0x%08" PRIx32
943 "[at91samd series] )",
949 chip = calloc(1,
sizeof(*chip));
951 LOG_ERROR(
"No memory for flash bank chip info");
958 bank->driver_priv = chip;
1032 for (code = 0; code <= 6; code++) {
1033 if (val == (2 << (13 - code)))
1039 "datasheet for a list valid sizes.");
1049 uint32_t
size = ((val >> 4) & 0x7);
1056 (2 << (13 -
size)));
1085 LOG_ERROR(
"Couldn't determine the mask for reserved bits.");
1110 LOG_ERROR(
"NVMUSERROW could not be read.");
1130 LOG_ERROR(
"Couldn't determine Flash page size");
1142 for (code = 0; code <= 6; code++) {
1143 if ((
unsigned int)val == (2UL << (8UL - code)) * page_size)
1149 "see datasheet for a list valid sizes.");
1160 uint32_t
size = (val & 0x7);
1166 nb = (2 << (8 -
size)) * page_size;
1169 command_print(
CMD,
"Bootloader size is %" PRIu32
" bytes (%" PRIu32
" rows)",
1170 nb, (uint32_t)(nb / (page_size * 4)));
1217 .
name =
"dsu_reset_deassert",
1218 .handler = samd_handle_reset_deassert,
1220 .help =
"Deassert internal reset held by DSU.",
1224 .name =
"chip-erase",
1225 .handler = samd_handle_chip_erase_command,
1227 .help =
"Erase the entire Flash by using the Chip-"
1228 "Erase feature in the Device Service Unit (DSU).",
1232 .name =
"set-security",
1233 .handler = samd_handle_set_security_command,
1235 .help =
"Secure the chip's Flash by setting the Security Bit. "
1236 "This makes it impossible to read the Flash contents. "
1237 "The only way to undo this is to issue the chip-erase "
1239 .usage =
"'enable'",
1243 .usage =
"[size_in_bytes]",
1244 .handler = samd_handle_eeprom_command,
1246 .help =
"Show or set the EEPROM size setting, stored in the User Row. "
1247 "Please see Table 20-3 of the SAMD20 datasheet for allowed values. "
1248 "Changes are stored immediately but take affect after the MCU is "
1252 .name =
"bootloader",
1253 .usage =
"[size_in_bytes]",
1254 .handler = samd_handle_bootloader_command,
1256 .help =
"Show or set the bootloader size, stored in the User Row. "
1257 "Please see Table 20-2 of the SAMD20 datasheet for allowed values. "
1258 "Changes are stored immediately but take affect after the MCU is "
1262 .name =
"nvmuserrow",
1263 .usage =
"[value] [mask]",
1264 .handler = samd_handle_nvmuserrow_command,
1266 .help =
"Show or set the nvmuserrow register. It is 64 bit wide "
1267 "and located at address 0x804000. Use the optional mask argument "
1268 "to prevent changes at positions where the bitvalue is zero. "
1269 "For security reasons the lock- and reserved-bits are masked out "
1270 "in background and therefore cannot be changed.",
1279 .help =
"at91samd flash command group",
1289 .flash_bank_command = samd_flash_bank_command,
static struct aice_port_param_s param
static const struct samd_part samd21_parts[]
#define SAMD_NVMCTRL_CTRLB
const struct flash_driver at91samd_flash
#define SAMD_GET_SERIES(id)
#define NVMUSERROW_LOCKBIT_MASK
#define SAMD_NVMCTRL_CTRLA
static const struct samd_part samd20_parts[]
static int samd_get_flash_page_info(struct target *target, uint32_t *sizep, int *nump)
static const struct samd_family * samd_find_family(uint32_t id)
Gives the family structure to specific device id.
#define SAMD_NUM_PROT_BLOCKS
COMMAND_HANDLER(samd_handle_chip_erase_command)
static int samd_probe(struct flash_bank *bank)
FLASH_BANK_COMMAND_HANDLER(samd_flash_bank_command)
#define SAMD_GET_DEVSEL(id)
#define SAMD_GET_FAMILY(id)
static int samd_protect_check(struct flash_bank *bank)
static int samd_modify_user_row_masked(struct target *target, uint64_t value_input, uint64_t value_mask)
Modify the contents of the User Row in Flash.
#define SAMD_NVMCTRL_LOCK
#define SAMD_GET_PROCESSOR(id)
static int samd_check_error(struct target *target)
static const struct command_registration at91samd_exec_command_handlers[]
#define SAMD_NVM_INTFLAG_READY
#define SAMD_PROCESSOR_M0
#define SAMD_DSU_CTRL_EXT
static const struct command_registration at91samd_command_handlers[]
static int samd_protect(struct flash_bank *bank, int set, unsigned int first, unsigned int last)
static const struct samd_part samd11_parts[]
#define SAMD_NVMCTRL_PARAM
#define SAMD_NVMCTRL_STATUS
#define SAMD_PAGE_SIZE_MAX
static const struct samd_part samd09_parts[]
static const struct samd_part saml22_parts[]
static int samd_issue_nvmctrl_command(struct target *target, uint16_t cmd)
static int samd_modify_user_row(struct target *target, uint64_t value, uint8_t startb, uint8_t endb)
Modifies the user row register to the given value.
static int read_userrow(struct target *target, uint64_t *userrow)
#define SAMD_NVMCTRL_INTFLAG
static const struct samd_part samd10_parts[]
static int samd_erase(struct flash_bank *bank, unsigned int first, unsigned int last)
#define SAMD_NVMCTRL_ADDR
static int samd_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
static const struct samd_part * samd_find_part(uint32_t id)
Gives the part structure to specific device id.
static const struct samd_family samd_families[]
static const struct samd_part saml21_parts[]
#define SAMD_NVM_CTRLB_MANW
static const struct samd_part samc20_parts[]
static const struct samd_part samc21_parts[]
static int samd_erase_row(struct target *target, uint32_t address)
Erases a flash-row at the given address.
static int samd_get_reservedmask(struct target *target, uint64_t *mask)
Returns the bitmask of reserved bits in register.
Support functions to access arbitrary bits in a byte array.
void command_print(struct command_invocation *cmd, const char *format,...)
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
#define ERROR_COMMAND_SYNTAX_ERROR
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
#define ERROR_FLASH_OPER_UNSUPPORTED
#define ERROR_FLASH_PROTECTED
#define ERROR_FLASH_BANK_NOT_PROBED
#define ERROR_FLASH_OPERATION_FAILED
struct flash_sector * alloc_block_array(uint32_t offset, uint32_t size, unsigned int num_blocks)
Allocate and fill an array of sectors or protection blocks.
int default_flash_blank_check(struct flash_bank *bank)
Provides default erased-bank check handling.
int default_flash_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
Provides default read implementation for flash memory.
void default_flash_free_driver_priv(struct flash_bank *bank)
Deallocates bank->driver_priv.
static enum reset_types jtag_reset_config
enum reset_types jtag_get_reset_config(void)
The JTAG interface can be implemented with a software or hardware fifo.
#define LOG_WARNING(expr ...)
#define LOG_ERROR(expr ...)
#define LOG_INFO(expr ...)
size_t size
Size of the control block search area.
char id[RTT_CB_MAX_ID_LENGTH]
Control block identifier.
Provides details of a flash bank, available either on-chip or through a major interface.
Provides the implementation-independent structure that defines all of the callbacks required by OpenO...
const char * name
Gives a human-readable name of this flash driver, This field is used to select and initialize the dri...
const struct samd_part * parts
uint64_t nvm_userrow_res_mask
uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer)
int target_write_u8(struct target *target, target_addr_t address, uint8_t value)
int target_write_u16(struct target *target, target_addr_t address, uint16_t value)
int target_read_u8(struct target *target, target_addr_t address, uint8_t *value)
int target_write_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, const uint8_t *buffer)
Write count items of size bytes to the memory of target at the address given.
int target_write_u32(struct target *target, target_addr_t address, uint32_t value)
int target_examine_one(struct target *target)
Examine the specified target, letting it perform any Initialisation that requires JTAG access.
int target_poll(struct target *target)
int target_read_u16(struct target *target, target_addr_t address, uint16_t *value)
void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
int target_read_u32(struct target *target, target_addr_t address, uint32_t *value)
int target_read_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Read count items of size bytes from the memory of target at the address given.
struct target * get_current_target(struct command_context *cmd_ctx)
#define ERROR_TARGET_NOT_HALTED
static bool target_was_examined(struct target *target)
#define ARRAY_SIZE(x)
Compute the number of elements of a variable length array.