target/adi_v5_swd: add "usage" field to command "swd"
[openocd.git] / src / flash / nor / at91samd.c
1 /***************************************************************************
2 * Copyright (C) 2013 by Andrey Yurovsky *
3 * Andrey Yurovsky <yurovsky@gmail.com> *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
18
19 #ifdef HAVE_CONFIG_H
20 #include "config.h"
21 #endif
22
23 #include "imp.h"
24 #include "helper/binarybuffer.h"
25
26 #include <target/cortex_m.h>
27
28 #define SAMD_NUM_PROT_BLOCKS 16
29 #define SAMD_PAGE_SIZE_MAX 1024
30
31 #define SAMD_FLASH ((uint32_t)0x00000000) /* physical Flash memory */
32 #define SAMD_USER_ROW ((uint32_t)0x00804000) /* User Row of Flash */
33 #define SAMD_PAC1 0x41000000 /* Peripheral Access Control 1 */
34 #define SAMD_DSU 0x41002000 /* Device Service Unit */
35 #define SAMD_NVMCTRL 0x41004000 /* Non-volatile memory controller */
36
37 #define SAMD_DSU_STATUSA 1 /* DSU status register */
38 #define SAMD_DSU_DID 0x18 /* Device ID register */
39 #define SAMD_DSU_CTRL_EXT 0x100 /* CTRL register, external access */
40
41 #define SAMD_NVMCTRL_CTRLA 0x00 /* NVM control A register */
42 #define SAMD_NVMCTRL_CTRLB 0x04 /* NVM control B register */
43 #define SAMD_NVMCTRL_PARAM 0x08 /* NVM parameters register */
44 #define SAMD_NVMCTRL_INTFLAG 0x18 /* NVM Interupt Flag Status & Clear */
45 #define SAMD_NVMCTRL_STATUS 0x18 /* NVM status register */
46 #define SAMD_NVMCTRL_ADDR 0x1C /* NVM address register */
47 #define SAMD_NVMCTRL_LOCK 0x20 /* NVM Lock section register */
48
49 #define SAMD_CMDEX_KEY 0xA5UL
50 #define SAMD_NVM_CMD(n) ((SAMD_CMDEX_KEY << 8) | (n & 0x7F))
51
52 /* NVMCTRL commands. See Table 20-4 in 42129F–SAM–10/2013 */
53 #define SAMD_NVM_CMD_ER 0x02 /* Erase Row */
54 #define SAMD_NVM_CMD_WP 0x04 /* Write Page */
55 #define SAMD_NVM_CMD_EAR 0x05 /* Erase Auxilary Row */
56 #define SAMD_NVM_CMD_WAP 0x06 /* Write Auxilary Page */
57 #define SAMD_NVM_CMD_LR 0x40 /* Lock Region */
58 #define SAMD_NVM_CMD_UR 0x41 /* Unlock Region */
59 #define SAMD_NVM_CMD_SPRM 0x42 /* Set Power Reduction Mode */
60 #define SAMD_NVM_CMD_CPRM 0x43 /* Clear Power Reduction Mode */
61 #define SAMD_NVM_CMD_PBC 0x44 /* Page Buffer Clear */
62 #define SAMD_NVM_CMD_SSB 0x45 /* Set Security Bit */
63 #define SAMD_NVM_CMD_INVALL 0x46 /* Invalidate all caches */
64
65 /* NVMCTRL bits */
66 #define SAMD_NVM_CTRLB_MANW 0x80
67
68 /* Known identifiers */
69 #define SAMD_PROCESSOR_M0 0x01
70 #define SAMD_FAMILY_D 0x00
71 #define SAMD_FAMILY_L 0x01
72 #define SAMD_FAMILY_C 0x02
73 #define SAMD_SERIES_20 0x00
74 #define SAMD_SERIES_21 0x01
75 #define SAMD_SERIES_22 0x02
76 #define SAMD_SERIES_10 0x02
77 #define SAMD_SERIES_11 0x03
78 #define SAMD_SERIES_09 0x04
79
80 /* Device ID macros */
81 #define SAMD_GET_PROCESSOR(id) (id >> 28)
82 #define SAMD_GET_FAMILY(id) (((id >> 23) & 0x1F))
83 #define SAMD_GET_SERIES(id) (((id >> 16) & 0x3F))
84 #define SAMD_GET_DEVSEL(id) (id & 0xFF)
85
86 /* Bits to mask out lockbits in user row */
87 #define NVMUSERROW_LOCKBIT_MASK ((uint64_t)0x0000FFFFFFFFFFFF)
88
89 struct samd_part {
90 uint8_t id;
91 const char *name;
92 uint32_t flash_kb;
93 uint32_t ram_kb;
94 };
95
96 /* Known SAMD09 parts. DID reset values missing in RM, see
97 * https://github.com/avrxml/asf/blob/master/sam0/utils/cmsis/samd09/include/ */
98 static const struct samd_part samd09_parts[] = {
99 { 0x0, "SAMD09D14A", 16, 4 },
100 { 0x7, "SAMD09C13A", 8, 4 },
101 };
102
103 /* Known SAMD10 parts */
104 static const struct samd_part samd10_parts[] = {
105 { 0x0, "SAMD10D14AMU", 16, 4 },
106 { 0x1, "SAMD10D13AMU", 8, 4 },
107 { 0x2, "SAMD10D12AMU", 4, 4 },
108 { 0x3, "SAMD10D14ASU", 16, 4 },
109 { 0x4, "SAMD10D13ASU", 8, 4 },
110 { 0x5, "SAMD10D12ASU", 4, 4 },
111 { 0x6, "SAMD10C14A", 16, 4 },
112 { 0x7, "SAMD10C13A", 8, 4 },
113 { 0x8, "SAMD10C12A", 4, 4 },
114 };
115
116 /* Known SAMD11 parts */
117 static const struct samd_part samd11_parts[] = {
118 { 0x0, "SAMD11D14AM", 16, 4 },
119 { 0x1, "SAMD11D13AMU", 8, 4 },
120 { 0x2, "SAMD11D12AMU", 4, 4 },
121 { 0x3, "SAMD11D14ASS", 16, 4 },
122 { 0x4, "SAMD11D13ASU", 8, 4 },
123 { 0x5, "SAMD11D12ASU", 4, 4 },
124 { 0x6, "SAMD11C14A", 16, 4 },
125 { 0x7, "SAMD11C13A", 8, 4 },
126 { 0x8, "SAMD11C12A", 4, 4 },
127 { 0x9, "SAMD11D14AU", 16, 4 },
128 };
129
130 /* Known SAMD20 parts. See Table 12-8 in 42129F–SAM–10/2013 */
131 static const struct samd_part samd20_parts[] = {
132 { 0x0, "SAMD20J18A", 256, 32 },
133 { 0x1, "SAMD20J17A", 128, 16 },
134 { 0x2, "SAMD20J16A", 64, 8 },
135 { 0x3, "SAMD20J15A", 32, 4 },
136 { 0x4, "SAMD20J14A", 16, 2 },
137 { 0x5, "SAMD20G18A", 256, 32 },
138 { 0x6, "SAMD20G17A", 128, 16 },
139 { 0x7, "SAMD20G16A", 64, 8 },
140 { 0x8, "SAMD20G15A", 32, 4 },
141 { 0x9, "SAMD20G14A", 16, 2 },
142 { 0xA, "SAMD20E18A", 256, 32 },
143 { 0xB, "SAMD20E17A", 128, 16 },
144 { 0xC, "SAMD20E16A", 64, 8 },
145 { 0xD, "SAMD20E15A", 32, 4 },
146 { 0xE, "SAMD20E14A", 16, 2 },
147 };
148
149 /* Known SAMD21 parts. */
150 static const struct samd_part samd21_parts[] = {
151 { 0x0, "SAMD21J18A", 256, 32 },
152 { 0x1, "SAMD21J17A", 128, 16 },
153 { 0x2, "SAMD21J16A", 64, 8 },
154 { 0x3, "SAMD21J15A", 32, 4 },
155 { 0x4, "SAMD21J14A", 16, 2 },
156 { 0x5, "SAMD21G18A", 256, 32 },
157 { 0x6, "SAMD21G17A", 128, 16 },
158 { 0x7, "SAMD21G16A", 64, 8 },
159 { 0x8, "SAMD21G15A", 32, 4 },
160 { 0x9, "SAMD21G14A", 16, 2 },
161 { 0xA, "SAMD21E18A", 256, 32 },
162 { 0xB, "SAMD21E17A", 128, 16 },
163 { 0xC, "SAMD21E16A", 64, 8 },
164 { 0xD, "SAMD21E15A", 32, 4 },
165 { 0xE, "SAMD21E14A", 16, 2 },
166
167 /* SAMR21 parts have integrated SAMD21 with a radio */
168 { 0x18, "SAMR21G19A", 256, 32 }, /* with 512k of serial flash */
169 { 0x19, "SAMR21G18A", 256, 32 },
170 { 0x1A, "SAMR21G17A", 128, 32 },
171 { 0x1B, "SAMR21G16A", 64, 16 },
172 { 0x1C, "SAMR21E18A", 256, 32 },
173 { 0x1D, "SAMR21E17A", 128, 32 },
174 { 0x1E, "SAMR21E16A", 64, 16 },
175
176 /* SAMD21 B Variants (Table 3-7 from rev I of datasheet) */
177 { 0x20, "SAMD21J16B", 64, 8 },
178 { 0x21, "SAMD21J15B", 32, 4 },
179 { 0x23, "SAMD21G16B", 64, 8 },
180 { 0x24, "SAMD21G15B", 32, 4 },
181 { 0x26, "SAMD21E16B", 64, 8 },
182 { 0x27, "SAMD21E15B", 32, 4 },
183
184 /* Known SAMDA1 parts.
185 SAMD-A1 series uses the same series identifier like the SAMD21
186 taken from http://ww1.microchip.com/downloads/en/DeviceDoc/40001895A.pdf (pages 14-17) */
187 { 0x29, "SAMDA1J16A", 64, 8 },
188 { 0x2A, "SAMDA1J15A", 32, 4 },
189 { 0x2B, "SAMDA1J14A", 16, 4 },
190 { 0x2C, "SAMDA1G16A", 64, 8 },
191 { 0x2D, "SAMDA1G15A", 32, 4 },
192 { 0x2E, "SAMDA1G14A", 16, 4 },
193 { 0x2F, "SAMDA1E16A", 64, 8 },
194 { 0x30, "SAMDA1E15A", 32, 4 },
195 { 0x31, "SAMDA1E14A", 16, 4 },
196 { 0x64, "SAMDA1J16B", 64, 8 },
197 { 0x65, "SAMDA1J15B", 32, 4 },
198 { 0x66, "SAMDA1J14B", 16, 4 },
199 { 0x67, "SAMDA1G16B", 64, 8 },
200 { 0x68, "SAMDA1G15B", 32, 4 },
201 { 0x69, "SAMDA1G14B", 16, 4 },
202 { 0x6A, "SAMDA1E16B", 64, 8 },
203 { 0x6B, "SAMDA1E15B", 32, 4 },
204 { 0x6C, "SAMDA1E14B", 16, 4 },
205 };
206
207 /* Known SAML21 parts. */
208 static const struct samd_part saml21_parts[] = {
209 { 0x00, "SAML21J18A", 256, 32 },
210 { 0x01, "SAML21J17A", 128, 16 },
211 { 0x02, "SAML21J16A", 64, 8 },
212 { 0x05, "SAML21G18A", 256, 32 },
213 { 0x06, "SAML21G17A", 128, 16 },
214 { 0x07, "SAML21G16A", 64, 8 },
215 { 0x0A, "SAML21E18A", 256, 32 },
216 { 0x0B, "SAML21E17A", 128, 16 },
217 { 0x0C, "SAML21E16A", 64, 8 },
218 { 0x0D, "SAML21E15A", 32, 4 },
219 { 0x0F, "SAML21J18B", 256, 32 },
220 { 0x10, "SAML21J17B", 128, 16 },
221 { 0x11, "SAML21J16B", 64, 8 },
222 { 0x14, "SAML21G18B", 256, 32 },
223 { 0x15, "SAML21G17B", 128, 16 },
224 { 0x16, "SAML21G16B", 64, 8 },
225 { 0x19, "SAML21E18B", 256, 32 },
226 { 0x1A, "SAML21E17B", 128, 16 },
227 { 0x1B, "SAML21E16B", 64, 8 },
228 { 0x1C, "SAML21E15B", 32, 4 },
229
230 /* SAMR30 parts have integrated SAML21 with a radio */
231 { 0x1E, "SAMR30G18A", 256, 32 },
232 { 0x1F, "SAMR30E18A", 256, 32 },
233
234 /* SAMR34/R35 parts have integrated SAML21 with a lora radio */
235 { 0x28, "SAMR34J18", 256, 32 },
236 };
237
238 /* Known SAML22 parts. */
239 static const struct samd_part saml22_parts[] = {
240 { 0x00, "SAML22N18A", 256, 32 },
241 { 0x01, "SAML22N17A", 128, 16 },
242 { 0x02, "SAML22N16A", 64, 8 },
243 { 0x05, "SAML22J18A", 256, 32 },
244 { 0x06, "SAML22J17A", 128, 16 },
245 { 0x07, "SAML22J16A", 64, 8 },
246 { 0x0A, "SAML22G18A", 256, 32 },
247 { 0x0B, "SAML22G17A", 128, 16 },
248 { 0x0C, "SAML22G16A", 64, 8 },
249 };
250
251 /* Known SAMC20 parts. */
252 static const struct samd_part samc20_parts[] = {
253 { 0x00, "SAMC20J18A", 256, 32 },
254 { 0x01, "SAMC20J17A", 128, 16 },
255 { 0x02, "SAMC20J16A", 64, 8 },
256 { 0x03, "SAMC20J15A", 32, 4 },
257 { 0x05, "SAMC20G18A", 256, 32 },
258 { 0x06, "SAMC20G17A", 128, 16 },
259 { 0x07, "SAMC20G16A", 64, 8 },
260 { 0x08, "SAMC20G15A", 32, 4 },
261 { 0x0A, "SAMC20E18A", 256, 32 },
262 { 0x0B, "SAMC20E17A", 128, 16 },
263 { 0x0C, "SAMC20E16A", 64, 8 },
264 { 0x0D, "SAMC20E15A", 32, 4 },
265 { 0x20, "SAMC20N18A", 256, 32 },
266 { 0x21, "SAMC20N17A", 128, 16 },
267 };
268
269 /* Known SAMC21 parts. */
270 static const struct samd_part samc21_parts[] = {
271 { 0x00, "SAMC21J18A", 256, 32 },
272 { 0x01, "SAMC21J17A", 128, 16 },
273 { 0x02, "SAMC21J16A", 64, 8 },
274 { 0x03, "SAMC21J15A", 32, 4 },
275 { 0x05, "SAMC21G18A", 256, 32 },
276 { 0x06, "SAMC21G17A", 128, 16 },
277 { 0x07, "SAMC21G16A", 64, 8 },
278 { 0x08, "SAMC21G15A", 32, 4 },
279 { 0x0A, "SAMC21E18A", 256, 32 },
280 { 0x0B, "SAMC21E17A", 128, 16 },
281 { 0x0C, "SAMC21E16A", 64, 8 },
282 { 0x0D, "SAMC21E15A", 32, 4 },
283 { 0x20, "SAMC21N18A", 256, 32 },
284 { 0x21, "SAMC21N17A", 128, 16 },
285 };
286
287 /* Each family of parts contains a parts table in the DEVSEL field of DID. The
288 * processor ID, family ID, and series ID are used to determine which exact
289 * family this is and then we can use the corresponding table. */
290 struct samd_family {
291 uint8_t processor;
292 uint8_t family;
293 uint8_t series;
294 const struct samd_part *parts;
295 size_t num_parts;
296 uint64_t nvm_userrow_res_mask; /* protect bits which are reserved, 0 -> protect */
297 };
298
299 /* Known SAMD families */
300 static const struct samd_family samd_families[] = {
301 { SAMD_PROCESSOR_M0, SAMD_FAMILY_D, SAMD_SERIES_20,
302 samd20_parts, ARRAY_SIZE(samd20_parts),
303 (uint64_t)0xFFFF01FFFE01FF77 },
304 { SAMD_PROCESSOR_M0, SAMD_FAMILY_D, SAMD_SERIES_21,
305 samd21_parts, ARRAY_SIZE(samd21_parts),
306 (uint64_t)0xFFFF01FFFE01FF77 },
307 { SAMD_PROCESSOR_M0, SAMD_FAMILY_D, SAMD_SERIES_09,
308 samd09_parts, ARRAY_SIZE(samd09_parts),
309 (uint64_t)0xFFFF01FFFE01FF77 },
310 { SAMD_PROCESSOR_M0, SAMD_FAMILY_D, SAMD_SERIES_10,
311 samd10_parts, ARRAY_SIZE(samd10_parts),
312 (uint64_t)0xFFFF01FFFE01FF77 },
313 { SAMD_PROCESSOR_M0, SAMD_FAMILY_D, SAMD_SERIES_11,
314 samd11_parts, ARRAY_SIZE(samd11_parts),
315 (uint64_t)0xFFFF01FFFE01FF77 },
316 { SAMD_PROCESSOR_M0, SAMD_FAMILY_L, SAMD_SERIES_21,
317 saml21_parts, ARRAY_SIZE(saml21_parts),
318 (uint64_t)0xFFFF03FFFC01FF77 },
319 { SAMD_PROCESSOR_M0, SAMD_FAMILY_L, SAMD_SERIES_22,
320 saml22_parts, ARRAY_SIZE(saml22_parts),
321 (uint64_t)0xFFFF03FFFC01FF77 },
322 { SAMD_PROCESSOR_M0, SAMD_FAMILY_C, SAMD_SERIES_20,
323 samc20_parts, ARRAY_SIZE(samc20_parts),
324 (uint64_t)0xFFFF03FFFC01FF77 },
325 { SAMD_PROCESSOR_M0, SAMD_FAMILY_C, SAMD_SERIES_21,
326 samc21_parts, ARRAY_SIZE(samc21_parts),
327 (uint64_t)0xFFFF03FFFC01FF77 },
328 };
329
330 struct samd_info {
331 uint32_t page_size;
332 int num_pages;
333 int sector_size;
334 int prot_block_size;
335
336 bool probed;
337 struct target *target;
338 };
339
340
341 /**
342 * Gives the family structure to specific device id.
343 * @param id The id of the device.
344 * @return On failure NULL, otherwise a pointer to the structure.
345 */
346 static const struct samd_family *samd_find_family(uint32_t id)
347 {
348 uint8_t processor = SAMD_GET_PROCESSOR(id);
349 uint8_t family = SAMD_GET_FAMILY(id);
350 uint8_t series = SAMD_GET_SERIES(id);
351
352 for (unsigned i = 0; i < ARRAY_SIZE(samd_families); i++) {
353 if (samd_families[i].processor == processor &&
354 samd_families[i].series == series &&
355 samd_families[i].family == family)
356 return &samd_families[i];
357 }
358
359 return NULL;
360 }
361
362 /**
363 * Gives the part structure to specific device id.
364 * @param id The id of the device.
365 * @return On failure NULL, otherwise a pointer to the structure.
366 */
367 static const struct samd_part *samd_find_part(uint32_t id)
368 {
369 uint8_t devsel = SAMD_GET_DEVSEL(id);
370 const struct samd_family *family = samd_find_family(id);
371 if (family == NULL)
372 return NULL;
373
374 for (unsigned i = 0; i < family->num_parts; i++) {
375 if (family->parts[i].id == devsel)
376 return &family->parts[i];
377 }
378
379 return NULL;
380 }
381
382 static int samd_protect_check(struct flash_bank *bank)
383 {
384 int res, prot_block;
385 uint16_t lock;
386
387 res = target_read_u16(bank->target,
388 SAMD_NVMCTRL + SAMD_NVMCTRL_LOCK, &lock);
389 if (res != ERROR_OK)
390 return res;
391
392 /* Lock bits are active-low */
393 for (prot_block = 0; prot_block < bank->num_prot_blocks; prot_block++)
394 bank->prot_blocks[prot_block].is_protected = !(lock & (1u<<prot_block));
395
396 return ERROR_OK;
397 }
398
399 static int samd_get_flash_page_info(struct target *target,
400 uint32_t *sizep, int *nump)
401 {
402 int res;
403 uint32_t param;
404
405 res = target_read_u32(target, SAMD_NVMCTRL + SAMD_NVMCTRL_PARAM, &param);
406 if (res == ERROR_OK) {
407 /* The PSZ field (bits 18:16) indicate the page size bytes as 2^(3+n)
408 * so 0 is 8KB and 7 is 1024KB. */
409 if (sizep)
410 *sizep = (8 << ((param >> 16) & 0x7));
411 /* The NVMP field (bits 15:0) indicates the total number of pages */
412 if (nump)
413 *nump = param & 0xFFFF;
414 } else {
415 LOG_ERROR("Couldn't read NVM Parameters register");
416 }
417
418 return res;
419 }
420
421 static int samd_probe(struct flash_bank *bank)
422 {
423 uint32_t id;
424 int res;
425 struct samd_info *chip = (struct samd_info *)bank->driver_priv;
426 const struct samd_part *part;
427
428 if (chip->probed)
429 return ERROR_OK;
430
431 res = target_read_u32(bank->target, SAMD_DSU + SAMD_DSU_DID, &id);
432 if (res != ERROR_OK) {
433 LOG_ERROR("Couldn't read Device ID register");
434 return res;
435 }
436
437 part = samd_find_part(id);
438 if (part == NULL) {
439 LOG_ERROR("Couldn't find part corresponding to DID %08" PRIx32, id);
440 return ERROR_FAIL;
441 }
442
443 bank->size = part->flash_kb * 1024;
444
445 res = samd_get_flash_page_info(bank->target, &chip->page_size,
446 &chip->num_pages);
447 if (res != ERROR_OK) {
448 LOG_ERROR("Couldn't determine Flash page size");
449 return res;
450 }
451
452 /* Sanity check: the total flash size in the DSU should match the page size
453 * multiplied by the number of pages. */
454 if (bank->size != chip->num_pages * chip->page_size) {
455 LOG_WARNING("SAMD: bank size doesn't match NVM parameters. "
456 "Identified %" PRIu32 "KB Flash but NVMCTRL reports %u %" PRIu32 "B pages",
457 part->flash_kb, chip->num_pages, chip->page_size);
458 }
459
460 /* Erase granularity = 1 row = 4 pages */
461 chip->sector_size = chip->page_size * 4;
462
463 /* Allocate the sector table */
464 bank->num_sectors = chip->num_pages / 4;
465 bank->sectors = alloc_block_array(0, chip->sector_size, bank->num_sectors);
466 if (!bank->sectors)
467 return ERROR_FAIL;
468
469 /* 16 protection blocks per device */
470 chip->prot_block_size = bank->size / SAMD_NUM_PROT_BLOCKS;
471
472 /* Allocate the table of protection blocks */
473 bank->num_prot_blocks = SAMD_NUM_PROT_BLOCKS;
474 bank->prot_blocks = alloc_block_array(0, chip->prot_block_size, bank->num_prot_blocks);
475 if (!bank->prot_blocks)
476 return ERROR_FAIL;
477
478 samd_protect_check(bank);
479
480 /* Done */
481 chip->probed = true;
482
483 LOG_INFO("SAMD MCU: %s (%" PRIu32 "KB Flash, %" PRIu32 "KB RAM)", part->name,
484 part->flash_kb, part->ram_kb);
485
486 return ERROR_OK;
487 }
488
489 static int samd_check_error(struct target *target)
490 {
491 int ret, ret2;
492 uint16_t status;
493
494 ret = target_read_u16(target,
495 SAMD_NVMCTRL + SAMD_NVMCTRL_STATUS, &status);
496 if (ret != ERROR_OK) {
497 LOG_ERROR("Can't read NVM status");
498 return ret;
499 }
500
501 if ((status & 0x001C) == 0)
502 return ERROR_OK;
503
504 if (status & (1 << 4)) { /* NVME */
505 LOG_ERROR("SAMD: NVM Error");
506 ret = ERROR_FLASH_OPERATION_FAILED;
507 }
508
509 if (status & (1 << 3)) { /* LOCKE */
510 LOG_ERROR("SAMD: NVM lock error");
511 ret = ERROR_FLASH_PROTECTED;
512 }
513
514 if (status & (1 << 2)) { /* PROGE */
515 LOG_ERROR("SAMD: NVM programming error");
516 ret = ERROR_FLASH_OPER_UNSUPPORTED;
517 }
518
519 /* Clear the error conditions by writing a one to them */
520 ret2 = target_write_u16(target,
521 SAMD_NVMCTRL + SAMD_NVMCTRL_STATUS, status);
522 if (ret2 != ERROR_OK)
523 LOG_ERROR("Can't clear NVM error conditions");
524
525 return ret;
526 }
527
528 static int samd_issue_nvmctrl_command(struct target *target, uint16_t cmd)
529 {
530 int res;
531
532 if (target->state != TARGET_HALTED) {
533 LOG_ERROR("Target not halted");
534 return ERROR_TARGET_NOT_HALTED;
535 }
536
537 /* Issue the NVM command */
538 res = target_write_u16(target,
539 SAMD_NVMCTRL + SAMD_NVMCTRL_CTRLA, SAMD_NVM_CMD(cmd));
540 if (res != ERROR_OK)
541 return res;
542
543 /* Check to see if the NVM command resulted in an error condition. */
544 return samd_check_error(target);
545 }
546
547 /**
548 * Erases a flash-row at the given address.
549 * @param target Pointer to the target structure.
550 * @param address The address of the row.
551 * @return On success ERROR_OK, on failure an errorcode.
552 */
553 static int samd_erase_row(struct target *target, uint32_t address)
554 {
555 int res;
556
557 /* Set an address contained in the row to be erased */
558 res = target_write_u32(target,
559 SAMD_NVMCTRL + SAMD_NVMCTRL_ADDR, address >> 1);
560
561 /* Issue the Erase Row command to erase that row. */
562 if (res == ERROR_OK)
563 res = samd_issue_nvmctrl_command(target,
564 address == SAMD_USER_ROW ? SAMD_NVM_CMD_EAR : SAMD_NVM_CMD_ER);
565
566 if (res != ERROR_OK) {
567 LOG_ERROR("Failed to erase row containing %08" PRIx32, address);
568 return ERROR_FAIL;
569 }
570
571 return ERROR_OK;
572 }
573
574 /**
575 * Returns the bitmask of reserved bits in register.
576 * @param target Pointer to the target structure.
577 * @param mask Bitmask, 0 -> value stays untouched.
578 * @return On success ERROR_OK, on failure an errorcode.
579 */
580 static int samd_get_reservedmask(struct target *target, uint64_t *mask)
581 {
582 int res;
583 /* Get the devicetype */
584 uint32_t id;
585 res = target_read_u32(target, SAMD_DSU + SAMD_DSU_DID, &id);
586 if (res != ERROR_OK) {
587 LOG_ERROR("Couldn't read Device ID register");
588 return res;
589 }
590 const struct samd_family *family;
591 family = samd_find_family(id);
592 if (family == NULL) {
593 LOG_ERROR("Couldn't determine device family");
594 return ERROR_FAIL;
595 }
596 *mask = family->nvm_userrow_res_mask;
597 return ERROR_OK;
598 }
599
600 static int read_userrow(struct target *target, uint64_t *userrow)
601 {
602 int res;
603 uint8_t buffer[8];
604
605 res = target_read_memory(target, SAMD_USER_ROW, 4, 2, buffer);
606 if (res != ERROR_OK)
607 return res;
608
609 *userrow = target_buffer_get_u64(target, buffer);
610 return ERROR_OK;
611 }
612
613 /**
614 * Modify the contents of the User Row in Flash. The User Row itself
615 * has a size of one page and contains a combination of "fuses" and
616 * calibration data. Bits which have a value of zero in the mask will
617 * not be changed. Up to now devices only use the first 64 bits.
618 * @param target Pointer to the target structure.
619 * @param value_input The value to write.
620 * @param value_mask Bitmask, 0 -> value stays untouched.
621 * @return On success ERROR_OK, on failure an errorcode.
622 */
623 static int samd_modify_user_row_masked(struct target *target,
624 uint64_t value_input, uint64_t value_mask)
625 {
626 int res;
627 uint32_t nvm_ctrlb;
628 bool manual_wp = true;
629
630 /* Retrieve the MCU's page size, in bytes. This is also the size of the
631 * entire User Row. */
632 uint32_t page_size;
633 res = samd_get_flash_page_info(target, &page_size, NULL);
634 if (res != ERROR_OK) {
635 LOG_ERROR("Couldn't determine Flash page size");
636 return res;
637 }
638
639 /* Make sure the size is sane. */
640 assert(page_size <= SAMD_PAGE_SIZE_MAX &&
641 page_size >= sizeof(value_input));
642
643 uint8_t buf[SAMD_PAGE_SIZE_MAX];
644 /* Read the user row (comprising one page) by words. */
645 res = target_read_memory(target, SAMD_USER_ROW, 4, page_size / 4, buf);
646 if (res != ERROR_OK)
647 return res;
648
649 uint64_t value_device;
650 res = read_userrow(target, &value_device);
651 if (res != ERROR_OK)
652 return res;
653 uint64_t value_new = (value_input & value_mask) | (value_device & ~value_mask);
654
655 /* We will need to erase before writing if the new value needs a '1' in any
656 * position for which the current value had a '0'. Otherwise we can avoid
657 * erasing. */
658 if ((~value_device) & value_new) {
659 res = samd_erase_row(target, SAMD_USER_ROW);
660 if (res != ERROR_OK) {
661 LOG_ERROR("Couldn't erase user row");
662 return res;
663 }
664 }
665
666 /* Modify */
667 target_buffer_set_u64(target, buf, value_new);
668
669 /* Write the page buffer back out to the target. */
670 res = target_write_memory(target, SAMD_USER_ROW, 4, page_size / 4, buf);
671 if (res != ERROR_OK)
672 return res;
673
674 /* Check if we need to do manual page write commands */
675 res = target_read_u32(target, SAMD_NVMCTRL + SAMD_NVMCTRL_CTRLB, &nvm_ctrlb);
676 if (res == ERROR_OK)
677 manual_wp = (nvm_ctrlb & SAMD_NVM_CTRLB_MANW) != 0;
678 else {
679 LOG_ERROR("Read of NVM register CTRKB failed.");
680 return ERROR_FAIL;
681 }
682 if (manual_wp) {
683 /* Trigger flash write */
684 res = samd_issue_nvmctrl_command(target, SAMD_NVM_CMD_WAP);
685 } else {
686 res = samd_check_error(target);
687 }
688
689 return res;
690 }
691
692 /**
693 * Modifies the user row register to the given value.
694 * @param target Pointer to the target structure.
695 * @param value The value to write.
696 * @param startb The bit-offset by which the given value is shifted.
697 * @param endb The bit-offset of the last bit in value to write.
698 * @return On success ERROR_OK, on failure an errorcode.
699 */
700 static int samd_modify_user_row(struct target *target, uint64_t value,
701 uint8_t startb, uint8_t endb)
702 {
703 uint64_t mask = 0;
704 int i;
705 for (i = startb ; i <= endb ; i++)
706 mask |= ((uint64_t)1) << i;
707
708 return samd_modify_user_row_masked(target, value << startb, mask);
709 }
710
711 static int samd_protect(struct flash_bank *bank, int set, int first_prot_bl, int last_prot_bl)
712 {
713 int res = ERROR_OK;
714 int prot_block;
715
716 /* We can issue lock/unlock region commands with the target running but
717 * the settings won't persist unless we're able to modify the LOCK regions
718 * and that requires the target to be halted. */
719 if (bank->target->state != TARGET_HALTED) {
720 LOG_ERROR("Target not halted");
721 return ERROR_TARGET_NOT_HALTED;
722 }
723
724 for (prot_block = first_prot_bl; prot_block <= last_prot_bl; prot_block++) {
725 if (set != bank->prot_blocks[prot_block].is_protected) {
726 /* Load an address that is within this protection block (we use offset 0) */
727 res = target_write_u32(bank->target,
728 SAMD_NVMCTRL + SAMD_NVMCTRL_ADDR,
729 bank->prot_blocks[prot_block].offset >> 1);
730 if (res != ERROR_OK)
731 goto exit;
732
733 /* Tell the controller to lock that block */
734 res = samd_issue_nvmctrl_command(bank->target,
735 set ? SAMD_NVM_CMD_LR : SAMD_NVM_CMD_UR);
736 if (res != ERROR_OK)
737 goto exit;
738 }
739 }
740
741 /* We've now applied our changes, however they will be undone by the next
742 * reset unless we also apply them to the LOCK bits in the User Page. The
743 * LOCK bits start at bit 48, corresponding to Sector 0 and end with bit 63,
744 * corresponding to Sector 15. A '1' means unlocked and a '0' means
745 * locked. See Table 9-3 in the SAMD20 datasheet for more details. */
746
747 res = samd_modify_user_row(bank->target,
748 set ? (uint64_t)0 : (uint64_t)UINT64_MAX,
749 48 + first_prot_bl, 48 + last_prot_bl);
750 if (res != ERROR_OK)
751 LOG_WARNING("SAMD: protect settings were not made persistent!");
752
753 res = ERROR_OK;
754
755 exit:
756 samd_protect_check(bank);
757
758 return res;
759 }
760
761 static int samd_erase(struct flash_bank *bank, int first_sect, int last_sect)
762 {
763 int res, s;
764 struct samd_info *chip = (struct samd_info *)bank->driver_priv;
765
766 if (bank->target->state != TARGET_HALTED) {
767 LOG_ERROR("Target not halted");
768
769 return ERROR_TARGET_NOT_HALTED;
770 }
771
772 if (!chip->probed) {
773 if (samd_probe(bank) != ERROR_OK)
774 return ERROR_FLASH_BANK_NOT_PROBED;
775 }
776
777 /* For each sector to be erased */
778 for (s = first_sect; s <= last_sect; s++) {
779 res = samd_erase_row(bank->target, bank->sectors[s].offset);
780 if (res != ERROR_OK) {
781 LOG_ERROR("SAMD: failed to erase sector %d at 0x%08" PRIx32, s, bank->sectors[s].offset);
782 return res;
783 }
784 }
785
786 return ERROR_OK;
787 }
788
789
790 static int samd_write(struct flash_bank *bank, const uint8_t *buffer,
791 uint32_t offset, uint32_t count)
792 {
793 int res;
794 uint32_t nvm_ctrlb;
795 uint32_t address;
796 uint32_t pg_offset;
797 uint32_t nb;
798 uint32_t nw;
799 struct samd_info *chip = (struct samd_info *)bank->driver_priv;
800 uint8_t *pb = NULL;
801 bool manual_wp;
802
803 if (bank->target->state != TARGET_HALTED) {
804 LOG_ERROR("Target not halted");
805 return ERROR_TARGET_NOT_HALTED;
806 }
807
808 if (!chip->probed) {
809 if (samd_probe(bank) != ERROR_OK)
810 return ERROR_FLASH_BANK_NOT_PROBED;
811 }
812
813 /* Check if we need to do manual page write commands */
814 res = target_read_u32(bank->target, SAMD_NVMCTRL + SAMD_NVMCTRL_CTRLB, &nvm_ctrlb);
815
816 if (res != ERROR_OK)
817 return res;
818
819 if (nvm_ctrlb & SAMD_NVM_CTRLB_MANW)
820 manual_wp = true;
821 else
822 manual_wp = false;
823
824 res = samd_issue_nvmctrl_command(bank->target, SAMD_NVM_CMD_PBC);
825 if (res != ERROR_OK) {
826 LOG_ERROR("%s: %d", __func__, __LINE__);
827 return res;
828 }
829
830 while (count) {
831 nb = chip->page_size - offset % chip->page_size;
832 if (count < nb)
833 nb = count;
834
835 address = bank->base + offset;
836 pg_offset = offset % chip->page_size;
837
838 if (offset % 4 || (offset + nb) % 4) {
839 /* Either start or end of write is not word aligned */
840 if (!pb) {
841 pb = malloc(chip->page_size);
842 if (!pb)
843 return ERROR_FAIL;
844 }
845
846 /* Set temporary page buffer to 0xff and overwrite the relevant part */
847 memset(pb, 0xff, chip->page_size);
848 memcpy(pb + pg_offset, buffer, nb);
849
850 /* Align start address to a word boundary */
851 address -= offset % 4;
852 pg_offset -= offset % 4;
853 assert(pg_offset % 4 == 0);
854
855 /* Extend length to whole words */
856 nw = (nb + offset % 4 + 3) / 4;
857 assert(pg_offset + 4 * nw <= chip->page_size);
858
859 /* Now we have original data extended by 0xff bytes
860 * to the nearest word boundary on both start and end */
861 res = target_write_memory(bank->target, address, 4, nw, pb + pg_offset);
862 } else {
863 assert(nb % 4 == 0);
864 nw = nb / 4;
865 assert(pg_offset + 4 * nw <= chip->page_size);
866
867 /* Word aligned data, use direct write from buffer */
868 res = target_write_memory(bank->target, address, 4, nw, buffer);
869 }
870 if (res != ERROR_OK) {
871 LOG_ERROR("%s: %d", __func__, __LINE__);
872 goto free_pb;
873 }
874
875 /* Devices with errata 13134 have automatic page write enabled by default
876 * For other devices issue a write page CMD to the NVM
877 * If the page has not been written up to the last word
878 * then issue CMD_WP always */
879 if (manual_wp || pg_offset + 4 * nw < chip->page_size) {
880 res = samd_issue_nvmctrl_command(bank->target, SAMD_NVM_CMD_WP);
881 } else {
882 /* Access through AHB is stalled while flash is being programmed */
883 usleep(200);
884
885 res = samd_check_error(bank->target);
886 }
887
888 if (res != ERROR_OK) {
889 LOG_ERROR("%s: write failed at address 0x%08" PRIx32, __func__, address);
890 goto free_pb;
891 }
892
893 /* We're done with the page contents */
894 count -= nb;
895 offset += nb;
896 buffer += nb;
897 }
898
899 free_pb:
900 if (pb)
901 free(pb);
902
903 return res;
904 }
905
906 FLASH_BANK_COMMAND_HANDLER(samd_flash_bank_command)
907 {
908 if (bank->base != SAMD_FLASH) {
909 LOG_ERROR("Address " TARGET_ADDR_FMT
910 " invalid bank address (try 0x%08" PRIx32
911 "[at91samd series] )",
912 bank->base, SAMD_FLASH);
913 return ERROR_FAIL;
914 }
915
916 struct samd_info *chip;
917 chip = calloc(1, sizeof(*chip));
918 if (!chip) {
919 LOG_ERROR("No memory for flash bank chip info");
920 return ERROR_FAIL;
921 }
922
923 chip->target = bank->target;
924 chip->probed = false;
925
926 bank->driver_priv = chip;
927
928 return ERROR_OK;
929 }
930
931 COMMAND_HANDLER(samd_handle_info_command)
932 {
933 return ERROR_OK;
934 }
935
936 COMMAND_HANDLER(samd_handle_chip_erase_command)
937 {
938 struct target *target = get_current_target(CMD_CTX);
939 int res = ERROR_FAIL;
940
941 if (target) {
942 /* Enable access to the DSU by disabling the write protect bit */
943 target_write_u32(target, SAMD_PAC1, (1<<1));
944 /* intentionally without error checking - not accessible on secured chip */
945
946 /* Tell the DSU to perform a full chip erase. It takes about 240ms to
947 * perform the erase. */
948 res = target_write_u8(target, SAMD_DSU + SAMD_DSU_CTRL_EXT, (1<<4));
949 if (res == ERROR_OK)
950 command_print(CMD_CTX, "chip erase started");
951 else
952 command_print(CMD_CTX, "write to DSU CTRL failed");
953 }
954
955 return res;
956 }
957
958 COMMAND_HANDLER(samd_handle_set_security_command)
959 {
960 int res = ERROR_OK;
961 struct target *target = get_current_target(CMD_CTX);
962
963 if (CMD_ARGC < 1 || (CMD_ARGC >= 1 && (strcmp(CMD_ARGV[0], "enable")))) {
964 command_print(CMD_CTX, "supply the \"enable\" argument to proceed.");
965 return ERROR_COMMAND_SYNTAX_ERROR;
966 }
967
968 if (target) {
969 if (target->state != TARGET_HALTED) {
970 LOG_ERROR("Target not halted");
971 return ERROR_TARGET_NOT_HALTED;
972 }
973
974 res = samd_issue_nvmctrl_command(target, SAMD_NVM_CMD_SSB);
975
976 /* Check (and clear) error conditions */
977 if (res == ERROR_OK)
978 command_print(CMD_CTX, "chip secured on next power-cycle");
979 else
980 command_print(CMD_CTX, "failed to secure chip");
981 }
982
983 return res;
984 }
985
986 COMMAND_HANDLER(samd_handle_eeprom_command)
987 {
988 int res = ERROR_OK;
989 struct target *target = get_current_target(CMD_CTX);
990
991 if (target) {
992 if (target->state != TARGET_HALTED) {
993 LOG_ERROR("Target not halted");
994 return ERROR_TARGET_NOT_HALTED;
995 }
996
997 if (CMD_ARGC >= 1) {
998 int val = atoi(CMD_ARGV[0]);
999 uint32_t code;
1000
1001 if (val == 0)
1002 code = 7;
1003 else {
1004 /* Try to match size in bytes with corresponding size code */
1005 for (code = 0; code <= 6; code++) {
1006 if (val == (2 << (13 - code)))
1007 break;
1008 }
1009
1010 if (code > 6) {
1011 command_print(CMD_CTX, "Invalid EEPROM size. Please see "
1012 "datasheet for a list valid sizes.");
1013 return ERROR_COMMAND_SYNTAX_ERROR;
1014 }
1015 }
1016
1017 res = samd_modify_user_row(target, code, 4, 6);
1018 } else {
1019 uint16_t val;
1020 res = target_read_u16(target, SAMD_USER_ROW, &val);
1021 if (res == ERROR_OK) {
1022 uint32_t size = ((val >> 4) & 0x7); /* grab size code */
1023
1024 if (size == 0x7)
1025 command_print(CMD_CTX, "EEPROM is disabled");
1026 else {
1027 /* Otherwise, 6 is 256B, 0 is 16KB */
1028 command_print(CMD_CTX, "EEPROM size is %u bytes",
1029 (2 << (13 - size)));
1030 }
1031 }
1032 }
1033 }
1034
1035 return res;
1036 }
1037
1038 static COMMAND_HELPER(get_u64_from_hexarg, unsigned int num, uint64_t *value)
1039 {
1040 if (num >= CMD_ARGC) {
1041 command_print(CMD_CTX, "Too few Arguments.");
1042 return ERROR_COMMAND_SYNTAX_ERROR;
1043 }
1044
1045 if (strlen(CMD_ARGV[num]) >= 3 &&
1046 CMD_ARGV[num][0] == '0' &&
1047 CMD_ARGV[num][1] == 'x') {
1048 char *check = NULL;
1049 *value = strtoull(&(CMD_ARGV[num][2]), &check, 16);
1050 if ((value == 0 && errno == ERANGE) ||
1051 check == NULL || *check != 0) {
1052 command_print(CMD_CTX, "Invalid 64-bit hex value in argument %d.",
1053 num + 1);
1054 return ERROR_COMMAND_SYNTAX_ERROR;
1055 }
1056 } else {
1057 command_print(CMD_CTX, "Argument %d needs to be a hex value.", num + 1);
1058 return ERROR_COMMAND_SYNTAX_ERROR;
1059 }
1060 return ERROR_OK;
1061 }
1062
1063 COMMAND_HANDLER(samd_handle_nvmuserrow_command)
1064 {
1065 int res = ERROR_OK;
1066 struct target *target = get_current_target(CMD_CTX);
1067
1068 if (target) {
1069 if (CMD_ARGC > 2) {
1070 command_print(CMD_CTX, "Too much Arguments given.");
1071 return ERROR_COMMAND_SYNTAX_ERROR;
1072 }
1073
1074 if (CMD_ARGC > 0) {
1075 if (target->state != TARGET_HALTED) {
1076 LOG_ERROR("Target not halted.");
1077 return ERROR_TARGET_NOT_HALTED;
1078 }
1079
1080 uint64_t mask;
1081 res = samd_get_reservedmask(target, &mask);
1082 if (res != ERROR_OK) {
1083 LOG_ERROR("Couldn't determine the mask for reserved bits.");
1084 return ERROR_FAIL;
1085 }
1086 mask &= NVMUSERROW_LOCKBIT_MASK;
1087
1088 uint64_t value;
1089 res = CALL_COMMAND_HANDLER(get_u64_from_hexarg, 0, &value);
1090 if (res != ERROR_OK)
1091 return res;
1092 if (CMD_ARGC == 2) {
1093 uint64_t mask_temp;
1094 res = CALL_COMMAND_HANDLER(get_u64_from_hexarg, 1, &mask_temp);
1095 if (res != ERROR_OK)
1096 return res;
1097 mask &= mask_temp;
1098 }
1099 res = samd_modify_user_row_masked(target, value, mask);
1100 if (res != ERROR_OK)
1101 return res;
1102 }
1103
1104 /* read register */
1105 uint64_t value;
1106 res = read_userrow(target, &value);
1107 if (res == ERROR_OK)
1108 command_print(CMD_CTX, "NVMUSERROW: 0x%016"PRIX64, value);
1109 else
1110 LOG_ERROR("NVMUSERROW could not be read.");
1111 }
1112 return res;
1113 }
1114
1115 COMMAND_HANDLER(samd_handle_bootloader_command)
1116 {
1117 int res = ERROR_OK;
1118 struct target *target = get_current_target(CMD_CTX);
1119
1120 if (target) {
1121 if (target->state != TARGET_HALTED) {
1122 LOG_ERROR("Target not halted");
1123 return ERROR_TARGET_NOT_HALTED;
1124 }
1125
1126 /* Retrieve the MCU's page size, in bytes. */
1127 uint32_t page_size;
1128 res = samd_get_flash_page_info(target, &page_size, NULL);
1129 if (res != ERROR_OK) {
1130 LOG_ERROR("Couldn't determine Flash page size");
1131 return res;
1132 }
1133
1134 if (CMD_ARGC >= 1) {
1135 int val = atoi(CMD_ARGV[0]);
1136 uint32_t code;
1137
1138 if (val == 0)
1139 code = 7;
1140 else {
1141 /* Try to match size in bytes with corresponding size code */
1142 for (code = 0; code <= 6; code++) {
1143 if ((unsigned int)val == (2UL << (8UL - code)) * page_size)
1144 break;
1145 }
1146
1147 if (code > 6) {
1148 command_print(CMD_CTX, "Invalid bootloader size. Please "
1149 "see datasheet for a list valid sizes.");
1150 return ERROR_COMMAND_SYNTAX_ERROR;
1151 }
1152
1153 }
1154
1155 res = samd_modify_user_row(target, code, 0, 2);
1156 } else {
1157 uint16_t val;
1158 res = target_read_u16(target, SAMD_USER_ROW, &val);
1159 if (res == ERROR_OK) {
1160 uint32_t size = (val & 0x7); /* grab size code */
1161 uint32_t nb;
1162
1163 if (size == 0x7)
1164 nb = 0;
1165 else
1166 nb = (2 << (8 - size)) * page_size;
1167
1168 /* There are 4 pages per row */
1169 command_print(CMD_CTX, "Bootloader size is %" PRIu32 " bytes (%" PRIu32 " rows)",
1170 nb, (uint32_t)(nb / (page_size * 4)));
1171 }
1172 }
1173 }
1174
1175 return res;
1176 }
1177
1178
1179
1180 COMMAND_HANDLER(samd_handle_reset_deassert)
1181 {
1182 struct target *target = get_current_target(CMD_CTX);
1183 int retval = ERROR_OK;
1184 enum reset_types jtag_reset_config = jtag_get_reset_config();
1185
1186 /* If the target has been unresponsive before, try to re-establish
1187 * communication now - CPU is held in reset by DSU, DAP is working */
1188 if (!target_was_examined(target))
1189 target_examine_one(target);
1190 target_poll(target);
1191
1192 /* In case of sysresetreq, debug retains state set in cortex_m_assert_reset()
1193 * so we just release reset held by DSU
1194 *
1195 * n_RESET (srst) clears the DP, so reenable debug and set vector catch here
1196 *
1197 * After vectreset DSU release is not needed however makes no harm
1198 */
1199 if (target->reset_halt && (jtag_reset_config & RESET_HAS_SRST)) {
1200 retval = target_write_u32(target, DCB_DHCSR, DBGKEY | C_HALT | C_DEBUGEN);
1201 if (retval == ERROR_OK)
1202 retval = target_write_u32(target, DCB_DEMCR,
1203 TRCENA | VC_HARDERR | VC_BUSERR | VC_CORERESET);
1204 /* do not return on error here, releasing DSU reset is more important */
1205 }
1206
1207 /* clear CPU Reset Phase Extension bit */
1208 int retval2 = target_write_u8(target, SAMD_DSU + SAMD_DSU_STATUSA, (1<<1));
1209 if (retval2 != ERROR_OK)
1210 return retval2;
1211
1212 return retval;
1213 }
1214
1215 static const struct command_registration at91samd_exec_command_handlers[] = {
1216 {
1217 .name = "dsu_reset_deassert",
1218 .handler = samd_handle_reset_deassert,
1219 .mode = COMMAND_EXEC,
1220 .help = "Deasert internal reset held by DSU."
1221 },
1222 {
1223 .name = "info",
1224 .handler = samd_handle_info_command,
1225 .mode = COMMAND_EXEC,
1226 .help = "Print information about the current at91samd chip "
1227 "and its flash configuration.",
1228 },
1229 {
1230 .name = "chip-erase",
1231 .handler = samd_handle_chip_erase_command,
1232 .mode = COMMAND_EXEC,
1233 .help = "Erase the entire Flash by using the Chip-"
1234 "Erase feature in the Device Service Unit (DSU).",
1235 },
1236 {
1237 .name = "set-security",
1238 .handler = samd_handle_set_security_command,
1239 .mode = COMMAND_EXEC,
1240 .help = "Secure the chip's Flash by setting the Security Bit. "
1241 "This makes it impossible to read the Flash contents. "
1242 "The only way to undo this is to issue the chip-erase "
1243 "command.",
1244 .usage = "'enable'",
1245 },
1246 {
1247 .name = "eeprom",
1248 .usage = "[size_in_bytes]",
1249 .handler = samd_handle_eeprom_command,
1250 .mode = COMMAND_EXEC,
1251 .help = "Show or set the EEPROM size setting, stored in the User Row. "
1252 "Please see Table 20-3 of the SAMD20 datasheet for allowed values. "
1253 "Changes are stored immediately but take affect after the MCU is "
1254 "reset.",
1255 },
1256 {
1257 .name = "bootloader",
1258 .usage = "[size_in_bytes]",
1259 .handler = samd_handle_bootloader_command,
1260 .mode = COMMAND_EXEC,
1261 .help = "Show or set the bootloader size, stored in the User Row. "
1262 "Please see Table 20-2 of the SAMD20 datasheet for allowed values. "
1263 "Changes are stored immediately but take affect after the MCU is "
1264 "reset.",
1265 },
1266 {
1267 .name = "nvmuserrow",
1268 .usage = "[value] [mask]",
1269 .handler = samd_handle_nvmuserrow_command,
1270 .mode = COMMAND_EXEC,
1271 .help = "Show or set the nvmuserrow register. It is 64 bit wide "
1272 "and located at address 0x804000. Use the optional mask argument "
1273 "to prevent changes at positions where the bitvalue is zero. "
1274 "For security reasons the lock- and reserved-bits are masked out "
1275 "in background and therefore cannot be changed.",
1276 },
1277 COMMAND_REGISTRATION_DONE
1278 };
1279
1280 static const struct command_registration at91samd_command_handlers[] = {
1281 {
1282 .name = "at91samd",
1283 .mode = COMMAND_ANY,
1284 .help = "at91samd flash command group",
1285 .usage = "",
1286 .chain = at91samd_exec_command_handlers,
1287 },
1288 COMMAND_REGISTRATION_DONE
1289 };
1290
1291 const struct flash_driver at91samd_flash = {
1292 .name = "at91samd",
1293 .commands = at91samd_command_handlers,
1294 .flash_bank_command = samd_flash_bank_command,
1295 .erase = samd_erase,
1296 .protect = samd_protect,
1297 .write = samd_write,
1298 .read = default_flash_read,
1299 .probe = samd_probe,
1300 .auto_probe = samd_probe,
1301 .erase_check = default_flash_blank_check,
1302 .protect_check = samd_protect_check,
1303 .free_driver_priv = default_flash_free_driver_priv,
1304 };

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)