1 /***************************************************************************
2 * Copyright (C) 2013 by Andrey Yurovsky *
3 * Andrey Yurovsky <yurovsky@gmail.com> *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
19 ***************************************************************************/
27 #define SAMD_NUM_SECTORS 16
29 #define SAMD_FLASH 0x00000000 /* physical Flash memory */
30 #define SAMD_DSU 0x41002000 /* Device Service Unit */
31 #define SAMD_NVMCTRL 0x41004000 /* Non-volatile memory controller */
33 #define SAMD_DSU_DID 0x18 /* Device ID register */
35 #define SAMD_NVMCTRL_CTRLA 0x00 /* NVM control A register */
36 #define SAMD_NVMCTRL_CTRLB 0x04 /* NVM control B register */
37 #define SAMD_NVMCTRL_PARAM 0x08 /* NVM parameters register */
38 #define SAMD_NVMCTRL_INTFLAG 0x18 /* NVM Interupt Flag Status & Clear */
39 #define SAMD_NVMCTRL_STATUS 0x18 /* NVM status register */
40 #define SAMD_NVMCTRL_ADDR 0x1C /* NVM address register */
41 #define SAMD_NVMCTRL_LOCK 0x20 /* NVM Lock section register */
43 #define SAMD_CMDEX_KEY 0xA5UL
44 #define SAMD_NVM_CMD(n) ((SAMD_CMDEX_KEY << 8) | (n & 0x7F))
46 /* NVMCTRL commands. See Table 20-4 in 42129F–SAM–10/2013 */
47 #define SAMD_NVM_CMD_ER 0x02 /* Erase Row */
48 #define SAMD_NVM_CMD_WP 0x04 /* Write Page */
49 #define SAMD_NVM_CMD_EAR 0x05 /* Erase Auxilary Row */
50 #define SAMD_NVM_CMD_WAP 0x06 /* Write Auxilary Page */
51 #define SAMD_NVM_CMD_LR 0x40 /* Lock Region */
52 #define SAMD_NVM_CMD_UR 0x41 /* Unlock Region */
53 #define SAMD_NVM_CMD_SPRM 0x42 /* Set Power Reduction Mode */
54 #define SAMD_NVM_CMD_CPRM 0x43 /* Clear Power Reduction Mode */
55 #define SAMD_NVM_CMD_PBC 0x44 /* Page Buffer Clear */
56 #define SAMD_NVM_CMD_SSB 0x45 /* Set Security Bit */
57 #define SAMD_NVM_CMD_INVALL 0x46 /* Invalidate all caches */
59 /* Known identifiers */
60 #define SAMD_PROCESSOR_M0 0x01
61 #define SAMD_FAMILY_D 0x00
62 #define SAMD_SERIES_20 0x00
71 /* Known SAMD20 parts. See Table 12-8 in 42129F–SAM–10/2013 */
72 static struct samd_part samd20_parts
[] = {
73 { 0x0, "SAMD20J18A", 256, 32 },
74 { 0x1, "SAMD20J17A", 128, 16 },
75 { 0x2, "SAMD20J16A", 64, 8 },
76 { 0x3, "SAMD20J15A", 32, 4 },
77 { 0x4, "SAMD20J14A", 16, 2 },
78 { 0x5, "SAMD20G18A", 256, 32 },
79 { 0x6, "SAMD20G17A", 128, 16 },
80 { 0x7, "SAMD20G16A", 64, 8 },
81 { 0x8, "SAMD20G15A", 32, 4 },
82 { 0x9, "SAMD20G14A", 16, 2 },
83 { 0xB, "SAMD20E17A", 128, 16 },
84 { 0xC, "SAMD20E16A", 64, 8 },
85 { 0xD, "SAMD20E15A", 32, 4 },
86 { 0xE, "SAMD20E14A", 16, 2 },
89 /* Each family of parts contains a parts table in the DEVSEL field of DID. The
90 * processor ID, family ID, and series ID are used to determine which exact
91 * family this is and then we can use the corresponding table. */
96 struct samd_part
*parts
;
100 /* Known SAMD families */
101 static struct samd_family samd_families
[] = {
102 { SAMD_PROCESSOR_M0
, SAMD_FAMILY_D
, SAMD_SERIES_20
,
103 samd20_parts
, ARRAY_SIZE(samd20_parts
) },
112 struct target
*target
;
113 struct samd_info
*next
;
116 static struct samd_info
*samd_chips
;
118 static struct samd_part
*samd_find_part(uint32_t id
)
120 uint8_t processor
= (id
>> 28);
121 uint8_t family
= (id
>> 24) & 0x0F;
122 uint8_t series
= (id
>> 16) & 0xFF;
123 uint8_t devsel
= id
& 0xFF;
125 for (unsigned i
= 0; i
< ARRAY_SIZE(samd_families
); i
++) {
126 if (samd_families
[i
].processor
== processor
&&
127 samd_families
[i
].series
== series
&&
128 samd_families
[i
].family
== family
) {
129 for (unsigned j
= 0; j
< samd_families
[i
].num_parts
; j
++) {
130 if (samd_families
[i
].parts
[j
].id
== devsel
)
131 return &samd_families
[i
].parts
[j
];
139 static int samd_protect_check(struct flash_bank
*bank
)
144 res
= target_read_u16(bank
->target
,
145 SAMD_NVMCTRL
+ SAMD_NVMCTRL_LOCK
, &lock
);
149 /* Lock bits are active-low */
150 for (int i
= 0; i
< bank
->num_sectors
; i
++)
151 bank
->sectors
[i
].is_protected
= !(lock
& (1<<i
));
156 static int samd_probe(struct flash_bank
*bank
)
160 struct samd_info
*chip
= (struct samd_info
*)bank
->driver_priv
;
161 struct samd_part
*part
;
166 res
= target_read_u32(bank
->target
, SAMD_DSU
+ SAMD_DSU_DID
, &id
);
167 if (res
!= ERROR_OK
) {
168 LOG_ERROR("Couldn't read Device ID register");
172 part
= samd_find_part(id
);
174 LOG_ERROR("Couldn't find part correspoding to DID %08" PRIx32
, id
);
178 res
= target_read_u32(bank
->target
,
179 SAMD_NVMCTRL
+ SAMD_NVMCTRL_PARAM
, ¶m
);
180 if (res
!= ERROR_OK
) {
181 LOG_ERROR("Couldn't read NVM Parameters register");
185 bank
->size
= part
->flash_kb
* 1024;
187 chip
->sector_size
= bank
->size
/ SAMD_NUM_SECTORS
;
189 /* The PSZ field (bits 18:16) indicate the page size bytes as 2^(3+n) so
190 * 0 is 8KB and 7 is 1024KB. */
191 chip
->page_size
= (8 << ((param
>> 16) & 0x7));
192 /* The NVMP field (bits 15:0) indicates the total number of pages */
193 chip
->num_pages
= param
& 0xFFFF;
195 /* Sanity check: the total flash size in the DSU should match the page size
196 * multiplied by the number of pages. */
197 if (bank
->size
!= chip
->num_pages
* chip
->page_size
) {
198 LOG_WARNING("SAMD: bank size doesn't match NVM parameters. "
199 "Identified %uKB Flash but NVMCTRL reports %u %uB pages",
200 part
->flash_kb
, chip
->num_pages
, chip
->page_size
);
203 /* Allocate the sector table */
204 bank
->num_sectors
= SAMD_NUM_SECTORS
;
205 bank
->sectors
= calloc(bank
->num_sectors
, sizeof((bank
->sectors
)[0]));
209 /* Fill out the sector information: all SAMD sectors are the same size and
210 * there is always a fixed number of them. */
211 for (int i
= 0; i
< bank
->num_sectors
; i
++) {
212 bank
->sectors
[i
].size
= chip
->sector_size
;
213 bank
->sectors
[i
].offset
= i
* chip
->sector_size
;
214 /* mark as unknown */
215 bank
->sectors
[i
].is_erased
= -1;
216 bank
->sectors
[i
].is_protected
= -1;
219 samd_protect_check(bank
);
224 LOG_INFO("SAMD MCU: %s (%uKB Flash, %uKB RAM)", part
->name
,
225 part
->flash_kb
, part
->ram_kb
);
230 static int samd_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
233 struct samd_info
*chip
= (struct samd_info
*)bank
->driver_priv
;
235 for (int s
= first
; s
<= last
; s
++) {
236 /* Load an address that is within this sector (we use offset 0) */
237 res
= target_write_u32(bank
->target
, SAMD_NVMCTRL
+ SAMD_NVMCTRL_ADDR
,
238 s
* chip
->sector_size
);
242 /* Tell the controller to lock that sector */
243 res
= target_write_u16(bank
->target
,
244 SAMD_NVMCTRL
+ SAMD_NVMCTRL_CTRLA
,
245 SAMD_NVM_CMD(SAMD_NVM_CMD_LR
));
250 samd_protect_check(bank
);
255 static bool samd_check_error(struct flash_bank
*bank
)
261 ret
= target_read_u16(bank
->target
,
262 SAMD_NVMCTRL
+ SAMD_NVMCTRL_STATUS
, &status
);
263 if (ret
!= ERROR_OK
) {
264 LOG_ERROR("Can't read NVM status");
268 if (status
& 0x001C) {
269 if (status
& (1 << 4)) /* NVME */
270 LOG_ERROR("SAMD: NVM Error");
271 if (status
& (1 << 3)) /* LOCKE */
272 LOG_ERROR("SAMD: NVM lock error");
273 if (status
& (1 << 2)) /* PROGE */
274 LOG_ERROR("SAMD: NVM programming error");
281 /* Clear the error conditions by writing a one to them */
282 ret
= target_write_u16(bank
->target
,
283 SAMD_NVMCTRL
+ SAMD_NVMCTRL_STATUS
, status
);
285 LOG_ERROR("Can't clear NVM error conditions");
290 static int samd_erase_row(struct flash_bank
*bank
, uint32_t address
)
295 /* Set an address contained in the row to be erased */
296 res
= target_write_u32(bank
->target
,
297 SAMD_NVMCTRL
+ SAMD_NVMCTRL_ADDR
, address
>> 1);
298 if (res
== ERROR_OK
) {
299 /* Issue the Erase Row command to erase that row */
300 res
= target_write_u16(bank
->target
,
301 SAMD_NVMCTRL
+ SAMD_NVMCTRL_CTRLA
,
302 SAMD_NVM_CMD(SAMD_NVM_CMD_ER
));
304 /* Check (and clear) error conditions */
305 error
= samd_check_error(bank
);
308 if (res
!= ERROR_OK
|| error
) {
309 LOG_ERROR("Failed to erase row containing %08X" PRIx32
, address
);
316 static int samd_erase(struct flash_bank
*bank
, int first
, int last
)
320 struct samd_info
*chip
= (struct samd_info
*)bank
->driver_priv
;
322 if (bank
->target
->state
!= TARGET_HALTED
) {
323 LOG_ERROR("Target not halted");
325 return ERROR_TARGET_NOT_HALTED
;
329 if (samd_probe(bank
) != ERROR_OK
)
330 return ERROR_FLASH_BANK_NOT_PROBED
;
333 /* Make sure the sectors make sense. */
334 if (first
>= bank
->num_sectors
|| last
>= bank
->num_sectors
) {
335 LOG_ERROR("Erase range %d - %d not valid (%d sectors total)",
336 first
, last
, bank
->num_sectors
);
340 /* The SAMD NVM has row erase granularity. There are four pages in a row
341 * and the number of rows in a sector depends on the sector size, which in
342 * turn depends on the Flash capacity as there is a fixed number of
344 rows_in_sector
= chip
->sector_size
/ (chip
->page_size
* 4);
346 /* For each sector to be erased */
347 for (int s
= first
; s
<= last
; s
++) {
348 /* For each row in that sector */
349 for (int r
= s
* rows_in_sector
; r
< (s
+ 1) * rows_in_sector
; r
++) {
350 res
= samd_erase_row(bank
, r
* chip
->page_size
* 4);
351 if (res
!= ERROR_OK
) {
352 LOG_ERROR("SAMD: failed to erase sector %d", s
);
357 bank
->sectors
[s
].is_erased
= 1;
363 /* Write an entire row (four pages) from host buffer 'buf' to row-aligned
364 * 'address' in the Flash. */
365 static int samd_write_row(struct flash_bank
*bank
, uint32_t address
,
369 struct samd_info
*chip
= (struct samd_info
*)bank
->driver_priv
;
371 /* Erase the row that we'll be writing to */
372 res
= samd_erase_row(bank
, address
);
376 /* Now write the pages in this row. */
377 for (unsigned int i
= 0; i
< 4; i
++) {
380 /* Write the page contents to the target's page buffer. A page write
381 * is issued automatically once the last location is written in the
382 * page buffer (ie: a complete page has been written out). */
383 res
= target_write_memory(bank
->target
, address
, 4,
384 chip
->page_size
/ 4, buf
);
385 if (res
!= ERROR_OK
) {
386 LOG_ERROR("%s: %d", __func__
, __LINE__
);
390 error
= samd_check_error(bank
);
395 address
+= chip
->page_size
;
396 buf
+= chip
->page_size
;
402 /* Write partial contents into row-aligned 'address' on the Flash from host
403 * buffer 'buf' by writing 'nb' of 'buf' at 'row_offset' into the Flash row. */
404 static int samd_write_row_partial(struct flash_bank
*bank
, uint32_t address
,
405 uint8_t *buf
, uint32_t row_offset
, uint32_t nb
)
408 struct samd_info
*chip
= (struct samd_info
*)bank
->driver_priv
;
409 uint32_t row_size
= chip
->page_size
* 4;
410 uint8_t *rb
= malloc(row_size
);
414 assert(row_offset
+ nb
< row_size
);
415 assert((address
% row_size
) == 0);
417 /* Retrieve the full row contents from Flash */
418 res
= target_read_memory(bank
->target
, address
, 4, row_size
/ 4, rb
);
419 if (res
!= ERROR_OK
) {
424 /* Insert our partial row over the data from Flash */
425 memcpy(rb
+ (row_offset
% row_size
), buf
, nb
);
427 /* Write the row back out */
428 res
= samd_write_row(bank
, address
, rb
);
434 static int samd_write(struct flash_bank
*bank
, uint8_t *buffer
,
435 uint32_t offset
, uint32_t count
)
440 struct samd_info
*chip
= (struct samd_info
*)bank
->driver_priv
;
441 uint32_t row_size
= chip
->page_size
* 4;
443 if (bank
->target
->state
!= TARGET_HALTED
) {
444 LOG_ERROR("Target not halted");
446 return ERROR_TARGET_NOT_HALTED
;
450 if (samd_probe(bank
) != ERROR_OK
)
451 return ERROR_FLASH_BANK_NOT_PROBED
;
454 if (offset
% row_size
) {
455 /* We're starting at an unaligned offset so we'll write a partial row
456 * comprising that offset and up to the end of that row. */
457 nb
= row_size
- (offset
% row_size
);
460 } else if (count
< row_size
) {
461 /* We're writing an aligned but partial row. */
465 address
= (offset
/ row_size
) * row_size
+ bank
->base
;
468 res
= samd_write_row_partial(bank
, address
, buffer
,
469 offset
% row_size
, nb
);
473 /* We're done with the row contents */
479 /* There's at least one aligned row to write out. */
480 if (count
>= row_size
) {
481 int nr
= count
/ row_size
+ ((count
% row_size
) ? 1 : 0);
484 for (unsigned int i
= address
/ row_size
;
485 (i
< (address
/ row_size
) + nr
) && count
> 0; i
++) {
486 address
= (i
* row_size
) + bank
->base
;
488 if (count
>= row_size
) {
489 res
= samd_write_row(bank
, address
, buffer
+ (r
* row_size
));
490 /* Advance one row */
494 res
= samd_write_row_partial(bank
, address
,
495 buffer
+ (r
* row_size
), 0, count
);
496 /* We're done after this. */
511 FLASH_BANK_COMMAND_HANDLER(samd_flash_bank_command
)
513 struct samd_info
*chip
= samd_chips
;
516 if (chip
->target
== bank
->target
)
522 /* Create a new chip */
523 chip
= calloc(1, sizeof(*chip
));
527 chip
->target
= bank
->target
;
528 chip
->probed
= false;
530 bank
->driver_priv
= chip
;
532 /* Insert it into the chips list (at head) */
533 chip
->next
= samd_chips
;
537 if (bank
->base
!= SAMD_FLASH
) {
538 LOG_ERROR("Address 0x%08" PRIx32
" invalid bank address (try 0x%08" PRIx32
539 "[at91samd series] )",
540 bank
->base
, SAMD_FLASH
);
547 COMMAND_HANDLER(samd_handle_info_command
)
552 static const struct command_registration at91samd_exec_command_handlers
[] = {
555 .handler
= samd_handle_info_command
,
556 .mode
= COMMAND_EXEC
,
557 .help
= "Print information about the current at91samd chip"
558 "and its flash configuration.",
560 COMMAND_REGISTRATION_DONE
563 static const struct command_registration at91samd_command_handlers
[] = {
567 .help
= "at91samd flash command group",
569 .chain
= at91samd_exec_command_handlers
,
571 COMMAND_REGISTRATION_DONE
574 struct flash_driver at91samd_flash
= {
576 .commands
= at91samd_command_handlers
,
577 .flash_bank_command
= samd_flash_bank_command
,
579 .protect
= samd_protect
,
581 .read
= default_flash_read
,
583 .auto_probe
= samd_probe
,
584 .erase_check
= default_flash_blank_check
,
585 .protect_check
= samd_protect_check
,
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)