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>
20 #include <helper/bits.h>
22 /* Both those values are constant across the current spectrum ofr nRF5 devices */
23 #define WATCHDOG_REFRESH_REGISTER 0x40010600
24 #define WATCHDOG_REFRESH_VALUE 0x6e524635
27 NRF5_FLASH_BASE
= 0x00000000,
30 enum nrf5_ficr_registers
{
31 NRF5_FICR_BASE
= 0x10000000, /* Factory Information Configuration Registers */
33 #define NRF5_FICR_REG(offset) (NRF5_FICR_BASE + offset)
35 NRF5_FICR_CODEPAGESIZE
= NRF5_FICR_REG(0x010),
36 NRF5_FICR_CODESIZE
= NRF5_FICR_REG(0x014),
38 NRF51_FICR_CLENR0
= NRF5_FICR_REG(0x028),
39 NRF51_FICR_PPFC
= NRF5_FICR_REG(0x02C),
40 NRF51_FICR_NUMRAMBLOCK
= NRF5_FICR_REG(0x034),
41 NRF51_FICR_SIZERAMBLOCK0
= NRF5_FICR_REG(0x038),
42 NRF51_FICR_SIZERAMBLOCK1
= NRF5_FICR_REG(0x03C),
43 NRF51_FICR_SIZERAMBLOCK2
= NRF5_FICR_REG(0x040),
44 NRF51_FICR_SIZERAMBLOCK3
= NRF5_FICR_REG(0x044),
46 /* CONFIGID is documented on nRF51 series only.
47 * On nRF52 is present but not documented */
48 NRF5_FICR_CONFIGID
= NRF5_FICR_REG(0x05C),
50 /* Following registers are available on nRF52 and on nRF51 since rev 3 */
51 NRF5_FICR_INFO_PART
= NRF5_FICR_REG(0x100),
52 NRF5_FICR_INFO_VARIANT
= NRF5_FICR_REG(0x104),
53 NRF5_FICR_INFO_PACKAGE
= NRF5_FICR_REG(0x108),
54 NRF5_FICR_INFO_RAM
= NRF5_FICR_REG(0x10C),
55 NRF5_FICR_INFO_FLASH
= NRF5_FICR_REG(0x110),
58 enum nrf5_uicr_registers
{
59 NRF5_UICR_BASE
= 0x10001000, /* User Information
60 * Configuration Registers */
62 #define NRF5_UICR_REG(offset) (NRF5_UICR_BASE + offset)
64 NRF51_UICR_CLENR0
= NRF5_UICR_REG(0x000),
67 enum nrf5_nvmc_registers
{
68 NRF5_NVMC_BASE
= 0x4001E000, /* Non-Volatile Memory
69 * Controller Registers */
71 #define NRF5_NVMC_REG(offset) (NRF5_NVMC_BASE + offset)
73 NRF5_NVMC_READY
= NRF5_NVMC_REG(0x400),
74 NRF5_NVMC_CONFIG
= NRF5_NVMC_REG(0x504),
75 NRF5_NVMC_ERASEPAGE
= NRF5_NVMC_REG(0x508),
76 NRF5_NVMC_ERASEALL
= NRF5_NVMC_REG(0x50C),
77 NRF5_NVMC_ERASEUICR
= NRF5_NVMC_REG(0x514),
79 NRF5_BPROT_BASE
= 0x40000000,
82 enum nrf5_nvmc_config_bits
{
83 NRF5_NVMC_CONFIG_REN
= 0x00,
84 NRF5_NVMC_CONFIG_WEN
= 0x01,
85 NRF5_NVMC_CONFIG_EEN
= 0x02,
89 struct nrf52_ficr_info
{
98 NRF5_FEATURE_SERIES_51
= BIT(0),
99 NRF5_FEATURE_SERIES_52
= BIT(1),
100 NRF5_FEATURE_BPROT
= BIT(2),
101 NRF5_FEATURE_ACL_PROT
= BIT(3),
104 struct nrf5_device_spec
{
108 const char *build_code
;
109 unsigned int flash_size_kb
;
110 enum nrf5_features features
;
114 unsigned int refcount
;
117 struct nrf5_info
*chip
;
120 struct target
*target
;
122 /* chip identification stored in nrf5_probe() for use in nrf5_info() */
123 bool ficr_info_valid
;
124 struct nrf52_ficr_info ficr_info
;
125 const struct nrf5_device_spec
*spec
;
127 enum nrf5_features features
;
128 unsigned int flash_size_kb
;
129 unsigned int ram_size_kb
;
132 #define NRF51_DEVICE_DEF(id, pt, var, bcode, fsize) \
137 .build_code = bcode, \
138 .flash_size_kb = (fsize), \
139 .features = NRF5_FEATURE_SERIES_51, \
143 * The table maps known HWIDs to the part numbers, variant
144 * build code and some other info. For nRF51 rev 1 and 2 devices
145 * this is the only way how to get the part number and variant.
147 * All tested nRF51 rev 3 devices have FICR INFO fields
148 * but the fields are not documented in RM so we keep HWIDs in
151 * nRF52 and newer devices have FICR INFO documented, the autodetection
152 * can rely on it and HWIDs table is not used.
154 * The known devices table below is derived from the "nRF5x series
155 * compatibility matrix" documents.
157 * Up to date with Matrix v2.0, plus some additional HWIDs.
159 * The additional HWIDs apply where the build code in the matrix is
160 * shown as Gx0, Bx0, etc. In these cases the HWID in the matrix is
161 * for x==0, x!=0 means different (unspecified) HWIDs.
163 static const struct nrf5_device_spec nrf5_known_devices_table
[] = {
164 /* nRF51822 Devices (IC rev 1). */
165 NRF51_DEVICE_DEF(0x001D, "51822", "QFAA", "CA/C0", 256),
166 NRF51_DEVICE_DEF(0x0026, "51822", "QFAB", "AA", 128),
167 NRF51_DEVICE_DEF(0x0027, "51822", "QFAB", "A0", 128),
168 NRF51_DEVICE_DEF(0x0020, "51822", "CEAA", "BA", 256),
169 NRF51_DEVICE_DEF(0x002F, "51822", "CEAA", "B0", 256),
171 /* Some early nRF51-DK (PCA10028) & nRF51-Dongle (PCA10031) boards
172 with built-in jlink seem to use engineering samples not listed
173 in the nRF51 Series Compatibility Matrix V1.0. */
174 NRF51_DEVICE_DEF(0x0071, "51822", "QFAC", "AB", 256),
176 /* nRF51822 Devices (IC rev 2). */
177 NRF51_DEVICE_DEF(0x002A, "51822", "QFAA", "FA0", 256),
178 NRF51_DEVICE_DEF(0x0044, "51822", "QFAA", "GC0", 256),
179 NRF51_DEVICE_DEF(0x003C, "51822", "QFAA", "G0", 256),
180 NRF51_DEVICE_DEF(0x0057, "51822", "QFAA", "G2", 256),
181 NRF51_DEVICE_DEF(0x0058, "51822", "QFAA", "G3", 256),
182 NRF51_DEVICE_DEF(0x004C, "51822", "QFAB", "B0", 128),
183 NRF51_DEVICE_DEF(0x0040, "51822", "CEAA", "CA0", 256),
184 NRF51_DEVICE_DEF(0x0047, "51822", "CEAA", "DA0", 256),
185 NRF51_DEVICE_DEF(0x004D, "51822", "CEAA", "D00", 256),
187 /* nRF51822 Devices (IC rev 3). */
188 NRF51_DEVICE_DEF(0x0072, "51822", "QFAA", "H0", 256),
189 NRF51_DEVICE_DEF(0x00D1, "51822", "QFAA", "H2", 256),
190 NRF51_DEVICE_DEF(0x007B, "51822", "QFAB", "C0", 128),
191 NRF51_DEVICE_DEF(0x0083, "51822", "QFAC", "A0", 256),
192 NRF51_DEVICE_DEF(0x0084, "51822", "QFAC", "A1", 256),
193 NRF51_DEVICE_DEF(0x007D, "51822", "CDAB", "A0", 128),
194 NRF51_DEVICE_DEF(0x0079, "51822", "CEAA", "E0", 256),
195 NRF51_DEVICE_DEF(0x0087, "51822", "CFAC", "A0", 256),
196 NRF51_DEVICE_DEF(0x008F, "51822", "QFAA", "H1", 256),
198 /* nRF51422 Devices (IC rev 1). */
199 NRF51_DEVICE_DEF(0x001E, "51422", "QFAA", "CA", 256),
200 NRF51_DEVICE_DEF(0x0024, "51422", "QFAA", "C0", 256),
201 NRF51_DEVICE_DEF(0x0031, "51422", "CEAA", "A0A", 256),
203 /* nRF51422 Devices (IC rev 2). */
204 NRF51_DEVICE_DEF(0x002D, "51422", "QFAA", "DAA", 256),
205 NRF51_DEVICE_DEF(0x002E, "51422", "QFAA", "E0", 256),
206 NRF51_DEVICE_DEF(0x0061, "51422", "QFAB", "A00", 128),
207 NRF51_DEVICE_DEF(0x0050, "51422", "CEAA", "B0", 256),
209 /* nRF51422 Devices (IC rev 3). */
210 NRF51_DEVICE_DEF(0x0073, "51422", "QFAA", "F0", 256),
211 NRF51_DEVICE_DEF(0x007C, "51422", "QFAB", "B0", 128),
212 NRF51_DEVICE_DEF(0x0085, "51422", "QFAC", "A0", 256),
213 NRF51_DEVICE_DEF(0x0086, "51422", "QFAC", "A1", 256),
214 NRF51_DEVICE_DEF(0x007E, "51422", "CDAB", "A0", 128),
215 NRF51_DEVICE_DEF(0x007A, "51422", "CEAA", "C0", 256),
216 NRF51_DEVICE_DEF(0x0088, "51422", "CFAC", "A0", 256),
218 /* The driver fully autodetects nRF52 series devices by FICR INFO,
219 * no need for nRF52xxx HWIDs in this table */
222 struct nrf5_device_package
{
227 /* Newer devices have FICR INFO.PACKAGE.
228 * This table converts its value to two character code */
229 static const struct nrf5_device_package nrf52_packages_table
[] = {
234 { 0x2004, "QI/CA" }, /* differs nRF52805, 810, 811: CA, nRF52833, 840: QI */
241 const struct flash_driver nrf5_flash
, nrf51_flash
;
243 static bool nrf5_bank_is_probed(const struct flash_bank
*bank
)
245 struct nrf5_bank
*nbank
= bank
->driver_priv
;
248 return nbank
->probed
;
251 static int nrf5_wait_for_nvmc(struct nrf5_info
*chip
)
255 int timeout_ms
= 340;
256 int64_t ts_start
= timeval_ms();
259 res
= target_read_u32(chip
->target
, NRF5_NVMC_READY
, &ready
);
260 if (res
!= ERROR_OK
) {
261 LOG_ERROR("Error waiting NVMC_READY: generic flash write/erase error (check protection etc...)");
265 if (ready
== 0x00000001)
270 } while ((timeval_ms()-ts_start
) < timeout_ms
);
272 LOG_DEBUG("Timed out waiting for NVMC_READY");
273 return ERROR_FLASH_BUSY
;
276 static int nrf5_nvmc_erase_enable(struct nrf5_info
*chip
)
279 res
= target_write_u32(chip
->target
,
281 NRF5_NVMC_CONFIG_EEN
);
283 if (res
!= ERROR_OK
) {
284 LOG_ERROR("Failed to enable erase operation");
289 According to NVMC examples in Nordic SDK busy status must be
290 checked after writing to NVMC_CONFIG
292 res
= nrf5_wait_for_nvmc(chip
);
294 LOG_ERROR("Erase enable did not complete");
299 static int nrf5_nvmc_write_enable(struct nrf5_info
*chip
)
302 res
= target_write_u32(chip
->target
,
304 NRF5_NVMC_CONFIG_WEN
);
306 if (res
!= ERROR_OK
) {
307 LOG_ERROR("Failed to enable write operation");
312 According to NVMC examples in Nordic SDK busy status must be
313 checked after writing to NVMC_CONFIG
315 res
= nrf5_wait_for_nvmc(chip
);
317 LOG_ERROR("Write enable did not complete");
322 static int nrf5_nvmc_read_only(struct nrf5_info
*chip
)
325 res
= target_write_u32(chip
->target
,
327 NRF5_NVMC_CONFIG_REN
);
329 if (res
!= ERROR_OK
) {
330 LOG_ERROR("Failed to enable read-only operation");
334 According to NVMC examples in Nordic SDK busy status must be
335 checked after writing to NVMC_CONFIG
337 res
= nrf5_wait_for_nvmc(chip
);
339 LOG_ERROR("Read only enable did not complete");
344 static int nrf5_nvmc_generic_erase(struct nrf5_info
*chip
,
345 uint32_t erase_register
, uint32_t erase_value
)
349 res
= nrf5_nvmc_erase_enable(chip
);
353 res
= target_write_u32(chip
->target
,
359 res
= nrf5_wait_for_nvmc(chip
);
363 return nrf5_nvmc_read_only(chip
);
366 nrf5_nvmc_read_only(chip
);
368 LOG_ERROR("Failed to erase reg: 0x%08"PRIx32
" val: 0x%08"PRIx32
,
369 erase_register
, erase_value
);
373 static int nrf5_protect_check_clenr0(struct flash_bank
*bank
)
378 struct nrf5_bank
*nbank
= bank
->driver_priv
;
380 struct nrf5_info
*chip
= nbank
->chip
;
383 res
= target_read_u32(chip
->target
, NRF51_FICR_CLENR0
,
385 if (res
!= ERROR_OK
) {
386 LOG_ERROR("Couldn't read code region 0 size[FICR]");
390 if (clenr0
== 0xFFFFFFFF) {
391 res
= target_read_u32(chip
->target
, NRF51_UICR_CLENR0
,
393 if (res
!= ERROR_OK
) {
394 LOG_ERROR("Couldn't read code region 0 size[UICR]");
399 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++)
400 bank
->sectors
[i
].is_protected
=
401 clenr0
!= 0xFFFFFFFF && bank
->sectors
[i
].offset
< clenr0
;
406 static int nrf5_protect_check_bprot(struct flash_bank
*bank
)
408 struct nrf5_bank
*nbank
= bank
->driver_priv
;
410 struct nrf5_info
*chip
= nbank
->chip
;
413 static uint32_t nrf5_bprot_offsets
[4] = { 0x600, 0x604, 0x610, 0x614 };
414 uint32_t bprot_reg
= 0;
417 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++) {
418 unsigned int bit
= i
% 32;
420 unsigned int n_reg
= i
/ 32;
421 if (n_reg
>= ARRAY_SIZE(nrf5_bprot_offsets
))
424 res
= target_read_u32(chip
->target
, NRF5_BPROT_BASE
+ nrf5_bprot_offsets
[n_reg
], &bprot_reg
);
428 bank
->sectors
[i
].is_protected
= (bprot_reg
& (1 << bit
)) ? 1 : 0;
433 static int nrf5_protect_check(struct flash_bank
*bank
)
435 /* UICR cannot be write protected so just return early */
436 if (bank
->base
== NRF5_UICR_BASE
)
439 struct nrf5_bank
*nbank
= bank
->driver_priv
;
441 struct nrf5_info
*chip
= nbank
->chip
;
444 if (chip
->features
& NRF5_FEATURE_BPROT
)
445 return nrf5_protect_check_bprot(bank
);
447 if (chip
->features
& NRF5_FEATURE_SERIES_51
)
448 return nrf5_protect_check_clenr0(bank
);
450 LOG_WARNING("Flash protection of this nRF device is not supported");
451 return ERROR_FLASH_OPER_UNSUPPORTED
;
454 static int nrf5_protect_clenr0(struct flash_bank
*bank
, int set
, unsigned int first
,
458 uint32_t clenr0
, ppfc
;
460 struct nrf5_bank
*nbank
= bank
->driver_priv
;
462 struct nrf5_info
*chip
= nbank
->chip
;
466 LOG_ERROR("Code region 0 must start at the beginning of the bank");
470 res
= target_read_u32(chip
->target
, NRF51_FICR_PPFC
,
472 if (res
!= ERROR_OK
) {
473 LOG_ERROR("Couldn't read PPFC register");
477 if ((ppfc
& 0xFF) == 0x00) {
478 LOG_ERROR("Code region 0 size was pre-programmed at the factory, can't change flash protection settings");
482 res
= target_read_u32(chip
->target
, NRF51_UICR_CLENR0
,
484 if (res
!= ERROR_OK
) {
485 LOG_ERROR("Couldn't read code region 0 size from UICR");
489 if (!set
|| clenr0
!= 0xFFFFFFFF) {
490 LOG_ERROR("You need to perform chip erase before changing the protection settings");
494 res
= nrf5_nvmc_write_enable(chip
);
498 clenr0
= bank
->sectors
[last
].offset
+ bank
->sectors
[last
].size
;
499 res
= target_write_u32(chip
->target
, NRF51_UICR_CLENR0
, clenr0
);
501 int res2
= nrf5_wait_for_nvmc(chip
);
507 LOG_INFO("A reset or power cycle is required for the new protection settings to take effect.");
509 LOG_ERROR("Couldn't write code region 0 size to UICR");
512 nrf5_nvmc_read_only(chip
);
517 static int nrf5_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
520 /* UICR cannot be write protected so just bail out early */
521 if (bank
->base
== NRF5_UICR_BASE
) {
522 LOG_ERROR("UICR page does not support protection");
523 return ERROR_FLASH_OPER_UNSUPPORTED
;
526 if (bank
->target
->state
!= TARGET_HALTED
) {
527 LOG_ERROR("Target not halted");
528 return ERROR_TARGET_NOT_HALTED
;
531 struct nrf5_bank
*nbank
= bank
->driver_priv
;
533 struct nrf5_info
*chip
= nbank
->chip
;
536 if (chip
->features
& NRF5_FEATURE_SERIES_51
)
537 return nrf5_protect_clenr0(bank
, set
, first
, last
);
539 LOG_ERROR("Flash protection setting is not supported on this nRF5 device");
540 return ERROR_FLASH_OPER_UNSUPPORTED
;
543 static bool nrf5_info_variant_to_str(uint32_t variant
, char *bf
)
547 h_u32_to_be(b
, variant
);
548 if (isalnum(b
[0]) && isalnum(b
[1]) && isalnum(b
[2]) && isalnum(b
[3])) {
558 static const char *nrf5_decode_info_package(uint32_t package
)
560 for (size_t i
= 0; i
< ARRAY_SIZE(nrf52_packages_table
); i
++) {
561 if (nrf52_packages_table
[i
].package
== package
)
562 return nrf52_packages_table
[i
].code
;
567 static int get_nrf5_chip_type_str(const struct nrf5_info
*chip
, char *buf
, unsigned int buf_size
)
571 res
= snprintf(buf
, buf_size
, "nRF%s-%s(build code: %s)",
572 chip
->spec
->part
, chip
->spec
->variant
, chip
->spec
->build_code
);
573 } else if (chip
->ficr_info_valid
) {
575 nrf5_info_variant_to_str(chip
->ficr_info
.variant
, variant
);
576 res
= snprintf(buf
, buf_size
, "nRF%" PRIx32
"-%s%.2s(build code: %s)",
577 chip
->ficr_info
.part
,
578 nrf5_decode_info_package(chip
->ficr_info
.package
),
579 variant
, &variant
[2]);
581 res
= snprintf(buf
, buf_size
, "nRF51xxx (HWID 0x%04" PRIx16
")", chip
->hwid
);
585 if (res
<= 0 || (unsigned int)res
>= buf_size
) {
586 LOG_ERROR("BUG: buffer problem in %s", __func__
);
592 static int nrf5_info(struct flash_bank
*bank
, struct command_invocation
*cmd
)
594 struct nrf5_bank
*nbank
= bank
->driver_priv
;
596 struct nrf5_info
*chip
= nbank
->chip
;
599 char chip_type_str
[256];
600 if (get_nrf5_chip_type_str(chip
, chip_type_str
, sizeof(chip_type_str
)) != ERROR_OK
)
603 command_print_sameline(cmd
, "%s %ukB Flash, %ukB RAM",
604 chip_type_str
, chip
->flash_size_kb
, chip
->ram_size_kb
);
608 static int nrf5_read_ficr_info(struct nrf5_info
*chip
)
611 struct target
*target
= chip
->target
;
613 chip
->ficr_info_valid
= false;
615 res
= target_read_u32(target
, NRF5_FICR_INFO_PART
, &chip
->ficr_info
.part
);
616 if (res
!= ERROR_OK
) {
617 LOG_DEBUG("Couldn't read FICR INFO.PART register");
621 uint32_t series
= chip
->ficr_info
.part
& 0xfffff000;
624 chip
->features
= NRF5_FEATURE_SERIES_51
;
628 chip
->features
= NRF5_FEATURE_SERIES_52
;
630 switch (chip
->ficr_info
.part
) {
635 chip
->features
|= NRF5_FEATURE_BPROT
;
641 chip
->features
|= NRF5_FEATURE_ACL_PROT
;
647 LOG_DEBUG("FICR INFO likely not implemented. Invalid PART value 0x%08"
648 PRIx32
, chip
->ficr_info
.part
);
649 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
652 /* Now we know the device has FICR INFO filled by something relevant:
653 * Although it is not documented, the tested nRF51 rev 3 devices
654 * have FICR INFO.PART, RAM and FLASH of the same format as nRF52.
655 * VARIANT and PACKAGE coding is unknown for a nRF51 device.
656 * nRF52 devices have FICR INFO documented and always filled. */
658 res
= target_read_u32(target
, NRF5_FICR_INFO_VARIANT
, &chip
->ficr_info
.variant
);
662 res
= target_read_u32(target
, NRF5_FICR_INFO_PACKAGE
, &chip
->ficr_info
.package
);
666 res
= target_read_u32(target
, NRF5_FICR_INFO_RAM
, &chip
->ficr_info
.ram
);
670 res
= target_read_u32(target
, NRF5_FICR_INFO_FLASH
, &chip
->ficr_info
.flash
);
674 chip
->ficr_info_valid
= true;
678 static int nrf5_get_ram_size(struct target
*target
, uint32_t *ram_size
)
684 uint32_t numramblock
;
685 res
= target_read_u32(target
, NRF51_FICR_NUMRAMBLOCK
, &numramblock
);
686 if (res
!= ERROR_OK
) {
687 LOG_DEBUG("Couldn't read FICR NUMRAMBLOCK register");
691 if (numramblock
< 1 || numramblock
> 4) {
692 LOG_DEBUG("FICR NUMRAMBLOCK strange value %" PRIx32
, numramblock
);
693 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
696 for (unsigned int i
= 0; i
< numramblock
; i
++) {
697 uint32_t sizeramblock
;
698 res
= target_read_u32(target
, NRF51_FICR_SIZERAMBLOCK0
+ sizeof(uint32_t)*i
, &sizeramblock
);
699 if (res
!= ERROR_OK
) {
700 LOG_DEBUG("Couldn't read FICR NUMRAMBLOCK register");
703 if (sizeramblock
< 1024 || sizeramblock
> 65536)
704 LOG_DEBUG("FICR SIZERAMBLOCK strange value %" PRIx32
, sizeramblock
);
706 *ram_size
+= sizeramblock
;
711 static int nrf5_probe(struct flash_bank
*bank
)
715 struct nrf5_bank
*nbank
= bank
->driver_priv
;
717 struct nrf5_info
*chip
= nbank
->chip
;
719 struct target
*target
= chip
->target
;
722 res
= target_read_u32(target
, NRF5_FICR_CONFIGID
, &configid
);
723 if (res
!= ERROR_OK
) {
724 LOG_ERROR("Couldn't read CONFIGID register");
728 /* HWID is stored in the lower two bytes of the CONFIGID register */
729 chip
->hwid
= configid
& 0xFFFF;
731 /* guess a nRF51 series if the device has no FICR INFO and we don't know HWID */
732 chip
->features
= NRF5_FEATURE_SERIES_51
;
734 /* Don't bail out on error for the case that some old engineering
735 * sample has FICR INFO registers unreadable. We can proceed anyway. */
736 (void)nrf5_read_ficr_info(chip
);
739 for (size_t i
= 0; i
< ARRAY_SIZE(nrf5_known_devices_table
); i
++) {
740 if (chip
->hwid
== nrf5_known_devices_table
[i
].hwid
) {
741 chip
->spec
= &nrf5_known_devices_table
[i
];
742 chip
->features
= chip
->spec
->features
;
747 if (chip
->spec
&& chip
->ficr_info_valid
) {
748 /* check if HWID table gives the same part as FICR INFO */
749 if (chip
->ficr_info
.part
!= strtoul(chip
->spec
->part
, NULL
, 16))
750 LOG_WARNING("HWID 0x%04" PRIx32
" mismatch: FICR INFO.PART %"
751 PRIx32
, chip
->hwid
, chip
->ficr_info
.part
);
754 if (chip
->ficr_info_valid
) {
755 chip
->ram_size_kb
= chip
->ficr_info
.ram
;
758 nrf5_get_ram_size(target
, &ram_size
);
759 chip
->ram_size_kb
= ram_size
/ 1024;
762 /* The value stored in NRF5_FICR_CODEPAGESIZE is the number of bytes in one page of FLASH. */
763 uint32_t flash_page_size
;
764 res
= target_read_u32(chip
->target
, NRF5_FICR_CODEPAGESIZE
,
766 if (res
!= ERROR_OK
) {
767 LOG_ERROR("Couldn't read code page size");
771 /* Note the register name is misleading,
772 * NRF5_FICR_CODESIZE is the number of pages in flash memory, not the number of bytes! */
773 uint32_t num_sectors
;
774 res
= target_read_u32(chip
->target
, NRF5_FICR_CODESIZE
, &num_sectors
);
775 if (res
!= ERROR_OK
) {
776 LOG_ERROR("Couldn't read code memory size");
780 chip
->flash_size_kb
= num_sectors
* flash_page_size
/ 1024;
782 if (!chip
->bank
[0].probed
&& !chip
->bank
[1].probed
) {
783 char chip_type_str
[256];
784 if (get_nrf5_chip_type_str(chip
, chip_type_str
, sizeof(chip_type_str
)) != ERROR_OK
)
786 const bool device_is_unknown
= (!chip
->spec
&& !chip
->ficr_info_valid
);
787 LOG_INFO("%s%s %ukB Flash, %ukB RAM",
788 device_is_unknown
? "Unknown device: " : "",
796 if (bank
->base
== NRF5_FLASH_BASE
) {
798 if (chip
->spec
&& chip
->flash_size_kb
!= chip
->spec
->flash_size_kb
)
799 LOG_WARNING("Chip's reported Flash capacity does not match expected one");
800 if (chip
->ficr_info_valid
&& chip
->flash_size_kb
!= chip
->ficr_info
.flash
)
801 LOG_WARNING("Chip's reported Flash capacity does not match FICR INFO.FLASH");
803 bank
->num_sectors
= num_sectors
;
804 bank
->size
= num_sectors
* flash_page_size
;
806 bank
->sectors
= alloc_block_array(0, flash_page_size
, num_sectors
);
810 chip
->bank
[0].probed
= true;
813 bank
->num_sectors
= 1;
814 bank
->size
= flash_page_size
;
816 bank
->sectors
= alloc_block_array(0, flash_page_size
, num_sectors
);
820 bank
->sectors
[0].is_protected
= 0;
822 chip
->bank
[1].probed
= true;
828 static int nrf5_auto_probe(struct flash_bank
*bank
)
830 if (nrf5_bank_is_probed(bank
))
833 return nrf5_probe(bank
);
836 static int nrf5_erase_all(struct nrf5_info
*chip
)
838 LOG_DEBUG("Erasing all non-volatile memory");
839 return nrf5_nvmc_generic_erase(chip
,
844 static int nrf5_erase_page(struct flash_bank
*bank
,
845 struct nrf5_info
*chip
,
846 struct flash_sector
*sector
)
850 LOG_DEBUG("Erasing page at 0x%"PRIx32
, sector
->offset
);
852 if (bank
->base
== NRF5_UICR_BASE
) {
853 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
855 res
= target_read_u32(chip
->target
, NRF51_FICR_PPFC
,
857 if (res
!= ERROR_OK
) {
858 LOG_ERROR("Couldn't read PPFC register");
862 if ((ppfc
& 0xFF) == 0xFF) {
863 /* We can't erase the UICR. Double-check to
864 see if it's already erased before complaining. */
865 default_flash_blank_check(bank
);
866 if (sector
->is_erased
== 1)
869 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");
874 res
= nrf5_nvmc_generic_erase(chip
,
880 res
= nrf5_nvmc_generic_erase(chip
,
888 /* Start a low level flash write for the specified region */
889 static int nrf5_ll_flash_write(struct nrf5_info
*chip
, uint32_t address
, const uint8_t *buffer
, uint32_t bytes
)
891 struct target
*target
= chip
->target
;
892 uint32_t buffer_size
= 8192;
893 struct working_area
*write_algorithm
;
894 struct working_area
*source
;
895 struct reg_param reg_params
[6];
896 struct armv7m_algorithm armv7m_info
;
897 int retval
= ERROR_OK
;
899 static const uint8_t nrf5_flash_write_code
[] = {
900 #include "../../../contrib/loaders/flash/nrf5/nrf5.inc"
903 LOG_DEBUG("Writing buffer to flash address=0x%"PRIx32
" bytes=0x%"PRIx32
, address
, bytes
);
904 assert(bytes
% 4 == 0);
906 /* allocate working area with flash programming code */
907 if (target_alloc_working_area(target
, sizeof(nrf5_flash_write_code
),
908 &write_algorithm
) != ERROR_OK
) {
909 LOG_WARNING("no working area available, falling back to slow memory writes");
911 for (; bytes
> 0; bytes
-= 4) {
912 retval
= target_write_memory(target
, address
, 4, 1, buffer
);
913 if (retval
!= ERROR_OK
)
916 retval
= nrf5_wait_for_nvmc(chip
);
917 if (retval
!= ERROR_OK
)
927 retval
= target_write_buffer(target
, write_algorithm
->address
,
928 sizeof(nrf5_flash_write_code
),
929 nrf5_flash_write_code
);
930 if (retval
!= ERROR_OK
)
934 while (target_alloc_working_area(target
, buffer_size
, &source
) != ERROR_OK
) {
936 buffer_size
&= ~3UL; /* Make sure it's 4 byte aligned */
937 if (buffer_size
<= 256) {
938 /* free working area, write algorithm already allocated */
939 target_free_working_area(target
, write_algorithm
);
941 LOG_WARNING("No large enough working area available, can't do block memory writes");
942 return ERROR_TARGET_RESOURCE_NOT_AVAILABLE
;
946 armv7m_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
947 armv7m_info
.core_mode
= ARM_MODE_THREAD
;
949 init_reg_param(®_params
[0], "r0", 32, PARAM_IN_OUT
); /* byte count */
950 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
); /* buffer start */
951 init_reg_param(®_params
[2], "r2", 32, PARAM_OUT
); /* buffer end */
952 init_reg_param(®_params
[3], "r3", 32, PARAM_IN_OUT
); /* target address */
953 init_reg_param(®_params
[4], "r6", 32, PARAM_OUT
); /* watchdog refresh value */
954 init_reg_param(®_params
[5], "r7", 32, PARAM_OUT
); /* watchdog refresh register address */
956 buf_set_u32(reg_params
[0].value
, 0, 32, bytes
);
957 buf_set_u32(reg_params
[1].value
, 0, 32, source
->address
);
958 buf_set_u32(reg_params
[2].value
, 0, 32, source
->address
+ source
->size
);
959 buf_set_u32(reg_params
[3].value
, 0, 32, address
);
960 buf_set_u32(reg_params
[4].value
, 0, 32, WATCHDOG_REFRESH_VALUE
);
961 buf_set_u32(reg_params
[5].value
, 0, 32, WATCHDOG_REFRESH_REGISTER
);
963 retval
= target_run_flash_async_algorithm(target
, buffer
, bytes
/4, 4,
965 ARRAY_SIZE(reg_params
), reg_params
,
966 source
->address
, source
->size
,
967 write_algorithm
->address
, write_algorithm
->address
+ sizeof(nrf5_flash_write_code
) - 2,
970 target_free_working_area(target
, source
);
971 target_free_working_area(target
, write_algorithm
);
973 destroy_reg_param(®_params
[0]);
974 destroy_reg_param(®_params
[1]);
975 destroy_reg_param(®_params
[2]);
976 destroy_reg_param(®_params
[3]);
977 destroy_reg_param(®_params
[4]);
978 destroy_reg_param(®_params
[5]);
983 static int nrf5_write(struct flash_bank
*bank
, const uint8_t *buffer
,
984 uint32_t offset
, uint32_t count
)
988 if (bank
->target
->state
!= TARGET_HALTED
) {
989 LOG_ERROR("Target not halted");
990 return ERROR_TARGET_NOT_HALTED
;
993 struct nrf5_bank
*nbank
= bank
->driver_priv
;
995 struct nrf5_info
*chip
= nbank
->chip
;
998 assert(offset
% 4 == 0);
999 assert(count
% 4 == 0);
1001 /* UICR CLENR0 based protection used on nRF51 is somewhat clumsy:
1002 * RM reads: Code running from code region 1 will not be able to write
1004 * Unfortunately the flash loader running from RAM can write to both
1005 * code regions without any hint the protection is violated.
1007 * Update protection state and check if any flash sector to be written
1009 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
1011 res
= nrf5_protect_check_clenr0(bank
);
1012 if (res
!= ERROR_OK
)
1015 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
1016 struct flash_sector
*bs
= &bank
->sectors
[sector
];
1018 /* Start offset in or before this sector? */
1019 /* End offset in or behind this sector? */
1020 if ((offset
< (bs
->offset
+ bs
->size
))
1021 && ((offset
+ count
- 1) >= bs
->offset
)
1022 && bs
->is_protected
== 1) {
1023 LOG_ERROR("Write refused, sector %d is protected", sector
);
1024 return ERROR_FLASH_PROTECTED
;
1029 res
= nrf5_nvmc_write_enable(chip
);
1030 if (res
!= ERROR_OK
)
1033 res
= nrf5_ll_flash_write(chip
, bank
->base
+ offset
, buffer
, count
);
1034 if (res
!= ERROR_OK
)
1037 return nrf5_nvmc_read_only(chip
);
1040 nrf5_nvmc_read_only(chip
);
1041 LOG_ERROR("Failed to write to nrf5 flash");
1045 static int nrf5_erase(struct flash_bank
*bank
, unsigned int first
,
1050 if (bank
->target
->state
!= TARGET_HALTED
) {
1051 LOG_ERROR("Target not halted");
1052 return ERROR_TARGET_NOT_HALTED
;
1055 struct nrf5_bank
*nbank
= bank
->driver_priv
;
1057 struct nrf5_info
*chip
= nbank
->chip
;
1060 /* UICR CLENR0 based protection used on nRF51 prevents erase
1061 * absolutely silently. NVMC has no flag to indicate the protection
1064 * Update protection state and check if any flash sector to be erased
1066 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
1068 res
= nrf5_protect_check_clenr0(bank
);
1069 if (res
!= ERROR_OK
)
1073 /* For each sector to be erased */
1074 for (unsigned int s
= first
; s
<= last
; s
++) {
1076 if (chip
->features
& NRF5_FEATURE_SERIES_51
1077 && bank
->sectors
[s
].is_protected
== 1) {
1078 LOG_ERROR("Flash sector %d is protected", s
);
1079 return ERROR_FLASH_PROTECTED
;
1082 res
= nrf5_erase_page(bank
, chip
, &bank
->sectors
[s
]);
1083 if (res
!= ERROR_OK
) {
1084 LOG_ERROR("Error erasing sector %d", s
);
1092 static void nrf5_free_driver_priv(struct flash_bank
*bank
)
1094 struct nrf5_bank
*nbank
= bank
->driver_priv
;
1096 struct nrf5_info
*chip
= nbank
->chip
;
1101 if (chip
->refcount
== 0) {
1103 bank
->driver_priv
= NULL
;
1107 static struct nrf5_info
*nrf5_get_chip(struct target
*target
)
1109 struct flash_bank
*bank_iter
;
1111 /* iterate over nrf5 banks of same target */
1112 for (bank_iter
= flash_bank_list(); bank_iter
; bank_iter
= bank_iter
->next
) {
1113 if (bank_iter
->driver
!= &nrf5_flash
&& bank_iter
->driver
!= &nrf51_flash
)
1116 if (bank_iter
->target
!= target
)
1119 struct nrf5_bank
*nbank
= bank_iter
->driver_priv
;
1129 FLASH_BANK_COMMAND_HANDLER(nrf5_flash_bank_command
)
1131 struct nrf5_info
*chip
;
1132 struct nrf5_bank
*nbank
= NULL
;
1134 if (bank
->driver
== &nrf51_flash
)
1135 LOG_WARNING("Flash driver 'nrf51' is deprecated! Use 'nrf5' instead.");
1137 switch (bank
->base
) {
1138 case NRF5_FLASH_BASE
:
1139 case NRF5_UICR_BASE
:
1142 LOG_ERROR("Invalid bank address " TARGET_ADDR_FMT
, bank
->base
);
1146 chip
= nrf5_get_chip(bank
->target
);
1148 /* Create a new chip */
1149 chip
= calloc(1, sizeof(*chip
));
1153 chip
->target
= bank
->target
;
1156 switch (bank
->base
) {
1157 case NRF5_FLASH_BASE
:
1158 nbank
= &chip
->bank
[0];
1160 case NRF5_UICR_BASE
:
1161 nbank
= &chip
->bank
[1];
1168 nbank
->probed
= false;
1169 bank
->driver_priv
= nbank
;
1170 bank
->write_start_alignment
= bank
->write_end_alignment
= 4;
1175 COMMAND_HANDLER(nrf5_handle_mass_erase_command
)
1178 struct flash_bank
*bank
= NULL
;
1179 struct target
*target
= get_current_target(CMD_CTX
);
1181 res
= get_flash_bank_by_addr(target
, NRF5_FLASH_BASE
, true, &bank
);
1182 if (res
!= ERROR_OK
)
1187 if (target
->state
!= TARGET_HALTED
) {
1188 LOG_ERROR("Target not halted");
1189 return ERROR_TARGET_NOT_HALTED
;
1192 struct nrf5_bank
*nbank
= bank
->driver_priv
;
1194 struct nrf5_info
*chip
= nbank
->chip
;
1197 if (chip
->features
& NRF5_FEATURE_SERIES_51
) {
1199 res
= target_read_u32(target
, NRF51_FICR_PPFC
,
1201 if (res
!= ERROR_OK
) {
1202 LOG_ERROR("Couldn't read PPFC register");
1206 if ((ppfc
& 0xFF) == 0x00) {
1207 LOG_ERROR("Code region 0 size was pre-programmed at the factory, "
1208 "mass erase command won't work.");
1213 res
= nrf5_erase_all(chip
);
1214 if (res
== ERROR_OK
) {
1215 LOG_INFO("Mass erase completed.");
1216 if (chip
->features
& NRF5_FEATURE_SERIES_51
)
1217 LOG_INFO("A reset or power cycle is required if the flash was protected before.");
1220 LOG_ERROR("Failed to erase the chip");
1227 static const struct command_registration nrf5_exec_command_handlers
[] = {
1229 .name
= "mass_erase",
1230 .handler
= nrf5_handle_mass_erase_command
,
1231 .mode
= COMMAND_EXEC
,
1232 .help
= "Erase all flash contents of the chip.",
1235 COMMAND_REGISTRATION_DONE
1238 static const struct command_registration nrf5_command_handlers
[] = {
1241 .mode
= COMMAND_ANY
,
1242 .help
= "nrf5 flash command group",
1244 .chain
= nrf5_exec_command_handlers
,
1248 .mode
= COMMAND_ANY
,
1249 .help
= "nrf51 flash command group",
1251 .chain
= nrf5_exec_command_handlers
,
1253 COMMAND_REGISTRATION_DONE
1256 const struct flash_driver nrf5_flash
= {
1258 .commands
= nrf5_command_handlers
,
1259 .flash_bank_command
= nrf5_flash_bank_command
,
1261 .erase
= nrf5_erase
,
1262 .protect
= nrf5_protect
,
1263 .write
= nrf5_write
,
1264 .read
= default_flash_read
,
1265 .probe
= nrf5_probe
,
1266 .auto_probe
= nrf5_auto_probe
,
1267 .erase_check
= default_flash_blank_check
,
1268 .protect_check
= nrf5_protect_check
,
1269 .free_driver_priv
= nrf5_free_driver_priv
,
1272 /* We need to retain the flash-driver name as well as the commands
1273 * for backwards compatibility */
1274 const struct flash_driver nrf51_flash
= {
1276 .commands
= nrf5_command_handlers
,
1277 .flash_bank_command
= nrf5_flash_bank_command
,
1279 .erase
= nrf5_erase
,
1280 .protect
= nrf5_protect
,
1281 .write
= nrf5_write
,
1282 .read
= default_flash_read
,
1283 .probe
= nrf5_probe
,
1284 .auto_probe
= nrf5_auto_probe
,
1285 .erase_check
= default_flash_blank_check
,
1286 .protect_check
= nrf5_protect_check
,
1287 .free_driver_priv
= nrf5_free_driver_priv
,