1 /***************************************************************************
2 * Copyright (C) 2010 by Antonio Borneo <borneo.antonio@gmail.com> *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
16 ***************************************************************************/
18 /* STM Serial Memory Interface (SMI) controller is a SPI bus controller
19 * specifically designed for SPI memories.
20 * Only SPI "mode 3" (CPOL=1 and CPHA=1) is supported.
21 * Two working modes are available:
22 * - SW mode: the SPI is controlled by SW. Any custom commands can be sent
24 * - HW mode: the SPI but is under SMI control. Memory content is directly
25 * accessible in CPU memory space. CPU can read, write and execute memory
29 * To have flash memory mapped in CPU memory space, the SMI controller
30 * have to be in "HW mode". This requires following constraints:
31 * 1) The command "reset init" have to initialize SMI controller and put
33 * 2) every command in this file have to return to prompt in HW mode. */
41 #include <jtag/jtag.h>
42 #include <helper/time_support.h>
44 #define SMI_READ_REG(a) (_SMI_READ_REG(a))
45 #define _SMI_READ_REG(a) \
50 __a = target_read_u32(target, io_base + (a), &__v); \
51 if (__a != ERROR_OK) \
56 #define SMI_WRITE_REG(a, v) \
60 __r = target_write_u32(target, io_base + (a), (v)); \
61 if (__r != ERROR_OK) \
65 #define SMI_POLL_TFF(timeout) \
69 __r = poll_tff(target, io_base, timeout); \
70 if (__r != ERROR_OK) \
74 #define SMI_SET_SW_MODE() SMI_WRITE_REG(SMI_CR1, \
75 SMI_READ_REG(SMI_CR1) | SMI_SW_MODE)
76 #define SMI_SET_HWWB_MODE() SMI_WRITE_REG(SMI_CR1, \
77 (SMI_READ_REG(SMI_CR1) | SMI_WB_MODE) & ~SMI_SW_MODE)
78 #define SMI_SET_HW_MODE() SMI_WRITE_REG(SMI_CR1, \
79 SMI_READ_REG(SMI_CR1) & ~(SMI_SW_MODE | SMI_WB_MODE))
80 #define SMI_CLEAR_TFF() SMI_WRITE_REG(SMI_SR, ~SMI_TFF)
82 #define SMI_BANK_SIZE (0x01000000)
84 #define SMI_CR1 (0x00) /* Control register 1 */
85 #define SMI_CR2 (0x04) /* Control register 2 */
86 #define SMI_SR (0x08) /* Status register */
87 #define SMI_TR (0x0c) /* TX */
88 #define SMI_RR (0x10) /* RX */
90 /* fields in SMI_CR1 */
91 #define SMI_SW_MODE 0x10000000 /* set to enable SW Mode */
92 #define SMI_WB_MODE 0x20000000 /* Write Burst Mode */
94 /* fields in SMI_CR2 */
95 #define SMI_TX_LEN_1 0x00000001 /* data length = 1 byte */
96 #define SMI_TX_LEN_4 0x00000004 /* data length = 4 byte */
97 #define SMI_RX_LEN_3 0x00000030 /* data length = 3 byte */
98 #define SMI_SEND 0x00000080 /* Send data */
99 #define SMI_RSR 0x00000400 /* reads status reg */
100 #define SMI_WE 0x00000800 /* Write Enable */
101 #define SMI_SEL_BANK0 0x00000000 /* Select Bank0 */
102 #define SMI_SEL_BANK1 0x00001000 /* Select Bank1 */
103 #define SMI_SEL_BANK2 0x00002000 /* Select Bank2 */
104 #define SMI_SEL_BANK3 0x00003000 /* Select Bank3 */
106 /* fields in SMI_SR */
107 #define SMI_TFF 0x00000100 /* Transfer Finished Flag */
110 #define SMI_READ_ID 0x0000009F /* Read Flash Identification */
113 #define SMI_CMD_TIMEOUT (100)
114 #define SMI_PROBE_TIMEOUT (100)
115 #define SMI_MAX_TIMEOUT (3000)
117 struct stmsmi_flash_bank
{
121 const struct flash_device
*dev
;
124 struct stmsmi_target
{
131 static const struct stmsmi_target target_devices
[] = {
132 /* name, tap_idcode, smi_base, io_base */
133 { "SPEAr3xx/6xx", 0x07926041, 0xf8000000, 0xfc000000 },
134 { "STR75x", 0x4f1f0041, 0x80000000, 0x90000000 },
138 FLASH_BANK_COMMAND_HANDLER(stmsmi_flash_bank_command
)
140 struct stmsmi_flash_bank
*stmsmi_info
;
142 LOG_DEBUG("%s", __func__
);
145 return ERROR_COMMAND_SYNTAX_ERROR
;
147 stmsmi_info
= malloc(sizeof(struct stmsmi_flash_bank
));
148 if (stmsmi_info
== NULL
) {
149 LOG_ERROR("not enough memory");
153 bank
->driver_priv
= stmsmi_info
;
154 stmsmi_info
->probed
= false;
159 /* Poll transmit finished flag */
161 static int poll_tff(struct target
*target
, uint32_t io_base
, int timeout
)
165 if (SMI_READ_REG(SMI_SR
) & SMI_TFF
)
168 endtime
= timeval_ms() + timeout
;
171 if (SMI_READ_REG(SMI_SR
) & SMI_TFF
)
173 } while (timeval_ms() < endtime
);
175 LOG_ERROR("Timeout while polling TFF");
176 return ERROR_FLASH_OPERATION_FAILED
;
179 /* Read the status register of the external SPI flash chip.
180 * The operation is triggered by setting SMI_RSR bit.
181 * SMI sends the proper SPI command (0x05) and returns value in SMI_SR */
182 static int read_status_reg(struct flash_bank
*bank
, uint32_t *status
)
184 struct target
*target
= bank
->target
;
185 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
186 uint32_t io_base
= stmsmi_info
->io_base
;
188 /* clear transmit finished flag */
192 SMI_WRITE_REG(SMI_CR2
, stmsmi_info
->bank_num
| SMI_RSR
);
194 /* Poll transmit finished flag */
195 SMI_POLL_TFF(SMI_CMD_TIMEOUT
);
197 /* clear transmit finished flag */
200 *status
= SMI_READ_REG(SMI_SR
) & 0x0000ffff;
202 /* clean-up SMI_CR2 */
203 SMI_WRITE_REG(SMI_CR2
, 0); /* AB: Required ? */
208 /* check for WIP (write in progress) bit in status register */
210 static int wait_till_ready(struct flash_bank
*bank
, int timeout
)
216 endtime
= timeval_ms() + timeout
;
218 /* read flash status register */
219 retval
= read_status_reg(bank
, &status
);
220 if (retval
!= ERROR_OK
)
223 if ((status
& SPIFLASH_BSY_BIT
) == 0)
226 } while (timeval_ms() < endtime
);
228 LOG_ERROR("timeout");
232 /* Send "write enable" command to SPI flash chip.
233 * The operation is triggered by setting SMI_WE bit, and SMI sends
234 * the proper SPI command (0x06) */
235 static int smi_write_enable(struct flash_bank
*bank
)
237 struct target
*target
= bank
->target
;
238 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
239 uint32_t io_base
= stmsmi_info
->io_base
;
243 /* Enter in HW mode */
244 SMI_SET_HW_MODE(); /* AB: is this correct ?*/
246 /* clear transmit finished flag */
249 /* Send write enable command */
250 SMI_WRITE_REG(SMI_CR2
, stmsmi_info
->bank_num
| SMI_WE
);
252 /* Poll transmit finished flag */
253 SMI_POLL_TFF(SMI_CMD_TIMEOUT
);
255 /* read flash status register */
256 retval
= read_status_reg(bank
, &status
);
257 if (retval
!= ERROR_OK
)
260 /* Check write enabled */
261 if ((status
& SPIFLASH_WE_BIT
) == 0) {
262 LOG_ERROR("Cannot enable write to flash. Status=0x%08" PRIx32
, status
);
269 static uint32_t erase_command(struct stmsmi_flash_bank
*stmsmi_info
,
272 uint8_t cmd_bytes
[] = {
273 stmsmi_info
->dev
->erase_cmd
,
279 return le_to_h_u32(cmd_bytes
);
282 static int smi_erase_sector(struct flash_bank
*bank
, int sector
)
284 struct target
*target
= bank
->target
;
285 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
286 uint32_t io_base
= stmsmi_info
->io_base
;
290 retval
= smi_write_enable(bank
);
291 if (retval
!= ERROR_OK
)
294 /* Switch to SW mode to send sector erase command */
297 /* clear transmit finished flag */
300 /* send SPI command "block erase" */
301 cmd
= erase_command(stmsmi_info
, bank
->sectors
[sector
].offset
);
302 SMI_WRITE_REG(SMI_TR
, cmd
);
303 SMI_WRITE_REG(SMI_CR2
, stmsmi_info
->bank_num
| SMI_SEND
| SMI_TX_LEN_4
);
305 /* Poll transmit finished flag */
306 SMI_POLL_TFF(SMI_CMD_TIMEOUT
);
308 /* poll WIP for end of self timed Sector Erase cycle */
309 retval
= wait_till_ready(bank
, SMI_MAX_TIMEOUT
);
310 if (retval
!= ERROR_OK
)
316 static int stmsmi_erase(struct flash_bank
*bank
, unsigned int first
,
319 struct target
*target
= bank
->target
;
320 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
321 uint32_t io_base
= stmsmi_info
->io_base
;
322 int retval
= ERROR_OK
;
324 LOG_DEBUG("%s: from sector %u to sector %u", __func__
, first
, last
);
326 if (target
->state
!= TARGET_HALTED
) {
327 LOG_ERROR("Target not halted");
328 return ERROR_TARGET_NOT_HALTED
;
331 if ((last
< first
) || (last
>= bank
->num_sectors
)) {
332 LOG_ERROR("Flash sector invalid");
333 return ERROR_FLASH_SECTOR_INVALID
;
336 if (!(stmsmi_info
->probed
)) {
337 LOG_ERROR("Flash bank not probed");
338 return ERROR_FLASH_BANK_NOT_PROBED
;
341 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
342 if (bank
->sectors
[sector
].is_protected
) {
343 LOG_ERROR("Flash sector %u protected", sector
);
348 if (stmsmi_info
->dev
->erase_cmd
== 0x00)
349 return ERROR_FLASH_OPER_UNSUPPORTED
;
351 for (unsigned int sector
= first
; sector
<= last
; sector
++) {
352 retval
= smi_erase_sector(bank
, sector
);
353 if (retval
!= ERROR_OK
)
358 /* Switch to HW mode before return to prompt */
363 static int stmsmi_protect(struct flash_bank
*bank
, int set
,
364 unsigned int first
, unsigned int last
)
366 for (unsigned int sector
= first
; sector
<= last
; sector
++)
367 bank
->sectors
[sector
].is_protected
= set
;
371 static int smi_write_buffer(struct flash_bank
*bank
, const uint8_t *buffer
,
372 uint32_t address
, uint32_t len
)
374 struct target
*target
= bank
->target
;
375 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
376 uint32_t io_base
= stmsmi_info
->io_base
;
379 LOG_DEBUG("%s: address=0x%08" PRIx32
" len=0x%08" PRIx32
,
380 __func__
, address
, len
);
382 retval
= smi_write_enable(bank
);
383 if (retval
!= ERROR_OK
)
386 /* HW mode, write burst mode */
389 retval
= target_write_buffer(target
, address
, len
, buffer
);
390 if (retval
!= ERROR_OK
)
396 static int stmsmi_write(struct flash_bank
*bank
, const uint8_t *buffer
,
397 uint32_t offset
, uint32_t count
)
399 struct target
*target
= bank
->target
;
400 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
401 uint32_t io_base
= stmsmi_info
->io_base
;
402 uint32_t cur_count
, page_size
, page_offset
;
403 int retval
= ERROR_OK
;
405 LOG_DEBUG("%s: offset=0x%08" PRIx32
" count=0x%08" PRIx32
,
406 __func__
, offset
, count
);
408 if (target
->state
!= TARGET_HALTED
) {
409 LOG_ERROR("Target not halted");
410 return ERROR_TARGET_NOT_HALTED
;
413 if (offset
+ count
> stmsmi_info
->dev
->size_in_bytes
) {
414 LOG_WARNING("Write pasts end of flash. Extra data discarded.");
415 count
= stmsmi_info
->dev
->size_in_bytes
- offset
;
418 /* Check sector protection */
419 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
420 /* Start offset in or before this sector? */
421 /* End offset in or behind this sector? */
423 (bank
->sectors
[sector
].offset
+ bank
->sectors
[sector
].size
))
424 && ((offset
+ count
- 1) >= bank
->sectors
[sector
].offset
)
425 && bank
->sectors
[sector
].is_protected
) {
426 LOG_ERROR("Flash sector %u protected", sector
);
431 /* if no valid page_size, use reasonable default */
432 page_size
= stmsmi_info
->dev
->pagesize
?
433 stmsmi_info
->dev
->pagesize
: SPIFLASH_DEF_PAGESIZE
;
435 /* unaligned buffer head */
436 if (count
> 0 && (offset
& 3) != 0) {
437 cur_count
= 4 - (offset
& 3);
438 if (cur_count
> count
)
440 retval
= smi_write_buffer(bank
, buffer
, bank
->base
+ offset
,
442 if (retval
!= ERROR_OK
)
449 page_offset
= offset
% page_size
;
450 /* central part, aligned words */
452 /* clip block at page boundary */
453 if (page_offset
+ count
> page_size
)
454 cur_count
= page_size
- page_offset
;
456 cur_count
= count
& ~3;
458 retval
= smi_write_buffer(bank
, buffer
, bank
->base
+ offset
,
460 if (retval
!= ERROR_OK
)
473 retval
= smi_write_buffer(bank
, buffer
, bank
->base
+ offset
, count
);
476 /* Switch to HW mode before return to prompt */
481 /* Return ID of flash device */
482 /* On exit, SW mode is kept */
483 static int read_flash_id(struct flash_bank
*bank
, uint32_t *id
)
485 struct target
*target
= bank
->target
;
486 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
487 uint32_t io_base
= stmsmi_info
->io_base
;
490 if (target
->state
!= TARGET_HALTED
) {
491 LOG_ERROR("Target not halted");
492 return ERROR_TARGET_NOT_HALTED
;
496 retval
= wait_till_ready(bank
, SMI_PROBE_TIMEOUT
);
497 if (retval
!= ERROR_OK
)
500 /* enter in SW mode */
503 /* clear transmit finished flag */
506 /* Send SPI command "read ID" */
507 SMI_WRITE_REG(SMI_TR
, SMI_READ_ID
);
508 SMI_WRITE_REG(SMI_CR2
,
509 stmsmi_info
->bank_num
| SMI_SEND
| SMI_RX_LEN_3
| SMI_TX_LEN_1
);
511 /* Poll transmit finished flag */
512 SMI_POLL_TFF(SMI_CMD_TIMEOUT
);
514 /* clear transmit finished flag */
517 /* read ID from Receive Register */
518 *id
= SMI_READ_REG(SMI_RR
) & 0x00ffffff;
522 static int stmsmi_probe(struct flash_bank
*bank
)
524 struct target
*target
= bank
->target
;
525 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
526 uint32_t io_base
, sectorsize
;
527 struct flash_sector
*sectors
;
528 uint32_t id
= 0; /* silence uninitialized warning */
529 const struct stmsmi_target
*target_device
;
532 if (stmsmi_info
->probed
)
534 stmsmi_info
->probed
= false;
536 for (target_device
= target_devices
; target_device
->name
; ++target_device
)
537 if (target_device
->tap_idcode
== target
->tap
->idcode
)
539 if (!target_device
->name
) {
540 LOG_ERROR("Device ID 0x%" PRIx32
" is not known as SMI capable",
541 target
->tap
->idcode
);
545 switch (bank
->base
- target_device
->smi_base
) {
547 stmsmi_info
->bank_num
= SMI_SEL_BANK0
;
550 stmsmi_info
->bank_num
= SMI_SEL_BANK1
;
552 case 2*SMI_BANK_SIZE
:
553 stmsmi_info
->bank_num
= SMI_SEL_BANK2
;
555 case 3*SMI_BANK_SIZE
:
556 stmsmi_info
->bank_num
= SMI_SEL_BANK3
;
559 LOG_ERROR("Invalid SMI base address " TARGET_ADDR_FMT
, bank
->base
);
562 io_base
= target_device
->io_base
;
563 stmsmi_info
->io_base
= io_base
;
565 LOG_DEBUG("Valid SMI on device %s at address " TARGET_ADDR_FMT
,
566 target_device
->name
, bank
->base
);
568 /* read and decode flash ID; returns in SW mode */
569 retval
= read_flash_id(bank
, &id
);
571 if (retval
!= ERROR_OK
)
574 stmsmi_info
->dev
= NULL
;
575 for (const struct flash_device
*p
= flash_devices
; p
->name
; p
++)
576 if (p
->device_id
== id
) {
577 stmsmi_info
->dev
= p
;
581 if (!stmsmi_info
->dev
) {
582 LOG_ERROR("Unknown flash device (ID 0x%08" PRIx32
")", id
);
586 LOG_INFO("Found flash device \'%s\' (ID 0x%08" PRIx32
")",
587 stmsmi_info
->dev
->name
, stmsmi_info
->dev
->device_id
);
589 /* Set correct size value */
590 bank
->size
= stmsmi_info
->dev
->size_in_bytes
;
591 if (bank
->size
<= (1UL << 16))
592 LOG_WARNING("device needs 2-byte addresses - not implemented");
593 if (bank
->size
> (1UL << 24))
594 LOG_WARNING("device needs paging or 4-byte addresses - not implemented");
596 /* if no sectors, treat whole bank as single sector */
597 sectorsize
= stmsmi_info
->dev
->sectorsize
?
598 stmsmi_info
->dev
->sectorsize
: stmsmi_info
->dev
->size_in_bytes
;
600 /* create and fill sectors array */
602 stmsmi_info
->dev
->size_in_bytes
/ sectorsize
;
603 sectors
= malloc(sizeof(struct flash_sector
) * bank
->num_sectors
);
604 if (sectors
== NULL
) {
605 LOG_ERROR("not enough memory");
609 for (unsigned int sector
= 0; sector
< bank
->num_sectors
; sector
++) {
610 sectors
[sector
].offset
= sector
* sectorsize
;
611 sectors
[sector
].size
= sectorsize
;
612 sectors
[sector
].is_erased
= -1;
613 sectors
[sector
].is_protected
= 1;
616 bank
->sectors
= sectors
;
617 stmsmi_info
->probed
= true;
621 static int stmsmi_auto_probe(struct flash_bank
*bank
)
623 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
624 if (stmsmi_info
->probed
)
626 return stmsmi_probe(bank
);
629 static int stmsmi_protect_check(struct flash_bank
*bank
)
631 /* Nothing to do. Protection is only handled in SW. */
635 static int get_stmsmi_info(struct flash_bank
*bank
, char *buf
, int buf_size
)
637 struct stmsmi_flash_bank
*stmsmi_info
= bank
->driver_priv
;
639 if (!(stmsmi_info
->probed
)) {
640 snprintf(buf
, buf_size
,
641 "\nSMI flash bank not probed yet\n");
645 snprintf(buf
, buf_size
, "\nSMI flash information:\n"
646 " Device \'%s\' (ID 0x%08" PRIx32
")\n",
647 stmsmi_info
->dev
->name
, stmsmi_info
->dev
->device_id
);
652 const struct flash_driver stmsmi_flash
= {
654 .flash_bank_command
= stmsmi_flash_bank_command
,
655 .erase
= stmsmi_erase
,
656 .protect
= stmsmi_protect
,
657 .write
= stmsmi_write
,
658 .read
= default_flash_read
,
659 .probe
= stmsmi_probe
,
660 .auto_probe
= stmsmi_auto_probe
,
661 .erase_check
= default_flash_blank_check
,
662 .protect_check
= stmsmi_protect_check
,
663 .info
= get_stmsmi_info
,
664 .free_driver_priv
= default_flash_free_driver_priv
,
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)