- 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-e2dbd0fdcd60tags/v0.1.0
@@ -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. |
@@ -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); | |||
@@ -868,7 +867,7 @@ int flash_write(target_t *target, image_t *image, u32 *written, char **error_str | |||
} | |||
retval = ERROR_OK; | |||
if (erase) | |||
{ | |||
/* calculate and erase sectors */ | |||
@@ -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); | |||
/* set readout protection */ | |||
target_write_u16(target, STM32_OB_ADR, 0); | |||
status = stm32x_wait_status_busy(bank, 10); | |||
if (stm32x_erase_options(bank) != ERROR_OK) | |||
{ | |||
command_print(cmd_ctx, "stm32x failed to erase options"); | |||
return ERROR_OK; | |||
} | |||
/* set readout protection */ | |||
stm32x_info->option_bytes.RDP = 0; | |||
if( status & FLASH_WRPRTERR ) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
if( status & FLASH_PGERR ) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
if (stm32x_write_options(bank) != ERROR_OK) | |||
{ | |||
command_print(cmd_ctx, "stm32x failed to lock device"); | |||
return ERROR_OK; | |||
} | |||
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; | |||
@@ -601,40 +774,19 @@ int stm32x_handle_unlock_command(struct command_context_s *cmd_ctx, char *cmd, c | |||
{ | |||
return ERROR_TARGET_NOT_HALTED; | |||
} | |||
if (stm32x_erase_options(bank) != ERROR_OK) | |||
{ | |||
command_print(cmd_ctx, "stm32x failed to unlock device"); | |||
return ERROR_OK; | |||
} | |||
/* 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); | |||
/* 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; | |||
if (stm32x_write_options(bank) != ERROR_OK) | |||
{ | |||
command_print(cmd_ctx, "stm32x failed to lock device"); | |||
return ERROR_OK; | |||
} | |||
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); | |||
/* 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 option byte */ | |||
target_write_u16(target, STM32_OB_ADR + 2, optionbyte); | |||
if (stm32x_erase_options(bank) != ERROR_OK) | |||
{ | |||
command_print(cmd_ctx, "stm32x failed to erase options"); | |||
return ERROR_OK; | |||
} | |||
status = stm32x_wait_status_busy(bank, 10); | |||
stm32x_info->option_bytes.user_options = optionbyte; | |||
if( status & FLASH_WRPRTERR ) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
if( status & FLASH_PGERR ) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
if (stm32x_write_options(bank) != ERROR_OK) | |||
{ | |||
command_print(cmd_ctx, "stm32x failed to write options"); | |||
return ERROR_OK; | |||
} | |||
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); | |||
target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK); | |||
if( status & FLASH_WRPRTERR ) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
{ | |||
command_print(cmd_ctx, "stm32x device protected"); | |||
return ERROR_OK; | |||
} | |||
if( status & FLASH_PGERR ) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
{ | |||
command_print(cmd_ctx, "stm32x device programming failed"); | |||
return ERROR_OK; | |||
} | |||
target_write_u32(target, STM32_FLASH_CR, FLASH_LOCK); | |||
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 */ | |||
@@ -791,10 +791,10 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) | |||
} while(!(status & ISC_STATUS_BUSY)); | |||
if ((status & ISC_STATUS_ERROR) != STR9XPEC_ISC_SUCCESS) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
//if ((status & ISC_STATUS_INT_ERROR) != STR9XPEC_ISC_INTFAIL) | |||
// return ERROR_FLASH_OPERATION_FAILED; | |||
// return ERROR_FLASH_OPERATION_FAILED; | |||
dwords_remaining--; | |||
bytes_written += 8; | |||
@@ -854,7 +854,7 @@ int str9xpec_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count) | |||
return ERROR_FLASH_OPERATION_FAILED; | |||
//if ((status & ISC_STATUS_INT_ERROR) != STR9XPEC_ISC_INTFAIL) | |||
// return ERROR_FLASH_OPERATION_FAILED; | |||
// return ERROR_FLASH_OPERATION_FAILED; | |||
} | |||
free(scanbuf); | |||
@@ -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) | |||
@@ -365,10 +364,17 @@ enum target_state cortex_m3_poll(target_t *target) | |||
if (cortex_m3->dcb_dhcsr & S_RESET_ST) | |||
{ | |||
target->state = TARGET_RESET; | |||
return target->state; | |||
/* 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 */ | |||