1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2013 Synapse Product Development *
5 * Andrey Smirnov <andrew.smironv@gmail.com> *
6 * Angus Gratton <gus@projectgus.com> *
7 * Erdem U. Altunyurt <spamjunkeater@gmail.com> *
8 ***************************************************************************/
15 #include <helper/binarybuffer.h>
16 #include <target/algorithm.h>
17 #include <target/armv7m.h>
18 #include <helper/types.h>
19 #include <helper/time_support.h>
21 /* Both those values are constant across the current spectrum ofr nRF5 devices */
22 #define WATCHDOG_REFRESH_REGISTER 0x40010600
23 #define WATCHDOG_REFRESH_VALUE 0x6e524635
26 NRF5_FLASH_BASE
= 0x00000000,
29 enum nrf5_ficr_registers
{
30 NRF5_FICR_BASE
= 0x10000000, /* Factory Information Configuration Registers */
32 #define NRF5_FICR_REG(offset) (NRF5_FICR_BASE + offset)
34 NRF5_FICR_CODEPAGESIZE
= NRF5_FICR_REG(0x010),
35 NRF5_FICR_CODESIZE
= NRF5_FICR_REG(0x014),
37 NRF51_FICR_CLENR0
= NRF5_FICR_REG(0x028),
38 NRF51_FICR_PPFC
= NRF5_FICR_REG(0x02C),
39 NRF51_FICR_NUMRAMBLOCK
= NRF5_FICR_REG(0x034),
40 NRF51_FICR_SIZERAMBLOCK0
= NRF5_FICR_REG(0x038),
41 NRF51_FICR_SIZERAMBLOCK1
= NRF5_FICR_REG(0x03C),
42 NRF51_FICR_SIZERAMBLOCK2
= NRF5_FICR_REG(0x040),
43 NRF51_FICR_SIZERAMBLOCK3
= NRF5_FICR_REG(0x044),
45 /* CONFIGID is documented on nRF51 series only.
46 * On nRF52 is present but not documented */
47 NRF5_FICR_CONFIGID
= NRF5_FICR_REG(0x05C),
49 NRF5_FICR_DEVICEID0
= NRF5_FICR_REG(0x060),
50 NRF5_FICR_DEVICEID1
= NRF5_FICR_REG(0x064),
51 NRF5_FICR_ER0
= NRF5_FICR_REG(0x080),
52 NRF5_FICR_ER1
= NRF5_FICR_REG(0x084),
53 NRF5_FICR_ER2
= NRF5_FICR_REG(0x088),
54 NRF5_FICR_ER3
= NRF5_FICR_REG(0x08C),
55 NRF5_FICR_IR0
= NRF5_FICR_REG(0x090),
56 NRF5_FICR_IR1
= NRF5_FICR_REG(0x094),
57 NRF5_FICR_IR2
= NRF5_FICR_REG(0x098),
58 NRF5_FICR_IR3
= NRF5_FICR_REG(0x09C),
59 NRF5_FICR_DEVICEADDRTYPE
= NRF5_FICR_REG(0x0A0),
60 NRF5_FICR_DEVICEADDR0
= NRF5_FICR_REG(0x0A4),
61 NRF5_FICR_DEVICEADDR1
= NRF5_FICR_REG(0x0A8),
63 NRF51_FICR_OVERRIDEN
= NRF5_FICR_REG(0x0AC),
64 NRF51_FICR_NRF_1MBIT0
= NRF5_FICR_REG(0x0B0),
65 NRF51_FICR_NRF_1MBIT1
= NRF5_FICR_REG(0x0B4),
66 NRF51_FICR_NRF_1MBIT2
= NRF5_FICR_REG(0x0B8),
67 NRF51_FICR_NRF_1MBIT3
= NRF5_FICR_REG(0x0BC),
68 NRF51_FICR_NRF_1MBIT4
= NRF5_FICR_REG(0x0C0),
69 NRF51_FICR_BLE_1MBIT0
= NRF5_FICR_REG(0x0EC),
70 NRF51_FICR_BLE_1MBIT1
= NRF5_FICR_REG(0x0F0),
71 NRF51_FICR_BLE_1MBIT2
= NRF5_FICR_REG(0x0F4),
72 NRF51_FICR_BLE_1MBIT3
= NRF5_FICR_REG(0x0F8),
73 NRF51_FICR_BLE_1MBIT4
= NRF5_FICR_REG(0x0FC),
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),
83 enum nrf5_uicr_registers
{
84 NRF5_UICR_BASE
= 0x10001000, /* User Information
85 * Configuration Registers */
87 #define NRF5_UICR_REG(offset) (NRF5_UICR_BASE + offset)
89 NRF51_UICR_CLENR0
= NRF5_UICR_REG(0x000),
90 NRF51_UICR_RBPCONF
= NRF5_UICR_REG(0x004),
91 NRF51_UICR_XTALFREQ
= NRF5_UICR_REG(0x008),
92 NRF51_UICR_FWID
= NRF5_UICR_REG(0x010),
95 enum nrf5_nvmc_registers
{
96 NRF5_NVMC_BASE
= 0x4001E000, /* Non-Volatile Memory
97 * Controller Registers */
99 #define NRF5_NVMC_REG(offset) (NRF5_NVMC_BASE + offset)
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),
107 NRF5_BPROT_BASE
= 0x40000000,
110 enum nrf5_nvmc_config_bits
{
111 NRF5_NVMC_CONFIG_REN
= 0x00,
112 NRF5_NVMC_CONFIG_WEN
= 0x01,
113 NRF5_NVMC_CONFIG_EEN
= 0x02,
117 struct nrf52_ficr_info
{
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,
132 struct nrf5_device_spec
{
136 const char *build_code
;
137 unsigned int flash_size_kb
;
138 enum nrf5_features features
;
142 unsigned int refcount
;
145 struct nrf5_info
*chip
;
148 struct target
*target
;
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
;
155 enum nrf5_features features
;
156 unsigned int flash_size_kb
;
157 unsigned int ram_size_kb
;
160 #define NRF51_DEVICE_DEF(id, pt, var, bcode, fsize) \
165 .build_code = bcode, \
166 .flash_size_kb = (fsize), \
167 .features = NRF5_FEATURE_SERIES_51, \
171 * The table maps known HWIDs to the part numbers, variant
172 * build code and some other info. For nRF51 rev 1 and 2 devices
173 * this is the only way how to get the part number and variant.
175 * All tested nRF51 rev 3 devices have FICR INFO fields
176 * but the fields are not documented in RM so we keep HWIDs in
179 * nRF52 and newer devices have FICR INFO documented, the autodetection
180 * can rely on it and HWIDs table is not used.
182 * The known devices table below is derived from the "nRF5x series
183 * compatibility matrix" documents.
185 * Up to date with Matrix v2.0, plus some additional HWIDs.
187 * The additional HWIDs apply where the build code in the matrix is
188 * shown as Gx0, Bx0, etc. In these cases the HWID in the matrix is
189 * for x==0, x!=0 means different (unspecified) HWIDs.
191 static const struct nrf5_device_spec nrf5_known_devices_table
[] = {
192 /* nRF51822 Devices (IC rev 1). */
193 NRF51_DEVICE_DEF(0x001D, "51822", "QFAA", "CA/C0", 256),
194 NRF51_DEVICE_DEF(0x0026, "51822", "QFAB", "AA", 128),
195 NRF51_DEVICE_DEF(0x0027, "51822", "QFAB", "A0", 128),
196 NRF51_DEVICE_DEF(0x0020, "51822", "CEAA", "BA", 256),
197 NRF51_DEVICE_DEF(0x002F, "51822", "CEAA", "B0", 256),
199 /* Some early nRF51-DK (PCA10028) & nRF51-Dongle (PCA10031) boards
200 with built-in jlink seem to use engineering samples not listed
201 in the nRF51 Series Compatibility Matrix V1.0. */
202 NRF51_DEVICE_DEF(0x0071, "51822", "QFAC", "AB", 256),
204 /* nRF51822 Devices (IC rev 2). */
205 NRF51_DEVICE_DEF(0x002A, "51822", "QFAA", "FA0", 256),
206 NRF51_DEVICE_DEF(0x0044, "51822", "QFAA", "GC0", 256),
207 NRF51_DEVICE_DEF(0x003C, "51822", "QFAA", "G0", 256),
208 NRF51_DEVICE_DEF(0x0057, "51822", "QFAA", "G2", 256),
209 NRF51_DEVICE_DEF(0x0058, "51822", "QFAA", "G3", 256),
210 NRF51_DEVICE_DEF(0x004C, "51822", "QFAB", "B0", 128),
211 NRF51_DEVICE_DEF(0x0040, "51822", "CEAA", "CA0", 256),
212 NRF51_DEVICE_DEF(0x0047, "51822", "CEAA", "DA0", 256),
213 NRF51_DEVICE_DEF(0x004D, "51822", "CEAA", "D00", 256),
215 /* nRF51822 Devices (IC rev 3). */
216 NRF51_DEVICE_DEF(0x0072, "51822", "QFAA", "H0", 256),
217 NRF51_DEVICE_DEF(0x00D1, "51822", "QFAA", "H2", 256),
218 NRF51_DEVICE_DEF(0x007B, "51822", "QFAB", "C0", 128),
219 NRF51_DEVICE_DEF(0x0083, "51822", "QFAC", "A0", 256),
220 NRF51_DEVICE_DEF(0x0084, "51822", "QFAC", "A1", 256),
221 NRF51_DEVICE_DEF(0x007D, "51822", "CDAB", "A0", 128),
222 NRF51_DEVICE_DEF(0x0079, "51822", "CEAA", "E0", 256),
223 NRF51_DEVICE_DEF(0x0087, "51822", "CFAC", "A0", 256),
224 NRF51_DEVICE_DEF(0x008F, "51822", "QFAA", "H1", 256),
226 /* nRF51422 Devices (IC rev 1). */
227 NRF51_DEVICE_DEF(0x001E, "51422", "QFAA", "CA", 256),
228 NRF51_DEVICE_DEF(0x0024, "51422", "QFAA", "C0", 256),
229 NRF51_DEVICE_DEF(0x0031, "51422", "CEAA", "A0A", 256),
231 /* nRF51422 Devices (IC rev 2). */
232 NRF51_DEVICE_DEF(0x002D, "51422", "QFAA", "DAA", 256),
233 NRF51_DEVICE_DEF(0x002E, "51422", "QFAA", "E0", 256),
234 NRF51_DEVICE_DEF(0x0061, "51422", "QFAB", "A00", 128),
235 NRF51_DEVICE_DEF(0x0050, "51422", "CEAA", "B0", 256),
237 /* nRF51422 Devices (IC rev 3). */
238 NRF51_DEVICE_DEF(0x0073, "51422", "QFAA", "F0", 256),
239 NRF51_DEVICE_DEF(0x007C, "51422", "QFAB", "B0", 128),
240 NRF51_DEVICE_DEF(0x0085, "51422", "QFAC", "A0", 256),
241 NRF51_DEVICE_DEF(0x0086, "51422", "QFAC", "A1", 256),
242 NRF51_DEVICE_DEF(0x007E, "51422", "CDAB", "A0", 128),
243 NRF51_DEVICE_DEF(0x007A, "51422", "CEAA", "C0", 256),
244 NRF51_DEVICE_DEF(0x0088, "51422", "CFAC", "A0", 256),
246 /* The driver fully autodetects nRF52 series devices by FICR INFO,
247 * no need for nRF52xxx HWIDs in this table */
250 struct nrf5_device_package
{
255 /* Newer devices have FICR INFO.PACKAGE.
256 * This table converts its value to two character code */
257 static const struct nrf5_device_package nrf5_packages_table
[] = {
264 const struct flash_driver nrf5_flash
, nrf51_flash
;
266 static bool nrf5_bank_is_probed(const struct flash_bank
*bank
)
268 struct nrf5_bank
*nbank
= bank
->driver_priv
;
272 return nbank
->probed
;
274 static int nrf5_probe(struct flash_bank
*bank
);
276 static int nrf5_get_probed_chip_if_halted(struct flash_bank
*bank
, struct nrf5_info
**chip
)
278 if (bank
->target
->state
!= TARGET_HALTED
) {
279 LOG_ERROR("Target not halted");
280 return ERROR_TARGET_NOT_HALTED
;
283 struct nrf5_bank
*nbank
= bank
->driver_priv
;
286 if (nrf5_bank_is_probed(bank
))
289 return nrf5_probe(bank
);
292 static int nrf5_wait_for_nvmc(struct nrf5_info
*chip
)
296 int timeout_ms
= 340;
297 int64_t ts_start
= timeval_ms();
300 res
= target_read_u32(chip
->target
, NRF5_NVMC_READY
, &ready
);
301 if (res
!= ERROR_OK
) {
302 LOG_ERROR("Error waiting NVMC_READY: generic flash write/erase error (check protection etc...)");
306 if (ready
== 0x00000001)
311 } while ((timeval_ms()-ts_start
) < timeout_ms
);
313 LOG_DEBUG("Timed out waiting for NVMC_READY");
314 return ERROR_FLASH_BUSY
;
317 static int nrf5_nvmc_erase_enable(struct nrf5_info
*chip
)
320 res
= target_write_u32(chip
->target
,
322 NRF5_NVMC_CONFIG_EEN
);
324 if (res
!= ERROR_OK
) {
325 LOG_ERROR("Failed to enable erase operation");
330 According to NVMC examples in Nordic SDK busy status must be
331 checked after writing to NVMC_CONFIG
333 res
= nrf5_wait_for_nvmc(chip
);
335 LOG_ERROR("Erase enable did not complete");
340 static int nrf5_nvmc_write_enable(struct nrf5_info
*chip
)
343 res
= target_write_u32(chip
->target
,
345 NRF5_NVMC_CONFIG_WEN
);
347 if (res
!= ERROR_OK
) {
348 LOG_ERROR("Failed to enable write operation");
353 According to NVMC examples in Nordic SDK busy status must be
354 checked after writing to NVMC_CONFIG
356 res
= nrf5_wait_for_nvmc(chip
);
358 LOG_ERROR("Write enable did not complete");
363 static int nrf5_nvmc_read_only(struct nrf5_info
*chip
)
366 res
= target_write_u32(chip
->target
,
368 NRF5_NVMC_CONFIG_REN
);
370 if (res
!= ERROR_OK
) {
371 LOG_ERROR("Failed to enable read-only operation");
375 According to NVMC examples in Nordic SDK busy status must be
376 checked after writing to NVMC_CONFIG
378 res
= nrf5_wait_for_nvmc(chip
);
380 LOG_ERROR("Read only enable did not complete");
385 static int nrf5_nvmc_generic_erase(struct nrf5_info
*chip
,
386 uint32_t erase_register
, uint32_t erase_value
)
390 res
= nrf5_nvmc_erase_enable(chip
);
394 res
= target_write_u32(chip
->target
,
400 res
= nrf5_wait_for_nvmc(chip
);
404 return nrf5_nvmc_read_only(chip
);
407 nrf5_nvmc_read_only(chip
);
409 LOG_ERROR("Failed to erase reg: 0x%08"PRIx32
" val: 0x%08"PRIx32
,
410 erase_register
, erase_value
);
414 static int nrf5_protect_check_clenr0(struct flash_bank
*bank
)
418 struct nrf5_bank
*nbank
= bank
->driver_priv
;
419 struct nrf5_info
*chip
= nbank
->chip
;
423 res
= target_read_u32(chip
->target
, NRF51_FICR_CLENR0
,
425 if (res
!= ERROR_OK
) {
426 LOG_ERROR("Couldn't read code region 0 size[FICR]");
430 if (clenr0
== 0xFFFFFFFF) {
431 res
= target_read_u32(chip
->target
, NRF51_UICR_CLENR0
,
433 if (res
!= ERROR_OK
) {
434 LOG_ERROR("Couldn't read code region 0 size[UICR]");
439 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++)
440 bank
->sectors
[i
].is_protected
=
441 clenr0
!= 0xFFFFFFFF && bank
->sectors
[i
].offset
< clenr0
;
446 static int nrf5_protect_check_bprot(struct flash_bank
*bank
)
448 struct nrf5_bank
*nbank
= bank
->driver_priv
;
449 struct nrf5_info
*chip
= nbank
->chip
;
453 static uint32_t nrf5_bprot_offsets
[4] = { 0x600, 0x604, 0x610, 0x614 };
454 uint32_t bprot_reg
= 0;
457 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++) {
458 unsigned int bit
= i
% 32;
460 unsigned int n_reg
= i
/ 32;
461 if (n_reg
>= ARRAY_SIZE(nrf5_bprot_offsets
))
464 res
= target_read_u32(chip
->target
, NRF5_BPROT_BASE
+ nrf5_bprot_offsets
[n_reg
], &bprot_reg
);
468 bank
->sectors
[i
].is_protected
= (bprot_reg
& (1 << bit
)) ? 1 : 0;
473 static int nrf5_protect_check(struct flash_bank
*bank
)
475 /* UICR cannot be write protected so just return early */
476 if (bank
->base
== NRF5_UICR_BASE
)
479 struct nrf5_bank
*nbank
= bank
->driver_priv
;
480 struct nrf5_info
*chip
= nbank
->chip
;
484 if (chip
->features
& NRF5_FEATURE_BPROT
)
485 return nrf5_protect_check_bprot(bank
);
487 if (chip
->features
& NRF5_FEATURE_SERIES_51
)
488 return nrf5_protect_check_clenr0(bank
);
490 LOG_WARNING("Flash protection of this nRF device is not supported");
491 return ERROR_FLASH_OPER_UNSUPPORTED
;
494 static int nrf5_protect_clenr0(struct flash_bank
*bank
, int set
, unsigned int first
,
498 uint32_t clenr0
, ppfc
;
499 struct nrf5_bank
*nbank
= bank
->driver_priv
;
500 struct nrf5_info
*chip
= nbank
->chip
;
503 LOG_ERROR("Code region 0 must start at the beginning of the bank");
507 res
= target_read_u32(chip
->target
, NRF51_FICR_PPFC
,
509 if (res
!= ERROR_OK
) {
510 LOG_ERROR("Couldn't read PPFC register");
514 if ((ppfc
& 0xFF) == 0x00) {
515 LOG_ERROR("Code region 0 size was pre-programmed at the factory, can't change flash protection settings");
519 res
= target_read_u32(chip
->target
, NRF51_UICR_CLENR0
,
521 if (res
!= ERROR_OK
) {
522 LOG_ERROR("Couldn't read code region 0 size from UICR");
526 if (!set
|| clenr0
!= 0xFFFFFFFF) {
527 LOG_ERROR("You need to perform chip erase before changing the protection settings");
531 res
= nrf5_nvmc_write_enable(chip
);
535 clenr0
= bank
->sectors
[last
].offset
+ bank
->sectors
[last
].size
;
536 res
= target_write_u32(chip
->target
, NRF51_UICR_CLENR0
, clenr0
);
538 int res2
= nrf5_wait_for_nvmc(chip
);
544 LOG_INFO("A reset or power cycle is required for the new protection settings to take effect.");
546 LOG_ERROR("Couldn't write code region 0 size to UICR");
549 nrf5_nvmc_read_only(chip
);
554 static int nrf5_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
558 struct nrf5_info
*chip
;
560 /* UICR cannot be write protected so just bail out early */
561 if (bank
->base
== NRF5_UICR_BASE
) {
562 LOG_ERROR("UICR page does not support protection");
563 return ERROR_FLASH_OPER_UNSUPPORTED
;
566 res
= nrf5_get_probed_chip_if_halted(bank
, &chip
);
570 if (chip
->features
& NRF5_FEATURE_SERIES_51
)
571 return nrf5_protect_clenr0(bank
, set
, first
, last
);
573 LOG_ERROR("Flash protection setting is not supported on this nRF5 device");
574 return ERROR_FLASH_OPER_UNSUPPORTED
;
577 static bool nrf5_info_variant_to_str(uint32_t variant
, char *bf
)
581 h_u32_to_be(b
, variant
);
582 if (isalnum(b
[0]) && isalnum(b
[1]) && isalnum(b
[2]) && isalnum(b
[3])) {
592 static const char *nrf5_decode_info_package(uint32_t package
)
594 for (size_t i
= 0; i
< ARRAY_SIZE(nrf5_packages_table
); i
++) {
595 if (nrf5_packages_table
[i
].package
== package
)
596 return nrf5_packages_table
[i
].code
;
601 static int get_nrf5_chip_type_str(const struct nrf5_info
*chip
, char *buf
, unsigned int buf_size
)
605 res
= snprintf(buf
, buf_size
, "nRF%s-%s(build code: %s)",
606 chip
->spec
->part
, chip
->spec
->variant
, chip
->spec
->build_code
);
607 } else if (chip
->ficr_info_valid
) {
609 nrf5_info_variant_to_str(chip
->ficr_info
.variant
, variant
);
610 res
= snprintf(buf
, buf_size
, "nRF%" PRIx32
"-%s%.2s(build code: %s)",
611 chip
->ficr_info
.part
,
612 nrf5_decode_info_package(chip
->ficr_info
.package
),
613 variant
, &variant
[2]);
615 res
= snprintf(buf
, buf_size
, "nRF51xxx (HWID 0x%04" PRIx16
")", chip
->hwid
);
619 if (res
<= 0 || (unsigned int)res
>= buf_size
) {
620 LOG_ERROR("BUG: buffer problem in %s", __func__
);
626 static int nrf5_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
628 struct nrf5_bank
*nbank
= bank
->driver_priv
;
629 struct nrf5_info
*chip
= nbank
->chip
;
631 char chip_type_str
[256];
632 if (get_nrf5_chip_type_str(chip
, chip_type_str
, sizeof(chip_type_str
)) != ERROR_OK
)
635 command_print_sameline(cmd
, "%s %ukB Flash, %ukB RAM",
636 chip_type_str
, chip
->flash_size_kb
, chip
->ram_size_kb
);
640 static int nrf5_read_ficr_info(struct nrf5_info
*chip
)
643 struct target
*target
= chip
->target
;
645 chip
->ficr_info_valid
= false;
647 res
= target_read_u32(target
, NRF5_FICR_INFO_PART
, &chip
->ficr_info
.part
);
648 if (res
!= ERROR_OK
) {
649 LOG_DEBUG("Couldn't read FICR INFO.PART register");
653 uint32_t series
= chip
->ficr_info
.part
& 0xfffff000;
656 chip
->features
= NRF5_FEATURE_SERIES_51
;
660 chip
->features
= NRF5_FEATURE_SERIES_52
;
662 switch (chip
->ficr_info
.part
) {
665 chip
->features
|= NRF5_FEATURE_BPROT
;
669 chip
->features
|= NRF5_FEATURE_ACL_PROT
;
675 LOG_DEBUG("FICR INFO likely not implemented. Invalid PART value 0x%08"
676 PRIx32
, chip
->ficr_info
.part
);
677 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
680 /* Now we know the device has FICR INFO filled by something relevant:
681 * Although it is not documented, the tested nRF51 rev 3 devices
682 * have FICR INFO.PART, RAM and FLASH of the same format as nRF52.
683 * VARIANT and PACKAGE coding is unknown for a nRF51 device.
684 * nRF52 devices have FICR INFO documented and always filled. */
686 res
= target_read_u32(target
, NRF5_FICR_INFO_VARIANT
, &chip
->ficr_info
.variant
);
690 res
= target_read_u32(target
, NRF5_FICR_INFO_PACKAGE
, &chip
->ficr_info
.package
);
694 res
= target_read_u32(target
, NRF5_FICR_INFO_RAM
, &chip
->ficr_info
.ram
);
698 res
= target_read_u32(target
, NRF5_FICR_INFO_FLASH
, &chip
->ficr_info
.flash
);
702 chip
->ficr_info_valid
= true;
706 static int nrf5_get_ram_size(struct target
*target
, uint32_t *ram_size
)
712 uint32_t numramblock
;
713 res
= target_read_u32(target
, NRF51_FICR_NUMRAMBLOCK
, &numramblock
);
714 if (res
!= ERROR_OK
) {
715 LOG_DEBUG("Couldn't read FICR NUMRAMBLOCK register");
719 if (numramblock
< 1 || numramblock
> 4) {
720 LOG_DEBUG("FICR NUMRAMBLOCK strange value %" PRIx32
, numramblock
);
721 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
724 for (unsigned int i
= 0; i
< numramblock
; i
++) {
725 uint32_t sizeramblock
;
726 res
= target_read_u32(target
, NRF51_FICR_SIZERAMBLOCK0
+ sizeof(uint32_t)*i
, &sizeramblock
);
727 if (res
!= ERROR_OK
) {
728 LOG_DEBUG("Couldn't read FICR NUMRAMBLOCK register");
731 if (sizeramblock
< 1024 || sizeramblock
> 65536)
732 LOG_DEBUG("FICR SIZERAMBLOCK strange value %" PRIx32
, sizeramblock
);
734 *ram_size
+= sizeramblock
;
739 static int nrf5_probe(struct flash_bank
*bank
)
742 struct nrf5_bank
*nbank
= bank
->driver_priv
;
743 struct nrf5_info
*chip
= nbank
->chip
;
744 struct target
*target
= chip
->target
;
747 res
= target_read_u32(target
, NRF5_FICR_CONFIGID
, &configid
);
748 if (res
!= ERROR_OK
) {
749 LOG_ERROR("Couldn't read CONFIGID register");
753 /* HWID is stored in the lower two bytes of the CONFIGID register */
754 chip
->hwid
= configid
& 0xFFFF;
756 /* guess a nRF51 series if the device has no FICR INFO and we don't know HWID */
757 chip
->features
= NRF5_FEATURE_SERIES_51
;
759 /* Don't bail out on error for the case that some old engineering
760 * sample has FICR INFO registers unreadable. We can proceed anyway. */
761 (void)nrf5_read_ficr_info(chip
);
764 for (size_t i
= 0; i
< ARRAY_SIZE(nrf5_known_devices_table
); i
++) {
765 if (chip
->hwid
== nrf5_known_devices_table
[i
].hwid
) {
766 chip
->spec
= &nrf5_known_devices_table
[i
];
767 chip
->features
= chip
->spec
->features
;
772 if (chip
->spec
&& chip
->ficr_info_valid
) {
773 /* check if HWID table gives the same part as FICR INFO */
774 if (chip
->ficr_info
.part
!= strtoul(chip
->spec
->part
, NULL
, 16))
775 LOG_WARNING("HWID 0x%04" PRIx32
" mismatch: FICR INFO.PART %"
776 PRIx32
, chip
->hwid
, chip
->ficr_info
.part
);
779 if (chip
->ficr_info_valid
) {
780 chip
->ram_size_kb
= chip
->ficr_info
.ram
;
783 nrf5_get_ram_size(target
, &ram_size
);
784 chip
->ram_size_kb
= ram_size
/ 1024;
787 /* The value stored in NRF5_FICR_CODEPAGESIZE is the number of bytes in one page of FLASH. */
788 uint32_t flash_page_size
;
789 res
= target_read_u32(chip
->target
, NRF5_FICR_CODEPAGESIZE
,
791 if (res
!= ERROR_OK
) {
792 LOG_ERROR("Couldn't read code page size");
796 /* Note the register name is misleading,
797 * NRF5_FICR_CODESIZE is the number of pages in flash memory, not the number of bytes! */
798 uint32_t num_sectors
;
799 res
= target_read_u32(chip
->target
, NRF5_FICR_CODESIZE
, &num_sectors
);
800 if (res
!= ERROR_OK
) {
801 LOG_ERROR("Couldn't read code memory size");
805 chip
->flash_size_kb
= num_sectors
* flash_page_size
/ 1024;
807 if (!chip
->bank
[0].probed
&& !chip
->bank
[1].probed
) {
808 char chip_type_str
[256];
809 if (get_nrf5_chip_type_str(chip
, chip_type_str
, sizeof(chip_type_str
)) != ERROR_OK
)
811 const bool device_is_unknown
= (!chip
->spec
&& !chip
->ficr_info_valid
);
812 LOG_INFO("%s%s %ukB Flash, %ukB RAM",
813 device_is_unknown
? "Unknown device: " : "",
821 if (bank
->base
== NRF5_FLASH_BASE
) {
823 if (chip
->spec
&& chip
->flash_size_kb
!= chip
->spec
->flash_size_kb
)
824 LOG_WARNING("Chip's reported Flash capacity does not match expected one");
825 if (chip
->ficr_info_valid
&& chip
->flash_size_kb
!= chip
->ficr_info
.flash
)
826 LOG_WARNING("Chip's reported Flash capacity does not match FICR INFO.FLASH");
828 bank
->num_sectors
= num_sectors
;
829 bank
->size
= num_sectors
* flash_page_size
;
831 bank
->sectors
= alloc_block_array(0, flash_page_size
, num_sectors
);
835 chip
->bank
[0].probed
= true;
838 bank
->num_sectors
= 1;
839 bank
->size
= flash_page_size
;
841 bank
->sectors
= alloc_block_array(0, flash_page_size
, num_sectors
);
845 bank
->sectors
[0].is_protected
= 0;
847 chip
->bank
[1].probed
= true;
853 static int nrf5_auto_probe(struct flash_bank
*bank
)
855 if (nrf5_bank_is_probed(bank
))
858 return nrf5_probe(bank
);
861 static int nrf5_erase_all(struct nrf5_info
*chip
)
863 LOG_DEBUG("Erasing all non-volatile memory");
864 return nrf5_nvmc_generic_erase(chip
,
869 static int nrf5_erase_page(struct flash_bank
*bank
,
870 struct nrf5_info
*chip
,
871 struct flash_sector
*sector
)
875 LOG_DEBUG("Erasing page at 0x%"PRIx32
, sector
->offset
);
877 if (bank
->base
== NRF5_UICR_BASE
) {
878 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
880 res
= target_read_u32(chip
->target
, NRF51_FICR_PPFC
,
882 if (res
!= ERROR_OK
) {
883 LOG_ERROR("Couldn't read PPFC register");
887 if ((ppfc
& 0xFF) == 0xFF) {
888 /* We can't erase the UICR. Double-check to
889 see if it's already erased before complaining. */
890 default_flash_blank_check(bank
);
891 if (sector
->is_erased
== 1)
894 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");
899 res
= nrf5_nvmc_generic_erase(chip
,
905 res
= nrf5_nvmc_generic_erase(chip
,
913 /* Start a low level flash write for the specified region */
914 static int nrf5_ll_flash_write(struct nrf5_info
*chip
, uint32_t address
, const uint8_t *buffer
, uint32_t bytes
)
916 struct target
*target
= chip
->target
;
917 uint32_t buffer_size
= 8192;
918 struct working_area
*write_algorithm
;
919 struct working_area
*source
;
920 struct reg_param reg_params
[6];
921 struct armv7m_algorithm armv7m_info
;
922 int retval
= ERROR_OK
;
924 static const uint8_t nrf5_flash_write_code
[] = {
925 #include "../../../contrib/loaders/flash/nrf5/nrf5.inc"
928 LOG_DEBUG("Writing buffer to flash address=0x%"PRIx32
" bytes=0x%"PRIx32
, address
, bytes
);
929 assert(bytes
% 4 == 0);
931 /* allocate working area with flash programming code */
932 if (target_alloc_working_area(target
, sizeof(nrf5_flash_write_code
),
933 &write_algorithm
) != ERROR_OK
) {
934 LOG_WARNING("no working area available, falling back to slow memory writes");
936 for (; bytes
> 0; bytes
-= 4) {
937 retval
= target_write_memory(target
, address
, 4, 1, buffer
);
938 if (retval
!= ERROR_OK
)
941 retval
= nrf5_wait_for_nvmc(chip
);
942 if (retval
!= ERROR_OK
)
952 retval
= target_write_buffer(target
, write_algorithm
->address
,
953 sizeof(nrf5_flash_write_code
),
954 nrf5_flash_write_code
);
955 if (retval
!= ERROR_OK
)
959 while (target_alloc_working_area(target
, buffer_size
, &source
) != ERROR_OK
) {
961 buffer_size
&= ~3UL; /* Make sure it's 4 byte aligned */
962 if (buffer_size
<= 256) {
963 /* free working area, write algorithm already allocated */
964 target_free_working_area(target
, write_algorithm
);
966 LOG_WARNING("No large enough working area available, can't do block memory writes");
967 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
971 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
972 armv7m_info
.core_mode
= ARM_MODE_THREAD
;
974 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
); /* byte count */
975 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
); /* buffer start */
976 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
); /* buffer end */
977 init_reg_param(®_params
[3], "r3", 32, PARAM_IN_OUT
); /* target address */
978 init_reg_param(®_params
[4], "r6", 32, PARAM_OUT
); /* watchdog refresh value */
979 init_reg_param(®_params
[5], "r7", 32, PARAM_OUT
); /* watchdog refresh register address */
981 buf_set_u32(reg_params
[0].value
, 0, 32, bytes
);
982 buf_set_u32(reg_params
[1].value
, 0, 32, source
->address
);
983 buf_set_u32(reg_params
[2].value
, 0, 32, source
->address
+ source
->size
);
984 buf_set_u32(reg_params
[3].value
, 0, 32, address
);
985 buf_set_u32(reg_params
[4].value
, 0, 32, WATCHDOG_REFRESH_VALUE
);
986 buf_set_u32(reg_params
[5].value
, 0, 32, WATCHDOG_REFRESH_REGISTER
);
988 retval
= target_run_flash_async_algorithm(target
, buffer
, bytes
/4, 4,
990 ARRAY_SIZE(reg_params
), reg_params
,
991 source
->address
, source
->size
,
992 write_algorithm
->address
, write_algorithm
->address
+ sizeof(nrf5_flash_write_code
) - 2,
995 target_free_working_area(target
, source
);
996 target_free_working_area(target
, write_algorithm
);
998 destroy_reg_param(®_params
[0]);
999 destroy_reg_param(®_params
[1]);
1000 destroy_reg_param(®_params
[2]);
1001 destroy_reg_param(®_params
[3]);
1002 destroy_reg_param(®_params
[4]);
1003 destroy_reg_param(®_params
[5]);
1008 static int nrf5_write(struct flash_bank
*bank
, const uint8_t *buffer
,
1009 uint32_t offset
, uint32_t count
)
1011 struct nrf5_info
*chip
;
1013 int res
= nrf5_get_probed_chip_if_halted(bank
, &chip
);
1014 if (res
!= ERROR_OK
)
1017 assert(offset
% 4 == 0);
1018 assert(count
% 4 == 0);
1020 /* UICR CLENR0 based protection used on nRF51 is somewhat clumsy:
1021 * RM reads: Code running from code region 1 will not be able to write
1023 * Unfortunately the flash loader running from RAM can write to both
1024 * code regions without any hint the protection is violated.
1026 * Update protection state and check if any flash sector to be written
1028 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
1030 res
= nrf5_protect_check_clenr0(bank
);
1031 if (res
!= ERROR_OK
)
1034 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
1035 struct flash_sector
*bs
= &bank
->sectors
[sector
];
1037 /* Start offset in or before this sector? */
1038 /* End offset in or behind this sector? */
1039 if ((offset
< (bs
->offset
+ bs
->size
))
1040 && ((offset
+ count
- 1) >= bs
->offset
)
1041 && bs
->is_protected
== 1) {
1042 LOG_ERROR("Write refused, sector %d is protected", sector
);
1043 return ERROR_FLASH_PROTECTED
;
1048 res
= nrf5_nvmc_write_enable(chip
);
1049 if (res
!= ERROR_OK
)
1052 res
= nrf5_ll_flash_write(chip
, bank
->base
+ offset
, buffer
, count
);
1053 if (res
!= ERROR_OK
)
1056 return nrf5_nvmc_read_only(chip
);
1059 nrf5_nvmc_read_only(chip
);
1060 LOG_ERROR("Failed to write to nrf5 flash");
1064 static int nrf5_erase(struct flash_bank
*bank
, unsigned int first
,
1068 struct nrf5_info
*chip
;
1070 res
= nrf5_get_probed_chip_if_halted(bank
, &chip
);
1071 if (res
!= ERROR_OK
)
1074 /* UICR CLENR0 based protection used on nRF51 prevents erase
1075 * absolutely silently. NVMC has no flag to indicate the protection
1078 * Update protection state and check if any flash sector to be erased
1080 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
1082 res
= nrf5_protect_check_clenr0(bank
);
1083 if (res
!= ERROR_OK
)
1087 /* For each sector to be erased */
1088 for (unsigned int s
= first
; s
<= last
&& res
== ERROR_OK
; s
++) {
1090 if (chip
->features
& NRF5_FEATURE_SERIES_51
1091 && bank
->sectors
[s
].is_protected
== 1) {
1092 LOG_ERROR("Flash sector %d is protected", s
);
1093 return ERROR_FLASH_PROTECTED
;
1096 res
= nrf5_erase_page(bank
, chip
, &bank
->sectors
[s
]);
1097 if (res
!= ERROR_OK
) {
1098 LOG_ERROR("Error erasing sector %d", s
);
1106 static void nrf5_free_driver_priv(struct flash_bank
*bank
)
1108 struct nrf5_bank
*nbank
= bank
->driver_priv
;
1109 struct nrf5_info
*chip
= nbank
->chip
;
1114 if (chip
->refcount
== 0) {
1116 bank
->driver_priv
= NULL
;
1120 static struct nrf5_info
*nrf5_get_chip(struct target
*target
)
1122 struct flash_bank
*bank_iter
;
1124 /* iterate over nrf5 banks of same target */
1125 for (bank_iter
= flash_bank_list(); bank_iter
; bank_iter
= bank_iter
->next
) {
1126 if (bank_iter
->driver
!= &nrf5_flash
&& bank_iter
->driver
!= &nrf51_flash
)
1129 if (bank_iter
->target
!= target
)
1132 struct nrf5_bank
*nbank
= bank_iter
->driver_priv
;
1142 FLASH_BANK_COMMAND_HANDLER(nrf5_flash_bank_command
)
1144 struct nrf5_info
*chip
;
1145 struct nrf5_bank
*nbank
= NULL
;
1147 if (bank
->driver
== &nrf51_flash
)
1148 LOG_WARNING("Flash driver 'nrf51' is deprecated! Use 'nrf5' instead.");
1150 switch (bank
->base
) {
1151 case NRF5_FLASH_BASE
:
1152 case NRF5_UICR_BASE
:
1155 LOG_ERROR("Invalid bank address " TARGET_ADDR_FMT
, bank
->base
);
1159 chip
= nrf5_get_chip(bank
->target
);
1161 /* Create a new chip */
1162 chip
= calloc(1, sizeof(*chip
));
1166 chip
->target
= bank
->target
;
1169 switch (bank
->base
) {
1170 case NRF5_FLASH_BASE
:
1171 nbank
= &chip
->bank
[0];
1173 case NRF5_UICR_BASE
:
1174 nbank
= &chip
->bank
[1];
1181 nbank
->probed
= false;
1182 bank
->driver_priv
= nbank
;
1183 bank
->write_start_alignment
= bank
->write_end_alignment
= 4;
1188 COMMAND_HANDLER(nrf5_handle_mass_erase_command
)
1191 struct flash_bank
*bank
= NULL
;
1192 struct target
*target
= get_current_target(CMD_CTX
);
1194 res
= get_flash_bank_by_addr(target
, NRF5_FLASH_BASE
, true, &bank
);
1195 if (res
!= ERROR_OK
)
1200 struct nrf5_info
*chip
;
1202 res
= nrf5_get_probed_chip_if_halted(bank
, &chip
);
1203 if (res
!= ERROR_OK
)
1206 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
1208 res
= target_read_u32(target
, NRF51_FICR_PPFC
,
1210 if (res
!= ERROR_OK
) {
1211 LOG_ERROR("Couldn't read PPFC register");
1215 if ((ppfc
& 0xFF) == 0x00) {
1216 LOG_ERROR("Code region 0 size was pre-programmed at the factory, "
1217 "mass erase command won't work.");
1222 res
= nrf5_erase_all(chip
);
1223 if (res
== ERROR_OK
) {
1224 LOG_INFO("Mass erase completed.");
1225 if (chip
->features
& NRF5_FEATURE_SERIES_51
)
1226 LOG_INFO("A reset or power cycle is required if the flash was protected before.");
1229 LOG_ERROR("Failed to erase the chip");
1235 COMMAND_HANDLER(nrf5_handle_info_command
)
1238 struct flash_bank
*bank
= NULL
;
1239 struct target
*target
= get_current_target(CMD_CTX
);
1241 res
= get_flash_bank_by_addr(target
, NRF5_FLASH_BASE
, true, &bank
);
1242 if (res
!= ERROR_OK
)
1247 struct nrf5_info
*chip
;
1249 res
= nrf5_get_probed_chip_if_halted(bank
, &chip
);
1250 if (res
!= ERROR_OK
)
1254 const uint32_t address
;
1257 { .address
= NRF5_FICR_CODEPAGESIZE
},
1258 { .address
= NRF5_FICR_CODESIZE
},
1259 { .address
= NRF51_FICR_CLENR0
},
1260 { .address
= NRF51_FICR_PPFC
},
1261 { .address
= NRF51_FICR_NUMRAMBLOCK
},
1262 { .address
= NRF51_FICR_SIZERAMBLOCK0
},
1263 { .address
= NRF51_FICR_SIZERAMBLOCK1
},
1264 { .address
= NRF51_FICR_SIZERAMBLOCK2
},
1265 { .address
= NRF51_FICR_SIZERAMBLOCK3
},
1266 { .address
= NRF5_FICR_CONFIGID
},
1267 { .address
= NRF5_FICR_DEVICEID0
},
1268 { .address
= NRF5_FICR_DEVICEID1
},
1269 { .address
= NRF5_FICR_ER0
},
1270 { .address
= NRF5_FICR_ER1
},
1271 { .address
= NRF5_FICR_ER2
},
1272 { .address
= NRF5_FICR_ER3
},
1273 { .address
= NRF5_FICR_IR0
},
1274 { .address
= NRF5_FICR_IR1
},
1275 { .address
= NRF5_FICR_IR2
},
1276 { .address
= NRF5_FICR_IR3
},
1277 { .address
= NRF5_FICR_DEVICEADDRTYPE
},
1278 { .address
= NRF5_FICR_DEVICEADDR0
},
1279 { .address
= NRF5_FICR_DEVICEADDR1
},
1280 { .address
= NRF51_FICR_OVERRIDEN
},
1281 { .address
= NRF51_FICR_NRF_1MBIT0
},
1282 { .address
= NRF51_FICR_NRF_1MBIT1
},
1283 { .address
= NRF51_FICR_NRF_1MBIT2
},
1284 { .address
= NRF51_FICR_NRF_1MBIT3
},
1285 { .address
= NRF51_FICR_NRF_1MBIT4
},
1286 { .address
= NRF51_FICR_BLE_1MBIT0
},
1287 { .address
= NRF51_FICR_BLE_1MBIT1
},
1288 { .address
= NRF51_FICR_BLE_1MBIT2
},
1289 { .address
= NRF51_FICR_BLE_1MBIT3
},
1290 { .address
= NRF51_FICR_BLE_1MBIT4
},
1292 { .address
= NRF51_UICR_CLENR0
, },
1293 { .address
= NRF51_UICR_RBPCONF
},
1294 { .address
= NRF51_UICR_XTALFREQ
},
1295 { .address
= NRF51_UICR_FWID
},
1298 for (size_t i
= 0; i
< ARRAY_SIZE(ficr
); i
++) {
1299 res
= target_read_u32(chip
->target
, ficr
[i
].address
,
1301 if (res
!= ERROR_OK
) {
1302 LOG_ERROR("Couldn't read %" PRIx32
, ficr
[i
].address
);
1307 for (size_t i
= 0; i
< ARRAY_SIZE(uicr
); i
++) {
1308 res
= target_read_u32(chip
->target
, uicr
[i
].address
,
1310 if (res
!= ERROR_OK
) {
1311 LOG_ERROR("Couldn't read %" PRIx32
, uicr
[i
].address
);
1317 "\n[factory information control block]\n\n"
1318 "code page size: %"PRIu32
"B\n"
1319 "code memory size: %"PRIu32
"kB\n"
1320 "code region 0 size: %"PRIu32
"kB\n"
1321 "pre-programmed code: %s\n"
1322 "number of ram blocks: %"PRIu32
"\n"
1323 "ram block 0 size: %"PRIu32
"B\n"
1324 "ram block 1 size: %"PRIu32
"B\n"
1325 "ram block 2 size: %"PRIu32
"B\n"
1326 "ram block 3 size: %"PRIu32
"B\n"
1327 "config id: %" PRIx32
"\n"
1328 "device id: 0x%"PRIx32
"%08"PRIx32
"\n"
1329 "encryption root: 0x%08"PRIx32
"%08"PRIx32
"%08"PRIx32
"%08"PRIx32
"\n"
1330 "identity root: 0x%08"PRIx32
"%08"PRIx32
"%08"PRIx32
"%08"PRIx32
"\n"
1331 "device address type: 0x%"PRIx32
"\n"
1332 "device address: 0x%"PRIx32
"%08"PRIx32
"\n"
1333 "override enable: %"PRIx32
"\n"
1334 "NRF_1MBIT values: %"PRIx32
" %"PRIx32
" %"PRIx32
" %"PRIx32
" %"PRIx32
"\n"
1335 "BLE_1MBIT values: %"PRIx32
" %"PRIx32
" %"PRIx32
" %"PRIx32
" %"PRIx32
"\n"
1336 "\n[user information control block]\n\n"
1337 "code region 0 size: %"PRIu32
"kB\n"
1338 "read back protection configuration: %"PRIx32
"\n"
1339 "reset value for XTALFREQ: %"PRIx32
"\n"
1340 "firmware id: 0x%04"PRIx32
,
1342 (ficr
[1].value
* ficr
[0].value
) / 1024,
1343 (ficr
[2].value
== 0xFFFFFFFF) ? 0 : ficr
[2].value
/ 1024,
1344 ((ficr
[3].value
& 0xFF) == 0x00) ? "present" : "not present",
1347 (ficr
[6].value
== 0xFFFFFFFF) ? 0 : ficr
[6].value
,
1348 (ficr
[7].value
== 0xFFFFFFFF) ? 0 : ficr
[7].value
,
1349 (ficr
[8].value
== 0xFFFFFFFF) ? 0 : ficr
[8].value
,
1351 ficr
[10].value
, ficr
[11].value
,
1352 ficr
[12].value
, ficr
[13].value
, ficr
[14].value
, ficr
[15].value
,
1353 ficr
[16].value
, ficr
[17].value
, ficr
[18].value
, ficr
[19].value
,
1355 ficr
[21].value
, ficr
[22].value
,
1357 ficr
[24].value
, ficr
[25].value
, ficr
[26].value
, ficr
[27].value
, ficr
[28].value
,
1358 ficr
[29].value
, ficr
[30].value
, ficr
[31].value
, ficr
[32].value
, ficr
[33].value
,
1359 (uicr
[0].value
== 0xFFFFFFFF) ? 0 : uicr
[0].value
/ 1024,
1360 uicr
[1].value
& 0xFFFF,
1361 uicr
[2].value
& 0xFF,
1362 uicr
[3].value
& 0xFFFF);
1367 static const struct command_registration nrf5_exec_command_handlers
[] = {
1369 .name
= "mass_erase",
1370 .handler
= nrf5_handle_mass_erase_command
,
1371 .mode
= COMMAND_EXEC
,
1372 .help
= "Erase all flash contents of the chip.",
1377 .handler
= nrf5_handle_info_command
,
1378 .mode
= COMMAND_EXEC
,
1379 .help
= "Show FICR and UICR info.",
1382 COMMAND_REGISTRATION_DONE
1385 static const struct command_registration nrf5_command_handlers
[] = {
1388 .mode
= COMMAND_ANY
,
1389 .help
= "nrf5 flash command group",
1391 .chain
= nrf5_exec_command_handlers
,
1395 .mode
= COMMAND_ANY
,
1396 .help
= "nrf51 flash command group",
1398 .chain
= nrf5_exec_command_handlers
,
1400 COMMAND_REGISTRATION_DONE
1403 const struct flash_driver nrf5_flash
= {
1405 .commands
= nrf5_command_handlers
,
1406 .flash_bank_command
= nrf5_flash_bank_command
,
1408 .erase
= nrf5_erase
,
1409 .protect
= nrf5_protect
,
1410 .write
= nrf5_write
,
1411 .read
= default_flash_read
,
1412 .probe
= nrf5_probe
,
1413 .auto_probe
= nrf5_auto_probe
,
1414 .erase_check
= default_flash_blank_check
,
1415 .protect_check
= nrf5_protect_check
,
1416 .free_driver_priv
= nrf5_free_driver_priv
,
1419 /* We need to retain the flash-driver name as well as the commands
1420 * for backwards compatibility */
1421 const struct flash_driver nrf51_flash
= {
1423 .commands
= nrf5_command_handlers
,
1424 .flash_bank_command
= nrf5_flash_bank_command
,
1426 .erase
= nrf5_erase
,
1427 .protect
= nrf5_protect
,
1428 .write
= nrf5_write
,
1429 .read
= default_flash_read
,
1430 .probe
= nrf5_probe
,
1431 .auto_probe
= nrf5_auto_probe
,
1432 .erase_check
= default_flash_blank_check
,
1433 .protect_check
= nrf5_protect_check
,
1434 .free_driver_priv
= nrf5_free_driver_priv
,