Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
flash/nor/nrf5: implement BPROT protection check for nRF52810,832
[openocd.git] / src / flash / nor / nrf5.c
1 /***************************************************************************
2 * Copyright (C) 2013 Synapse Product Development *
3 * Andrey Smirnov <andrew.smironv@gmail.com> *
4 * Angus Gratton <gus@projectgus.com> *
5 * Erdem U. Altunyurt <spamjunkeater@gmail.com> *
6 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19 ***************************************************************************/
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24
25 #include "imp.h"
26 #include <target/algorithm.h>
27 #include <target/armv7m.h>
28 #include <helper/types.h>
29 #include <helper/time_support.h>
30
31 enum {
32 NRF5_FLASH_BASE = 0x00000000,
33 };
34
35 enum nrf5_ficr_registers {
36 NRF5_FICR_BASE = 0x10000000, /* Factory Information Configuration Registers */
37
38 #define NRF5_FICR_REG(offset) (NRF5_FICR_BASE + offset)
39
40 NRF5_FICR_CODEPAGESIZE = NRF5_FICR_REG(0x010),
41 NRF5_FICR_CODESIZE = NRF5_FICR_REG(0x014),
42 NRF5_FICR_CLENR0 = NRF5_FICR_REG(0x028),
43 NRF5_FICR_PPFC = NRF5_FICR_REG(0x02C),
44 NRF5_FICR_NUMRAMBLOCK = NRF5_FICR_REG(0x034),
45 NRF5_FICR_SIZERAMBLOCK0 = NRF5_FICR_REG(0x038),
46 NRF5_FICR_SIZERAMBLOCK1 = NRF5_FICR_REG(0x03C),
47 NRF5_FICR_SIZERAMBLOCK2 = NRF5_FICR_REG(0x040),
48 NRF5_FICR_SIZERAMBLOCK3 = NRF5_FICR_REG(0x044),
49 NRF5_FICR_CONFIGID = NRF5_FICR_REG(0x05C),
50 NRF5_FICR_DEVICEID0 = NRF5_FICR_REG(0x060),
51 NRF5_FICR_DEVICEID1 = NRF5_FICR_REG(0x064),
52 NRF5_FICR_ER0 = NRF5_FICR_REG(0x080),
53 NRF5_FICR_ER1 = NRF5_FICR_REG(0x084),
54 NRF5_FICR_ER2 = NRF5_FICR_REG(0x088),
55 NRF5_FICR_ER3 = NRF5_FICR_REG(0x08C),
56 NRF5_FICR_IR0 = NRF5_FICR_REG(0x090),
57 NRF5_FICR_IR1 = NRF5_FICR_REG(0x094),
58 NRF5_FICR_IR2 = NRF5_FICR_REG(0x098),
59 NRF5_FICR_IR3 = NRF5_FICR_REG(0x09C),
60 NRF5_FICR_DEVICEADDRTYPE = NRF5_FICR_REG(0x0A0),
61 NRF5_FICR_DEVICEADDR0 = NRF5_FICR_REG(0x0A4),
62 NRF5_FICR_DEVICEADDR1 = NRF5_FICR_REG(0x0A8),
63 NRF5_FICR_OVERRIDEN = NRF5_FICR_REG(0x0AC),
64 NRF5_FICR_NRF_1MBIT0 = NRF5_FICR_REG(0x0B0),
65 NRF5_FICR_NRF_1MBIT1 = NRF5_FICR_REG(0x0B4),
66 NRF5_FICR_NRF_1MBIT2 = NRF5_FICR_REG(0x0B8),
67 NRF5_FICR_NRF_1MBIT3 = NRF5_FICR_REG(0x0BC),
68 NRF5_FICR_NRF_1MBIT4 = NRF5_FICR_REG(0x0C0),
69 NRF5_FICR_BLE_1MBIT0 = NRF5_FICR_REG(0x0EC),
70 NRF5_FICR_BLE_1MBIT1 = NRF5_FICR_REG(0x0F0),
71 NRF5_FICR_BLE_1MBIT2 = NRF5_FICR_REG(0x0F4),
72 NRF5_FICR_BLE_1MBIT3 = NRF5_FICR_REG(0x0F8),
73 NRF5_FICR_BLE_1MBIT4 = NRF5_FICR_REG(0x0FC),
74
75 /* Following registers are available on nRF52 and on nRF51 since rev 3 */
76 NRF5_FICR_INFO_PART = NRF5_FICR_REG(0x100),
77 NRF5_FICR_INFO_VARIANT = NRF5_FICR_REG(0x104),
78 NRF5_FICR_INFO_PACKAGE = NRF5_FICR_REG(0x108),
79 NRF5_FICR_INFO_RAM = NRF5_FICR_REG(0x10C),
80 NRF5_FICR_INFO_FLASH = NRF5_FICR_REG(0x110),
81 };
82
83 enum nrf5_uicr_registers {
84 NRF5_UICR_BASE = 0x10001000, /* User Information
85 * Configuration Regsters */
86
87 #define NRF5_UICR_REG(offset) (NRF5_UICR_BASE + offset)
88
89 NRF5_UICR_CLENR0 = NRF5_UICR_REG(0x000),
90 NRF5_UICR_RBPCONF = NRF5_UICR_REG(0x004),
91 NRF5_UICR_XTALFREQ = NRF5_UICR_REG(0x008),
92 NRF5_UICR_FWID = NRF5_UICR_REG(0x010),
93 };
94
95 enum nrf5_nvmc_registers {
96 NRF5_NVMC_BASE = 0x4001E000, /* Non-Volatile Memory
97 * Controller Registers */
98
99 #define NRF5_NVMC_REG(offset) (NRF5_NVMC_BASE + offset)
100
101 NRF5_NVMC_READY = NRF5_NVMC_REG(0x400),
102 NRF5_NVMC_CONFIG = NRF5_NVMC_REG(0x504),
103 NRF5_NVMC_ERASEPAGE = NRF5_NVMC_REG(0x508),
104 NRF5_NVMC_ERASEALL = NRF5_NVMC_REG(0x50C),
105 NRF5_NVMC_ERASEUICR = NRF5_NVMC_REG(0x514),
106
107 NRF5_BPROT_BASE = 0x40000000,
108 };
109
110 enum nrf5_nvmc_config_bits {
111 NRF5_NVMC_CONFIG_REN = 0x00,
112 NRF5_NVMC_CONFIG_WEN = 0x01,
113 NRF5_NVMC_CONFIG_EEN = 0x02,
114
115 };
116
117 struct nrf52_ficr_info {
118 uint32_t part;
119 uint32_t variant;
120 uint32_t package;
121 uint32_t ram;
122 uint32_t flash;
123 };
124
125 enum nrf5_features {
126 NRF5_FEATURE_SERIES_51 = 1 << 0,
127 NRF5_FEATURE_SERIES_52 = 1 << 1,
128 NRF5_FEATURE_BPROT = 1 << 2,
129 NRF5_FEATURE_ACL_PROT = 1 << 3,
130 };
131
132 struct nrf5_device_spec {
133 uint16_t hwid;
134 const char *part;
135 const char *variant;
136 const char *build_code;
137 unsigned int flash_size_kb;
138 enum nrf5_features features;
139 };
140
141 struct nrf5_info {
142 uint32_t refcount;
143
144 struct nrf5_bank {
145 struct nrf5_info *chip;
146 bool probed;
147 } bank[2];
148 struct target *target;
149
150 /* chip identification stored in nrf5_probe() for use in nrf5_info() */
151 bool ficr_info_valid;
152 struct nrf52_ficr_info ficr_info;
153 const struct nrf5_device_spec *spec;
154 uint32_t hwid;
155 enum nrf5_features features;
156 unsigned int flash_size_kb;
157 };
158
159 #define NRF51_DEVICE_DEF(id, pt, var, bcode, fsize) \
160 { \
161 .hwid = (id), \
162 .part = pt, \
163 .variant = var, \
164 .build_code = bcode, \
165 .flash_size_kb = (fsize), \
166 .features = NRF5_FEATURE_SERIES_51, \
167 }
168
169 #define NRF5_DEVICE_DEF(id, pt, var, bcode, fsize, features) \
170 { \
171 .hwid = (id), \
172 .part = pt, \
173 .variant = var, \
174 .build_code = bcode, \
175 .flash_size_kb = (fsize), \
176 .features = features, \
177 }
178
179 /* The known devices table below is derived from the "nRF5x series
180 * compatibility matrix" documents, which can be found in the "DocLib" of
181 * nordic:
182 *
183 * https://www.nordicsemi.com/DocLib/Content/Comp_Matrix/nRF51/latest/COMP/nrf51/nRF51422_ic_revision_overview
184 * https://www.nordicsemi.com/DocLib/Content/Comp_Matrix/nRF51/latest/COMP/nrf51/nRF51822_ic_revision_overview
185 * https://www.nordicsemi.com/DocLib/Content/Comp_Matrix/nRF51/latest/COMP/nrf51/nRF51824_ic_revision_overview
186 * https://www.nordicsemi.com/DocLib/Content/Comp_Matrix/nRF52810/latest/COMP/nrf52810/nRF52810_ic_revision_overview
187 * https://www.nordicsemi.com/DocLib/Content/Comp_Matrix/nRF52832/latest/COMP/nrf52832/ic_revision_overview
188 * https://www.nordicsemi.com/DocLib/Content/Comp_Matrix/nRF52840/latest/COMP/nrf52840/nRF52840_ic_revision_overview
189 *
190 * Up to date with Matrix v2.0, plus some additional HWIDs.
191 *
192 * The additional HWIDs apply where the build code in the matrix is
193 * shown as Gx0, Bx0, etc. In these cases the HWID in the matrix is
194 * for x==0, x!=0 means different (unspecified) HWIDs.
195 */
196 static const struct nrf5_device_spec nrf5_known_devices_table[] = {
197 /* nRF51822 Devices (IC rev 1). */
198 NRF51_DEVICE_DEF(0x001D, "51822", "QFAA", "CA/C0", 256),
199 NRF51_DEVICE_DEF(0x0026, "51822", "QFAB", "AA", 128),
200 NRF51_DEVICE_DEF(0x0027, "51822", "QFAB", "A0", 128),
201 NRF51_DEVICE_DEF(0x0020, "51822", "CEAA", "BA", 256),
202 NRF51_DEVICE_DEF(0x002F, "51822", "CEAA", "B0", 256),
203
204 /* Some early nRF51-DK (PCA10028) & nRF51-Dongle (PCA10031) boards
205 with built-in jlink seem to use engineering samples not listed
206 in the nRF51 Series Compatibility Matrix V1.0. */
207 NRF51_DEVICE_DEF(0x0071, "51822", "QFAC", "AB", 256),
208
209 /* nRF51822 Devices (IC rev 2). */
210 NRF51_DEVICE_DEF(0x002A, "51822", "QFAA", "FA0", 256),
211 NRF51_DEVICE_DEF(0x0044, "51822", "QFAA", "GC0", 256),
212 NRF51_DEVICE_DEF(0x003C, "51822", "QFAA", "G0", 256),
213 NRF51_DEVICE_DEF(0x0057, "51822", "QFAA", "G2", 256),
214 NRF51_DEVICE_DEF(0x0058, "51822", "QFAA", "G3", 256),
215 NRF51_DEVICE_DEF(0x004C, "51822", "QFAB", "B0", 128),
216 NRF51_DEVICE_DEF(0x0040, "51822", "CEAA", "CA0", 256),
217 NRF51_DEVICE_DEF(0x0047, "51822", "CEAA", "DA0", 256),
218 NRF51_DEVICE_DEF(0x004D, "51822", "CEAA", "D00", 256),
219
220 /* nRF51822 Devices (IC rev 3). */
221 NRF51_DEVICE_DEF(0x0072, "51822", "QFAA", "H0", 256),
222 NRF51_DEVICE_DEF(0x00D1, "51822", "QFAA", "H2", 256),
223 NRF51_DEVICE_DEF(0x007B, "51822", "QFAB", "C0", 128),
224 NRF51_DEVICE_DEF(0x0083, "51822", "QFAC", "A0", 256),
225 NRF51_DEVICE_DEF(0x0084, "51822", "QFAC", "A1", 256),
226 NRF51_DEVICE_DEF(0x007D, "51822", "CDAB", "A0", 128),
227 NRF51_DEVICE_DEF(0x0079, "51822", "CEAA", "E0", 256),
228 NRF51_DEVICE_DEF(0x0087, "51822", "CFAC", "A0", 256),
229 NRF51_DEVICE_DEF(0x008F, "51822", "QFAA", "H1", 256),
230
231 /* nRF51422 Devices (IC rev 1). */
232 NRF51_DEVICE_DEF(0x001E, "51422", "QFAA", "CA", 256),
233 NRF51_DEVICE_DEF(0x0024, "51422", "QFAA", "C0", 256),
234 NRF51_DEVICE_DEF(0x0031, "51422", "CEAA", "A0A", 256),
235
236 /* nRF51422 Devices (IC rev 2). */
237 NRF51_DEVICE_DEF(0x002D, "51422", "QFAA", "DAA", 256),
238 NRF51_DEVICE_DEF(0x002E, "51422", "QFAA", "E0", 256),
239 NRF51_DEVICE_DEF(0x0061, "51422", "QFAB", "A00", 128),
240 NRF51_DEVICE_DEF(0x0050, "51422", "CEAA", "B0", 256),
241
242 /* nRF51422 Devices (IC rev 3). */
243 NRF51_DEVICE_DEF(0x0073, "51422", "QFAA", "F0", 256),
244 NRF51_DEVICE_DEF(0x007C, "51422", "QFAB", "B0", 128),
245 NRF51_DEVICE_DEF(0x0085, "51422", "QFAC", "A0", 256),
246 NRF51_DEVICE_DEF(0x0086, "51422", "QFAC", "A1", 256),
247 NRF51_DEVICE_DEF(0x007E, "51422", "CDAB", "A0", 128),
248 NRF51_DEVICE_DEF(0x007A, "51422", "CEAA", "C0", 256),
249 NRF51_DEVICE_DEF(0x0088, "51422", "CFAC", "A0", 256),
250
251 /* The driver fully autodects nRF52 series devices by FICR INFO,
252 * no need for nRF52xxx HWIDs in this table */
253 #if 0
254 /* nRF52810 Devices */
255 NRF5_DEVICE_DEF(0x0142, "52810", "QFAA", "B0", 192, NRF5_FEATURE_SERIES_52 | NRF5_FEATURE_BPROT),
256 NRF5_DEVICE_DEF(0x0143, "52810", "QCAA", "C0", 192, NRF5_FEATURE_SERIES_52 | NRF5_FEATURE_BPROT),
257
258 /* nRF52832 Devices */
259 NRF5_DEVICE_DEF(0x00C7, "52832", "QFAA", "B0", 512, NRF5_FEATURE_SERIES_52 | NRF5_FEATURE_BPROT),
260 NRF5_DEVICE_DEF(0x0139, "52832", "QFAA", "E0", 512, NRF5_FEATURE_SERIES_52 | NRF5_FEATURE_BPROT),
261 NRF5_DEVICE_DEF(0x00E3, "52832", "CIAA", "B0", 512, NRF5_FEATURE_SERIES_52 | NRF5_FEATURE_BPROT),
262
263 /* nRF52840 Devices */
264 NRF5_DEVICE_DEF(0x0150, "52840", "QIAA", "C0", 1024, NRF5_FEATURE_SERIES_52 | NRF5_FEATURE_ACL_PROT),
265 #endif
266 };
267
268 struct nrf5_device_package {
269 uint32_t package;
270 const char *code;
271 };
272
273 /* Newer devices have FICR INFO.PACKAGE.
274 * This table converts its value to two character code */
275 static const struct nrf5_device_package nrf5_packages_table[] = {
276 { 0x2000, "QF" },
277 { 0x2001, "CH" },
278 { 0x2002, "CI" },
279 { 0x2005, "CK" },
280 };
281
282 static int nrf5_bank_is_probed(struct flash_bank *bank)
283 {
284 struct nrf5_bank *nbank = bank->driver_priv;
285
286 assert(nbank != NULL);
287
288 return nbank->probed;
289 }
290 static int nrf5_probe(struct flash_bank *bank);
291
292 static int nrf5_get_probed_chip_if_halted(struct flash_bank *bank, struct nrf5_info **chip)
293 {
294 if (bank->target->state != TARGET_HALTED) {
295 LOG_ERROR("Target not halted");
296 return ERROR_TARGET_NOT_HALTED;
297 }
298
299 struct nrf5_bank *nbank = bank->driver_priv;
300 *chip = nbank->chip;
301
302 int probed = nrf5_bank_is_probed(bank);
303 if (probed < 0)
304 return probed;
305 else if (!probed)
306 return nrf5_probe(bank);
307 else
308 return ERROR_OK;
309 }
310
311 static int nrf5_wait_for_nvmc(struct nrf5_info *chip)
312 {
313 uint32_t ready;
314 int res;
315 int timeout_ms = 340;
316 int64_t ts_start = timeval_ms();
317
318 do {
319 res = target_read_u32(chip->target, NRF5_NVMC_READY, &ready);
320 if (res != ERROR_OK) {
321 LOG_ERROR("Couldn't read NVMC_READY register");
322 return res;
323 }
324
325 if (ready == 0x00000001)
326 return ERROR_OK;
327
328 keep_alive();
329
330 } while ((timeval_ms()-ts_start) < timeout_ms);
331
332 LOG_DEBUG("Timed out waiting for NVMC_READY");
333 return ERROR_FLASH_BUSY;
334 }
335
336 static int nrf5_nvmc_erase_enable(struct nrf5_info *chip)
337 {
338 int res;
339 res = target_write_u32(chip->target,
340 NRF5_NVMC_CONFIG,
341 NRF5_NVMC_CONFIG_EEN);
342
343 if (res != ERROR_OK) {
344 LOG_ERROR("Failed to enable erase operation");
345 return res;
346 }
347
348 /*
349 According to NVMC examples in Nordic SDK busy status must be
350 checked after writing to NVMC_CONFIG
351 */
352 res = nrf5_wait_for_nvmc(chip);
353 if (res != ERROR_OK)
354 LOG_ERROR("Erase enable did not complete");
355
356 return res;
357 }
358
359 static int nrf5_nvmc_write_enable(struct nrf5_info *chip)
360 {
361 int res;
362 res = target_write_u32(chip->target,
363 NRF5_NVMC_CONFIG,
364 NRF5_NVMC_CONFIG_WEN);
365
366 if (res != ERROR_OK) {
367 LOG_ERROR("Failed to enable write operation");
368 return res;
369 }
370
371 /*
372 According to NVMC examples in Nordic SDK busy status must be
373 checked after writing to NVMC_CONFIG
374 */
375 res = nrf5_wait_for_nvmc(chip);
376 if (res != ERROR_OK)
377 LOG_ERROR("Write enable did not complete");
378
379 return res;
380 }
381
382 static int nrf5_nvmc_read_only(struct nrf5_info *chip)
383 {
384 int res;
385 res = target_write_u32(chip->target,
386 NRF5_NVMC_CONFIG,
387 NRF5_NVMC_CONFIG_REN);
388
389 if (res != ERROR_OK) {
390 LOG_ERROR("Failed to enable read-only operation");
391 return res;
392 }
393 /*
394 According to NVMC examples in Nordic SDK busy status must be
395 checked after writing to NVMC_CONFIG
396 */
397 res = nrf5_wait_for_nvmc(chip);
398 if (res != ERROR_OK)
399 LOG_ERROR("Read only enable did not complete");
400
401 return res;
402 }
403
404 static int nrf5_nvmc_generic_erase(struct nrf5_info *chip,
405 uint32_t erase_register, uint32_t erase_value)
406 {
407 int res;
408
409 res = nrf5_nvmc_erase_enable(chip);
410 if (res != ERROR_OK)
411 goto error;
412
413 res = target_write_u32(chip->target,
414 erase_register,
415 erase_value);
416 if (res != ERROR_OK)
417 goto set_read_only;
418
419 res = nrf5_wait_for_nvmc(chip);
420 if (res != ERROR_OK)
421 goto set_read_only;
422
423 return nrf5_nvmc_read_only(chip);
424
425 set_read_only:
426 nrf5_nvmc_read_only(chip);
427 error:
428 LOG_ERROR("Failed to erase reg: 0x%08"PRIx32" val: 0x%08"PRIx32,
429 erase_register, erase_value);
430 return ERROR_FAIL;
431 }
432
433 static int nrf5_protect_check_bprot(struct flash_bank *bank)
434 {
435 struct nrf5_bank *nbank = bank->driver_priv;
436 struct nrf5_info *chip = nbank->chip;
437
438 assert(chip != NULL);
439
440 static uint32_t nrf5_bprot_offsets[4] = { 0x600, 0x604, 0x610, 0x614 };
441 uint32_t bprot_reg = 0;
442 int res;
443
444 for (int i = 0; i < bank->num_sectors; i++) {
445 unsigned int bit = i % 32;
446 if (bit == 0) {
447 unsigned int n_reg = i / 32;
448 if (n_reg >= ARRAY_SIZE(nrf5_bprot_offsets))
449 break;
450
451 res = target_read_u32(chip->target, NRF5_BPROT_BASE + nrf5_bprot_offsets[n_reg], &bprot_reg);
452 if (res != ERROR_OK)
453 return res;
454 }
455 bank->sectors[i].is_protected = (bprot_reg & (1 << bit)) ? 1 : 0;
456 }
457 return ERROR_OK;
458 }
459
460 static int nrf5_protect_check(struct flash_bank *bank)
461 {
462 int res;
463 uint32_t clenr0;
464
465 /* UICR cannot be write protected so just return early */
466 if (bank->base == NRF5_UICR_BASE)
467 return ERROR_OK;
468
469 struct nrf5_bank *nbank = bank->driver_priv;
470 struct nrf5_info *chip = nbank->chip;
471
472 assert(chip != NULL);
473
474 if (chip->features & NRF5_FEATURE_BPROT)
475 return nrf5_protect_check_bprot(bank);
476
477 if (!(chip->features & NRF5_FEATURE_SERIES_51)) {
478 LOG_WARNING("Flash protection of this nRF device is not supported");
479 return ERROR_FLASH_OPER_UNSUPPORTED;
480 }
481
482 res = target_read_u32(chip->target, NRF5_FICR_CLENR0,
483 &clenr0);
484 if (res != ERROR_OK) {
485 LOG_ERROR("Couldn't read code region 0 size[FICR]");
486 return res;
487 }
488
489 if (clenr0 == 0xFFFFFFFF) {
490 res = target_read_u32(chip->target, NRF5_UICR_CLENR0,
491 &clenr0);
492 if (res != ERROR_OK) {
493 LOG_ERROR("Couldn't read code region 0 size[UICR]");
494 return res;
495 }
496 }
497
498 for (int i = 0; i < bank->num_sectors; i++)
499 bank->sectors[i].is_protected =
500 clenr0 != 0xFFFFFFFF && bank->sectors[i].offset < clenr0;
501
502 return ERROR_OK;
503 }
504
505 static int nrf5_protect(struct flash_bank *bank, int set, int first, int last)
506 {
507 int res;
508 uint32_t clenr0, ppfc;
509 struct nrf5_info *chip;
510
511 /* UICR cannot be write protected so just bail out early */
512 if (bank->base == NRF5_UICR_BASE)
513 return ERROR_FAIL;
514
515 res = nrf5_get_probed_chip_if_halted(bank, &chip);
516 if (res != ERROR_OK)
517 return res;
518
519 if (!(chip->features & NRF5_FEATURE_SERIES_51)) {
520 LOG_ERROR("Flash protection setting of this nRF device is not supported");
521 return ERROR_FLASH_OPER_UNSUPPORTED;
522 }
523
524 if (first != 0) {
525 LOG_ERROR("Code region 0 must start at the begining of the bank");
526 return ERROR_FAIL;
527 }
528
529 res = target_read_u32(chip->target, NRF5_FICR_PPFC,
530 &ppfc);
531 if (res != ERROR_OK) {
532 LOG_ERROR("Couldn't read PPFC register");
533 return res;
534 }
535
536 if ((ppfc & 0xFF) == 0x00) {
537 LOG_ERROR("Code region 0 size was pre-programmed at the factory, can't change flash protection settings");
538 return ERROR_FAIL;
539 }
540
541 res = target_read_u32(chip->target, NRF5_UICR_CLENR0,
542 &clenr0);
543 if (res != ERROR_OK) {
544 LOG_ERROR("Couldn't read code region 0 size[UICR]");
545 return res;
546 }
547
548 if (clenr0 == 0xFFFFFFFF) {
549 res = target_write_u32(chip->target, NRF5_UICR_CLENR0,
550 clenr0);
551 if (res != ERROR_OK) {
552 LOG_ERROR("Couldn't write code region 0 size[UICR]");
553 return res;
554 }
555
556 } else {
557 LOG_ERROR("You need to perform chip erase before changing the protection settings");
558 }
559
560 nrf5_protect_check(bank);
561
562 return ERROR_OK;
563 }
564
565 static bool nrf5_info_variant_to_str(uint32_t variant, char *bf)
566 {
567 h_u32_to_be((uint8_t *)bf, variant);
568 bf[4] = '\0';
569 if (isalnum(bf[0]) && isalnum(bf[1]) && isalnum(bf[2]) && isalnum(bf[3]))
570 return true;
571
572 strcpy(bf, "xxxx");
573 return false;
574 }
575
576 static const char *nrf5_decode_info_package(uint32_t package)
577 {
578 for (size_t i = 0; i < ARRAY_SIZE(nrf5_packages_table); i++) {
579 if (nrf5_packages_table[i].package == package)
580 return nrf5_packages_table[i].code;
581 }
582 return "xx";
583 }
584
585 static int nrf5_info(struct flash_bank *bank, char *buf, int buf_size)
586 {
587 struct nrf5_bank *nbank = bank->driver_priv;
588 struct nrf5_info *chip = nbank->chip;
589
590 if (chip->spec) {
591 snprintf(buf, buf_size,
592 "nRF%s-%s(build code: %s) %ukB Flash",
593 chip->spec->part, chip->spec->variant, chip->spec->build_code,
594 chip->flash_size_kb);
595
596 } else if (chip->ficr_info_valid) {
597 char variant[5];
598 nrf5_info_variant_to_str(chip->ficr_info.variant, variant);
599 snprintf(buf, buf_size,
600 "nRF%" PRIx32 "-%s%.2s(build code: %s) %" PRIu32
601 "kB Flash, %" PRIu32 "kB RAM",
602 chip->ficr_info.part,
603 nrf5_decode_info_package(chip->ficr_info.package),
604 variant, &variant[2],
605 chip->flash_size_kb,
606 chip->ficr_info.ram);
607
608 } else {
609 snprintf(buf, buf_size, "nRF51xxx (HWID 0x%04" PRIx16 ") %ukB Flash",
610 chip->hwid, chip->flash_size_kb);
611 }
612 return ERROR_OK;
613 }
614
615 static int nrf5_read_ficr_info(struct nrf5_info *chip)
616 {
617 int res;
618 struct target *target = chip->target;
619
620 chip->ficr_info_valid = false;
621
622 res = target_read_u32(target, NRF5_FICR_INFO_PART, &chip->ficr_info.part);
623 if (res != ERROR_OK) {
624 LOG_DEBUG("Couldn't read FICR INFO.PART register");
625 return res;
626 }
627
628 uint32_t series = chip->ficr_info.part & 0xfffff000;
629 switch (series) {
630 case 0x51000:
631 chip->features = NRF5_FEATURE_SERIES_51;
632 break;
633
634 case 0x52000:
635 chip->features = NRF5_FEATURE_SERIES_52;
636
637 switch (chip->ficr_info.part) {
638 case 0x52810:
639 case 0x52832:
640 chip->features |= NRF5_FEATURE_BPROT;
641 break;
642
643 case 0x52840:
644 chip->features |= NRF5_FEATURE_ACL_PROT;
645 break;
646 }
647 break;
648
649 default:
650 LOG_DEBUG("FICR INFO likely not implemented. Invalid PART value 0x%08"
651 PRIx32, chip->ficr_info.part);
652 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
653 }
654
655 /* Now we know the device has FICR INFO filled by something relevant:
656 * Although it is not documented, the tested nRF51 rev 3 devices
657 * have FICR INFO.PART, RAM and FLASH of the same format as nRF52.
658 * VARIANT and PACKAGE coding is unknown for a nRF51 device.
659 * nRF52 devices have FICR INFO documented and always filled. */
660
661 res = target_read_u32(target, NRF5_FICR_INFO_VARIANT, &chip->ficr_info.variant);
662 if (res != ERROR_OK)
663 return res;
664
665 res = target_read_u32(target, NRF5_FICR_INFO_PACKAGE, &chip->ficr_info.package);
666 if (res != ERROR_OK)
667 return res;
668
669 res = target_read_u32(target, NRF5_FICR_INFO_RAM, &chip->ficr_info.ram);
670 if (res != ERROR_OK)
671 return res;
672
673 res = target_read_u32(target, NRF5_FICR_INFO_FLASH, &chip->ficr_info.flash);
674 if (res != ERROR_OK)
675 return res;
676
677 chip->ficr_info_valid = true;
678 return ERROR_OK;
679 }
680
681 static int nrf5_probe(struct flash_bank *bank)
682 {
683 int res;
684 struct nrf5_bank *nbank = bank->driver_priv;
685 struct nrf5_info *chip = nbank->chip;
686 struct target *target = chip->target;
687
688 res = target_read_u32(target, NRF5_FICR_CONFIGID, &chip->hwid);
689 if (res != ERROR_OK) {
690 LOG_ERROR("Couldn't read CONFIGID register");
691 return res;
692 }
693
694 chip->hwid &= 0xFFFF; /* HWID is stored in the lower two
695 * bytes of the CONFIGID register */
696
697 /* guess a nRF51 series if the device has no FICR INFO and we don't know HWID */
698 chip->features = NRF5_FEATURE_SERIES_51;
699
700 /* Don't bail out on error for the case that some old engineering
701 * sample has FICR INFO registers unreadable. We can proceed anyway. */
702 (void)nrf5_read_ficr_info(chip);
703
704 chip->spec = NULL;
705 for (size_t i = 0; i < ARRAY_SIZE(nrf5_known_devices_table); i++) {
706 if (chip->hwid == nrf5_known_devices_table[i].hwid) {
707 chip->spec = &nrf5_known_devices_table[i];
708 chip->features = chip->spec->features;
709 break;
710 }
711 }
712
713 if (chip->spec && chip->ficr_info_valid) {
714 /* check if HWID table gives the same part as FICR INFO */
715 if (chip->ficr_info.part != strtoul(chip->spec->part, NULL, 16))
716 LOG_WARNING("HWID 0x%04" PRIx32 " mismatch: FICR INFO.PART %"
717 PRIx32, chip->hwid, chip->ficr_info.part);
718 }
719
720 /* The value stored in NRF5_FICR_CODEPAGESIZE is the number of bytes in one page of FLASH. */
721 uint32_t flash_page_size;
722 res = target_read_u32(chip->target, NRF5_FICR_CODEPAGESIZE,
723 &flash_page_size);
724 if (res != ERROR_OK) {
725 LOG_ERROR("Couldn't read code page size");
726 return res;
727 }
728
729 /* Note the register name is misleading,
730 * NRF5_FICR_CODESIZE is the number of pages in flash memory, not the number of bytes! */
731 uint32_t num_sectors;
732 res = target_read_u32(chip->target, NRF5_FICR_CODESIZE, &num_sectors);
733 if (res != ERROR_OK) {
734 LOG_ERROR("Couldn't read code memory size");
735 return res;
736 }
737
738 chip->flash_size_kb = num_sectors * flash_page_size / 1024;
739
740 if (!chip->bank[0].probed && !chip->bank[1].probed) {
741 char buf[80];
742 nrf5_info(bank, buf, sizeof(buf));
743 if (!chip->spec && !chip->ficr_info_valid) {
744 LOG_INFO("Unknown device: %s", buf);
745 } else {
746 LOG_INFO("%s", buf);
747 }
748 }
749
750 if (bank->base == NRF5_FLASH_BASE) {
751 bank->num_sectors = num_sectors;
752 bank->size = num_sectors * flash_page_size;
753
754 /* Sanity check */
755 if (chip->spec && chip->flash_size_kb != chip->spec->flash_size_kb)
756 LOG_WARNING("Chip's reported Flash capacity does not match expected one");
757 if (chip->ficr_info_valid && chip->flash_size_kb != chip->ficr_info.flash)
758 LOG_WARNING("Chip's reported Flash capacity does not match FICR INFO.FLASH");
759
760 bank->sectors = calloc(bank->num_sectors,
761 sizeof((bank->sectors)[0]));
762 if (!bank->sectors)
763 return ERROR_FLASH_BANK_NOT_PROBED;
764
765 /* Fill out the sector information: all NRF5 sectors are the same size and
766 * there is always a fixed number of them. */
767 for (int i = 0; i < bank->num_sectors; i++) {
768 bank->sectors[i].size = flash_page_size;
769 bank->sectors[i].offset = i * flash_page_size;
770
771 /* mark as unknown */
772 bank->sectors[i].is_erased = -1;
773 bank->sectors[i].is_protected = -1;
774 }
775
776 nrf5_protect_check(bank);
777
778 chip->bank[0].probed = true;
779 } else {
780 bank->size = flash_page_size;
781 bank->num_sectors = 1;
782 bank->sectors = calloc(bank->num_sectors,
783 sizeof((bank->sectors)[0]));
784 if (!bank->sectors)
785 return ERROR_FLASH_BANK_NOT_PROBED;
786
787 bank->sectors[0].size = bank->size;
788 bank->sectors[0].offset = 0;
789
790 bank->sectors[0].is_erased = 0;
791 bank->sectors[0].is_protected = 0;
792
793 chip->bank[1].probed = true;
794 }
795
796 return ERROR_OK;
797 }
798
799 static int nrf5_auto_probe(struct flash_bank *bank)
800 {
801 int probed = nrf5_bank_is_probed(bank);
802
803 if (probed < 0)
804 return probed;
805 else if (probed)
806 return ERROR_OK;
807 else
808 return nrf5_probe(bank);
809 }
810
811 static int nrf5_erase_all(struct nrf5_info *chip)
812 {
813 LOG_DEBUG("Erasing all non-volatile memory");
814 return nrf5_nvmc_generic_erase(chip,
815 NRF5_NVMC_ERASEALL,
816 0x00000001);
817 }
818
819 static int nrf5_erase_page(struct flash_bank *bank,
820 struct nrf5_info *chip,
821 struct flash_sector *sector)
822 {
823 int res;
824
825 LOG_DEBUG("Erasing page at 0x%"PRIx32, sector->offset);
826 if (sector->is_protected) {
827 LOG_ERROR("Cannot erase protected sector at 0x%" PRIx32, sector->offset);
828 return ERROR_FAIL;
829 }
830
831 if (bank->base == NRF5_UICR_BASE) {
832 uint32_t ppfc;
833 res = target_read_u32(chip->target, NRF5_FICR_PPFC,
834 &ppfc);
835 if (res != ERROR_OK) {
836 LOG_ERROR("Couldn't read PPFC register");
837 return res;
838 }
839
840 if ((ppfc & 0xFF) == 0xFF) {
841 /* We can't erase the UICR. Double-check to
842 see if it's already erased before complaining. */
843 default_flash_blank_check(bank);
844 if (sector->is_erased == 1)
845 return ERROR_OK;
846
847 LOG_ERROR("The chip was not pre-programmed with SoftDevice stack and UICR cannot be erased separately. Please issue mass erase before trying to write to this region");
848 return ERROR_FAIL;
849 }
850
851 res = nrf5_nvmc_generic_erase(chip,
852 NRF5_NVMC_ERASEUICR,
853 0x00000001);
854
855
856 } else {
857 res = nrf5_nvmc_generic_erase(chip,
858 NRF5_NVMC_ERASEPAGE,
859 sector->offset);
860 }
861
862 return res;
863 }
864
865 static const uint8_t nrf5_flash_write_code[] = {
866 /* See contrib/loaders/flash/cortex-m0.S */
867 /* <wait_fifo>: */
868 0x0d, 0x68, /* ldr r5, [r1, #0] */
869 0x00, 0x2d, /* cmp r5, #0 */
870 0x0b, 0xd0, /* beq.n 1e <exit> */
871 0x4c, 0x68, /* ldr r4, [r1, #4] */
872 0xac, 0x42, /* cmp r4, r5 */
873 0xf9, 0xd0, /* beq.n 0 <wait_fifo> */
874 0x20, 0xcc, /* ldmia r4!, {r5} */
875 0x20, 0xc3, /* stmia r3!, {r5} */
876 0x94, 0x42, /* cmp r4, r2 */
877 0x01, 0xd3, /* bcc.n 18 <no_wrap> */
878 0x0c, 0x46, /* mov r4, r1 */
879 0x08, 0x34, /* adds r4, #8 */
880 /* <no_wrap>: */
881 0x4c, 0x60, /* str r4, [r1, #4] */
882 0x04, 0x38, /* subs r0, #4 */
883 0xf0, 0xd1, /* bne.n 0 <wait_fifo> */
884 /* <exit>: */
885 0x00, 0xbe /* bkpt 0x0000 */
886 };
887
888
889 /* Start a low level flash write for the specified region */
890 static int nrf5_ll_flash_write(struct nrf5_info *chip, uint32_t address, const uint8_t *buffer, uint32_t bytes)
891 {
892 struct target *target = chip->target;
893 uint32_t buffer_size = 8192;
894 struct working_area *write_algorithm;
895 struct working_area *source;
896 struct reg_param reg_params[4];
897 struct armv7m_algorithm armv7m_info;
898 int retval = ERROR_OK;
899
900 LOG_DEBUG("Writing buffer to flash address=0x%"PRIx32" bytes=0x%"PRIx32, address, bytes);
901 assert(bytes % 4 == 0);
902
903 /* allocate working area with flash programming code */
904 if (target_alloc_working_area(target, sizeof(nrf5_flash_write_code),
905 &write_algorithm) != ERROR_OK) {
906 LOG_WARNING("no working area available, falling back to slow memory writes");
907
908 for (; bytes > 0; bytes -= 4) {
909 retval = target_write_memory(target, address, 4, 1, buffer);
910 if (retval != ERROR_OK)
911 return retval;
912
913 retval = nrf5_wait_for_nvmc(chip);
914 if (retval != ERROR_OK)
915 return retval;
916
917 address += 4;
918 buffer += 4;
919 }
920
921 return ERROR_OK;
922 }
923
924 retval = target_write_buffer(target, write_algorithm->address,
925 sizeof(nrf5_flash_write_code),
926 nrf5_flash_write_code);
927 if (retval != ERROR_OK)
928 return retval;
929
930 /* memory buffer */
931 while (target_alloc_working_area(target, buffer_size, &source) != ERROR_OK) {
932 buffer_size /= 2;
933 buffer_size &= ~3UL; /* Make sure it's 4 byte aligned */
934 if (buffer_size <= 256) {
935 /* free working area, write algorithm already allocated */
936 target_free_working_area(target, write_algorithm);
937
938 LOG_WARNING("No large enough working area available, can't do block memory writes");
939 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE;
940 }
941 }
942
943 armv7m_info.common_magic = ARMV7M_COMMON_MAGIC;
944 armv7m_info.core_mode = ARM_MODE_THREAD;
945
946 init_reg_param(&reg_params[0], "r0", 32, PARAM_IN_OUT); /* byte count */
947 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT); /* buffer start */
948 init_reg_param(&reg_params[2], "r2", 32, PARAM_OUT); /* buffer end */
949 init_reg_param(&reg_params[3], "r3", 32, PARAM_IN_OUT); /* target address */
950
951 buf_set_u32(reg_params[0].value, 0, 32, bytes);
952 buf_set_u32(reg_params[1].value, 0, 32, source->address);
953 buf_set_u32(reg_params[2].value, 0, 32, source->address + source->size);
954 buf_set_u32(reg_params[3].value, 0, 32, address);
955
956 retval = target_run_flash_async_algorithm(target, buffer, bytes/4, 4,
957 0, NULL,
958 4, reg_params,
959 source->address, source->size,
960 write_algorithm->address, 0,
961 &armv7m_info);
962
963 target_free_working_area(target, source);
964 target_free_working_area(target, write_algorithm);
965
966 destroy_reg_param(&reg_params[0]);
967 destroy_reg_param(&reg_params[1]);
968 destroy_reg_param(&reg_params[2]);
969 destroy_reg_param(&reg_params[3]);
970
971 return retval;
972 }
973
974 static int nrf5_write(struct flash_bank *bank, const uint8_t *buffer,
975 uint32_t offset, uint32_t count)
976 {
977 struct nrf5_info *chip;
978
979 int res = nrf5_get_probed_chip_if_halted(bank, &chip);
980 if (res != ERROR_OK)
981 return res;
982
983 assert(offset % 4 == 0);
984 assert(count % 4 == 0);
985
986 res = nrf5_nvmc_write_enable(chip);
987 if (res != ERROR_OK)
988 goto error;
989
990 res = nrf5_ll_flash_write(chip, bank->base + offset, buffer, count);
991 if (res != ERROR_OK)
992 goto error;
993
994 return nrf5_nvmc_read_only(chip);
995
996 error:
997 nrf5_nvmc_read_only(chip);
998 LOG_ERROR("Failed to write to nrf5 flash");
999 return res;
1000 }
1001
1002 static int nrf5_erase(struct flash_bank *bank, int first, int last)
1003 {
1004 int res;
1005 struct nrf5_info *chip;
1006
1007 res = nrf5_get_probed_chip_if_halted(bank, &chip);
1008 if (res != ERROR_OK)
1009 return res;
1010
1011 /* For each sector to be erased */
1012 for (int s = first; s <= last && res == ERROR_OK; s++)
1013 res = nrf5_erase_page(bank, chip, &bank->sectors[s]);
1014
1015 return res;
1016 }
1017
1018 static void nrf5_free_driver_priv(struct flash_bank *bank)
1019 {
1020 struct nrf5_bank *nbank = bank->driver_priv;
1021 struct nrf5_info *chip = nbank->chip;
1022 if (chip == NULL)
1023 return;
1024
1025 chip->refcount--;
1026 if (chip->refcount == 0) {
1027 free(chip);
1028 bank->driver_priv = NULL;
1029 }
1030 }
1031
1032 FLASH_BANK_COMMAND_HANDLER(nrf5_flash_bank_command)
1033 {
1034 static struct nrf5_info *chip;
1035 struct nrf5_bank *nbank = NULL;
1036
1037 switch (bank->base) {
1038 case NRF5_FLASH_BASE:
1039 case NRF5_UICR_BASE:
1040 break;
1041 default:
1042 LOG_ERROR("Invalid bank address " TARGET_ADDR_FMT, bank->base);
1043 return ERROR_FAIL;
1044 }
1045
1046 if (!chip) {
1047 /* Create a new chip */
1048 chip = calloc(1, sizeof(*chip));
1049 if (!chip)
1050 return ERROR_FAIL;
1051
1052 chip->target = bank->target;
1053 }
1054
1055 switch (bank->base) {
1056 case NRF5_FLASH_BASE:
1057 nbank = &chip->bank[0];
1058 break;
1059 case NRF5_UICR_BASE:
1060 nbank = &chip->bank[1];
1061 break;
1062 }
1063 assert(nbank != NULL);
1064
1065 chip->refcount++;
1066 nbank->chip = chip;
1067 nbank->probed = false;
1068 bank->driver_priv = nbank;
1069 bank->write_start_alignment = bank->write_end_alignment = 4;
1070
1071 return ERROR_OK;
1072 }
1073
1074 COMMAND_HANDLER(nrf5_handle_mass_erase_command)
1075 {
1076 int res;
1077 struct flash_bank *bank = NULL;
1078 struct target *target = get_current_target(CMD_CTX);
1079
1080 res = get_flash_bank_by_addr(target, NRF5_FLASH_BASE, true, &bank);
1081 if (res != ERROR_OK)
1082 return res;
1083
1084 assert(bank != NULL);
1085
1086 struct nrf5_info *chip;
1087
1088 res = nrf5_get_probed_chip_if_halted(bank, &chip);
1089 if (res != ERROR_OK)
1090 return res;
1091
1092 uint32_t ppfc;
1093
1094 res = target_read_u32(target, NRF5_FICR_PPFC,
1095 &ppfc);
1096 if (res != ERROR_OK) {
1097 LOG_ERROR("Couldn't read PPFC register");
1098 return res;
1099 }
1100
1101 if ((ppfc & 0xFF) == 0x00) {
1102 LOG_ERROR("Code region 0 size was pre-programmed at the factory, "
1103 "mass erase command won't work.");
1104 return ERROR_FAIL;
1105 }
1106
1107 res = nrf5_erase_all(chip);
1108 if (res != ERROR_OK) {
1109 LOG_ERROR("Failed to erase the chip");
1110 nrf5_protect_check(bank);
1111 return res;
1112 }
1113
1114 res = nrf5_protect_check(bank);
1115 if (res != ERROR_OK) {
1116 LOG_ERROR("Failed to check chip's write protection");
1117 return res;
1118 }
1119
1120 res = get_flash_bank_by_addr(target, NRF5_UICR_BASE, true, &bank);
1121 if (res != ERROR_OK)
1122 return res;
1123
1124 return ERROR_OK;
1125 }
1126
1127 COMMAND_HANDLER(nrf5_handle_info_command)
1128 {
1129 int res;
1130 struct flash_bank *bank = NULL;
1131 struct target *target = get_current_target(CMD_CTX);
1132
1133 res = get_flash_bank_by_addr(target, NRF5_FLASH_BASE, true, &bank);
1134 if (res != ERROR_OK)
1135 return res;
1136
1137 assert(bank != NULL);
1138
1139 struct nrf5_info *chip;
1140
1141 res = nrf5_get_probed_chip_if_halted(bank, &chip);
1142 if (res != ERROR_OK)
1143 return res;
1144
1145 static struct {
1146 const uint32_t address;
1147 uint32_t value;
1148 } ficr[] = {
1149 { .address = NRF5_FICR_CODEPAGESIZE },
1150 { .address = NRF5_FICR_CODESIZE },
1151 { .address = NRF5_FICR_CLENR0 },
1152 { .address = NRF5_FICR_PPFC },
1153 { .address = NRF5_FICR_NUMRAMBLOCK },
1154 { .address = NRF5_FICR_SIZERAMBLOCK0 },
1155 { .address = NRF5_FICR_SIZERAMBLOCK1 },
1156 { .address = NRF5_FICR_SIZERAMBLOCK2 },
1157 { .address = NRF5_FICR_SIZERAMBLOCK3 },
1158 { .address = NRF5_FICR_CONFIGID },
1159 { .address = NRF5_FICR_DEVICEID0 },
1160 { .address = NRF5_FICR_DEVICEID1 },
1161 { .address = NRF5_FICR_ER0 },
1162 { .address = NRF5_FICR_ER1 },
1163 { .address = NRF5_FICR_ER2 },
1164 { .address = NRF5_FICR_ER3 },
1165 { .address = NRF5_FICR_IR0 },
1166 { .address = NRF5_FICR_IR1 },
1167 { .address = NRF5_FICR_IR2 },
1168 { .address = NRF5_FICR_IR3 },
1169 { .address = NRF5_FICR_DEVICEADDRTYPE },
1170 { .address = NRF5_FICR_DEVICEADDR0 },
1171 { .address = NRF5_FICR_DEVICEADDR1 },
1172 { .address = NRF5_FICR_OVERRIDEN },
1173 { .address = NRF5_FICR_NRF_1MBIT0 },
1174 { .address = NRF5_FICR_NRF_1MBIT1 },
1175 { .address = NRF5_FICR_NRF_1MBIT2 },
1176 { .address = NRF5_FICR_NRF_1MBIT3 },
1177 { .address = NRF5_FICR_NRF_1MBIT4 },
1178 { .address = NRF5_FICR_BLE_1MBIT0 },
1179 { .address = NRF5_FICR_BLE_1MBIT1 },
1180 { .address = NRF5_FICR_BLE_1MBIT2 },
1181 { .address = NRF5_FICR_BLE_1MBIT3 },
1182 { .address = NRF5_FICR_BLE_1MBIT4 },
1183 }, uicr[] = {
1184 { .address = NRF5_UICR_CLENR0, },
1185 { .address = NRF5_UICR_RBPCONF },
1186 { .address = NRF5_UICR_XTALFREQ },
1187 { .address = NRF5_UICR_FWID },
1188 };
1189
1190 for (size_t i = 0; i < ARRAY_SIZE(ficr); i++) {
1191 res = target_read_u32(chip->target, ficr[i].address,
1192 &ficr[i].value);
1193 if (res != ERROR_OK) {
1194 LOG_ERROR("Couldn't read %" PRIx32, ficr[i].address);
1195 return res;
1196 }
1197 }
1198
1199 for (size_t i = 0; i < ARRAY_SIZE(uicr); i++) {
1200 res = target_read_u32(chip->target, uicr[i].address,
1201 &uicr[i].value);
1202 if (res != ERROR_OK) {
1203 LOG_ERROR("Couldn't read %" PRIx32, uicr[i].address);
1204 return res;
1205 }
1206 }
1207
1208 command_print(CMD,
1209 "\n[factory information control block]\n\n"
1210 "code page size: %"PRIu32"B\n"
1211 "code memory size: %"PRIu32"kB\n"
1212 "code region 0 size: %"PRIu32"kB\n"
1213 "pre-programmed code: %s\n"
1214 "number of ram blocks: %"PRIu32"\n"
1215 "ram block 0 size: %"PRIu32"B\n"
1216 "ram block 1 size: %"PRIu32"B\n"
1217 "ram block 2 size: %"PRIu32"B\n"
1218 "ram block 3 size: %"PRIu32 "B\n"
1219 "config id: %" PRIx32 "\n"
1220 "device id: 0x%"PRIx32"%08"PRIx32"\n"
1221 "encryption root: 0x%08"PRIx32"%08"PRIx32"%08"PRIx32"%08"PRIx32"\n"
1222 "identity root: 0x%08"PRIx32"%08"PRIx32"%08"PRIx32"%08"PRIx32"\n"
1223 "device address type: 0x%"PRIx32"\n"
1224 "device address: 0x%"PRIx32"%08"PRIx32"\n"
1225 "override enable: %"PRIx32"\n"
1226 "NRF_1MBIT values: %"PRIx32" %"PRIx32" %"PRIx32" %"PRIx32" %"PRIx32"\n"
1227 "BLE_1MBIT values: %"PRIx32" %"PRIx32" %"PRIx32" %"PRIx32" %"PRIx32"\n"
1228 "\n[user information control block]\n\n"
1229 "code region 0 size: %"PRIu32"kB\n"
1230 "read back protection configuration: %"PRIx32"\n"
1231 "reset value for XTALFREQ: %"PRIx32"\n"
1232 "firmware id: 0x%04"PRIx32,
1233 ficr[0].value,
1234 (ficr[1].value * ficr[0].value) / 1024,
1235 (ficr[2].value == 0xFFFFFFFF) ? 0 : ficr[2].value / 1024,
1236 ((ficr[3].value & 0xFF) == 0x00) ? "present" : "not present",
1237 ficr[4].value,
1238 ficr[5].value,
1239 (ficr[6].value == 0xFFFFFFFF) ? 0 : ficr[6].value,
1240 (ficr[7].value == 0xFFFFFFFF) ? 0 : ficr[7].value,
1241 (ficr[8].value == 0xFFFFFFFF) ? 0 : ficr[8].value,
1242 ficr[9].value,
1243 ficr[10].value, ficr[11].value,
1244 ficr[12].value, ficr[13].value, ficr[14].value, ficr[15].value,
1245 ficr[16].value, ficr[17].value, ficr[18].value, ficr[19].value,
1246 ficr[20].value,
1247 ficr[21].value, ficr[22].value,
1248 ficr[23].value,
1249 ficr[24].value, ficr[25].value, ficr[26].value, ficr[27].value, ficr[28].value,
1250 ficr[29].value, ficr[30].value, ficr[31].value, ficr[32].value, ficr[33].value,
1251 (uicr[0].value == 0xFFFFFFFF) ? 0 : uicr[0].value / 1024,
1252 uicr[1].value & 0xFFFF,
1253 uicr[2].value & 0xFF,
1254 uicr[3].value & 0xFFFF);
1255
1256 return ERROR_OK;
1257 }
1258
1259 static const struct command_registration nrf5_exec_command_handlers[] = {
1260 {
1261 .name = "mass_erase",
1262 .handler = nrf5_handle_mass_erase_command,
1263 .mode = COMMAND_EXEC,
1264 .help = "Erase all flash contents of the chip.",
1265 .usage = "",
1266 },
1267 {
1268 .name = "info",
1269 .handler = nrf5_handle_info_command,
1270 .mode = COMMAND_EXEC,
1271 .help = "Show FICR and UICR info.",
1272 .usage = "",
1273 },
1274 COMMAND_REGISTRATION_DONE
1275 };
1276
1277 static const struct command_registration nrf5_command_handlers[] = {
1278 {
1279 .name = "nrf5",
1280 .mode = COMMAND_ANY,
1281 .help = "nrf5 flash command group",
1282 .usage = "",
1283 .chain = nrf5_exec_command_handlers,
1284 },
1285 {
1286 .name = "nrf51",
1287 .mode = COMMAND_ANY,
1288 .help = "nrf51 flash command group",
1289 .usage = "",
1290 .chain = nrf5_exec_command_handlers,
1291 },
1292 COMMAND_REGISTRATION_DONE
1293 };
1294
1295 const struct flash_driver nrf5_flash = {
1296 .name = "nrf5",
1297 .commands = nrf5_command_handlers,
1298 .flash_bank_command = nrf5_flash_bank_command,
1299 .info = nrf5_info,
1300 .erase = nrf5_erase,
1301 .protect = nrf5_protect,
1302 .write = nrf5_write,
1303 .read = default_flash_read,
1304 .probe = nrf5_probe,
1305 .auto_probe = nrf5_auto_probe,
1306 .erase_check = default_flash_blank_check,
1307 .protect_check = nrf5_protect_check,
1308 .free_driver_priv = nrf5_free_driver_priv,
1309 };
1310
1311 /* We need to retain the flash-driver name as well as the commands
1312 * for backwards compatability */
1313 const struct flash_driver nrf51_flash = {
1314 .name = "nrf51",
1315 .commands = nrf5_command_handlers,
1316 .flash_bank_command = nrf5_flash_bank_command,
1317 .info = nrf5_info,
1318 .erase = nrf5_erase,
1319 .protect = nrf5_protect,
1320 .write = nrf5_write,
1321 .read = default_flash_read,
1322 .probe = nrf5_probe,
1323 .auto_probe = nrf5_auto_probe,
1324 .erase_check = default_flash_blank_check,
1325 .protect_check = nrf5_protect_check,
1326 .free_driver_priv = nrf5_free_driver_priv,
1327 };
Open On-Chip Debugger

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)