- reset_run now works as expected on cortex-m3
- str9xpec erase status checked on option byte programming - stm32x flash driver now supports sector protection - surplus exit removed from flash.c - openocd.texi documentation added git-svn-id: svn://svn.berlios.de/openocd/trunk@212 b42882b7-edfa-0310-969c-e2dbd0fdcd60__archive__
ntfreak
parent
89d0e422c9
commit
8c634335b4
|
|
@ -2,4 +2,4 @@
|
|||
# have all needed files, that a GNU package needs
|
||||
AUTOMAKE_OPTIONS = foreign 1.4
|
||||
|
||||
SUBDIRS = src
|
||||
SUBDIRS = src doc
|
||||
|
|
|
|||
|
|
@ -249,4 +249,4 @@ AC_PROG_RANLIB
|
|||
|
||||
AC_SUBST(WITH_FTD2XX, $with_ftd2xx)
|
||||
|
||||
AC_OUTPUT(Makefile src/Makefile src/helper/Makefile src/jtag/Makefile src/xsvf/Makefile src/target/Makefile src/server/Makefile src/flash/Makefile src/pld/Makefile)
|
||||
AC_OUTPUT(Makefile src/Makefile src/helper/Makefile src/jtag/Makefile src/xsvf/Makefile src/target/Makefile src/server/Makefile src/flash/Makefile src/pld/Makefile doc/Makefile)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,3 @@
|
|||
info_TEXINFOS = openocd.texi
|
||||
openocd_TEXINFOS = fdl.texi
|
||||
|
||||
|
|
@ -0,0 +1,367 @@
|
|||
@c -*-texinfo-*-
|
||||
@node License
|
||||
@appendix GNU Free Documentation License
|
||||
@center Version 1.1, March 2000
|
||||
|
||||
@display
|
||||
Copyright (C) 2000, 2003 Free Software Foundation, Inc.
|
||||
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
|
||||
Everyone is permitted to copy and distribute verbatim copies
|
||||
of this license document, but changing it is not allowed.
|
||||
@end display
|
||||
@sp 1
|
||||
@enumerate 0
|
||||
@item
|
||||
PREAMBLE
|
||||
|
||||
The purpose of this License is to make a manual, textbook, or other
|
||||
written document ``free'' in the sense of freedom: to assure everyone
|
||||
the effective freedom to copy and redistribute it, with or without
|
||||
modifying it, either commercially or noncommercially. Secondarily,
|
||||
this License preserves for the author and publisher a way to get
|
||||
credit for their work, while not being considered responsible for
|
||||
modifications made by others.
|
||||
|
||||
This License is a kind of ``copyleft'', which means that derivative
|
||||
works of the document must themselves be free in the same sense. It
|
||||
complements the GNU General Public License, which is a copyleft
|
||||
license designed for free software.
|
||||
|
||||
We have designed this License in order to use it for manuals for free
|
||||
software, because free software needs free documentation: a free
|
||||
program should come with manuals providing the same freedoms that the
|
||||
software does. But this License is not limited to software manuals;
|
||||
it can be used for any textual work, regardless of subject matter or
|
||||
whether it is published as a printed book. We recommend this License
|
||||
principally for works whose purpose is instruction or reference.
|
||||
|
||||
@sp 1
|
||||
@item
|
||||
APPLICABILITY AND DEFINITIONS
|
||||
|
||||
This License applies to any manual or other work that contains a
|
||||
notice placed by the copyright holder saying it can be distributed
|
||||
under the terms of this License. The ``Document'', below, refers to any
|
||||
such manual or work. Any member of the public is a licensee, and is
|
||||
addressed as ``you.''
|
||||
|
||||
A ``Modified Version'' of the Document means any work containing the
|
||||
Document or a portion of it, either copied verbatim, or with
|
||||
modifications and/or translated into another language.
|
||||
|
||||
A ``Secondary Section'' is a named appendix or a front-matter section of
|
||||
the Document that deals exclusively with the relationship of the
|
||||
publishers or authors of the Document to the Document's overall subject
|
||||
(or to related matters) and contains nothing that could fall directly
|
||||
within that overall subject. (For example, if the Document is in part a
|
||||
textbook of mathematics, a Secondary Section may not explain any
|
||||
mathematics.) The relationship could be a matter of historical
|
||||
connection with the subject or with related matters, or of legal,
|
||||
commercial, philosophical, ethical or political position regarding
|
||||
them.
|
||||
|
||||
The ``Invariant Sections'' are certain Secondary Sections whose titles
|
||||
are designated, as being those of Invariant Sections, in the notice
|
||||
that says that the Document is released under this License.
|
||||
|
||||
The ``Cover Texts'' are certain short passages of text that are listed,
|
||||
as Front-Cover Texts or Back-Cover Texts, in the notice that says that
|
||||
the Document is released under this License.
|
||||
|
||||
A ``Transparent'' copy of the Document means a machine-readable copy,
|
||||
represented in a format whose specification is available to the
|
||||
general public, whose contents can be viewed and edited directly and
|
||||
straightforwardly with generic text editors or (for images composed of
|
||||
pixels) generic paint programs or (for drawings) some widely available
|
||||
drawing editor, and that is suitable for input to text formatters or
|
||||
for automatic translation to a variety of formats suitable for input
|
||||
to text formatters. A copy made in an otherwise Transparent file
|
||||
format whose markup has been designed to thwart or discourage
|
||||
subsequent modification by readers is not Transparent. A copy that is
|
||||
not ``Transparent'' is called ``Opaque.''
|
||||
|
||||
Examples of suitable formats for Transparent copies include plain
|
||||
ASCII without markup, Texinfo input format, LaTeX input format, SGML
|
||||
or XML using a publicly available DTD, and standard-conforming simple
|
||||
HTML designed for human modification. Opaque formats include
|
||||
PostScript, PDF, proprietary formats that can be read and edited only
|
||||
by proprietary word processors, SGML or XML for which the DTD and/or
|
||||
processing tools are not generally available, and the
|
||||
machine-generated HTML produced by some word processors for output
|
||||
purposes only.
|
||||
|
||||
The ``Title Page'' means, for a printed book, the title page itself,
|
||||
plus such following pages as are needed to hold, legibly, the material
|
||||
this License requires to appear in the title page. For works in
|
||||
formats which do not have any title page as such, ``Title Page'' means
|
||||
the text near the most prominent appearance of the work's title,
|
||||
preceding the beginning of the body of the text.
|
||||
@sp 1
|
||||
@item
|
||||
VERBATIM COPYING
|
||||
|
||||
You may copy and distribute the Document in any medium, either
|
||||
commercially or noncommercially, provided that this License, the
|
||||
copyright notices, and the license notice saying this License applies
|
||||
to the Document are reproduced in all copies, and that you add no other
|
||||
conditions whatsoever to those of this License. You may not use
|
||||
technical measures to obstruct or control the reading or further
|
||||
copying of the copies you make or distribute. However, you may accept
|
||||
compensation in exchange for copies. If you distribute a large enough
|
||||
number of copies you must also follow the conditions in section 3.
|
||||
|
||||
You may also lend copies, under the same conditions stated above, and
|
||||
you may publicly display copies.
|
||||
@sp 1
|
||||
@item
|
||||
COPYING IN QUANTITY
|
||||
|
||||
If you publish printed copies of the Document numbering more than 100,
|
||||
and the Document's license notice requires Cover Texts, you must enclose
|
||||
the copies in covers that carry, clearly and legibly, all these Cover
|
||||
Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on
|
||||
the back cover. Both covers must also clearly and legibly identify
|
||||
you as the publisher of these copies. The front cover must present
|
||||
the full title with all words of the title equally prominent and
|
||||
visible. You may add other material on the covers in addition.
|
||||
Copying with changes limited to the covers, as long as they preserve
|
||||
the title of the Document and satisfy these conditions, can be treated
|
||||
as verbatim copying in other respects.
|
||||
|
||||
If the required texts for either cover are too voluminous to fit
|
||||
legibly, you should put the first ones listed (as many as fit
|
||||
reasonably) on the actual cover, and continue the rest onto adjacent
|
||||
pages.
|
||||
|
||||
If you publish or distribute Opaque copies of the Document numbering
|
||||
more than 100, you must either include a machine-readable Transparent
|
||||
copy along with each Opaque copy, or state in or with each Opaque copy
|
||||
a publicly-accessible computer-network location containing a complete
|
||||
Transparent copy of the Document, free of added material, which the
|
||||
general network-using public has access to download anonymously at no
|
||||
charge using public-standard network protocols. If you use the latter
|
||||
option, you must take reasonably prudent steps, when you begin
|
||||
distribution of Opaque copies in quantity, to ensure that this
|
||||
Transparent copy will remain thus accessible at the stated location
|
||||
until at least one year after the last time you distribute an Opaque
|
||||
copy (directly or through your agents or retailers) of that edition to
|
||||
the public.
|
||||
|
||||
It is requested, but not required, that you contact the authors of the
|
||||
Document well before redistributing any large number of copies, to give
|
||||
them a chance to provide you with an updated version of the Document.
|
||||
@sp 1
|
||||
@item
|
||||
MODIFICATIONS
|
||||
|
||||
You may copy and distribute a Modified Version of the Document under
|
||||
the conditions of sections 2 and 3 above, provided that you release
|
||||
the Modified Version under precisely this License, with the Modified
|
||||
Version filling the role of the Document, thus licensing distribution
|
||||
and modification of the Modified Version to whoever possesses a copy
|
||||
of it. In addition, you must do these things in the Modified Version:
|
||||
|
||||
A. Use in the Title Page (and on the covers, if any) a title distinct
|
||||
from that of the Document, and from those of previous versions
|
||||
(which should, if there were any, be listed in the History section
|
||||
of the Document). You may use the same title as a previous version
|
||||
if the original publisher of that version gives permission.@*
|
||||
B. List on the Title Page, as authors, one or more persons or entities
|
||||
responsible for authorship of the modifications in the Modified
|
||||
Version, together with at least five of the principal authors of the
|
||||
Document (all of its principal authors, if it has less than five).@*
|
||||
C. State on the Title page the name of the publisher of the
|
||||
Modified Version, as the publisher.@*
|
||||
D. Preserve all the copyright notices of the Document.@*
|
||||
E. Add an appropriate copyright notice for your modifications
|
||||
adjacent to the other copyright notices.@*
|
||||
F. Include, immediately after the copyright notices, a license notice
|
||||
giving the public permission to use the Modified Version under the
|
||||
terms of this License, in the form shown in the Addendum below.@*
|
||||
G. Preserve in that license notice the full lists of Invariant Sections
|
||||
and required Cover Texts given in the Document's license notice.@*
|
||||
H. Include an unaltered copy of this License.@*
|
||||
I. Preserve the section entitled ``History'', and its title, and add to
|
||||
it an item stating at least the title, year, new authors, and
|
||||
publisher of the Modified Version as given on the Title Page. If
|
||||
there is no section entitled ``History'' in the Document, create one
|
||||
stating the title, year, authors, and publisher of the Document as
|
||||
given on its Title Page, then add an item describing the Modified
|
||||
Version as stated in the previous sentence.@*
|
||||
J. Preserve the network location, if any, given in the Document for
|
||||
public access to a Transparent copy of the Document, and likewise
|
||||
the network locations given in the Document for previous versions
|
||||
it was based on. These may be placed in the ``History'' section.
|
||||
You may omit a network location for a work that was published at
|
||||
least four years before the Document itself, or if the original
|
||||
publisher of the version it refers to gives permission.@*
|
||||
K. In any section entitled ``Acknowledgements'' or ``Dedications'',
|
||||
preserve the section's title, and preserve in the section all the
|
||||
substance and tone of each of the contributor acknowledgements
|
||||
and/or dedications given therein.@*
|
||||
L. Preserve all the Invariant Sections of the Document,
|
||||
unaltered in their text and in their titles. Section numbers
|
||||
or the equivalent are not considered part of the section titles.@*
|
||||
M. Delete any section entitled ``Endorsements.'' Such a section
|
||||
may not be included in the Modified Version.@*
|
||||
N. Do not retitle any existing section as ``Endorsements''
|
||||
or to conflict in title with any Invariant Section.@*
|
||||
@sp 1
|
||||
If the Modified Version includes new front-matter sections or
|
||||
appendices that qualify as Secondary Sections and contain no material
|
||||
copied from the Document, you may at your option designate some or all
|
||||
of these sections as invariant. To do this, add their titles to the
|
||||
list of Invariant Sections in the Modified Version's license notice.
|
||||
These titles must be distinct from any other section titles.
|
||||
|
||||
You may add a section entitled ``Endorsements'', provided it contains
|
||||
nothing but endorsements of your Modified Version by various
|
||||
parties--for example, statements of peer review or that the text has
|
||||
been approved by an organization as the authoritative definition of a
|
||||
standard.
|
||||
|
||||
You may add a passage of up to five words as a Front-Cover Text, and a
|
||||
passage of up to 25 words as a Back-Cover Text, to the end of the list
|
||||
of Cover Texts in the Modified Version. Only one passage of
|
||||
Front-Cover Text and one of Back-Cover Text may be added by (or
|
||||
through arrangements made by) any one entity. If the Document already
|
||||
includes a cover text for the same cover, previously added by you or
|
||||
by arrangement made by the same entity you are acting on behalf of,
|
||||
you may not add another; but you may replace the old one, on explicit
|
||||
permission from the previous publisher that added the old one.
|
||||
|
||||
The author(s) and publisher(s) of the Document do not by this License
|
||||
give permission to use their names for publicity for or to assert or
|
||||
imply endorsement of any Modified Version.
|
||||
@sp 1
|
||||
@item
|
||||
COMBINING DOCUMENTS
|
||||
|
||||
You may combine the Document with other documents released under this
|
||||
License, under the terms defined in section 4 above for modified
|
||||
versions, provided that you include in the combination all of the
|
||||
Invariant Sections of all of the original documents, unmodified, and
|
||||
list them all as Invariant Sections of your combined work in its
|
||||
license notice.
|
||||
|
||||
The combined work need only contain one copy of this License, and
|
||||
multiple identical Invariant Sections may be replaced with a single
|
||||
copy. If there are multiple Invariant Sections with the same name but
|
||||
different contents, make the title of each such section unique by
|
||||
adding at the end of it, in parentheses, the name of the original
|
||||
author or publisher of that section if known, or else a unique number.
|
||||
Make the same adjustment to the section titles in the list of
|
||||
Invariant Sections in the license notice of the combined work.
|
||||
|
||||
In the combination, you must combine any sections entitled ``History''
|
||||
in the various original documents, forming one section entitled
|
||||
``History''; likewise combine any sections entitled ``Acknowledgements'',
|
||||
and any sections entitled ``Dedications.'' You must delete all sections
|
||||
entitled ``Endorsements.''
|
||||
@sp 1
|
||||
@item
|
||||
COLLECTIONS OF DOCUMENTS
|
||||
|
||||
You may make a collection consisting of the Document and other documents
|
||||
released under this License, and replace the individual copies of this
|
||||
License in the various documents with a single copy that is included in
|
||||
the collection, provided that you follow the rules of this License for
|
||||
verbatim copying of each of the documents in all other respects.
|
||||
|
||||
You may extract a single document from such a collection, and distribute
|
||||
it individually under this License, provided you insert a copy of this
|
||||
License into the extracted document, and follow this License in all
|
||||
other respects regarding verbatim copying of that document.
|
||||
@sp 1
|
||||
@item
|
||||
AGGREGATION WITH INDEPENDENT WORKS
|
||||
|
||||
A compilation of the Document or its derivatives with other separate
|
||||
and independent documents or works, in or on a volume of a storage or
|
||||
distribution medium, does not as a whole count as a Modified Version
|
||||
of the Document, provided no compilation copyright is claimed for the
|
||||
compilation. Such a compilation is called an ``aggregate'', and this
|
||||
License does not apply to the other self-contained works thus compiled
|
||||
with the Document, on account of their being thus compiled, if they
|
||||
are not themselves derivative works of the Document.
|
||||
|
||||
If the Cover Text requirement of section 3 is applicable to these
|
||||
copies of the Document, then if the Document is less than one quarter
|
||||
of the entire aggregate, the Document's Cover Texts may be placed on
|
||||
covers that surround only the Document within the aggregate.
|
||||
Otherwise they must appear on covers around the whole aggregate.
|
||||
@sp 1
|
||||
@item
|
||||
TRANSLATION
|
||||
|
||||
Translation is considered a kind of modification, so you may
|
||||
distribute translations of the Document under the terms of section 4.
|
||||
Replacing Invariant Sections with translations requires special
|
||||
permission from their copyright holders, but you may include
|
||||
translations of some or all Invariant Sections in addition to the
|
||||
original versions of these Invariant Sections. You may include a
|
||||
translation of this License provided that you also include the
|
||||
original English version of this License. In case of a disagreement
|
||||
between the translation and the original English version of this
|
||||
License, the original English version will prevail.
|
||||
@sp 1
|
||||
@item
|
||||
TERMINATION
|
||||
|
||||
You may not copy, modify, sublicense, or distribute the Document except
|
||||
as expressly provided for under this License. Any other attempt to
|
||||
copy, modify, sublicense or distribute the Document is void, and will
|
||||
automatically terminate your rights under this License. However,
|
||||
parties who have received copies, or rights, from you under this
|
||||
License will not have their licenses terminated so long as such
|
||||
parties remain in full compliance.
|
||||
@sp 1
|
||||
@item
|
||||
FUTURE REVISIONS OF THIS LICENSE
|
||||
|
||||
The Free Software Foundation may publish new, revised versions
|
||||
of the GNU Free Documentation License from time to time. Such new
|
||||
versions will be similar in spirit to the present version, but may
|
||||
differ in detail to address new problems or concerns. See
|
||||
http://www.gnu.org/copyleft/.
|
||||
|
||||
Each version of the License is given a distinguishing version number.
|
||||
If the Document specifies that a particular numbered version of this
|
||||
License ``or any later version'' applies to it, you have the option of
|
||||
following the terms and conditions either of that specified version or
|
||||
of any later version that has been published (not as a draft) by the
|
||||
Free Software Foundation. If the Document does not specify a version
|
||||
number of this License, you may choose any version ever published (not
|
||||
as a draft) by the Free Software Foundation.
|
||||
|
||||
@end enumerate
|
||||
|
||||
@unnumberedsec ADDENDUM: How to use this License for your documents
|
||||
|
||||
To use this License in a document you have written, include a copy of
|
||||
the License in the document and put the following copyright and
|
||||
license notices just after the title page:
|
||||
|
||||
@smallexample
|
||||
@group
|
||||
Copyright (C) @var{year} @var{your name}.
|
||||
Permission is granted to copy, distribute and/or modify this document
|
||||
under the terms of the GNU Free Documentation License, Version 1.1
|
||||
or any later version published by the Free Software Foundation;
|
||||
with the Invariant Sections being @var{list their titles}, with the
|
||||
Front-Cover Texts being @var{list}, and with the Back-Cover Texts being @var{list}.
|
||||
A copy of the license is included in the section entitled "GNU
|
||||
Free Documentation License."
|
||||
@end group
|
||||
@end smallexample
|
||||
|
||||
If you have no Invariant Sections, write ``with no Invariant Sections''
|
||||
instead of saying which ones are invariant. If you have no
|
||||
Front-Cover Texts, write ``no Front-Cover Texts'' instead of
|
||||
``Front-Cover Texts being @var{list}''; likewise for Back-Cover Texts.
|
||||
|
||||
If your document contains nontrivial examples of program code, we
|
||||
recommend releasing these examples in parallel under your choice of
|
||||
free software license, such as the GNU General Public License,
|
||||
to permit their use in free software.
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -574,7 +574,6 @@ int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cm
|
|||
{
|
||||
command_print(cmd_ctx, "failed writing image %s: %s", args[0], error_str);
|
||||
free(error_str);
|
||||
free(failed);
|
||||
}
|
||||
|
||||
for (i = 0; i < image.num_sections; i++)
|
||||
|
|
@ -839,7 +838,7 @@ int flash_write(target_t *target, image_t *image, u32 *written, char **error_str
|
|||
size_read = image->sections[section].size - section_offset;
|
||||
|
||||
if ((retval = image_read_section(image, section, section_offset,
|
||||
size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
|
||||
run_size, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
|
||||
{
|
||||
free(buffer);
|
||||
|
||||
|
|
|
|||
|
|
@ -169,6 +169,155 @@ u32 stm32x_wait_status_busy(flash_bank_t *bank, int timeout)
|
|||
return status;
|
||||
}
|
||||
|
||||
int stm32x_read_options(struct flash_bank_s *bank)
|
||||
{
|
||||
u32 optiondata;
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
target_t *target = bank->target;
|
||||
|
||||
stm32x_info = bank->driver_priv;
|
||||
|
||||
/* read current option bytes */
|
||||
target_read_u32(target, STM32_FLASH_OBR, &optiondata);
|
||||
|
||||
stm32x_info->option_bytes.user_options = (u16)0xFFF8|((optiondata >> 2) & 0x07);
|
||||
stm32x_info->option_bytes.RDP = (optiondata & (1 << OPT_READOUT)) ? 0xFFFF : 0x5AA5;
|
||||
|
||||
if (optiondata & (1 << OPT_READOUT))
|
||||
INFO("Device Security Bit Set");
|
||||
|
||||
/* each bit refers to a 4bank protection */
|
||||
target_read_u32(target, STM32_FLASH_WRPR, &optiondata);
|
||||
|
||||
stm32x_info->option_bytes.protection[0] = (u16)optiondata;
|
||||
stm32x_info->option_bytes.protection[1] = (u16)(optiondata >> 8);
|
||||
stm32x_info->option_bytes.protection[2] = (u16)(optiondata >> 16);
|
||||
stm32x_info->option_bytes.protection[3] = (u16)(optiondata >> 24);
|
||||
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
int stm32x_erase_options(struct flash_bank_s *bank)
|
||||
{
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
target_t *target = bank->target;
|
||||
u32 status;
|
||||
|
||||
stm32x_info = bank->driver_priv;
|
||||
|
||||
/* read current options */
|
||||
stm32x_read_options(bank);
|
||||
|
||||
/* unlock flash registers */
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY2);
|
||||
|
||||
/* unlock option flash registers */
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY2);
|
||||
|
||||
/* erase option bytes */
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTER|FLASH_OPTWRE);
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTER|FLASH_STRT|FLASH_OPTWRE);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* clear readout protection and complementary option bytes
|
||||
* this will also force a device unlock if set */
|
||||
stm32x_info->option_bytes.RDP = 0x5AA5;
|
||||
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
int stm32x_write_options(struct flash_bank_s *bank)
|
||||
{
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
target_t *target = bank->target;
|
||||
u32 status;
|
||||
|
||||
stm32x_info = bank->driver_priv;
|
||||
|
||||
/* unlock flash registers */
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY2);
|
||||
|
||||
/* unlock option flash registers */
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY2);
|
||||
|
||||
/* program option bytes */
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTPG|FLASH_OPTWRE);
|
||||
|
||||
/* write user option byte */
|
||||
target_write_u16(target, STM32_OB_USER, stm32x_info->option_bytes.user_options);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* write protection byte 1 */
|
||||
target_write_u16(target, STM32_OB_WRP0, stm32x_info->option_bytes.protection[0]);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* write protection byte 2 */
|
||||
target_write_u16(target, STM32_OB_WRP1, stm32x_info->option_bytes.protection[1]);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* write protection byte 3 */
|
||||
target_write_u16(target, STM32_OB_WRP2, stm32x_info->option_bytes.protection[2]);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* write protection byte 4 */
|
||||
target_write_u16(target, STM32_OB_WRP3, stm32x_info->option_bytes.protection[3]);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* write readout protection bit */
|
||||
target_write_u16(target, STM32_OB_RDP, stm32x_info->option_bytes.RDP);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
|
||||
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
int stm32x_blank_check(struct flash_bank_s *bank, int first, int last)
|
||||
{
|
||||
target_t *target = bank->target;
|
||||
|
|
@ -213,6 +362,7 @@ int stm32x_protect_check(struct flash_bank_s *bank)
|
|||
|
||||
u32 protection;
|
||||
int i, s;
|
||||
int num_bits;
|
||||
|
||||
if (target->state != TARGET_HALTED)
|
||||
{
|
||||
|
|
@ -222,7 +372,10 @@ int stm32x_protect_check(struct flash_bank_s *bank)
|
|||
/* each bit refers to a 4bank protection */
|
||||
target_read_u32(target, STM32_FLASH_WRPR, &protection);
|
||||
|
||||
for (i = 0; i < 32; i++)
|
||||
/* each protection bit is for 4 1K pages */
|
||||
num_bits = (bank->num_sectors / 4);
|
||||
|
||||
for (i = 0; i < num_bits; i++)
|
||||
{
|
||||
int set = 1;
|
||||
|
||||
|
|
@ -243,15 +396,15 @@ int stm32x_erase(struct flash_bank_s *bank, int first, int last)
|
|||
int i;
|
||||
u32 status;
|
||||
|
||||
/* unlock flash registers */
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY2);
|
||||
|
||||
if (target->state != TARGET_HALTED)
|
||||
{
|
||||
return ERROR_TARGET_NOT_HALTED;
|
||||
}
|
||||
|
||||
/* unlock flash registers */
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY2);
|
||||
|
||||
for (i = first; i <= last; i++)
|
||||
{
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_PER);
|
||||
|
|
@ -274,14 +427,54 @@ int stm32x_erase(struct flash_bank_s *bank, int first, int last)
|
|||
|
||||
int stm32x_protect(struct flash_bank_s *bank, int set, int first, int last)
|
||||
{
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
target_t *target = bank->target;
|
||||
u16 prot_reg[4] = {0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF};
|
||||
int i, reg, bit;
|
||||
int status;
|
||||
u32 protection;
|
||||
|
||||
stm32x_info = bank->driver_priv;
|
||||
|
||||
if (target->state != TARGET_HALTED)
|
||||
{
|
||||
return ERROR_TARGET_NOT_HALTED;
|
||||
}
|
||||
|
||||
return ERROR_OK;
|
||||
if ((first && (first % 4)) || ((last + 1) && (last + 1) % 4))
|
||||
{
|
||||
WARNING("sector start/end incorrect - stm32 has 4K sector protection");
|
||||
return ERROR_FLASH_SECTOR_INVALID;
|
||||
}
|
||||
|
||||
/* each bit refers to a 4bank protection */
|
||||
target_read_u32(target, STM32_FLASH_WRPR, &protection);
|
||||
|
||||
prot_reg[0] = (u16)protection;
|
||||
prot_reg[1] = (u16)(protection >> 8);
|
||||
prot_reg[2] = (u16)(protection >> 16);
|
||||
prot_reg[3] = (u16)(protection >> 24);
|
||||
|
||||
for (i = first; i <= last; i++)
|
||||
{
|
||||
reg = (i / 4) / 8;
|
||||
bit = (i / 4) - (reg * 8);
|
||||
|
||||
if( set )
|
||||
prot_reg[reg] &= ~(1 << bit);
|
||||
else
|
||||
prot_reg[reg] |= (1 << bit);
|
||||
}
|
||||
|
||||
if ((status = stm32x_erase_options(bank)) != ERROR_OK)
|
||||
return status;
|
||||
|
||||
stm32x_info->option_bytes.protection[0] = prot_reg[0];
|
||||
stm32x_info->option_bytes.protection[1] = prot_reg[1];
|
||||
stm32x_info->option_bytes.protection[2] = prot_reg[2];
|
||||
stm32x_info->option_bytes.protection[3] = prot_reg[3];
|
||||
|
||||
return stm32x_write_options(bank);
|
||||
}
|
||||
|
||||
int stm32x_write_block(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
|
||||
|
|
@ -509,7 +702,6 @@ int stm32x_info(struct flash_bank_s *bank, char *buf, int buf_size)
|
|||
int stm32x_handle_lock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
|
||||
{
|
||||
flash_bank_t *bank;
|
||||
u32 status;
|
||||
target_t *target = NULL;
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
|
||||
|
|
@ -535,39 +727,21 @@ int stm32x_handle_lock_command(struct command_context_s *cmd_ctx, char *cmd, cha
|
|||
return ERROR_TARGET_NOT_HALTED;
|
||||
}
|
||||
|
||||
/* unlock flash registers */
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY2);
|
||||
|
||||
/* unlock option flash registers */
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY2);
|
||||
|
||||
/* erase option bytes */
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTER|FLASH_OPTWRE);
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTER|FLASH_STRT|FLASH_OPTWRE);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* program option bytes */
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTPG|FLASH_OPTWRE);
|
||||
if (stm32x_erase_options(bank) != ERROR_OK)
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x failed to erase options");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
/* set readout protection */
|
||||
target_write_u16(target, STM32_OB_ADR, 0);
|
||||
stm32x_info->option_bytes.RDP = 0;
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
if (stm32x_write_options(bank) != ERROR_OK)
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x failed to lock device");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
|
||||
command_print(cmd_ctx, "stm32x locked");
|
||||
|
||||
return ERROR_OK;
|
||||
|
|
@ -576,7 +750,6 @@ int stm32x_handle_lock_command(struct command_context_s *cmd_ctx, char *cmd, cha
|
|||
int stm32x_handle_unlock_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
|
||||
{
|
||||
flash_bank_t *bank;
|
||||
u32 status;
|
||||
target_t *target = NULL;
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
|
||||
|
|
@ -602,39 +775,18 @@ int stm32x_handle_unlock_command(struct command_context_s *cmd_ctx, char *cmd, c
|
|||
return ERROR_TARGET_NOT_HALTED;
|
||||
}
|
||||
|
||||
/* unlock flash registers */
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY2);
|
||||
if (stm32x_erase_options(bank) != ERROR_OK)
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x failed to unlock device");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
/* unlock option flash registers */
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY2);
|
||||
if (stm32x_write_options(bank) != ERROR_OK)
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x failed to lock device");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
/* erase option bytes */
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTER|FLASH_OPTWRE);
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTER|FLASH_STRT|FLASH_OPTWRE);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
/* program option bytes */
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTPG|FLASH_OPTWRE);
|
||||
|
||||
/* clear readout protection and complementary option bytes */
|
||||
target_write_u16(target, STM32_OB_ADR, 0x5AA5);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
|
||||
command_print(cmd_ctx, "stm32x unlocked");
|
||||
|
||||
return ERROR_OK;
|
||||
|
|
@ -669,15 +821,6 @@ int stm32x_handle_options_read_command(struct command_context_s *cmd_ctx, char *
|
|||
return ERROR_TARGET_NOT_HALTED;
|
||||
}
|
||||
|
||||
//target_read_u32(target, STM32_OB_ADR, &optionbyte);
|
||||
//command_print(cmd_ctx, "Option Byte 0: 0x%x", optionbyte);
|
||||
//target_read_u32(target, STM32_OB_ADR+4, &optionbyte);
|
||||
//command_print(cmd_ctx, "Option Byte 1: 0x%x", optionbyte);
|
||||
//target_read_u32(target, STM32_OB_ADR+8, &optionbyte);
|
||||
//command_print(cmd_ctx, "Option Byte 2: 0x%x", optionbyte);
|
||||
//target_read_u32(target, STM32_OB_ADR+12, &optionbyte);
|
||||
//command_print(cmd_ctx, "Option Byte 3: 0x%x", optionbyte);
|
||||
|
||||
target_read_u32(target, STM32_FLASH_OBR, &optionbyte);
|
||||
command_print(cmd_ctx, "Option Byte: 0x%x", optionbyte);
|
||||
|
||||
|
|
@ -713,7 +856,6 @@ int stm32x_handle_options_write_command(struct command_context_s *cmd_ctx, char
|
|||
target_t *target = NULL;
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
u16 optionbyte = 0xF8;
|
||||
u32 status;
|
||||
|
||||
if (argc < 4)
|
||||
{
|
||||
|
|
@ -764,38 +906,31 @@ int stm32x_handle_options_write_command(struct command_context_s *cmd_ctx, char
|
|||
optionbyte &= ~(1<<2);
|
||||
}
|
||||
|
||||
/* unlock flash registers */
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_KEYR, KEY2);
|
||||
if (stm32x_erase_options(bank) != ERROR_OK)
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x failed to erase options");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
/* unlock option flash registers */
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY1);
|
||||
target_write_u32(target, STM32_FLASH_OPTKEYR, KEY2);
|
||||
stm32x_info->option_bytes.user_options = optionbyte;
|
||||
|
||||
/* program option bytes */
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_OPTPG|FLASH_OPTWRE);
|
||||
if (stm32x_write_options(bank) != ERROR_OK)
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x failed to write options");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
/* write option byte */
|
||||
target_write_u16(target, STM32_OB_ADR + 2, optionbyte);
|
||||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
|
||||
command_print(cmd_ctx, "stm32x write options complete");
|
||||
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
int stm32x_handle_mass_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
|
||||
{
|
||||
flash_bank_t *bank;
|
||||
u32 status;
|
||||
target_t *target = NULL;
|
||||
stm32x_flash_bank_t *stm32x_info = NULL;
|
||||
flash_bank_t *bank;
|
||||
u32 status;
|
||||
|
||||
if (argc < 1)
|
||||
{
|
||||
|
|
@ -829,12 +964,21 @@ int stm32x_handle_mass_erase_command(struct command_context_s *cmd_ctx, char *cm
|
|||
|
||||
status = stm32x_wait_status_busy(bank, 10);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
if( status & FLASH_PGERR )
|
||||
return ERROR_FLASH_OPERATION_FAILED;
|
||||
|
||||
target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK);
|
||||
|
||||
if( status & FLASH_WRPRTERR )
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x device protected");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
if( status & FLASH_PGERR )
|
||||
{
|
||||
command_print(cmd_ctx, "stm32x device programming failed");
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
||||
command_print(cmd_ctx, "stm32x mass erase complete");
|
||||
|
||||
return ERROR_OK;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -23,8 +23,16 @@
|
|||
#include "flash.h"
|
||||
#include "target.h"
|
||||
|
||||
typedef struct stm32x_options_s
|
||||
{
|
||||
u16 RDP;
|
||||
u16 user_options;
|
||||
u16 protection[4];
|
||||
} stm32x_options_t;
|
||||
|
||||
typedef struct stm32x_flash_bank_s
|
||||
{
|
||||
stm32x_options_t option_bytes;
|
||||
working_area_t *write_algorithm;
|
||||
} stm32x_flash_bank_t;
|
||||
|
||||
|
|
@ -41,7 +49,14 @@ typedef struct stm32x_flash_bank_s
|
|||
|
||||
/* option byte location */
|
||||
|
||||
#define STM32_OB_ADR 0x1FFFF800
|
||||
#define STM32_OB_RDP 0x1FFFF800
|
||||
#define STM32_OB_USER 0x1FFFF802
|
||||
#define STM32_OB_DATA0 0x1FFFF804
|
||||
#define STM32_OB_DATA1 0x1FFFF806
|
||||
#define STM32_OB_WRP0 0x1FFFF808
|
||||
#define STM32_OB_WRP1 0x1FFFF80A
|
||||
#define STM32_OB_WRP2 0x1FFFF80C
|
||||
#define STM32_OB_WRP3 0x1FFFF80E
|
||||
|
||||
/* FLASH_CR register bits */
|
||||
|
||||
|
|
|
|||
|
|
@ -1001,7 +1001,10 @@ int str9xpec_write_options(struct flash_bank_s *bank)
|
|||
chain_pos = str9xpec_info->chain_pos;
|
||||
|
||||
/* erase config options first */
|
||||
str9xpec_erase_area( bank, 0xFE, 0xFE );
|
||||
status = str9xpec_erase_area( bank, 0xFE, 0xFE );
|
||||
|
||||
if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS)
|
||||
return status;
|
||||
|
||||
if (!str9xpec_info->isc_enable) {
|
||||
str9xpec_isc_enable( bank );
|
||||
|
|
|
|||
|
|
@ -1411,7 +1411,7 @@ int gdb_input(connection_t *connection)
|
|||
/* terminate with zero */
|
||||
packet[packet_size] = 0;
|
||||
|
||||
DEBUG("recevied packet: '%s'", packet);
|
||||
DEBUG("received packet: '%s'", packet);
|
||||
|
||||
if (packet_size > 0)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -173,7 +173,7 @@ int cortex_m3_endreset_event(target_t *target)
|
|||
if (!(cortex_m3->dcb_dhcsr & C_DEBUGEN))
|
||||
ahbap_write_system_u32(swjdp, DCB_DHCSR, DBGKEY | C_DEBUGEN );
|
||||
/* Enable trace and dwt */
|
||||
ahbap_write_system_u32(swjdp, DCB_DEMCR, TRCENA | VC_HARDERR | VC_BUSERR | VC_CORERESET );
|
||||
ahbap_write_system_u32(swjdp, DCB_DEMCR, TRCENA | VC_HARDERR | VC_BUSERR );
|
||||
/* Monitor bus faults */
|
||||
ahbap_write_system_u32(swjdp, NVIC_SHCSR, SHCSR_BUSFAULTENA );
|
||||
|
||||
|
|
@ -216,7 +216,6 @@ int cortex_m3_examine_debug_reason(target_t *target)
|
|||
if ((target->debug_reason != DBG_REASON_DBGRQ)
|
||||
&& (target->debug_reason != DBG_REASON_SINGLESTEP))
|
||||
{
|
||||
|
||||
/* INCOPMPLETE */
|
||||
|
||||
if (cortex_m3->nvic_dfsr & 0x2)
|
||||
|
|
@ -363,12 +362,19 @@ enum target_state cortex_m3_poll(target_t *target)
|
|||
return TARGET_UNKNOWN;
|
||||
}
|
||||
|
||||
if (cortex_m3->dcb_dhcsr & S_RESET_ST)
|
||||
{
|
||||
/* check if still in reset */
|
||||
ahbap_read_system_atomic_u32(swjdp, DCB_DHCSR, &cortex_m3->dcb_dhcsr);
|
||||
|
||||
if (cortex_m3->dcb_dhcsr & S_RESET_ST)
|
||||
{
|
||||
target->state = TARGET_RESET;
|
||||
return target->state;
|
||||
}
|
||||
else if (target->state == TARGET_RESET)
|
||||
}
|
||||
|
||||
if (target->state == TARGET_RESET)
|
||||
{
|
||||
/* Cannot switch context while running so endreset is called with target->state == TARGET_RESET */
|
||||
DEBUG("Exit from reset with dcb_dhcsr 0x%x", cortex_m3->dcb_dhcsr);
|
||||
|
|
@ -689,9 +695,25 @@ int cortex_m3_step(struct target_s *target, int current, u32 address, int handle
|
|||
int cortex_m3_assert_reset(target_t *target)
|
||||
{
|
||||
int retval;
|
||||
armv7m_common_t *armv7m = target->arch_info;
|
||||
cortex_m3_common_t *cortex_m3 = armv7m->arch_info;
|
||||
swjdp_common_t *swjdp = &cortex_m3->swjdp_info;
|
||||
|
||||
DEBUG("target->state: %s", target_state_strings[target->state]);
|
||||
|
||||
if (target->reset_mode == RESET_RUN)
|
||||
{
|
||||
/* Set/Clear C_MASKINTS in a separate operation */
|
||||
if (cortex_m3->dcb_dhcsr & C_MASKINTS)
|
||||
ahbap_write_system_atomic_u32(swjdp, DCB_DHCSR, DBGKEY | C_DEBUGEN | C_HALT );
|
||||
|
||||
cortex_m3_clear_halt(target);
|
||||
|
||||
/* Enter debug state on reset, cf. end_reset_event() */
|
||||
ahbap_write_system_u32(swjdp, DCB_DHCSR, DBGKEY | C_DEBUGEN );
|
||||
ahbap_write_system_u32(swjdp, DCB_DEMCR, TRCENA | VC_HARDERR | VC_BUSERR);
|
||||
}
|
||||
|
||||
if (target->state == TARGET_HALTED || target->state == TARGET_UNKNOWN)
|
||||
{
|
||||
/* assert SRST and TRST */
|
||||
|
|
|
|||
Loading…
Reference in New Issue