From a70bae6208f362e139fc60ce99d595f2da44cc48 Mon Sep 17 00:00:00 2001 From: ToshikazuOhiwa Date: Mon, 30 Mar 2020 09:42:00 +0900 Subject: ss-romaccesslibrary branch --- rom_access_library/LICENSE | 177 ++++ rom_access_library/Makefile.client | 19 + rom_access_library/library/Makefile | 19 + .../library/include/rom_access_library_nor.h | 43 + .../library/include/rom_access_library_rom.h | 45 + .../library/include/ss_rom_access_define.h | 38 + .../include/ss_rom_access_if_romaccesslibrarylog.h | 89 ++ .../library/include/ss_sm_checksum.h | 34 + .../library/include/system_service/nor_backup.h | 212 ++++ .../include/system_service/rom_access_library.h | 47 + .../include/system_service/ss_sm_boot_access.h | 362 +++++++ .../include/system_service/ss_sm_ram_access.h | 237 +++++ .../include/system_service/ss_sm_rom_access.h | 1010 ++++++++++++++++++++ rom_access_library/library/nor/Makefile | 46 + rom_access_library/library/nor/libBlkDev_API.ver | 30 + rom_access_library/library/nor/libssaccess.ver | 30 + rom_access_library/library/nor/src/nor_backup.c | 807 ++++++++++++++++ rom_access_library/library/rom/Makefile | 63 ++ .../library/rom/src/ss_sm_boot_access.cpp | 122 +++ .../library/rom/src/ss_sm_checksum.cpp | 37 + .../library/rom/src/ss_sm_ram_access.cpp | 215 +++++ .../library/rom/src/ss_sm_rom_access.cpp | 969 +++++++++++++++++++ system_service.mk | 44 + 23 files changed, 4695 insertions(+) create mode 100644 rom_access_library/LICENSE create mode 100644 rom_access_library/Makefile.client create mode 100644 rom_access_library/library/Makefile create mode 100644 rom_access_library/library/include/rom_access_library_nor.h create mode 100644 rom_access_library/library/include/rom_access_library_rom.h create mode 100644 rom_access_library/library/include/ss_rom_access_define.h create mode 100644 rom_access_library/library/include/ss_rom_access_if_romaccesslibrarylog.h create mode 100644 rom_access_library/library/include/ss_sm_checksum.h create mode 100644 rom_access_library/library/include/system_service/nor_backup.h create mode 100644 rom_access_library/library/include/system_service/rom_access_library.h create mode 100644 rom_access_library/library/include/system_service/ss_sm_boot_access.h create mode 100644 rom_access_library/library/include/system_service/ss_sm_ram_access.h create mode 100644 rom_access_library/library/include/system_service/ss_sm_rom_access.h create mode 100644 rom_access_library/library/nor/Makefile create mode 100644 rom_access_library/library/nor/libBlkDev_API.ver create mode 100644 rom_access_library/library/nor/libssaccess.ver create mode 100644 rom_access_library/library/nor/src/nor_backup.c create mode 100644 rom_access_library/library/rom/Makefile create mode 100644 rom_access_library/library/rom/src/ss_sm_boot_access.cpp create mode 100644 rom_access_library/library/rom/src/ss_sm_checksum.cpp create mode 100644 rom_access_library/library/rom/src/ss_sm_ram_access.cpp create mode 100644 rom_access_library/library/rom/src/ss_sm_rom_access.cpp create mode 100644 system_service.mk diff --git a/rom_access_library/LICENSE b/rom_access_library/LICENSE new file mode 100644 index 00000000..f433b1a5 --- /dev/null +++ b/rom_access_library/LICENSE @@ -0,0 +1,177 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS diff --git a/rom_access_library/Makefile.client b/rom_access_library/Makefile.client new file mode 100644 index 00000000..98aaecf1 --- /dev/null +++ b/rom_access_library/Makefile.client @@ -0,0 +1,19 @@ +# +# @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SUBDIRS += library mock + +include ../system_service.mk diff --git a/rom_access_library/library/Makefile b/rom_access_library/library/Makefile new file mode 100644 index 00000000..c3ea6d45 --- /dev/null +++ b/rom_access_library/library/Makefile @@ -0,0 +1,19 @@ +# +# @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +SUBDIRS := nor rom + +include ../../system_service.mk diff --git a/rom_access_library/library/include/rom_access_library_nor.h b/rom_access_library/library/include/rom_access_library_nor.h new file mode 100644 index 00000000..314f60ec --- /dev/null +++ b/rom_access_library/library/include/rom_access_library_nor.h @@ -0,0 +1,43 @@ +// +// @copyright Copyright (c) 2017-2019 TOYOTA MOTOR CORPORATION. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file rom_access_library_nor.h + * @brief This file include the head file of nor access + */ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup rom_access_library + * @ingroup system_service + * @{ + */ + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_ROM_ACCESS_LIBRARY_NOR_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_ROM_ACCESS_LIBRARY_NOR_H_ + +#include "system_service/nor_backup.h" + +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_ROM_ACCESS_LIBRARY_NOR_H_ + +/** @}*/ // end of rom_access_library +/** @}*/ // end of system_service +/** @}*/ // end of BaseSystem diff --git a/rom_access_library/library/include/rom_access_library_rom.h b/rom_access_library/library/include/rom_access_library_rom.h new file mode 100644 index 00000000..b09f94fc --- /dev/null +++ b/rom_access_library/library/include/rom_access_library_rom.h @@ -0,0 +1,45 @@ +// +// @copyright Copyright (c) 2017-2019 TOYOTA MOTOR CORPORATION. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file rom_access_library_rom.h + * @brief This file include all head file of rom access + */ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup rom_access_library + * @ingroup system_service + * @{ + */ + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_ROM_ACCESS_LIBRARY_ROM_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_ROM_ACCESS_LIBRARY_ROM_H_ + +#include "system_service/ss_sm_rom_access.h" +#include "system_service/ss_sm_boot_access.h" +#include "system_service/ss_sm_ram_access.h" + +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_ROM_ACCESS_LIBRARY_ROM_H_ + +/** @}*/ // end of rom_access_library +/** @}*/ // end of system_service +/** @}*/ // end of BaseSystem diff --git a/rom_access_library/library/include/ss_rom_access_define.h b/rom_access_library/library/include/ss_rom_access_define.h new file mode 100644 index 00000000..83b9d44b --- /dev/null +++ b/rom_access_library/library/include/ss_rom_access_define.h @@ -0,0 +1,38 @@ +/* + * @copyright Copyright (c) 2017-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_ROM_ACCESS_DEFINE_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_ROM_ACCESS_DEFINE_H_ + +#include + +#define ROM_ACCESS_ASERT(x) \ + if (!(x)) { \ + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "SS_ASSERT"); \ + } + +#define ROM_ACCESS_ERRNO(x) \ + if (!(x)) { \ + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "SS_ASSERT %d:%s", errno, strerror(errno)); \ + } + +#define ROM_ACCESS_STATIC_ASERT(expr) \ + { \ + char STATIC_ASSERTION_FAILED[(expr) ? 1 : -1]; \ + (void)STATIC_ASSERTION_FAILED; \ + } +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_ROM_ACCESS_DEFINE_H_ diff --git a/rom_access_library/library/include/ss_rom_access_if_romaccesslibrarylog.h b/rom_access_library/library/include/ss_rom_access_if_romaccesslibrarylog.h new file mode 100644 index 00000000..e4bc923a --- /dev/null +++ b/rom_access_library/library/include/ss_rom_access_if_romaccesslibrarylog.h @@ -0,0 +1,89 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_SS_RomAccess +/// \brief This file supports AGL application logging. +/// +/////////////////////////////////////////////////////////////////////////////// + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_ROM_ACCESS_IF_ROMACCESSLIBRARYLOG_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_ROM_ACCESS_IF_ROMACCESSLIBRARYLOG_H_ +#include + +#define ZONE_INIT ZONEMASK(10) +#define ZONE_FUNC ZONEMASK(11) +#define ZONE_MEM ZONEMASK(12) +#define ZONE_13 ZONEMASK(13) +#define ZONE_14 ZONEMASK(14) +#define ZONE_15 ZONEMASK(15) +#define ZONE_16 ZONEMASK(16) +#define ZONE_17 ZONEMASK(17) +#define ZONE_18 ZONEMASK(18) +#define ZONE_19 ZONEMASK(19) +#define ZONE_20 ZONEMASK(20) +#define ZONE_21 ZONEMASK(21) +#define ZONE_22 ZONEMASK(22) +#define ZONE_23 ZONEMASK(23) +#define ZONE_24 ZONEMASK(24) +#define ZONE_25 ZONEMASK(25) +#define ZONE_26 ZONEMASK(26) +#define ZONE_27 ZONEMASK(27) +#define ZONE_28 ZONEMASK(28) +#define ZONE_INFO ZONEMASK(29) +// #define ZONE_WARN ZONEMASK(30) +// #define ZONE_ERR ZONEMASK(31) + + +#define ZONE_TEXT_10 "Init" +#define ZONE_TEXT_11 "Function" +#define ZONE_TEXT_12 "Memory" +#define ZONE_TEXT_13 "" +#define ZONE_TEXT_14 "" +#define ZONE_TEXT_15 "" +#define ZONE_TEXT_16 "" +#define ZONE_TEXT_17 "" +#define ZONE_TEXT_18 "" +#define ZONE_TEXT_19 "" +#define ZONE_TEXT_20 "" +#define ZONE_TEXT_21 "" +#define ZONE_TEXT_22 "" +#define ZONE_TEXT_23 "" +#define ZONE_TEXT_24 "" +#define ZONE_TEXT_25 "" +#define ZONE_TEXT_26 "" +#define ZONE_TEXT_27 "" +#define ZONE_TEXT_28 "" +#define ZONE_TEXT_29 "Info" +// These ARE RESERVED AND SHOULDN'T BE TOUCHED +// USE THEM WHEN REALLY NEEDED!!!!! +#define ZONE_TEXT_30 "Warning" +#define ZONE_TEXT_31 "Error" +#define ZONE_WARN ZONEMASK(30) +#define ZONE_ERR ZONEMASK(31) +#define ALL_ZONES_BUT_IPC_INFO 0xEFFFFFFF + +#ifndef FRAMEWORKUNIFIEDLOGOPTIONS +#define FRAMEWORKUNIFIEDLOGOPTIONS (LMSGQ) // LPRINT , LMSGQ, LSLOGGER +#endif + +#ifndef FRAMEWORKUNIFIEDLOGAPPZONES +#define FRAMEWORKUNIFIEDLOGAPPZONES ZONE_ERR, WARN +#endif /* FRAMEWORKUNIFIEDLOGAPPZONES */ + +extern const CHAR kAppName[]; + +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_ROM_ACCESS_IF_ROMACCESSLIBRARYLOG_H_ diff --git a/rom_access_library/library/include/ss_sm_checksum.h b/rom_access_library/library/include/ss_sm_checksum.h new file mode 100644 index 00000000..bb0feec7 --- /dev/null +++ b/rom_access_library/library/include/ss_sm_checksum.h @@ -0,0 +1,34 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_SystemManager +/// \brief This file provides for checksum calculation. +/// +/////////////////////////////////////////////////////////////////////////////// +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_SM_CHECKSUM_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_SM_CHECKSUM_H_ + +#include +class CSMChecksum { + public: + CSMChecksum(); + ~CSMChecksum(); + UI_32 cal_checksum(const void* p_buf, size_t buf_size); + + private: +}; +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SS_SM_CHECKSUM_H_ diff --git a/rom_access_library/library/include/system_service/nor_backup.h b/rom_access_library/library/include/system_service/nor_backup.h new file mode 100644 index 00000000..596d2551 --- /dev/null +++ b/rom_access_library/library/include/system_service/nor_backup.h @@ -0,0 +1,212 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file nor_backup.h + * @brief This file provides API for get nor flash information + */ + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_NOR_BACKUP_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_NOR_BACKUP_H_ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup rom_access_library + * @ingroup system_service + * @{ + */ +#if defined(__cplusplus) +extern "C" { +#endif // __cplusplus + +/** + * \~english Common return value: Normal return value of API + */ +#define RET_DEV_NORMAL 0 + +/** + * \~english Common return value: Parameter error return value of API + */ +#define RET_DEV_ERR_PARAM 3 + +/** + * \~english Common return value: Error of getting device info + */ +#define RET_DEV_ERROR 4 + +/** + * \~english Read API return value: Internal error + */ +#define RET_DEV_RD_ERR_OTHER 1 + +/** + * \~english Read API return value: Acquire buffer error(malloc) + */ +#define RET_DEV_RD_ERR 2 + +/** + * \~english Read API return value: error type 1 + */ +#define RET_DEV_RD_ERR_1 -1 + +/** + * \~english Read API return value: error type 2 + */ +#define RET_DEV_RD_ERR_2 -2 + +/** + * \~english Read API return value: error type 3 + */ +#define RET_DEV_RD_ERR_3 -3 + +/** + * \~english Read API return value: error type 4 + */ +#define RET_DEV_RD_ERR_4 -4 + +/** + * \~english Write API return value: Other error + */ +#define RET_DEV_WT_ERR_OTHER 1 + +/** + * \~english Write API return value: Internal error + */ +#define RET_DEV_WT_ERR 2 + +/**\ingroup mtdn_backup_Read + * \~english @par Brief + * Read data from norflash device. + * \~english @param [in] path_name + * const char* - Device path to read(such as "/dev/mtd1ro") + * \~english @param [in] i_id + * int - Main block ID(0, 2, 4, ...) + * \~english @param [in] i_offset + * int - Data offset + * \~english @param [in] i_size + * int - Data size to read + * \~english @param [in] p_buff + * Void* - Buffer for storing read data + * \~english @retval RET_DEV_NORMAL OK + * \~english @retval RET_DEV_ERROR Get device error + * \~english @retval RET_DEV_ERR_PARAM Parameter error + * \~english @retval RET_DEV_RD_ERR_OTHER Internal error + * \~english @retval RET_DEV_RD_ERR Acquire buffer error(malloc) + * \~english @retval RET_DEV_RD_ERR_1 Error type 1 + * \~english @retval RET_DEV_RD_ERR_2 Error type 2 + * \~english @retval RET_DEV_RD_ERR_3 Error type 3 + * \~english @retval RET_DEV_RD_ERR_4 Error type 4 + * \~english @par Preconditions + * - There is no preconditions for this API. + * \~english @par Change of internal state + * - Change of internal state according to the API does not occur. + * \~english @par Conditions of processing failure + * - Parameter path_name is NULL. [RET_DEV_ERR_PARAM] + * - Parameter p_buff is NULL. [RET_DEV_ERR_PARAM] + * - Value of parameter i_id is less than 0. [RET_DEV_ERR_PARAM] + * - Value of parameter i_offset is less than 0 or value of parameter i_size + * is not greater than 0. [RET_DEV_ERR_PARAM] + * - Device specified by path_name is invalid. [RET_DEV_ERR_PARAM] + * - Sum value of i_offset and i_size is greater than block size - 16byte. + * [RET_DEV_ERR_PARAM] + * - Failed to get device info. [RET_DEV_ERROR] + * - Failed to acquire the send/receive buffer(malloc). [RET_DEV_RD_ERR] + * - Internal IO error(open, read, close, ioctl, lseek, other error). + * [RET_DEV_RD_ERR_OTHER] + * - Check text error of main block and backup block. [RET_DEV_RD_ERR_1] + * - Check text error of main block and checksum error of backup block. + * [RET_DEV_RD_ERR_2] + * - Checksum error of main block and check text error of backup block. + * [RET_DEV_RD_ERR_3] + * - Checksum error of main block and backup block. [RET_DEV_RD_ERR_4] + * \~english @par Detail + * - This API gets data from main or backup block according to specified\n + * norflash device pathname and main block ID. + * \~english @par + * - When this API is executed, read data from main block first. If failed to\n + * read main block, return RET_DEV_RD_ERR_OTHER. If read main block success,\n + * but check main block data error, turn to read data from backup block which\n + * block ID is i_id + 1. + * \~english @par Classification + * Public + * \~english @par Type + * Sync Only + * \~english @see mtdn_backup_Write + */ +int mtdn_backup_Read(const char * path_name, int i_id, int i_offset, int i_size, void *p_buff); + +/**\ingroup mtdn_backup_Write + * \~english @par Brief + * Write data to norflash device. + * \~english @param [in] path_name + * const char* - Device path to write(such as "/dev/mtd") + * \~english @param [in] i_id + * int - Main block ID(0, 2, 4, ...) + * \~english @param [in] i_offset + * int - Data offset + * \~english @param [in] i_size + * int - Data size to write + * \~english @param [in] p_buff + * Void* - Buffer for storing written data + * \~english @retval RET_DEV_NORMAL OK + * \~english @retval RET_DEV_ERROR Get device error + * \~english @retval RET_DEV_ERR_PARAM Parameter error + * \~english @retval RET_DEV_WT_ERR_OTHER Other error + * \~english @retval RET_DEV_WT_ERR Internal error + * \~english @par Preconditions + * - There is no preconditions for this API. + * \~english @par Change of internal state + * - Change of internal state according to the API does not occur. + * \~english @par Conditions of processing failure + * - Parameter path_name is NULL. [RET_DEV_ERR_PARAM] + * - Parameter p_buff is NULL. [RET_DEV_ERR_PARAM] + * - Value of parameter i_id is less than 0. [RET_DEV_ERR_PARAM] + * - Value of parameter i_offset is less than 0 or value of parameter i_size + * is not greater than 0. [RET_DEV_ERR_PARAM] + * - Device specified by path_name is invalid. [RET_DEV_ERR_PARAM] + * - Sum value of i_offset and i_size is greater than block size - 16byte. + * [RET_DEV_ERR_PARAM] + * - Failed to get device info. [RET_DEV_ERROR] + * - Internal processing error(Other error). [RET_DEV_WT_ERR_OTHER] + * - Internal IO error(open, write, close, ioctl, malloc, lseek). + * [RET_DEV_WT_ERR] + * \~english @par Detail + * - This API writes data to main and backup blocks according to specified\n + * norflash device pathname and main block ID. + * \~english @par + * - When this API is executed, p_buff data will be write to main and backup\n + * blocks. If failed to write any block, return RET_DEV_WT_ERR. + * \~english @par Classification + * Public + * \~english @par Type + * Sync Only + * \~english @see mtdn_backup_Read + */ +int mtdn_backup_Write(const char * path_name, int i_id, int i_offset, int i_size, void *p_buff); + +#if defined(__cplusplus) +} +#endif // __cplusplus + +/** @}*/ // end of rom_access_library +/** @}*/ // end of system_service +/** @}*/ // end of BaseSystem +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_NOR_BACKUP_H_ diff --git a/rom_access_library/library/include/system_service/rom_access_library.h b/rom_access_library/library/include/system_service/rom_access_library.h new file mode 100644 index 00000000..63a7db2a --- /dev/null +++ b/rom_access_library/library/include/system_service/rom_access_library.h @@ -0,0 +1,47 @@ +// +// @copyright Copyright (c) 2017-2019 TOYOTA MOTOR CORPORATION. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. +// + +/** + * @file rom_access_library.h + * @brief This file include all head file of rom and nor access library + */ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup rom_access_library + * @ingroup system_service + * @{ + */ + +#ifndef SYSTEMSERVICE_ROMACCESSLIBRARY_H_ // NOLINT(build/header_guard) +#define SYSTEMSERVICE_ROMACCESSLIBRARY_H_ + +#include "system_service/nor_backup.h" + +#include "system_service/ss_sm_rom_access.h" +#include "system_service/ss_sm_boot_access.h" +#include "system_service/ss_sm_ram_access.h" + +#endif // SYSTEMSERVICE_ROMACCESSLIBRARY_H_ + +/** @}*/ // end of rom_access_library +/** @}*/ // end of system_service +/** @}*/ // end of BaseSystem diff --git a/rom_access_library/library/include/system_service/ss_sm_boot_access.h b/rom_access_library/library/include/system_service/ss_sm_boot_access.h new file mode 100644 index 00000000..f0820027 --- /dev/null +++ b/rom_access_library/library/include/system_service/ss_sm_boot_access.h @@ -0,0 +1,362 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file ss_sm_boot_access.h + * @brief This file provides API for get boot information from nor flash + */ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup rom_access_library + * @ingroup system_service + * @{ + */ + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_BOOT_ACCESS_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_BOOT_ACCESS_H_ + +#include +#include + +// Top memory map of LINUX management outside domain (SYS area) +// Must not use it other than the model of C language specifications to refer to BOOT + +#define LBM_UINT32 unsigned int +#define LBM_UINT16 uint16_t +#define LBM_UINT8 unsigned char +#define LBM_INT64 int64_t +#define LBM_INT32 unsigned int +#define LBM_INT16 uint16_t +#define LBM_INT8 unsigned char + +// Each domain size +#define LBM_NOR_MIRROR_SIZE 0x10000 // MIRROR area of NOR +#define LBM_DRAM_SIZE 0x10000 // RAM area to share with BOOT in LINUX + +#define LBM_NOR_BOOT_SIZE 128 +#define LBM_NOR_TSKM_SIZE 128 +#define LBM_NOR_VUP_SIZE 1024 +#define LBM_NOR_ANA_SIZE 32 +#define LBM_NOR_VEHI_SIZE 32 +#define LBM_NOR_DEVMGR_SIZE 32 + + +//********* Value of the field **************** +/* SDRAMstart identification */ +#define SYSUP_DRAM_NORMAL (LBM_UINT32)0x4E524E52 /* normal value NRNR*/ +#define SYSUP_DRAM_SFTERRSR (LBM_UINT32)0x73667366 /* abnormal Soft Reset(softwareabnormality) sfsf*/ +#define SYSUP_DRAM_DISCARD (LBM_UINT32)0x44434443 /* need to discard backup DCDC*/ + +/* Start is in a state (navigator initial use)/System start state */ +#define SYSUP_CND_FACTRESET (LBM_UINT16)0x434c /* COLD START */ +#define SYSUP_CND_NORMAL (LBM_UINT16)0x4853 /* HOT START */ + +/* Start mode preservation table level */ +#define SYSUP_MODE_NORMAL (LBM_UINT32)0x4E524E52 /* normal mode */ +#define SYSUP_MODE_VERUP (LBM_UINT32)0x56555655 /* versionup mode */ + +/* Communication state between NAVI-SYS */ +#define SUBCPU_STS_NOMAL (LBM_UINT32)0x00000000 /* Communication normal */ +#define SUBCPU_STS_COMNG (LBM_UINT32)0x88888888 /* Communication abnormal */ + +/* SDRAM power supply abnormality detection */ +#define SDRAM_STS_NOMAL (LBM_UINT32)0x11111111 /* backup power supply is normal */ +#define SDRAM_STS_BUPNG (LBM_UINT32)0x99999999 /* backup power supply is abnormal */ + +/* HWDT Outbreak */ +#define HWDT_STS_NOMAL (LBM_UINT32)0x22222222 /* WDT normal */ +#define HWDT_STS_WDTTO (LBM_UINT32)0xAAAAAAAA /* WDT time-out outbreak */ + +/* SWDT Outbreak */ +#define SWDT_STS_NOMAL HWDT_STS_NOMAL /* SWDT normal */ +#define SWDT_STS_WDTTO HWDT_STS_WDTTO /* SWDT time-out outbreak */ + +/* Start side */ +#define IFS_PROG1_CODE (LBM_UINT8)0xAA /* Side PROG1 */ +#define IFS_PROG2_CODE (LBM_UINT8)0x55 /* Side PROG2 */ + +/* Start infomation ID */ +#define UPTBLE_ID_MAX (LBM_UINT8)0x20 /* LBM_UPTBLINFO Maximum value */ +#define UPTBLE_ID_NORBOOT (LBM_UINT8)0x00 /* NOR-BOOT ID */ +#define UPTBLE_ID_SCRLDR (LBM_UINT8)0x01 /* SecureLoader ID */ +#define UPTBLE_ID_NANDBOOT (LBM_UINT8)0x02 /* NAND-BOOT ID */ +#define UPTBLE_ID_ROOTFS (LBM_UINT8)0x03 /* Rootfs1 ID */ +#define UPTBLE_ID_ROOTFS2 (LBM_UINT8)0x04 /* Rootfs2 ID */ + +/* Start status */ +#define STUP_STS_NORMAL (LBM_UINT32)0x00000000 /* normal status */ +/* Rollback of protectionism is necessary by abnormal reset repetition */ +#define STUP_STS_ERROR_DETEC (LBM_UINT32)0x22222222 +#define STUP_STS_UPDATING (LBM_UINT32)0x33333333 /* updating status */ +/* not for use(will be removed) */ +#define STUP_STS_SIGNVRFY_ERROR (LBM_UINT32)0x11111111 + +/* mdUpdate/sdUpdate */ +#define UPDATE_NOTI_NONE (LBM_UINT32)0x00000000 /* Notify is NOT required. */ +#define UPDATE_NOTI_EXIST (LBM_UINT32)0xEEEEEEEE /* Notify is required. */ + +/* RAM Judge Flag */ +#define RAMJUDGE_STS_NOMAL (LBM_UINT32)0x44444444 /* RAM Judge Port is High */ +#define RAMJUDGE_STS_NG (LBM_UINT32)0xDDDDDDDD /* RAM Judge Port is Low */ + +/* DRAM Self Refresh */ +#define SELF_REFRESH_OK (LBM_UINT32)0x55555555 /* DRAM Self Refresh is OK */ +#define SELF_REFRESH_NG (LBM_UINT32)0xCCCCCCCC /* DRAM Self Refresh is NG */ + +/* Release ROM type */ +#define PRODUCTROM (LBM_UINT32)0x11111111 +#define RELEASEROM (LBM_UINT32)0x22222222 +#define RELEASEROM_REMAIN_USBBOOT (LBM_UINT32)0x44444444 +#define DEBUGROM (LBM_UINT32)0x88888888 + +/* Boot write Nor */ +#define WRITE_NONE (LBM_UINT32)0x00000000 +#define WRITE_DONE (LBM_UINT32)0x11111111 + + +/* opdtLoadSatus */ +#define DEFAULT_OPIMAGE_DRAM_BACKUPED (LBM_UINT32)0x00000000 +#define DEFAULT_OPIMAGE_FROM_EMMC (LBM_UINT32)0xAAAAAAAA +#define SPECIFIC_OPIMAGE_DRAM_BACKUPED (LBM_UINT32)0x11111111 +#define SPECIFIC_OPIMAGE_FROM_EMMC (LBM_UINT32)0xBBBBBBBB + +/* opdtLoadFactor */ +#define SPECIFIC_OPIMAGE_FLAG_NONE (LBM_UINT32)0x00000000 +#define SPECIFIC_OPIMAGE_FILE_NONE (LBM_UINT32)0x11111111 +#define SPECIFIC_OPIMAGE_FILESIZE_0 (LBM_UINT32)0x22222222 +#define SPECIFIC_OPIMAGE_FILE_EXIST (LBM_UINT32)0xEEEEEEEE + + +#pragma pack(push, 4) + +// Memory map of the SYS area of the mem0 + +#define SS_SYS_AREA_BOOT_MAX_SIZE (0x00010000UL) + +#define SS_SYS_AREA_ROM_OFFSET (0x00010000UL) +#define SS_SYS_AREA_ROM_MAX_SIZE (0x00001000UL) + +#define SS_SYS_AREA_RAM_OFFSET (0x00011000UL) +#define SS_SYS_AREA_RAM_MAX_SIZE (0x00001000UL) + +//********* NOR area **************** +typedef struct LBM_boot_wpinfo_t { + LBM_UINT32 currentside; // IFS_PROG*_CODE + LBM_UINT32 stupStsA; // STUP_STS_* + LBM_UINT32 stupStsB; // STUP_STS_* +}LBM_UPTBLINFO; + +typedef struct LBM_boot_t { + LBM_UINT32 sts1; // SYSUP_CND_* + LBM_UINT32 btmode; // SYSUP_MODE_* + LBM_UINT32 sts2; // SYSUP_CND_* + LBM_UPTBLINFO upTbl[UPTBLE_ID_MAX]; + LBM_UINT32 sts3; // SYSUP_CND_* +}LBM_NOR_t; + +//********* DRAM area **************** +typedef struct _tmb_ram_t { + LBM_UINT32 dram1; // SYSUP_DRAM_* + LBM_UINT32 sts; // SYSUP_CND_* + LBM_UINT32 upmode; // SYSUP_MODE_* + LBM_UINT32 dram2; // SYSUP_DRAM_* + LBM_UINT32 syscomSts; // SUBCPU_STS_* + LBM_UINT32 pwSts; // SDRAM_STS_* + LBM_UINT32 hwdtSts; // HWDT_STS_* + LBM_UINT32 dram3; // SYSUP_DRAM_* + LBM_UPTBLINFO upTbl[UPTBLE_ID_MAX]; + LBM_UINT32 sectorNo; // NOR Shared SectorNo + LBM_UINT32 mdUpdate; // UPDATE_NOTI_* LanServer Update Notification + LBM_UINT32 sdUpdate; // UPDATE_NOTI_* SettingService Update Notification + LBM_UINT32 ramjudgeSts; // RAMJUDGE_STS_* + LBM_UINT32 swdtSts; // SWDT_STS_* + LBM_UINT32 dram_self_refresh; // DRAM Self Refresh + LBM_UINT32 releaseNorType; + LBM_UINT32 socCpuType; // H2/E2/M2 + LBM_UINT32 socEsNumber; // ES1x/ES2x/ES3x + LBM_UINT32 spiBootDevice; // NorDeviceID + LBM_UINT32 bootNorWrite; // uboot-api + LBM_UINT32 naviDetFactor; + + LBM_UINT32 emmcTap; //emmcTap + LBM_UINT32 opdtUpdateReq; + LBM_UINT32 opdtLoadSatus; + LBM_UINT32 opdtLoadFactor; + +}LBM_RAM_t; + +#pragma pack(pop) + + +/** +* \~english Access type to the boot information +*/ +typedef enum { + BAI_OPEN_RO, /* \~english Access type for the Read only*/ + BAI_OPEN_RW /* \~english Access type for the Read and Write*/ +}BAI_OPEN_t; + +/** + * @class BOOT_AccessIf + * \~english @brief BOOT_AccessIf + * \~english @par Brief Introduction + * Class to provide the function of BOOT AccessIf + * + */ +class BOOT_AccessIf{ + private: + static void* g_m_plock; + BAI_OPEN_t m_type; + + public: + /** + * \ingroup BOOT_AccessIf + * \~english @par Summary: + * Obtain the access permission to the boot information (secondary storage area). + * \~english @param [in] type + * BAI_OPEN_t - Access type to the boot information\n + * \~english @par + * BAI_OPEN_t + * - BAI_MTD_DEV_RO Access type for the Read only \n + * - BAI_MTD_DEV_RW Access type for the Read and Write + * \~english @retval None + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - None + * \~english @par Classification: + * Public + * \~english @par Type + * None + * \~english @par Detail: + * Obtain the access permission to the boot information \n + * When the access permission is locked, the API waits for Mutex until the access permission is released. \n + * This API is assumed to be called by SystemManager. + * \~english @see ~BOOT_AccessIf, CL_LockMap, CL_LockGet + */ +explicit BOOT_AccessIf(BAI_OPEN_t type); + + /** + * \ingroup ~BOOT_AccessIf + * \~english @par Summary: + * Release the access permission to the boot information (secondary storage area). + * \~english @param None + * \~english @retval None + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - None + * \~english @par Classification: + * Public + * \~english @par Type + * None + * \~english @par Detail: + * Release the access permission to the boot information.\n + * \~english @see BOOT_AccessIf, CL_LockRelease + */ + ~BOOT_AccessIf(); + +/** + * \ingroup getBootInfo + * \~english @par Summary: + * Read the boot information (secondary storage area). + * \~english @param [out] p_boot_info + * LBM_NOR_t * - Destination buffer to read the boot information + * \~english @par + * LBM_NOR_t Structure body + * \~english @code + * typedef struct LBM_boot_t{ + * LBM_UINT32 sts1; //SYSUP_CND_* + * LBM_UINT32 btmode; //SYSUP_MODE_* + * LBM_UINT32 sts2; //SYSUP_CND_* + * LBM_UPTBLINFO upTbl[UPTBLE_ID_MAX]; + * LBM_UINT32 sts3; //SYSUP_CND_* + * }LBM_NOR_t; + * @endcode + * Refer to "ss_boot_map.h" for the parameters to be set to the member of struct LBM_NOR_t. + * \~english @retval eFrameworkunifiedStatusOK Reading success + * \~english @retval eFrameworkunifiedStatusFail Reading failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If p_boot_info is NULL [eFrameworkunifiedStatusFail] + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Copy the boot information stored in the secondary storage area to p_boot_info. \n + * \~english @see setBootInfo + */ + EFrameworkunifiedStatus getBootInfo(LBM_NOR_t* p_boot_info); + + /** + * \ingroup setBootInfo + * \~english @par Summary: + * Write the boot information (secondary storage area). + * \~english @param [in] p_boot_info + * LBM_NOR_t * - Original buffer to write the boot information + * \~english @par + * LBM_NOR_tStructure body + * \~english @code + * typedef struct LBM_boot_t{ + * LBM_UINT32 sts1; //SYSUP_CND_* + * LBM_UINT32 btmode; //SYSUP_MODE_* + * LBM_UINT32 sts2; //SYSUP_CND_* + * LBM_UPTBLINFO upTbl[UPTBLE_ID_MAX]; + * LBM_UINT32 sts3; //SYSUP_CND_* + * }LBM_NOR_t; + * @endcode + * Refer to "ss_boot_map.h" for the parameters to be set to the member of struct LBM_NOR_t. + * \~english @retval eFrameworkunifiedStatusOK Write success + * \~english @retval eFrameworkunifiedStatusFail Write failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If p_boot_info is NULL [eFrameworkunifiedStatusFail] + * - BOOT_AccessIf Opened secondary storage area with BAI_MTD_DEV_RO [eFrameworkunifiedStatusFail] + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Write the boot information stored in p_boot_info to the secondary storage area. \n + * \~english @see getBootInfo + */ + EFrameworkunifiedStatus setBootInfo(LBM_NOR_t* p_boot_info); +}; + +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_BOOT_ACCESS_H_ + +/** @}*/ // end of rom_access_library +/** @}*/ // end of system_service +/** @}*/ // end of BaseSystem diff --git a/rom_access_library/library/include/system_service/ss_sm_ram_access.h b/rom_access_library/library/include/system_service/ss_sm_ram_access.h new file mode 100644 index 00000000..c8283c63 --- /dev/null +++ b/rom_access_library/library/include/system_service/ss_sm_ram_access.h @@ -0,0 +1,237 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file ss_sm_ram_access.h + * @brief This file provides API for get ram information from extension memory + */ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup rom_access_library + * @ingroup system_service + * @{ + */ + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_RAM_ACCESS_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_RAM_ACCESS_H_ + +#include +#include + +/** + * \~english max length of ram product private + */ +#define RAM_PRODUCT_PRIVATE_MAX (96) +/** + * \~english max length of order file name + */ +#define SS_SM_ORDER_NAME_MAX (32) + +/** + * \~english System management information + */ +typedef struct { + char signature_in[4]; + BOOL isImmediateReset; + BOOL needRenotifyStartPrm; + uint32_t lastWakeupType; + uint32_t lastDramBackupStatus; + uint32_t lastResetStatus; + char productPrivate[RAM_PRODUCT_PRIVATE_MAX]; + char order_name[SS_SM_ORDER_NAME_MAX]; + BOOL isErrorReset; + char signature_out[4]; +}RAM_SM_INFO_t; + +/** + * \~english System wakeup state type + */ +typedef enum { + RAM_WAKEUP_STATE_DONT_CARE = 0, /* \~english Don't care wakeup state*/ + RAM_WAKEUP_STATE_BACKUP_NG, /* \~english Wakeup state is backup NG*/ + RAM_WAKEUP_STATE_BATTERY_DOWN /* \~english Wakeup state is battery down*/ +}RAM_WAKEUP_STATE; + +/** + * @class RAM_AccessIf + * \~english @brief RAM_AccessIf + * \~english @par Brief Introduction + * Class to provide the function of RAM AccessIf + * + */ +class RAM_AccessIf{ + private: + static void* g_m_plock; + static void* g_m_bakup_map; + static bool g_m_is_first_access; + RAM_SM_INFO_t m_buf; + bool m_dirty; + void initRamBackupEnable(RAM_WAKEUP_STATE wup_state); + void initRamBackupDisable(RAM_WAKEUP_STATE wup_state); + void finalRamBackupEnable(void); + void finalRamBackupDisable(void); + + public: +/** + * \ingroup RAM_AccessIf + * \~english @par Summary: + * Obtain the access permission to the system management information. + * \~english @param [in] wup_state + * RAM_WAKEUP_STATE - System maneger wakeup state type + * \~english @par + * RAM_WAKEUP_STATE + * - RAM_WAKEUP_STATE_DONT_CARE Don't care wakeup state\n + * - RAM_WAKEUP_STATE_BACKUP_NG Wakeup state is backup NG\n + * - RAM_WAKEUP_STATE_BATTERY_DOWN Wakeup state is battery down + * \~english @retval None + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - None + * \~english @par Classification: + * Public + * \~english @par Type + * None + * \~english @par Detail: + * Obtain the access permission to the system management information \n + * When the access permission is locked, the API waits for Mutex until the access permission is released. \n + * This API is supposed to be called by SystemManager. + * \~english @see ~RAM_AccessIf, CL_LockMap, CL_LockGet + */ +explicit RAM_AccessIf(RAM_WAKEUP_STATE wup_state = RAM_WAKEUP_STATE_DONT_CARE); + +/** + * \ingroup ~RAM_AccessIf + * \~english @par Summary: + * Release the access permission to the system management information. + * \~english @param None + * \~english @retval None + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - None + * \~english @par Classification: + * Public + * \~english @par Type + * None + * \~english @par Detail: + * Release the access permission to the system management information.\n + * \~english @see RAM_AccessIf, CL_LockRelease + */ + ~RAM_AccessIf(); + +/** + * \ingroup getRamInfo + * \~english @par Summary: + * Read the system management information. + * \~english @param [out] p_boot_info + * RAM_SM_INFO_t * - Destination buffer to read the system management information. + * \~english @par + * RAM_SM_INFO_t Structure body + * \~english @code + * typedef struct { + * char signature_in[4]; + * BOOL isImmediateReset; + * BOOL needRenotifyStartPrm; + * uint32_t lastWakeupType; + * uint32_t lastDramBackupStatus; + * uint32_t lastResetStatus; + * char productPrivate[RAM_PRODUCT_PRIVATE_MAX]; + * char order_name[SS_SM_ORDER_NAME_MAX]; + * BOOL isErrorReset; + * char signature_out[4]; + * }RAM_SM_INFO_t; + * @endcode + * \~english @retval eFrameworkunifiedStatusOK Reading success + * \~english @retval eFrameworkunifiedStatusFail Reading failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If p_boot_info is NULL [eFrameworkunifiedStatusFail] + * - If read data from secondary storage area or /nv/romaccess/ramdata.dat + * failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Copy the system information stored in the secondary storage area or + * in /nv/romaccess/ramdata.dat to p_boot_info. \n + * \~english @see setRamInfo + */ + EFrameworkunifiedStatus getRamInfo(RAM_SM_INFO_t* p_boot_info); + +/** + * \ingroup setRamInfo + * \~english @par Summary: + * Write the system management information. + * \~english @param [in] p_boot_info + * RAM_SM_INFO_t * - Original buffer to write the system management information + * \~english @par + * RAM_SM_INFO_t Structure body + * \~english @code + * typedef struct { + * char signature_in[4]; + * BOOL isImmediateReset; + * BOOL needRenotifyStartPrm; + * uint32_t lastWakeupType; + * uint32_t lastDramBackupStatus; + * uint32_t lastResetStatus; + * char productPrivate[RAM_PRODUCT_PRIVATE_MAX]; + * char order_name[SS_SM_ORDER_NAME_MAX]; + * BOOL isErrorReset; + * char signature_out[4]; + * }RAM_SM_INFO_t; + * @endcode + * \~english @retval eFrameworkunifiedStatusOK Write success + * \~english @retval eFrameworkunifiedStatusFail Write failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If p_boot_info is NULL [eFrameworkunifiedStatusFail] + * - If write data to secondary storage area or /nv/romaccess/ramdata.dat + * failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Write the system manegement information stored in p_boot_info to the + * secondary storage area or /nv/romaccess/ramdata.dat. \n + * \~english @see getRamInfo + */ + EFrameworkunifiedStatus setRamInfo(RAM_SM_INFO_t* p_boot_info); +}; + +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_RAM_ACCESS_H_ + +/** @}*/ // end of rom_access_library +/** @}*/ // end of system_service +/** @}*/ // end of BaseSystem diff --git a/rom_access_library/library/include/system_service/ss_sm_rom_access.h b/rom_access_library/library/include/system_service/ss_sm_rom_access.h new file mode 100644 index 00000000..d86d2bb9 --- /dev/null +++ b/rom_access_library/library/include/system_service/ss_sm_rom_access.h @@ -0,0 +1,1010 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/** + * @file ss_sm_rom_access.h + * @brief This file provides API for get rom information from extension memory + */ + +/** @addtogroup BaseSystem + * @{ + */ +/** @addtogroup system_service + * @ingroup BaseSystem + * @{ + */ +/** @addtogroup rom_access_library + * @ingroup system_service + * @{ + */ + +#ifndef ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_ROM_ACCESS_H_ +#define ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_ROM_ACCESS_H_ + +#include +#include + +#include "system_service/ss_sm_boot_access.h" + +/** + * \~english boot mode information + */ +typedef enum { + APPLICATION_MODE = 0, + PROGRAMMING_MODE +}EBOOT_MODE; + +/** + * \~english active flash load information + */ +typedef enum { + NEW_FLASHLOADER = 0, + OLD_FLASHLOADER +}EACTIVE_FLASHLOADER; + +/** + * \~english user mode information + */ +typedef enum { + USER_OFF = 0, + USER_ON +}EUSER_MODE; + +/** + * \~english control mode information + */ +typedef enum { + DISABLE_MODE = 0, + ENABLE_MODE +}ECONTROL_MODE; + +/** + * \~english data reset mode information + */ +typedef enum { + DATARESET_NONE = 0, + DATARESET_USER, + DATARESET_FACTORY +}EDATARESET_MODE; + +/** + * \~english last illegal reset mode information + */ +typedef enum { + LAST_ILGRESET_NORMAL = 0, + LAST_ILGRESET_NG +}ELASTILGRESET_MODE; + +/** + * \~english Program update state information + */ +typedef uint32_t EPROGUPDATE_STATE; + +/** + * \~english next wakeup type + */ +typedef enum { + NEXT_WAKEUP_TYPE_NONE = 0, + NEXT_WAKEUP_TYPE_COLD, + NEXT_WAKEUP_TYPE_HOT, +}ENEXT_WAKEUP_TYPE; + +/** + * \~english DRAM backup state + */ +typedef enum { + DRAM_BACKUP_STATE_OK = 0, + DRAM_BACKUP_STATE_NG +}DRAM_BACKUP_STATE; + +/** + * \~english max length of rom product private + */ +#define ROM_PRODUCT_PRIVATE_MAX 128 + +/** + * @class ROM_AccessIf + * \~english @brief ROM_AccessIf + * \~english @par Brief Introduction + * Class to provide the function of ROM AccessIf + * + */ +class ROM_AccessIf { + private: + BOOT_AccessIf* m_pBoot; + static void* g_m_plock; + static void* g_m_bakup_map; + static bool g_m_is_dram_valid; + LBM_NOR_t m_nor; + bool m_norIsDirty; + + EFrameworkunifiedStatus LBA_Read(UI_32 offset, UI_32* buffer, UI_32 word_count); + + EFrameworkunifiedStatus LBA_Write(UI_32 offset, UI_32 value); + + EFrameworkunifiedStatus LBA_Write(UI_32 offset, UI_32* value, UI_32 size); + + EFrameworkunifiedStatus GetDataResetMode_sub(EDATARESET_MODE* p_data_reset_mode); + + public: +/** + * \ingroup ROM_AccessIf + * \~english @par Summary: + * Obtain the access permission to SYS area (secondary storage area). + * \~english @param None + * \~english @retval None + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - None + * \~english @par Classification: + * Public + * \~ english @par Type + * None + * \~english @par Detail: + * Obtain the access permission to SYS area. \n + * When the access permission is locked, the API watis for Mutex until the access permission is released. \n + * This API is assumed to be called by the SystemManager. + * \~english @see ~ROM_AccessIf, CL_LockMap, CL_LockGet + */ + ROM_AccessIf(); + +/** + * \ingroup ~ROM_AccessIf + * \~english @par Summary: + * Release the access permission to SYS area (secondary storage area). + * \~english @param None + * \~english @retval None + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - None + * \~english @par Classification: + * Public + * \~ english @par Type + * None + * \~english @par Detail: + * Release the access permission to SYS area. + * \~english @see ROM_AccessIf, CL_LockRelease + */ + ~ROM_AccessIf(); + +/** + * \ingroup Initialize + * \~english @par Summary: + * Synchronize SYS area (secondary storage area) and the mirror data in DRAM + * \~english @param None + * \~english @retval eFrameworkunifiedStatusOK Synchronization success + * \~english @retval eFrameworkunifiedStatusFail Synchronization failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If system call mmap failed. [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Prepare the access to SYS area. \n + * \~english @see EL_mem_exram_mmap + */ + EFrameworkunifiedStatus Initialize(); + +/** + * \ingroup SetProductPrivate + * \~english @par Summary: + * Write data information depending on the product specification to the secondary storage area. + * \~english @param [in] buf[ROM_PRODUCT_PRIVATE_MAX] + * UI_8[] - Data information depending on the product specification + * \~english @par + * Definition of ROM_PRODUCT_PRIVATE_MAX + * \~english @code + * #define ROM_PRODUCT_PRIVATE_MAX 128 + * @endcode + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Write data information depending on the product specification to the secondary storage area. \n + * \~english @see GetProductPrivate + */ + EFrameworkunifiedStatus SetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]); + +/** + * \ingroup GetProductPrivate + * \~english @par Summary: + * Read the data information depending on the product specification from the secondary storage area. + * \~english @param [out] buf[ROM_PRODUCT_PRIVATE_MAX] + * UI_8[] - Storing destination of data information depending on the product specification + * \~english @par + * Definition of ROM_PRODUCT_PRIVATE_MAX + * \~english @code + * #define ROM_PRODUCT_PRIVATE_MAX 128 + * @endcode + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Read data information depending on the product specification from the secondary storage area. \n + * \~english @see SetProductPrivate + */ + EFrameworkunifiedStatus GetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]); + +/** + * \ingroup SystemInitialize + * \~english @par Summary: + * Initialize the handles used for ROM access. + * \~english @param [in] bkup_state + * \~english @par + * DRAM_BACKUP_STATE + * - DRAM_BACKUP_STATE_OK + * - DRAM_BACKUP_STATE_NG + * \~english @retval eFrameworkunifiedStatusOK Initialize the handles used for ROM access success + * \~english @retval eFrameworkunifiedStatusFail Initialize the handles used for ROM access failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If system call mmap failed. [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Initialize the handles used for ROM access. \n + * \~english @see EL_mem_exram_mmap + */ + EFrameworkunifiedStatus SystemInitialize(DRAM_BACKUP_STATE bkup_state); + +/** + * \ingroup GetBootMode + * \~english @par Summary: + * Get boot mode information. + * \~english @param [out] p_boot_mode + * EBOOT_MODE* - Destination buffer to store information of boot mode. + * \~english @par + * EBOOT_MODE + * - APPLICATION_MODE + * - PROGRAMMING_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get boot mode information from the secondary storage area. \n + * \~english @see SetBootMode + */ + EFrameworkunifiedStatus GetBootMode(EBOOT_MODE* p_boot_mode); + +/** + * \ingroup SetBootMode + * \~english @par Summary: + * Set boot mode information. + * \~english @param [in] boot_mode + * EBOOT_MODE - Boot mode information which write to the secondary storage area. + * \~english @par + * EBOOT_MODE + * - APPLICATION_MODE + * - PROGRAMMING_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set boot mode information to the secondary storage area. \n + * \~english @see GetBootMode + */ + EFrameworkunifiedStatus SetBootMode(EBOOT_MODE boot_mode); + +/** + * \ingroup GetSignature + * \~english @par Summary: + * Get signature information. + * \~english @param [out] p_sig_value + * UI_32 - Destination buffer to store signature information + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write signature information to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get signature information from the secondary storage area. \n + * \~english @see SetSignature + */ + EFrameworkunifiedStatus GetSignature(UI_32* p_sig_value); + +/** + * \ingroup SetSignature + * \~english @par Summary: + * Set signature information. + * \~english @param [in] sig_value + * UI_32 - Signature information which write to the secondary storage area. + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write signature information to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set signature information to the secondary storage area. \n + * \~english @see GetSignature + */ + EFrameworkunifiedStatus SetSignature(UI_32 sig_value); + +/** + * \ingroup SetActiveFlashloader + * \~english @par Summary: + * Set active flash loader information. + * \~english @param [in] active_flash_loader + * EACTIVE_FLASHLOADER - Active flash loader information which write to secondary storage area. + * \~english @par + * EBOOT_MODE + * - APPLICATION_MODE + * - PROGRAMMING_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set active flash loader information to the secondary storage area. \n + * \~english @see GetBootMode + */ + EFrameworkunifiedStatus SetActiveFlashloader(EACTIVE_FLASHLOADER active_flash_loader); + +/** + * \ingroup GetLastUserMode + * \~english @par Summary: + * Get last user mode information. + * \~english @param [out] p_user_mode + * EUSER_MODE* - Destination buffer to store information of user mode. + * \~english @par + * EUSER_MODE + * - USER_ON + * - USER_OFF + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get last user mode information from the secondary storage area. \n + * \~english @see SetLastUserMode + */ + EFrameworkunifiedStatus GetLastUserMode(EUSER_MODE* p_user_mode); + +/** + * \ingroup SetLastUserMode + * \~english @par Summary: + * Set last user mode information. + * \~english @param [in] user_mode + * EUSER_MODE - User mode information which write to the secondary storage area. + * \~english @par + * EUSER_MODE + * - USER_ON + * - USER_OFF + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set last user mode information to the secondary storage area. \n + * \~english @see GetLastUserMode + */ + EFrameworkunifiedStatus SetLastUserMode(EUSER_MODE user_mode); + +/** + * \ingroup GetTransportMode + * \~english @par Summary: + * Get transport mode information. + * \~english @param [out] p_control_mode + * ECONTROL_MODE* - Destination buffer to store information of transport mode. + * \~english @par + * ECONTROL_MODE + * - DISABLE_MODE + * - ENABLE_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get transport mode information from the secondary storage area. \n + * \~english @see SetTransportMode + */ + EFrameworkunifiedStatus GetTransportMode(ECONTROL_MODE* p_control_mode); + +/** + * \ingroup SetTransportMode + * \~english @par Summary: + * Set transport mode information. + * \~english @param [in] control_mode + * ECONTROL_MODE - Transport mode information which write to the secondary storage area. + * \~english @par + * ECONTROL_MODE + * - DISABLE_MODE + * - ENABLE_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set transport mode information to the secondary storage area. \n + * \~english @see GetTransportMode + */ + EFrameworkunifiedStatus SetTransportMode(ECONTROL_MODE control_mode); + +/** + * \ingroup GetProductionMode + * \~english @par Summary: + * Get production mode information. + * \~english @param [out] p_control_mode + * ECONTROL_MODE* - Destination buffer to store information of production mode. + * \~english @par + * ECONTROL_MODE + * - DISABLE_MODE + * - ENABLE_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get production mode information from the secondary storage area. \n + * \~english @see SetProductionMode + */ + EFrameworkunifiedStatus GetProductionMode(ECONTROL_MODE* p_control_mode); + +/** + * \ingroup SetProductionMode + * \~english @par Summary: + * Set transport mode information. + * \~english @param [in] control_mode + * ECONTROL_MODE - Production mode information which write to the secondary storage area. + * \~english @par + * ECONTROL_MODE + * - DISABLE_MODE + * - ENABLE_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set production mode information to the secondary storage area. \n + * \~english @see GetProductionMode + */ + EFrameworkunifiedStatus SetProductionMode(ECONTROL_MODE control_mode); + +/** + * \ingroup GetLimpHomeCutOffReqMode + * \~english @par Summary: + * Get limp home cut off request mode information. + * \~english @param [out] p_control_mode + * ECONTROL_MODE* - Destination buffer to store information of limp home cut off request mode. + * \~english @par + * ECONTROL_MODE + * - DISABLE_MODE + * - ENABLE_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get limp home cut off request mode information from the secondary storage area. \n + * \~english @see SetLimpHomeCutOffReqMode + */ + EFrameworkunifiedStatus GetLimpHomeCutOffReqMode(ECONTROL_MODE* p_control_mode); + +/** + * \ingroup SetLimpHomeCutOffReqMode + * \~english @par Summary: + * Set limp home cut off request mode information. + * \~english @param [in] control_mode + * ECONTROL_MODE - Limp home cut off request mode information which write to the secondary storage area. + * \~english @par + * ECONTROL_MODE + * - DISABLE_MODE + * - ENABLE_MODE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set limp home cut off request mode information to the secondary storage area. \n + * \~english @see GetLimpHomeCutOffReqMode + */ + EFrameworkunifiedStatus SetLimpHomeCutOffReqMode(ECONTROL_MODE control_mode); + +/** + * \ingroup GetDataResetMode + * \~english @par Summary: + * Get reserved data reset mode information. + * \~english @param [out] p_data_reset_mode + * EDATARESET_MODE* - Destination buffer to store information of reserved data reset mode. + * \~english @par + * EDATARESET_MODE + * - DATARESET_NONE + * - DATARESET_USER + * - DATARESET_FACTORY + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get reserved data reset mode information from the secondary storage area. \n + * \~english @see SetDataResetMode + */ + EFrameworkunifiedStatus GetDataResetMode(EDATARESET_MODE* p_data_reset_mode); + +/** + * \ingroup GetDataResetModeFast + * \~english @par Summary: + * Get reserved data reset mode information faster.This api can get correct value before + * calling SetDataResetMode.So it shoud be used only immediately after boot. + * \~english @param [out] p_data_reset_mode + * EDATARESET_MODE* - Destination buffer to store information of reserved data reset mode faster. + * \~english @par + * EDATARESET_MODE + * - DATARESET_NONE + * - DATARESET_USER + * - DATARESET_FACTORY + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * - If system call mmap failed. [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get reserved data reset mode information faster from the secondary storage area.This api can get + * correct value before calling SetDataResetMode.So it shoud be used only immediately after boot. + * \~english @see SetDataResetMode + */ + EFrameworkunifiedStatus GetDataResetModeFast(EDATARESET_MODE* p_data_reset_mode); + +/** + * \ingroup SetDataResetMode + * \~english @par Summary: + * Set reserve data reset mode information. + * \~english @param [in] data_reset_mode + * EDATARESET_MODE - Reserve data reset mode information which write to the secondary storage area. + * \~english @par + * EDATARESET_MODE + * - DATARESET_NONE + * - DATARESET_USER + * - DATARESET_FACTORY + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set reserve data reset mode information to the secondary storage area. \n + * \~english @see GetDataResetMode + */ + EFrameworkunifiedStatus SetDataResetMode(EDATARESET_MODE data_reset_mode); + +/** + * \ingroup GetResetCount + * \~english @par Summary: + * Get reset count information. + * \~english @param [out] p_reset_count + * UI_32* - Destination buffer to store information of reset count. + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get reset count from the secondary storage area. \n + * \~english @see SetResetCount + */ + EFrameworkunifiedStatus GetResetCount(UI_32* p_reset_count); + +/** + * \ingroup SetResetCount + * \~english @par Summary: + * Set reset count information. + * \~english @param [in] reset_count + * UI_32 - Reset count information which write to the secondary storage area. + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set reset count information to the secondary storage area. \n + * \~english @see GetResetCount + */ + EFrameworkunifiedStatus SetResetCount(UI_32 reset_count); + +/** + * \ingroup GetLastIlgReset + * \~english @par Summary: + * Get last illegal reset information. + * \~english @param [out] p_last_ilg_reset + * ELASTILGRESET_MODE* - Destination buffer to store information of last illegal reset. + * \~english @par + * ELASTILGRESET_MODE + * - LAST_ILGRESET_NORMAL + * - LAST_ILGRESET_NG + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get last illegal reset information from the secondary storage area. \n + * \~english @see SetLastIlgReset + */ + EFrameworkunifiedStatus GetLastIlgReset(ELASTILGRESET_MODE* p_last_ilg_reset); + +/** + * \ingroup SetLastIlgReset + * \~english @par Summary: + * Set last illegal reset information. + * \~english @param [in] last_ilg_reset + * ELASTILGRESET_MODE - Last illegal reset information which write to the secondary storage area. + * \~english @par + * ELASTILGRESET_MODE + * - LAST_ILGRESET_NORMAL + * - LAST_ILGRESET_NG + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set last illegal reset information to the secondary storage area. \n + * \~english @see GetLastIlgReset + */ + EFrameworkunifiedStatus SetLastIlgReset(ELASTILGRESET_MODE last_ilg_reset); + +/** + * \ingroup GetProgUpdateState + * \~english @par Summary: + * Get program update status information. + * \~english @param [out] p_prog_update_state + * EPROGUPDATE_STATE* - Destination buffer to store information of program update status. + * \~english @par + * typedef uint32_t EPROGUPDATE_STATE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get program update status information from the secondary storage area. \n + * \~english @see SetProgUpdateState + */ + EFrameworkunifiedStatus GetProgUpdateState(EPROGUPDATE_STATE* p_prog_update_state); + +/** + * \ingroup SetProgUpdateState + * \~english @par Summary: + * Set program update status information. + * \~english @param [in] prog_update_state + * EPROGUPDATE_STATE - Program update status information which write to the secondary storage area. + * \~english @par + * typedef uint32_t EPROGUPDATE_STATE + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If write data to secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Set program update status information to the secondary storage area. \n + * \~english @see GetProgUpdateState + */ + EFrameworkunifiedStatus SetProgUpdateState(EPROGUPDATE_STATE prog_update_state); + +/** + * \ingroup GetErrLogCount + * \~english @par Summary: + * Get error logging count information. + * \~english @param [out] p_err_log_count + * UI_32* - Destination buffer to store information of error logging count. + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get error logging count information from the secondary storage area. \n + * \~english @see SetErrLogCount + */ + EFrameworkunifiedStatus GetErrLogCount(UI_32* p_err_log_count); + +/** + * \ingroup SetErrLogCount + * \~english @par Summary: + * Get error logging count information. + * \~english @param [out] err_log_count + * UI_32* - Destination buffer to store information of error logging count. + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get error logging count information from the secondary storage area. \n + * \~english @see GetErrLogCount + */ + EFrameworkunifiedStatus SetErrLogCount(UI_32 err_log_count); + +/** + * \ingroup GetNextWakeupType + * \~english @par Summary: + * Get next wakeup type information. + * \~english @param [out] p_next_wakeup_type + * ENEXT_WAKEUP_TYPE* - Destination buffer to store information of next wakeup type. + * \~english @par + * ENEXT_WAKEUP_TYPE + * - NEXT_WAKEUP_TYPE_NONE + * - NEXT_WAKEUP_TYPE_COLD + * - NEXT_WAKEUP_TYPE_HOT + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get next wakeup type information from the secondary storage area. \n + * \~english @see SetNextWakeupType + */ + EFrameworkunifiedStatus GetNextWakeupType(ENEXT_WAKEUP_TYPE *p_next_wakeup_type); + +/** + * \ingroup SetNextWakeupType + * \~english @par Summary: + * Get next wakeup type information. + * \~english @param [out] next_wakeup_type + * ENEXT_WAKEUP_TYPE* - Destination buffer to store information of next wakeup type. + * \~english @par + * ENEXT_WAKEUP_TYPE + * - NEXT_WAKEUP_TYPE_NONE + * - NEXT_WAKEUP_TYPE_COLD + * - NEXT_WAKEUP_TYPE_HOT + * \~english @retval eFrameworkunifiedStatusOK Success + * \~english @retval eFrameworkunifiedStatusFail Failed + * \~english @par Precondition: + * - None + * \~english @par Change in the internal status: + * - The change in the internal status does not occur by this API. + * \~english @par Conditions of processing failure + * - If read data from secondary storage area failed [eFrameworkunifiedStatusFail] + * \~english @par Classification: + * Public + * \~ english @par Type + * Sync only(None communication) + * \~english @par Detail: + * Get next wakeup type information from the secondary storage area. \n + * \~english @see GetNextWakeupType + */ + EFrameworkunifiedStatus SetNextWakeupType(ENEXT_WAKEUP_TYPE next_wakeup_type); +}; + +#endif // ROM_ACCESS_LIBRARY_LIBRARY_INCLUDE_SYSTEM_SERVICE_SS_SM_ROM_ACCESS_H_ + +/** @}*/ // end of rom_access_library +/** @}*/ // end of system_service +/** @}*/ // end of BaseSystem diff --git a/rom_access_library/library/nor/Makefile b/rom_access_library/library/nor/Makefile new file mode 100644 index 00000000..9b0f878d --- /dev/null +++ b/rom_access_library/library/nor/Makefile @@ -0,0 +1,46 @@ +# +# @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +######### search paths ############# +VPATH += src +VPATH += ../include/$(COMPONENT_NAME) + +######### installed shared library(*.so) ############# +INST_SHLIBS = libssaccess + +######### headers to be installed(*.h) ############# +INST_HEADERS = nor_backup.h + +######### compiled sources ############# +libssaccess_SRCS = nor_backup.c + +######### add include path ############# +CPPFLAGS += -I../include/ + +######### frameworkunifiedlog options ############# +LDFLAGS += -Wl,--no-undefined +LDFLAGS += -Wl,--no-as-needed + +######### add compile option ############# +LINK_SHLIB_CXX := y +CPPFLAGS += -Werror=implicit-function-declaration +CPPFLAGS += -Werror=format-security +CPPFLAGS += -Wconversion +CPPFLAGS += -Wint-to-pointer-cast +CPPFLAGS += -Wpointer-arith +CPPFLAGS += -Wformat + +include ../../../system_service.mk diff --git a/rom_access_library/library/nor/libBlkDev_API.ver b/rom_access_library/library/nor/libBlkDev_API.ver new file mode 100644 index 00000000..9f668a46 --- /dev/null +++ b/rom_access_library/library/nor/libBlkDev_API.ver @@ -0,0 +1,30 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +# +# CommonLib version script +# +{ + global: + ### .text section ### + blkDrv_DirectReadData; + blkDrv_DirectWriteData; + blkDrv_GetBlockInfo; + ### .data section ### + local: + *; +}; + diff --git a/rom_access_library/library/nor/libssaccess.ver b/rom_access_library/library/nor/libssaccess.ver new file mode 100644 index 00000000..8b89c2a8 --- /dev/null +++ b/rom_access_library/library/nor/libssaccess.ver @@ -0,0 +1,30 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +# +# CommonLib version script +# +{ + global: + ### .text section ### + mtdn_backup_GetErCnt; + mtdn_backup_Read; + mtdn_backup_Write; + ### .data section ### + local: + *; +}; + diff --git a/rom_access_library/library/nor/src/nor_backup.c b/rom_access_library/library/nor/src/nor_backup.c new file mode 100644 index 00000000..769171f6 --- /dev/null +++ b/rom_access_library/library/nor/src/nor_backup.c @@ -0,0 +1,807 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/******************************************************************************* +* $Header:: $ +* $Revision:: $ +*******************************************************************************/ + +/******************************************************************************* +@file mtd_backup.c +@system +@process +@detail + ******************************************************************************/ +#include "system_service/nor_backup.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define BACKUP_RETRY_CNT 3 + +/* Invalid Value */ +#define FLSBACKUP_SEMAPHORE_INVALID (0) + + +#define BACKUP_SECTOR_SIZ 1024 // Secter Size + +#define BACKUP_CHECK_OFFSET 16 +#define BACKUP_CHECK_SIZE 12 +#define BACKUP_CHECK_TEXT "MTD_BACKUPDT" +#define BACKUP_CHECK_DAT1 1 // Lower 8bit +#define BACKUP_CHECK_DAT2 2 // Upper 8bit + +#define NOR_ERRLOG(fmt, args...) \ + fprintf(stderr, "[ERR]%ld/%s/%d/= "fmt"\n", syscall(__NR_gettid), __func__, __LINE__, ##args) + +static pthread_mutex_t g_semid_flash = PTHREAD_MUTEX_INITIALIZER; /* Semaphore ID of dram area access */ +static int g_backup_init = FLSBACKUP_SEMAPHORE_INVALID; + +typedef enum { + RET_WT_CHK_OK = 0, + RET_WT_ERR_OTHER, + RET_WT_DEV_ERR, +} NOR_WRITE_BLK_CHK; + +typedef enum { + RET_RD_CHK_OK = 0, + RET_RD_ERR_OTHER, + RET_RD_DEV_ERR, + RET_RD_ERR_1 = -1, + RET_RD_ERR_2 = -2, + RET_RD_ERR_3 = -3, + RET_RD_ERR_4 = -4, +} NOR_READ_BLK_CHK; + +typedef enum { + RET_CHK_OK = 0, + RET_CHK_TEXT_ERR, + RET_CHK_BCC_ERR, +} NOR_BLK_CHK; + +typedef enum { + NOR_IDLE = 0, // 0:Read-out of block data + NOR_ORG_TEXT, // 1:OrgText Error + NOR_ORG_BCC, // 2:OrgBcc error + NOR_READ_OK, // 3:Normal read-out + NOR_READ_END // 4:end state +} NOR_R_STATE; + +typedef enum { + NOR_IDEL = 0, // 0:IDEL + NOR_READ_ERR, // 1:Read Error + NOR_ORG_READ, // 2:Org Read OK + NOR_BAK_WRT, // 3:Bak Write OK + NOR_BACK_READ, // 4:Bak Read OK + NOR_ORG_WRITE, // 5:Org Write OK + NOR_WRITE_END // 6:end state +} NOR_W_STATE; + +NOR_READ_BLK_CHK MtdnBackupReadSub( + const char * path_name, int i_id, int i_offset, int i_size, + void *p_buff, mtd_info_t * mtd_info, int * get_state); +NOR_WRITE_BLK_CHK MtdnBackupWriteSub( + const char * path_name, int i_id, int i_offset, int i_size, + void *p_buff, mtd_info_t * mtd_info); + +int MtdnBackupWriteBase( + const char * path_name, int i_id, int i_offset, int i_size, + void *p_buff, mtd_info_t * mtd_info); +int MtdnBackupReadBase( + const char * path_name, int i_id, int i_offset, int i_size, + void *p_buff, mtd_info_t * mtd_info); + +int MtdBackupInfo(const char * path_name, mtd_info_t * mtd_info); // INFO Get + +NOR_BLK_CHK MtdBackupCheksumRead(char * p_buff, int erase_size, int * ret_sum); // check SUM +int MtdBackupCheksumWrite(char * p_buff, int erase_size); // check SUM + +/*************************************************************************** +@brief mtdn_backup_Read +@outline Read-out of specified block ID +@type Completion return type +@param[in] const char * path_name : (/dev/mtd Device) +@param[in] int i_id : ID...0~ +@param[in] int i_offset : ( i_offset >= 0) +@param[in] int i_size : ( i_size > 0) +@param[in] void *p_buff : (p_buff != NULL) +@return int +@retval 0 : No error +@retval Except : Error +@usage It is Backup API of data read. +*****************************************************************************/ +int mtdn_backup_Read(const char * path_name, int i_id, int i_offset, int i_size, void *p_buff ) { + int ret_status = RET_DEV_NORMAL; + + if (path_name == NULL) { + NOR_ERRLOG("invalid path:%p", path_name); + return RET_DEV_ERR_PARAM; + } + if (p_buff == NULL) { + NOR_ERRLOG("invalid buf:%p", p_buff); + return RET_DEV_ERR_PARAM; + } + if (i_id < 0) { + NOR_ERRLOG("invalid id:%d", i_id); + return RET_DEV_ERR_PARAM; + } + if ((i_offset < 0) || (i_size <= 0)) { + NOR_ERRLOG("invalid size:%d offset:%d", i_size, i_offset); + return RET_DEV_ERR_PARAM; + } + if (g_backup_init == FLSBACKUP_SEMAPHORE_INVALID) { // LCOV_EXCL_BR_LINE 200: g_backup_init is static variable + pthread_mutex_init(&g_semid_flash, NULL); + g_backup_init = ~FLSBACKUP_SEMAPHORE_INVALID; + } + mtd_info_t mtd_info; + memset(&mtd_info, 0, sizeof(mtd_info_t)); + ret_status = MtdBackupInfo((const char *)path_name, &mtd_info); + if (ret_status == RET_DEV_NORMAL) { + if (mtd_info.type != MTD_NORFLASH) { + NOR_ERRLOG("invalid type:%d", mtd_info.type); + ret_status = RET_DEV_ERR_PARAM; + } else { + if ((i_offset + i_size) > (int)(mtd_info.erasesize - BACKUP_CHECK_OFFSET)) { + NOR_ERRLOG("invalid size:%d offset:%d erasesize:%d", i_size, i_offset, mtd_info.erasesize); + ret_status = RET_DEV_ERR_PARAM; + } + } + if (ret_status == RET_DEV_NORMAL) { + /* Start Semaphore(flash) */ + pthread_mutex_lock(&g_semid_flash); + int get_state; // Read status + ret_status = (int)MtdnBackupReadSub(path_name, i_id, i_offset, i_size, + p_buff, &mtd_info, &get_state); + + /* End Semaphore(flash) */ + pthread_mutex_unlock(&g_semid_flash); + } + } + if (ret_status != RET_DEV_NORMAL) { + NOR_ERRLOG("error return:%d", ret_status); + } + return ret_status; +} + +/*************************************************************************** +@brief mtdn_backup_Write +@outline Writing of specified block ID +@type Completion return type +@param[in] const char * path_name : (/dev/mtd Device) +@param[in] int i_id : ID...0~ +@param[in] int i_offset : ( i_offset >= 0) +@param[in] int i_size : ( i_size > 0) +@param[in] void *p_buff : (p_buff != NULL) +@return int +@retval 0 : No error +@retval Except: Error +@usage It is Backup API of data read. +*****************************************************************************/ +int mtdn_backup_Write(const char * path_name, int i_id, int i_offset, int i_size, void *p_buff) { + int ret_status = RET_DEV_NORMAL; + + if (path_name == NULL) { + NOR_ERRLOG("invalid path:%p", path_name); + return RET_DEV_ERR_PARAM; + } + if (p_buff == NULL) { + NOR_ERRLOG("invalid buf:%p", p_buff); + return RET_DEV_ERR_PARAM; + } + if (i_id < 0) { + NOR_ERRLOG("invalid id:%d", i_id); + return RET_DEV_ERR_PARAM; + } + if ((i_offset < 0) || (i_size <= 0)) { + NOR_ERRLOG("invalid size:%d offset:%d", i_size, i_offset); + return RET_DEV_ERR_PARAM; + } + if (g_backup_init == FLSBACKUP_SEMAPHORE_INVALID) { + pthread_mutex_init(&g_semid_flash, NULL); + g_backup_init = ~FLSBACKUP_SEMAPHORE_INVALID; + } + mtd_info_t mtd_info; + memset(&mtd_info, 0, sizeof(mtd_info_t)); + ret_status = MtdBackupInfo((const char *)path_name, &mtd_info); + if (ret_status == RET_DEV_NORMAL) { + if (mtd_info.type != MTD_NORFLASH) { + NOR_ERRLOG("invalid type:%d", mtd_info.type); + ret_status = RET_DEV_ERR_PARAM; + } else if (mtd_info.erasesize == 0) { + NOR_ERRLOG("invalid erasesize:%d", mtd_info.erasesize); + ret_status = RET_DEV_ERR_PARAM; + } else { + if ((i_offset + i_size) > (int)(mtd_info.erasesize - BACKUP_CHECK_OFFSET)) { + NOR_ERRLOG("invalid size:%d offset:%d erasesize:%d", i_size, i_offset, mtd_info.erasesize); + ret_status = RET_DEV_ERR_PARAM; + } + } + if (ret_status == RET_DEV_NORMAL) { + /* Start Semaphore(flash) */ + pthread_mutex_lock(&g_semid_flash); + ret_status = (int)MtdnBackupWriteSub(path_name, i_id, i_offset, i_size, p_buff, &mtd_info); + + /* End Semaphore(flash) */ + pthread_mutex_unlock(&g_semid_flash); + } + } + if (ret_status != RET_DEV_NORMAL) { + NOR_ERRLOG("error return:%d", ret_status); + } + return ret_status; +} + +/*************************************************************************** +@brief MtdnBackupReadSub +@outline Read-out of specified block ID +@type Completion return type +@param[in] const char * path_name : (/dev/mtd Device) +@param[in] int i_id : ID...0~ +@param[in] int i_offset : ( i_offset >= 0) +@param[in] int i_size : ( i_size > 0) +@param[in] void *p_buff : (p_buff != NULL) +@param[in] mtd_info_t * mtd_info : info +@param[in] int * get_state : 0:Rrg Normal 1:Bak Normal +@return NOR_READ_BLK_CHK +@retval RET_RD_CHK_OK : No error +@retval Except : Error +@usage It is Backup API of data read. +*****************************************************************************/ +NOR_READ_BLK_CHK MtdnBackupReadSub(const char * path_name, int i_id, int i_offset, int i_size, + void *p_buff, mtd_info_t * mtd_info, int * get_state) { + NOR_READ_BLK_CHK ret_status = RET_RD_CHK_OK; + char * lp_buffer; + + if (mtd_info->erasesize != 0) { // LCOV_EXCL_BR_LINE 6: double check + lp_buffer = (char *)malloc(mtd_info->erasesize); + if (lp_buffer == NULL) { + NOR_ERRLOG("malloc:%p", lp_buffer); + ret_status = RET_RD_DEV_ERR; // error + } + } else { + // LCOV_EXCL_START 8: dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + NOR_ERRLOG("invalid erasesize:%d", mtd_info->erasesize); + ret_status = RET_RD_DEV_ERR; // error + // LCOV_EXCL_STOP + } + if (ret_status == RET_RD_CHK_OK) { + memset(lp_buffer, 0x00, mtd_info->erasesize); + NOR_R_STATE cycle_state = NOR_IDLE; + int block_check_mode = 0; + int ret_sum = 0; + while ((cycle_state < NOR_READ_END) + &&(ret_status == RET_RD_CHK_OK)) { + switch (cycle_state) { + case NOR_IDLE: + // Read-out of block data + if (0 != MtdnBackupReadBase((const char *)path_name, i_id, 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info)) { + ret_status = RET_RD_ERR_OTHER; // Other abnormalities + } else { + NOR_BLK_CHK ret = MtdBackupCheksumRead(lp_buffer, (int)mtd_info->erasesize, (int *)&ret_sum); + if (ret == RET_CHK_TEXT_ERR) { // Text character sequence Abnormalities + cycle_state = NOR_ORG_TEXT; + } else if (ret == RET_CHK_BCC_ERR) { // (BCC)error + cycle_state = NOR_ORG_BCC; + } else { + block_check_mode = 0; // Org Normal + cycle_state = NOR_READ_OK; + } + } + break; + case NOR_ORG_TEXT: // OrgText Error + // Read-out of block data + if (0 != MtdnBackupReadBase((const char *)path_name, (i_id+1), 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info)) { + // other error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ret_status = RET_RD_ERR_OTHER; // LCOV_EXCL_LINE 5: c API error case. + } else { + NOR_BLK_CHK ret = MtdBackupCheksumRead(lp_buffer, (int)mtd_info->erasesize, + (int *)&ret_sum); // check SUM + if (ret == RET_CHK_TEXT_ERR) { // Text character sequence Abnormalities + ret_status = RET_RD_ERR_1; // Uninitialized. + } else if (ret == RET_CHK_BCC_ERR) { // BCC error + ret_status = RET_RD_ERR_2; // write error + } + block_check_mode = 1; // Bak Normal + cycle_state = NOR_READ_OK; + } + break; + case NOR_ORG_BCC: // OrgBcc error + // Read-out of block data + if (0 != MtdnBackupReadBase((const char *)path_name, (i_id+1), 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info)) { + // other error + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ret_status = RET_RD_ERR_OTHER; // LCOV_EXCL_LINE 5: c API error case. + } else { + NOR_BLK_CHK ret = MtdBackupCheksumRead(lp_buffer, (int)mtd_info->erasesize, + (int *)&ret_sum); // check SUM + if (ret == RET_CHK_TEXT_ERR) { // Text character sequence Abnormalities + ret_status = RET_RD_ERR_3; // write error + } else if (ret == RET_CHK_BCC_ERR) { // BCC error + ret_status = RET_RD_ERR_4; // write error + } + block_check_mode = 1; // Bak Normal + cycle_state = NOR_READ_OK; + } + break; + case NOR_READ_OK: // Normal read-out + // The pickup of the read data + memcpy(p_buff, &lp_buffer[i_offset], (size_t)i_size); + cycle_state = NOR_READ_END; + break; + default: + // LCOV_EXCL_START 8: dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + NOR_ERRLOG("invalid state:%d", cycle_state); + // other error + ret_status = RET_RD_ERR_OTHER; + break; + // LCOV_EXCL_STOP + } + } + *get_state = block_check_mode; // 0:OrgNormal 1:BakNormal + free(lp_buffer); + } + return ret_status; // Normal +} + +static inline NOR_WRITE_BLK_CHK MtdnBackupWriteRetryCount(int *count, NOR_WRITE_BLK_CHK cur_state) { + NOR_WRITE_BLK_CHK ret_state = cur_state; + (*count)++; + if (*count > BACKUP_RETRY_CNT) { + NOR_ERRLOG("retry over!! state:%d count:%d", ret_state, *count); + ret_state = RET_WT_DEV_ERR; + } + return ret_state; +} + +/*************************************************************************** +@brief MtdnBackupWriteSub +@outline Writing of specified block ID +@type Completion return type +@param[in] const char * path_name : (/dev/mtd Device) +@param[in] int i_id : ID...0~ +@param[in] int i_offset : ( i_offset >= 0) +@param[in] int i_size : ( i_size > 0) +@param[in] void *p_buff : (p_buff != NULL) +@param[in] mtd_info_t * mtd_info : info +@return NOR_WRITE_BLK_CHK +@retval RET_WT_CHK_OK : No error +@retval Except : Error +@usage It is Backup API of data read. +*****************************************************************************/ +NOR_WRITE_BLK_CHK MtdnBackupWriteSub(const char * path_name, int i_id, int i_offset, + int i_size, void *p_buff, mtd_info_t * mtd_info) { + NOR_WRITE_BLK_CHK ret_status = RET_WT_CHK_OK; + char* lp_buffer; + + lp_buffer = (char *)malloc(mtd_info->erasesize); + if (lp_buffer == NULL) { + NOR_ERRLOG("malloc:%p", lp_buffer); + ret_status = RET_WT_DEV_ERR; // error + } else { + memset(lp_buffer, 0x00, mtd_info->erasesize); + NOR_W_STATE cycle_state = NOR_IDEL; + int retry_cnt = 0; + int get_state = 0; // Read status + + while ((cycle_state < NOR_WRITE_END) + &&(ret_status == RET_WT_CHK_OK)) { + switch (cycle_state) { + case NOR_IDEL: // IDLE + if (RET_RD_CHK_OK != MtdnBackupReadSub((const char *)path_name, i_id, 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info, &get_state)) { + cycle_state = NOR_READ_ERR; // read error + } else { + // write data set + memcpy(&lp_buffer[i_offset], p_buff, (size_t)i_size); + if (get_state == 0) { + cycle_state = NOR_ORG_READ; // Org read Normal + } else { + // Bakread Normal + cycle_state = NOR_BACK_READ; + } + // Embedding of write-in data + memcpy(&lp_buffer[i_offset], p_buff, (size_t)i_size); + } + break; + case NOR_READ_ERR: // read error + memset((char *)lp_buffer, 0x00, mtd_info->erasesize); + // Embedding of write-in data + memcpy(&lp_buffer[i_offset], p_buff, (size_t)i_size); + cycle_state = NOR_ORG_READ; // Org read Normal + break; + case NOR_ORG_READ: // Orgread Normal + // LCOV_EXCL_BR_START 6: double check + if (0 != MtdBackupCheksumWrite(lp_buffer, (int)mtd_info->erasesize )) { // check SUM + // LCOV_EXCL_BR_STOP + // error(It does not generate.) + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ret_status = RET_WT_DEV_ERR; // LCOV_EXCL_LINE 8: dead code + } else { + // data write + if (0 == MtdnBackupWriteBase((const char *)path_name, (i_id+1), 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info)) { + cycle_state = NOR_BAK_WRT; // Bakwrite Success + retry_cnt = 0; + } else { + ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status); + } + } + break; + case NOR_BAK_WRT: // BakWriteSuccess + // Data write + // LCOV_EXCL_BR_START 11:unexpected branch + if (0 == MtdnBackupWriteBase((const char *)path_name, i_id, 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info)) { + // LCOV_EXCL_BR_STOP + cycle_state = NOR_WRITE_END; // Normal end + } else { + // LCOV_EXCL_START 5: c API error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status); + // LCOV_EXCL_STOP + } + break; + case NOR_BACK_READ: // Bak read normal + // LCOV_EXCL_BR_START 6: double check + if (0 != MtdBackupCheksumWrite(lp_buffer, (int)mtd_info->erasesize )) { // check SUM + // LCOV_EXCL_BR_STOP + // Retry over + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ret_status = RET_WT_DEV_ERR; // LCOV_EXCL_LINE 8: dead code + } else { + // data write + if (0 == MtdnBackupWriteBase((const char *)path_name, i_id, 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info)) { + // Org write Succses + cycle_state = NOR_ORG_WRITE; + retry_cnt = 0; + } else { + // LCOV_EXCL_START 5: c API error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status); + // LCOV_EXCL_STOP + } + } + break; + case NOR_ORG_WRITE: // Org write Succses + // data write + if (0 == MtdnBackupWriteBase((const char *)path_name, (i_id+1), 0, + (int)mtd_info->erasesize, lp_buffer, mtd_info)) { + // Normal end + cycle_state = NOR_WRITE_END; + } else { + // LCOV_EXCL_START 5: c API error case. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status); + // LCOV_EXCL_STOP + } + break; + default: + // LCOV_EXCL_START 8: dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + NOR_ERRLOG("invalid state:%d", cycle_state); + // other error + ret_status = RET_WT_ERR_OTHER; + break; + // LCOV_EXCL_STOP + } + } + free(lp_buffer); + } + return ret_status; // Normal +} + +/*************************************************************************** +@brief MtdnBackupReadBase +@outline Read-out of specified block ID +@type Completion return type +@param[in] const char * path_name : (/dev/mtd Device) +@param[in] int i_id : ID...0~ +@param[in] int i_offset : ( i_offset >= 0) +@param[in] int i_size : ( i_size > 0) +@param[in] void *p_buff : (p_buff != NULL) +@param[in] mtd_info_t * mtd_info : +@return int +@retval 0 : No error +@retval Except : Error +@usage It is Backup API of data read. +*****************************************************************************/ +int MtdnBackupReadBase(const char * path_name, int i_id, int i_offset, + int i_size, void *p_buff, mtd_info_t * mtd_info) { + int ret_status = RET_DEV_NORMAL; + + int mtd_fd = open(path_name, O_RDONLY|O_CLOEXEC); + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (mtd_fd == -1) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 5:It's impossible to mock open() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + NOR_ERRLOG("open(%s):%s", path_name, strerror(errno)); + ret_status = RET_DEV_ERROR; + // LCOV_EXCL_STOP + } else { + int seek_top = i_id * (int)mtd_info->erasesize + i_offset; + int sector_size = BACKUP_SECTOR_SIZ; + int block_size = (int)mtd_info->erasesize / sector_size; // Division number + int llpi; + int buff_top = 0; + int get_size = i_size; + char * work_buff = (char *)p_buff; + ssize_t read_size; + + // It reads several sector minutes. + for (llpi=0; llpi < block_size; llpi++) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // It moves to a head. + if (-1 == (off_t)lseek(mtd_fd, seek_top, SEEK_SET)) { + NOR_ERRLOG("lseek():%s", strerror(errno)); + ret_status = RET_DEV_ERROR; + break; + } + if (get_size >= sector_size) { // LCOV_EXCL_BR_LINE 6:double check + read_size = read(mtd_fd, &work_buff[buff_top], (size_t)sector_size); + if (read_size < 0) { + NOR_ERRLOG("read():%zd %s", read_size, strerror(errno)); + ret_status = RET_DEV_ERROR; + break; + } + + get_size -= sector_size; + if (get_size <= 0) { + break; + } + } else { + // LCOV_EXCL_START 8: dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + read_size = read(mtd_fd, &work_buff[buff_top], (size_t)get_size); + if (read_size < 0) { + NOR_ERRLOG("read():%zd %s", read_size, strerror(errno)); + ret_status = RET_DEV_ERROR; + break; + } + break; + // LCOV_EXCL_STOP + } + seek_top += (int)read_size; + buff_top += (int)read_size; + } + // LCOV_EXCL_BR_START 5:It's impossible to mock close() function,so this line can not be passed. + if (0 != close(mtd_fd)) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 5:It's impossible to mock close() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + NOR_ERRLOG("close():%s", strerror(errno)); + ret_status = RET_DEV_ERROR; + // LCOV_EXCL_STOP + } + } + return ret_status; +} + +/*************************************************************************** +@brief MtdnBackupWriteBase +@outline Writing of specified block ID +@type Completion return type +@param[in] const char * path_name : (/dev/mtd Device) +@param[in] int i_id : ID...0~ +@param[in] int i_offset : ( i_offset >= 0) +@param[in] int i_size : ( i_size > 0) +@param[in] void *p_buff : (p_buff != NULL) +@param[in] mtd_info_t * mtd_info : +@return int +@retval 0 : No error +@retval Except : Error +@usage It is Backup API of data read. +*****************************************************************************/ +int MtdnBackupWriteBase(const char * path_name, int i_id, int i_offset, + int i_size, void *p_buff, mtd_info_t * mtd_info) { + int ret_status = RET_DEV_NORMAL; + + int mtd_fd = open(path_name, O_RDWR|O_CLOEXEC); + if (mtd_fd == -1) { + NOR_ERRLOG("open(%s):%s", path_name, strerror(errno)); + ret_status = RET_DEV_ERROR; + } else { + erase_info_t s_mtd_erase; + s_mtd_erase.start = (__u32)i_id * mtd_info->erasesize; + s_mtd_erase.length = mtd_info->erasesize; + // erase + if (ioctl(mtd_fd, MEMERASE, &s_mtd_erase) < 0) { + NOR_ERRLOG("ioctl(MEMERASE):%s", strerror(errno)); + ret_status = RET_DEV_ERROR; + } else { + // write + int seek_top = i_id * (int)mtd_info->erasesize + i_offset; + int sector_size = BACKUP_SECTOR_SIZ; // + int block_size = (int)mtd_info->erasesize/sector_size; + int llpi; + int buff_top = 0; + int put_size = i_size; + char * work_buff = (char *)p_buff; + ssize_t write_size; + + for (llpi=0; llpi < block_size; llpi++) { // LCOV_EXCL_BR_LINE 11:unexpected branch + if (-1 == (off_t)lseek(mtd_fd, seek_top, SEEK_SET)) { + NOR_ERRLOG("lseek():%s", strerror(errno)); + ret_status = RET_DEV_ERROR; + break; + } + if (put_size >= sector_size) { // LCOV_EXCL_BR_LINE 6:double check + write_size = write(mtd_fd, &work_buff[buff_top], (size_t)sector_size); + if (write_size < 0) { + NOR_ERRLOG("write():%zd %s", write_size, strerror(errno)); + ret_status = RET_DEV_ERROR; + break; + } + put_size -= sector_size; + if (put_size <= 0) { + break; + } + } else { + // LCOV_EXCL_START 8: dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + write_size = write(mtd_fd, &work_buff[buff_top], (size_t)put_size); + if (write_size < 0) { + NOR_ERRLOG("write():%zd %s", write_size, strerror(errno)); + ret_status = RET_DEV_ERROR; + break; + } + break; + // LCOV_EXCL_STOP + } + seek_top += (int)write_size; + buff_top += (int)write_size; + } + } + // LCOV_EXCL_BR_START 5:It's impossible to mock close() function,so this line can not be passed. + if (0 != close(mtd_fd)) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 5:It's impossible to mock close() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + NOR_ERRLOG("close():%s", strerror(errno)); + ret_status = RET_DEV_ERROR; + // LCOV_EXCL_STOP + } + } + return ret_status; +} + +/*************************************************************************** +int backup_cheksum_read(char * p_buff, int erase_size ,int * ret_sum) + * A text character sequence and a sum value are checked. + IN: char * p_buff ...top address + int erase_size ...erase size + int * ret_sum ...return sum + + OUT: NOR_BLK_CHK RET_CHK_OK:Normal + RET_CHK_TEXT_ERR:test error + RET_CHK_BCC_ERR:sum error Except:other error + Remarks: +*****************************************************************************/ +NOR_BLK_CHK MtdBackupCheksumRead(char * p_buff, int erase_size, int * ret_sum) { + if (erase_size > BACKUP_CHECK_OFFSET) { // LCOV_EXCL_BR_LINE 6: double check + // The check of the compatibility of block data + if (0 != memcmp(&p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_TEXT, BACKUP_CHECK_SIZE)) { + char tmp[BACKUP_CHECK_SIZE + 1]; + memcpy(tmp, &p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_SIZE); + tmp[BACKUP_CHECK_SIZE] = '\0'; + NOR_ERRLOG("invalid check_text:%s", tmp); + return RET_CHK_TEXT_ERR; + } + // The check of the compatibility of block data + int llpi; + int get_sum; + int work_sum = 0; + get_sum = ((int)p_buff[(erase_size-BACKUP_CHECK_DAT2)] & 0xff) + + (((int)p_buff[(erase_size-BACKUP_CHECK_DAT1)]) << 8 & 0xff00); + + for (llpi=0; llpi < (erase_size-BACKUP_CHECK_OFFSET); llpi++) { + work_sum += p_buff[llpi]; + } + work_sum = (work_sum & 0xffff); + if (work_sum != get_sum) { + NOR_ERRLOG("invalid checksum: work:%d get:%d", work_sum, get_sum); + return RET_CHK_BCC_ERR; // checksum error + } + if (ret_sum != NULL) { // LCOV_EXCL_BR_LINE 6: double check + *ret_sum = work_sum; // chesum Storing + } + } else { + // LCOV_EXCL_START 8: dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + NOR_ERRLOG("invalid erase_size:%d", erase_size); + // checksum error + return RET_CHK_BCC_ERR; + // LCOV_EXCL_STOP + } + return RET_CHK_OK; +} + +/*************************************************************************** +int backup_cheksum_write(char * p_buff, int erase_size ) + * A text character sequence and a sum value are written in a buffer. + IN: char * p_buff ...top address + int erase_size ...erase size + + OUT: int 0:normal Except:error + Remarks: +*****************************************************************************/ +int MtdBackupCheksumWrite(char * p_buff, int erase_size ) { + int sum_add = 0; + + if (erase_size > BACKUP_CHECK_OFFSET) { // LCOV_EXCL_BR_LINE 11:unexpected branch + int ret_status; + // The check of the compatibility of block data + ret_status = memcmp(&p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_TEXT, BACKUP_CHECK_SIZE); + if (ret_status != 0) { + memcpy(&p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_TEXT, BACKUP_CHECK_SIZE); + } + int llpi; + for (llpi=0; llpi < (erase_size-BACKUP_CHECK_OFFSET); llpi++) { + sum_add += p_buff[llpi]; + } + } + p_buff[(erase_size-BACKUP_CHECK_DAT2)] = (char)(sum_add & 0xff); + p_buff[(erase_size-BACKUP_CHECK_DAT1)] = (char)((sum_add>>8) & 0xff); + return RET_DEV_NORMAL; +} + +/*************************************************************************** +@brief MtdBackupInfo( mtd_info_t * mtd_info) +@outline The information to obtain is obtained. +@type Completion return type +@param[in] mtd_info_t * mtd_info +@return int +@retval 0 : No error +@retval Except : Error +@usage It is Backup API of data read. +*****************************************************************************/ +int MtdBackupInfo(const char * path_name, mtd_info_t * mtd_info) { + int ret_status = RET_DEV_NORMAL; + + int mtd_fd = open(path_name, O_RDONLY|O_CLOEXEC); + if (mtd_fd == -1) { + NOR_ERRLOG("open(%s):%s", path_name, strerror(errno)); + ret_status = RET_DEV_ERROR; + } else { + // device control mtdchar_ioctl of mtdchar.c + if (ioctl(mtd_fd, MEMGETINFO, mtd_info) < 0) { + NOR_ERRLOG("ioctl(MEMGETINFO):%s", strerror(errno)); + ret_status = RET_DEV_ERROR; + } + if (0 != close(mtd_fd)) { + NOR_ERRLOG("close():%s", strerror(errno)); + ret_status = RET_DEV_ERROR; + } + } + return ret_status; +} + +/************************************************************** + End Of Files +**************************************************************/ diff --git a/rom_access_library/library/rom/Makefile b/rom_access_library/library/rom/Makefile new file mode 100644 index 00000000..064bf2cc --- /dev/null +++ b/rom_access_library/library/rom/Makefile @@ -0,0 +1,63 @@ +# +# @copyright Copyright (c) 2017-2019 TOYOTA MOTOR CORPORATION. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +######### search paths ############# +VPATH += src +VPATH += ../include/$(COMPONENT_NAME) + + +######### installed shared library(*.so) ############# +INST_SHLIBS = libSS_RomAccessIf + +######### headers to be installed(*.h) ############# +INST_HEADERS = rom_access_library.h ss_sm_boot_access.h ss_sm_ram_access.h ss_sm_rom_access.h + +######### compiled sources ############# +libSS_RomAccessIf_SRCS += ss_sm_rom_access.cpp ss_sm_boot_access.cpp ss_sm_ram_access.cpp ss_sm_checksum.cpp + +######### add include path ############# +CPPFLAGS += -I./../include + +######### frameworkunifiedlog options ############# +CPPFLAGS += -DLINUX +CPPFLAGS += -DFRAMEWORKUNIFIEDLOGOPTIONS=0x08 -DFRAMEWORKUNIFIEDLOGAPPZONES=31,30,29,28,27,26,9,8,3 +LDFLAGS += -Wl,--no-as-needed +LDFLAGS += -Wl,--no-undefined + +######### add compile option ############# +LDFLAGS += -L./../nor/ +LINK_SHLIB_CXX := y +LDFLAGS += -g -Wl,--gc-sections -shared +CPPFLAGS += -Werror=implicit-function-declaration +CPPFLAGS += -Werror=format-security +CPPFLAGS += -Wconversion +CPPFLAGS += -Wint-to-pointer-cast +CPPFLAGS += -Wpointer-arith +CPPFLAGS += -Wformat + +######### linked library (dynamic) ############# +LDLIBS += -Wl,-Bdynamic -lNS_FrameworkUnified +LDLIBS += -Wl,-Bdynamic -lvp +LDLIBS += -Wl,-Bdynamic -lcommon +LDLIBS += -Wl,-Bdynamic -lssaccess +#LDLIBS += -Wl,-Bdynamic -lextension + +CPPFLAGS_ss_sm_checksum.o += -fno-exceptions +CPPFLAGS_ss_sm_checksum.os += -fno-exceptions +CPPFLAGS_ss_sm_ram_access.o += -fno-exceptions +CPPFLAGS_ss_sm_ram_access.os += -fno-exceptions + +include ../../../system_service.mk diff --git a/rom_access_library/library/rom/src/ss_sm_boot_access.cpp b/rom_access_library/library/rom/src/ss_sm_boot_access.cpp new file mode 100644 index 00000000..36f3a9f4 --- /dev/null +++ b/rom_access_library/library/rom/src/ss_sm_boot_access.cpp @@ -0,0 +1,122 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "system_service/ss_sm_boot_access.h" +#include +#include +#include +#include "system_service/nor_backup.h" +#include "ss_rom_access_if_romaccesslibrarylog.h" +#include "ss_rom_access_define.h" + +#define BAI_MTD_DEV_RO "/dev/mtd1ro" // NOR device for RO +#define BAI_MTD_DEV_RW "/dev/mtd1" // NOR device for RW + +#define BAI_SERCTOR_OFFSET 0 +#define BAI_DATA_OFFSET 0 + +void* BOOT_AccessIf::g_m_plock = NULL; + +BOOT_AccessIf::BOOT_AccessIf(BAI_OPEN_t type) + : m_type(type) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (!(m_type == BAI_OPEN_RO // LCOV_EXCL_BR_LINE 6: double check + || m_type == BAI_OPEN_RW)) { // LCOV_EXCL_BR_LINE 6: double check + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + throw __LINE__; // LCOV_EXCL_LINE 6: double check + } + + if (g_m_plock == NULL) { + g_m_plock = CL_LockMap(LOCK_BOOT_ACCESS_IF); + + if (g_m_plock == MAP_FAILED) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, __FUNCTION__, + "CL_LockMap Error, please check whether you call CL_LockProcessInit"); + // LCOV_EXCL_BR_STOP + } + } + + if (g_m_plock) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + ROM_ACCESS_ASERT(0 == CL_LockGet(g_m_plock)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +BOOT_AccessIf::~BOOT_AccessIf() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (g_m_plock) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + ROM_ACCESS_ASERT(0 == CL_LockRelease(g_m_plock)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +EFrameworkunifiedStatus BOOT_AccessIf::getBootInfo(LBM_NOR_t* p_bootInfo) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus eRet = eFrameworkunifiedStatusOK; + try { + int ret; + if (p_bootInfo == NULL) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + ret = mtdn_backup_Read((const char *) BAI_MTD_DEV_RO, BAI_SERCTOR_OFFSET, + BAI_DATA_OFFSET, sizeof(LBM_NOR_t), p_bootInfo); // LCOV_EXCL_BR_LINE 11:unexpected branch + + if (ret != 0) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + } catch (...) { + eRet = eFrameworkunifiedStatusFail; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eRet; +} + +EFrameworkunifiedStatus BOOT_AccessIf::setBootInfo(LBM_NOR_t* p_bootInfo) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus eRet = eFrameworkunifiedStatusOK; + try { + int ret; + if (p_bootInfo == NULL) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + if (m_type != BAI_OPEN_RW) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + ret = mtdn_backup_Write((const char *) BAI_MTD_DEV_RW, BAI_SERCTOR_OFFSET, + BAI_DATA_OFFSET, sizeof(LBM_NOR_t), p_bootInfo); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (ret != 0) { // LCOV_EXCL_BR_LINE 5:c API error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); // LCOV_EXCL_LINE 5:c API error case + throw __LINE__; // LCOV_EXCL_LINE 5:c API error case + } + } catch (...) { + eRet = eFrameworkunifiedStatusFail; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eRet; +} + diff --git a/rom_access_library/library/rom/src/ss_sm_checksum.cpp b/rom_access_library/library/rom/src/ss_sm_checksum.cpp new file mode 100644 index 00000000..39a087ae --- /dev/null +++ b/rom_access_library/library/rom/src/ss_sm_checksum.cpp @@ -0,0 +1,37 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_SystemManager +/// \brief This file provides for checksum calculation. +/// +/////////////////////////////////////////////////////////////////////////////// +#include "ss_sm_checksum.h" + +CSMChecksum::CSMChecksum() {} +CSMChecksum::~CSMChecksum() {} +UI_32 CSMChecksum::cal_checksum(const void* p_buf, size_t bufSize) { + size_t num; + UI_32 sum = 0; + const UI_32 *p_calcBuf = reinterpret_cast(p_buf); + num = bufSize / sizeof(UI_32); + + for (size_t i = 0; i < num; i++) { + sum += p_calcBuf[i]; + } + return sum; +} + diff --git a/rom_access_library/library/rom/src/ss_sm_ram_access.cpp b/rom_access_library/library/rom/src/ss_sm_ram_access.cpp new file mode 100644 index 00000000..f101fb4b --- /dev/null +++ b/rom_access_library/library/rom/src/ss_sm_ram_access.cpp @@ -0,0 +1,215 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "system_service/ss_sm_ram_access.h" +#include +#include +#include +#include +#include +#include +//#include +#include "system_service/ss_sm_boot_access.h" +#include "ss_rom_access_if_romaccesslibrarylog.h" +#include "ss_sm_checksum.h" +#include "ss_rom_access_define.h" + + + +#define RAM_PATH "/nv/romaccess/ramdata.dat" +#define RAM_OLD_PATH RAM_PATH".old" +static const uint8_t kSigNature[] = { 0xDE, 0xAD, 0xBE, 0xEF }; +static const uint8_t kMagic[] = { 0xDE, 0xAD, 0xBE, 0xEF }; + +void* RAM_AccessIf::g_m_plock = NULL; +void* RAM_AccessIf::g_m_bakup_map = MAP_FAILED; +bool RAM_AccessIf::g_m_is_first_access = false; + +typedef struct { + char magic_in[4]; + RAM_SM_INFO_t data0; + uint32_t checksum0; + RAM_SM_INFO_t data1; + uint32_t checksum1; + char magic_out[4]; +} RAM_SM_DRAM_INFO_t; + +void RAM_AccessIf::initRamBackupEnable(RAM_WAKEUP_STATE wupState) { + RAM_SM_DRAM_INFO_t* p_buf; + CSMChecksum l_checksum; + + ROM_ACCESS_STATIC_ASERT(sizeof(RAM_SM_DRAM_INFO_t) <= SS_SYS_AREA_RAM_MAX_SIZE); + // Checking sizes because checksum calculations expect 4 bytes alignments + ROM_ACCESS_STATIC_ASERT((sizeof(RAM_SM_DRAM_INFO_t) % sizeof(UI_32)) == 0); + + if (g_m_bakup_map == MAP_FAILED) { +// g_m_bakup_map = EL_mem_exram_mmap( // LCOV_EXCL_BR_LINE 11:unexpected branch +// EL_MEM_TYPE_REGION_SYS, +// EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_RAM_OFFSET, // LCOV_EXCL_BR_LINE 11:unexpected branch +// SS_SYS_AREA_RAM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, +// EL_MEM_CACHE_INVALID); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + return; // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + } + } + p_buf = static_cast(g_m_bakup_map); + + // LCOV_EXCL_BR_START 6:impossible to confirm because wupState can not be changed + if ((RAM_WAKEUP_STATE_BACKUP_NG == wupState) || + (RAM_WAKEUP_STATE_BATTERY_DOWN == wupState) || + (memcmp(p_buf->magic_out, kMagic, sizeof(kMagic)) != 0) || + (memcmp(p_buf->magic_in, p_buf->magic_out, sizeof(p_buf->magic_in)) != 0)) { + // LCOV_EXCL_BR_STOP + // BACKUP NG + g_m_is_first_access = false; + bzero(p_buf, sizeof(RAM_SM_DRAM_INFO_t)); + } + + if (!g_m_is_first_access) { + // LCOV_EXCL_BR_START 11:unexpected branch + if ((memcmp(p_buf->data0.signature_in, kSigNature, sizeof(kSigNature)) == 0) + && (memcmp(p_buf->data0.signature_out, kSigNature, + sizeof(kSigNature)) == 0) + && (l_checksum.cal_checksum(&(p_buf->data0), sizeof(p_buf->data0)) == p_buf->checksum0)) { + // LCOV_EXCL_BR_STOP + // Use data0 content + memcpy(&(p_buf->data1), &(p_buf->data0), sizeof(p_buf->data1)); + p_buf->checksum1 = p_buf->checksum0; + // LCOV_EXCL_BR_START 11:unexpected branch + } else if ((memcmp(p_buf->data1.signature_in, kSigNature, sizeof(kSigNature)) == 0) + && (memcmp(p_buf->data1.signature_out, kSigNature, + sizeof(kSigNature)) == 0) + && (l_checksum.cal_checksum(&(p_buf->data1), sizeof(p_buf->data1)) == p_buf->checksum1)) { + // LCOV_EXCL_BR_STOP + // Use data1 content + memcpy(&(p_buf->data0), &(p_buf->data1), sizeof(p_buf->data0)); + p_buf->checksum0 = p_buf->checksum1; + } else { + // BACKUP NG or SIGNATURE CHECK or CHECK SUM NG + bzero(p_buf, sizeof(RAM_SM_DRAM_INFO_t)); + memcpy(p_buf->magic_in, kMagic, sizeof(kMagic)); + // data0 + memcpy(p_buf->data0.signature_in, kSigNature, sizeof(kSigNature)); + memcpy(p_buf->data0.signature_out, kSigNature, sizeof(kSigNature)); + p_buf->checksum0 = + l_checksum.cal_checksum(&(p_buf->data0), sizeof(p_buf->data0)); // LCOV_EXCL_BR_LINE 11:unexpected branch + // data1 + memcpy(p_buf->data1.signature_in, kSigNature, sizeof(kSigNature)); + memcpy(p_buf->data1.signature_out, kSigNature, sizeof(kSigNature)); + p_buf->checksum1 = + l_checksum.cal_checksum(&(p_buf->data1), sizeof(p_buf->data1)); // LCOV_EXCL_BR_LINE 11:unexpected branch + memcpy(p_buf->magic_out, kMagic, sizeof(kMagic)); + } + } + memcpy(&m_buf, &(p_buf->data0), sizeof(p_buf->data0)); +} + +void RAM_AccessIf::finalRamBackupEnable(void) { + RAM_SM_DRAM_INFO_t* p_buf; + CSMChecksum l_checksum; + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + return; // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + } + + p_buf = static_cast(g_m_bakup_map); + + // kSigNature is cleared during writing + bzero(m_buf.signature_in, sizeof(kSigNature)); + + // data0 + memcpy(&(p_buf->data0), &m_buf, sizeof(p_buf->data0)); + memcpy(p_buf->data0.signature_in, kSigNature, sizeof(kSigNature)); + p_buf->checksum0 = l_checksum.cal_checksum(&(p_buf->data0), // LCOV_EXCL_BR_LINE 11:unexpected branch + sizeof(p_buf->data0)); + + // data1 + memcpy(&(p_buf->data1), &m_buf, sizeof(p_buf->data1)); + memcpy(p_buf->data1.signature_in, kSigNature, sizeof(kSigNature)); + p_buf->checksum1 = l_checksum.cal_checksum(&(p_buf->data1), // LCOV_EXCL_BR_LINE 11:unexpected branch + sizeof(p_buf->data1)); + + // Set kSigNature + memcpy(m_buf.signature_in, kSigNature, + sizeof(kSigNature)); +} + +RAM_AccessIf::RAM_AccessIf( + RAM_WAKEUP_STATE wupState /* = RAM_WAKEUP_STATE_DONT_CARE */) + : m_buf(), + m_dirty(false) { + + if (g_m_plock == NULL) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + g_m_plock = CL_LockMap(LOCK_RAM_ACCESS_IF); + if (g_m_plock == MAP_FAILED) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, __FUNCTION__, + "CL_LockMap Error, please check whether you call CL_LockProcessInit"); + // LCOV_EXCL_BR_STOP + g_m_plock = NULL; + } + } + if (g_m_plock) { + if (0 != CL_LockGet(g_m_plock)) { + ROM_ACCESS_ASERT(0); + } + } + + if (RAM_WAKEUP_STATE_BATTERY_DOWN == wupState) { // LCOV_EXCL_BR_LINE 13: + // Models without DRAM backups are initialized when +B is down. + // Deletes files because models with DRAM backups are also backwards compatible + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + unlink(RAM_PATH); // LCOV_EXCL_LINE 13: + unlink(RAM_OLD_PATH); // LCOV_EXCL_LINE 13: + } + + initRamBackupEnable(wupState); + g_m_is_first_access = true; +} + +RAM_AccessIf::~RAM_AccessIf() { + if (m_dirty) { + finalRamBackupEnable(); + } + if (g_m_plock) { + ROM_ACCESS_ASERT(0 == CL_LockRelease(g_m_plock)); + } + + return; +} + +EFrameworkunifiedStatus RAM_AccessIf::getRamInfo(RAM_SM_INFO_t* p_bootInfo) { + *p_bootInfo = m_buf; + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus RAM_AccessIf::setRamInfo(RAM_SM_INFO_t* p_bootInfo) { + if (0 != memcmp(&m_buf, p_bootInfo, sizeof(m_buf))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + m_buf = *p_bootInfo; + m_dirty = true; + } + + return eFrameworkunifiedStatusOK; +} diff --git a/rom_access_library/library/rom/src/ss_sm_rom_access.cpp b/rom_access_library/library/rom/src/ss_sm_rom_access.cpp new file mode 100644 index 00000000..5c70846f --- /dev/null +++ b/rom_access_library/library/rom/src/ss_sm_rom_access.cpp @@ -0,0 +1,969 @@ +/* + * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_SS_RomAccess +/// \brief This file supports ROM Access. +/// +/////////////////////////////////////////////////////////////////////////////// +#include "system_service/ss_sm_rom_access.h" +#include +#include +#include +#include +#include +#include + +#include +#include + +//#include +#include +#include + +#include "ss_rom_access_if_romaccesslibrarylog.h" +#include "ss_sm_checksum.h" +#include "ss_rom_access_define.h" + +#define ROM_ACCESS_DIR "/nv/romaccess" +#define ROM_ACCESS_FILE "romdata.dat" +const CHAR kDefaultRomDevice[] = ROM_ACCESS_DIR"/"ROM_ACCESS_FILE; +const CHAR kRecoveryRomDevice[] = ROM_ACCESS_DIR"/"ROM_ACCESS_FILE".old"; +static const uint8_t kMagic[] = { 0xDE, 0xAD, 0xBE, 0xEF }; + +typedef enum { + INDEX_BOOTFLAG = 0, + INDEX_ACTIVE_FLASHLOADER, + INDEX_PARTITIONS_RW_FLAG, + INDEX_LAST_USER_MODE, + INDEX_TRANSPORT_MODE, + INDEX_PRODUCTION_MODE, + INDEX_LIMP_HOME_CUT_OFF_REQUEST, + INDEX_DATARESET_MODE, + INDEX_RESET_COUNT, + INDEX_LAST_ILGRESET, + INDEX_PROGUPDATE_STATE, + INDEX_ERR_LOG_COUNT, + INDEX_NEXT_WAKEUP_TYPE, + INDEX_SIGNATURE = 15, // As far as possible, do not modify this index value!!!!! + INDEX_PROG_STATE = 20, + INDEX_PROG_STATE_END = 63, + INDEX_PRODUCT_PRIVATE, // 64 + INDEX_PRODUCT_PRIVATE_END = (INDEX_PRODUCT_PRIVATE + ROM_PRODUCT_PRIVATE_MAX + - 1), + INDEX_MAX +} eRomIndices; + +void* ROM_AccessIf::g_m_plock = NULL; +void* ROM_AccessIf::g_m_bakup_map = MAP_FAILED; +bool ROM_AccessIf::g_m_is_dram_valid = false; + +typedef struct { + char magic_in[4]; + bool is_dirty; + UI_32 data[INDEX_MAX]; + uint32_t checksum; + char magic_out[4]; +} ROM_SM_DRAM_INFO_t; + +ROM_AccessIf::ROM_AccessIf() + : m_pBoot(NULL), + m_norIsDirty(false) { + bzero(&m_nor, sizeof(m_nor)); + + if (g_m_plock == NULL) { + g_m_plock = CL_LockMap(LOCK_ROM_ACCESS_IF); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (g_m_plock == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, __FUNCTION__, + "CL_LockMap Error, please check whether you call CL_LockProcessInit"); + // LCOV_EXCL_BR_STOP + } + } + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (g_m_plock) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (0 != CL_LockGet(g_m_plock)) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + } + } +} + +ROM_AccessIf::~ROM_AccessIf() { + if (m_pBoot) { + if (m_norIsDirty) { + ROM_ACCESS_ASERT(eFrameworkunifiedStatusOK == m_pBoot->setBootInfo(&m_nor)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + delete m_pBoot; // LCOV_EXCL_BR_LINE 11:unexpected branch + m_pBoot = NULL; + } + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (g_m_plock) { + ROM_ACCESS_ASERT(0 == CL_LockRelease(g_m_plock)); + } // LCOV_EXCL_BR_STOP +} + +EFrameworkunifiedStatus ROM_AccessIf::LBA_Read(UI_32 offset, UI_32* buffer, + UI_32 word_count) { + ROM_SM_DRAM_INFO_t* p_buf; + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " g_m_bakup_map uninitialize"); + return eFrameworkunifiedStatusFail; + } + + p_buf = static_cast(g_m_bakup_map); + memcpy(buffer, &p_buf->data[offset], word_count * sizeof(UI_32)); + + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus ROM_AccessIf::LBA_Write(UI_32 offset, UI_32 value) { + UI_32 l_value = value; + return LBA_Write(offset, &l_value, sizeof(UI_32)); +} + +EFrameworkunifiedStatus ROM_AccessIf::LBA_Write(UI_32 offset, UI_32* value, UI_32 size) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + const CHAR *l_file = kDefaultRomDevice; + SI_32 fd = -1; + ROM_SM_DRAM_INFO_t* p_buf; + if (g_m_bakup_map == MAP_FAILED) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " g_m_bakup_map uninitialize"); + return eFrameworkunifiedStatusFail; + } + + p_buf = static_cast(g_m_bakup_map); + + if (memcmp(&p_buf->data[offset], value, size) == 0) { + // Not Write when the value does not change + return eFrameworkunifiedStatusOK; + } + + p_buf->is_dirty = true; + memcpy(&p_buf->data[offset], value, size); + + CSMChecksum l_checksum; + p_buf->checksum = l_checksum.cal_checksum(&(p_buf->data), // LCOV_EXCL_BR_LINE 11:unexpected branch + sizeof(p_buf->data)); // LCOV_EXCL_BR_LINE 11:unexpected branch + + if (0 != rename(kDefaultRomDevice, kRecoveryRomDevice)) { + ROM_ACCESS_ERRNO(0); + } else { + int sync_fd; + sync_fd = open(kRecoveryRomDevice, O_RDWR | O_DSYNC | O_CLOEXEC); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (sync_fd != -1) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ERRNO(0 == fsync(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ERRNO(0 == close(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_LINE 5:It's impossible to mock open() function,so this line can not be passed. + } + } + fd = open(l_file, O_CREAT | O_TRUNC | O_RDWR | O_DSYNC | O_CLOEXEC, 00664); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (fd == -1) { + ROM_ACCESS_ERRNO(0); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: open(%s) returned -1", l_file); + eStatus = eFrameworkunifiedStatusFail; + goto ERROR; + } + + /** Write the value of 32-bits at offset location */ + if (sizeof(p_buf->data) != write(fd, p_buf->data, sizeof(p_buf->data))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_START 5:It's impossible to mock write() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: write(%s) returned -1", l_file); + eStatus = eFrameworkunifiedStatusFail; + goto ERROR; + // LCOV_EXCL_STOP + } else { + ROM_ACCESS_ERRNO(0 == close(fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + fd = -1; + + if (0 != unlink(kRecoveryRomDevice)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_START 5:It's impossible to mock unlink() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + // LCOV_EXCL_STOP + } + + int sync_fd; + sync_fd = open(ROM_ACCESS_DIR, O_RDONLY); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (sync_fd != -1) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ERRNO(0 == fsync(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ERRNO(0 == close(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_LINE 5:It's impossible to mock open() function,so this line can not be passed. + } + } + p_buf->is_dirty = false; + ERROR: if (fd != -1) { // LCOV_EXCL_BR_LINE 5:It's impossible to mock open() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + close(fd); // LCOV_EXCL_LINE 5:It's impossible to mock write() function,so this line can not be passed. + } + // @todo memory value is not restored if non-volatile area writing fails after writing to memory + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetDataResetMode_sub(EDATARESET_MODE* pDataResetMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_DATARESET_MODE, + reinterpret_cast(pDataResetMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +// This function may be called in duplicate, +// so it is necessary to operate normally even if it is called in duplicate. +EFrameworkunifiedStatus ROM_AccessIf::SystemInitialize(DRAM_BACKUP_STATE bkupState) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + ROM_ACCESS_STATIC_ASERT(sizeof(ROM_SM_DRAM_INFO_t) <= SS_SYS_AREA_ROM_MAX_SIZE); + + // Checksum calculations expect 4-bytes alignments + ROM_ACCESS_STATIC_ASERT((sizeof(ROM_SM_DRAM_INFO_t) % sizeof(UI_32)) == 0); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP +// g_m_bakup_map = EL_mem_exram_mmap( +// EL_MEM_TYPE_REGION_SYS, +// EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_ROM_OFFSET, +// SS_SYS_AREA_ROM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, +// EL_MEM_CACHE_INVALID); + if (g_m_bakup_map == MAP_FAILED) { + ROM_ACCESS_ERRNO(0); + return eFrameworkunifiedStatusFail; + } + } + + if (bkupState + == DRAM_BACKUP_STATE_NG) { + // BACKUP NG + ROM_SM_DRAM_INFO_t* p_buf; + CSMChecksum l_checksum; + + p_buf = static_cast(g_m_bakup_map); + bzero(&(p_buf->magic_in), sizeof(p_buf->magic_in)); + bzero(&(p_buf->magic_out), sizeof(p_buf->magic_out)); + g_m_is_dram_valid = false; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::Initialize() { + const CHAR *l_file = kDefaultRomDevice; + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + CSMChecksum l_checksum; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (g_m_bakup_map == MAP_FAILED) { +// g_m_bakup_map = EL_mem_exram_mmap( // LCOV_EXCL_BR_LINE 11:unexpected branch +// EL_MEM_TYPE_REGION_SYS, +// EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_ROM_OFFSET, // LCOV_EXCL_BR_LINE 11:unexpected branch +// SS_SYS_AREA_ROM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, +// EL_MEM_CACHE_INVALID); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ERRNO(0); + return eFrameworkunifiedStatusFail; + } + } + if (!g_m_is_dram_valid) { + SI_32 fd = -1; + ROM_SM_DRAM_INFO_t* p_buf; + p_buf = static_cast(g_m_bakup_map); + if ((p_buf->is_dirty) + || (memcmp(kMagic, p_buf->magic_in, sizeof(kMagic)) != 0) + || (memcmp(kMagic, p_buf->magic_out, sizeof(kMagic)) != 0) + || ((l_checksum.cal_checksum(&(p_buf->data), sizeof(p_buf->data)) != p_buf->checksum))) { + // Need to synchronize the NVs with the data on the DRAM + struct stat stutInfo; + if (0 != stat(ROM_ACCESS_DIR, &stutInfo)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock stat() function,so this line can not be passed. + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s not found", ROM_ACCESS_DIR); + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ASERT(0 == mkdir(ROM_ACCESS_DIR, 0775)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + int expectSize = (INT32)(INDEX_MAX * sizeof(UI_32)); + int sigSize = (INT32)((INDEX_SIGNATURE + 1) * sizeof(UI_32)); + + if (access(kRecoveryRomDevice, F_OK) == 0) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock access() function,so this line can not be passed. + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s is found", kRecoveryRomDevice); + // LCOV_EXCL_BR_STOP + if (0 != unlink(kDefaultRomDevice)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock unlink() function,so this line can not be passed. + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error:unlink(%s)", kDefaultRomDevice); + // LCOV_EXCL_BR_STOP + } + if (0 != rename(kRecoveryRomDevice, kDefaultRomDevice)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + } + if (0 == stat(kDefaultRomDevice, &stutInfo) // LCOV_EXCL_BR_LINE 11:unexpected branch + && stutInfo.st_size >= sigSize) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // Use this value if there are more sizes than SIGNITURE + #define ROM_ACCESS_INFO_SIZE (sizeof(ROM_SM_DRAM_INFO_t) - (sizeof(UI_32)*INDEX_MAX)) + #define ROM_ACCESS_MAX_SIZE (INT32)(SS_SYS_AREA_ROM_MAX_SIZE - ROM_ACCESS_INFO_SIZE) + // Maximum size of RAM area - An upper size limit of the management info size + if (stutInfo.st_size > ROM_ACCESS_MAX_SIZE) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + stutInfo.st_size = ROM_ACCESS_MAX_SIZE; + } + fd = open(l_file, // LCOV_EXCL_BR_LINE 11:unexpected branch + O_RDWR | O_DSYNC | O_CLOEXEC); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (fd != -1) { + int ret; + if (stutInfo.st_size < expectSize) { + // If the files are large, APPEND them + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "PADDING"); + ret = ftruncate(fd, expectSize); + ROM_ACCESS_ERRNO(ret == 0); + fsync(fd); + } else if (stutInfo.st_size > expectSize) { + // If the files are small, TRANC them + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "CUT"); + ret = ftruncate(fd, expectSize); + ROM_ACCESS_ERRNO(ret == 0); + fsync(fd); + } + } + // LCOV_EXCL_BR_STOP + } else { + // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s size is not crrect", + kDefaultRomDevice); + // LCOV_EXCL_BR_STOP + fd = open(l_file, O_CREAT | O_TRUNC | O_RDWR | O_DSYNC | O_CLOEXEC, + 00664); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (fd != -1) { + UI_32 buf[INDEX_MAX]; + bzero(buf, sizeof(buf)); + ROM_ACCESS_ASERT(sizeof(buf) == write(fd, buf, sizeof(buf))) + fsync(fd); + } + // LCOV_EXCL_BR_STOP + } + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (fd != -1) { + // LCOV_EXCL_BR_STOP + UI_32 read_buf[INDEX_MAX]; + if (-1 == lseek(fd, 0, SEEK_SET)) { + // LCOV_EXCL_START 5:It's impossible to mock lseek() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + // LCOV_EXCL_STOP + } else { + if (-1 == read(fd, read_buf, sizeof(read_buf))) { + // LCOV_EXCL_START 5:It's impossible to mock read() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + // LCOV_EXCL_STOP + } else { + memcpy(p_buf->magic_in, kMagic, sizeof(kMagic)); + memcpy(&p_buf->data, read_buf, sizeof(p_buf->data)); + p_buf->checksum = l_checksum.cal_checksum(&(p_buf->data), + sizeof(p_buf->data)); + memcpy(p_buf->magic_out, kMagic, sizeof(kMagic)); + p_buf->is_dirty = false; + + // Synchronization of NV data with data on the DRAM completed + g_m_is_dram_valid = true; + } + } + close(fd); + } else { + // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:open(%s)", l_file); + // LCOV_EXCL_BR_STOP + } + } else { + // No need to synchronize NV data with data on the DRAM + g_m_is_dram_valid = true; + } + } else { + // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " alreay initialized"); + // LCOV_EXCL_BR_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetSignature(UI_32* pSigValue) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_SIGNATURE, + reinterpret_cast(pSigValue), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetSignature(UI_32 sigValue) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_SIGNATURE, + sigValue))) { + // LCOV_EXCL_BR_STOP + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(0x%X) errored: 0x%X", + sigValue, eStatus); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetBootMode(EBOOT_MODE* pBootMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_BOOTFLAG, + reinterpret_cast(pBootMode), 1))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: LBA_Read() errored: 0x%X", eStatus); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetBootMode(EBOOT_MODE bootMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_BOOTFLAG, bootMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%d) errored: 0x%X", + bootMode, eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetLastUserMode(EUSER_MODE* pUserMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LAST_USER_MODE, + reinterpret_cast(pUserMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetLastUserMode(EUSER_MODE userMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_LAST_USER_MODE, userMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + userMode == USER_OFF ? "USER_OFF" : "USER_ON", eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetTransportMode(ECONTROL_MODE* pControlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_TRANSPORT_MODE, + reinterpret_cast(pControlMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetTransportMode(ECONTROL_MODE controlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_TRANSPORT_MODE, controlMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + + +EFrameworkunifiedStatus ROM_AccessIf::GetProductionMode(ECONTROL_MODE* pControlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_PRODUCTION_MODE, + reinterpret_cast(pControlMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetProductionMode(ECONTROL_MODE controlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_PRODUCTION_MODE, controlMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetLimpHomeCutOffReqMode(ECONTROL_MODE* pControlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LIMP_HOME_CUT_OFF_REQUEST, + reinterpret_cast(pControlMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetLimpHomeCutOffReqMode(ECONTROL_MODE controlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_LIMP_HOME_CUT_OFF_REQUEST, controlMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetDataResetMode(EDATARESET_MODE* pDataResetMode) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + try { + UI_32 sts; + if (m_pBoot == NULL) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because m_pBoot can not be changed + m_pBoot = new BOOT_AccessIf(BAI_OPEN_RW); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (eFrameworkunifiedStatusOK != m_pBoot->getBootInfo(&m_nor)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw eFrameworkunifiedStatusFail; + } + } + + if ((m_nor.sts1 == m_nor.sts2) || (m_nor.sts1 == m_nor.sts3)) { + sts = m_nor.sts1; + } else if (m_nor.sts2 == m_nor.sts3) { + sts = m_nor.sts2; + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + } else { + sts = SYSUP_CND_NORMAL; + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + + if (sts == SYSUP_CND_FACTRESET) { + *pDataResetMode = DATARESET_FACTORY; + } else { + eStatus = GetDataResetMode_sub(pDataResetMode); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + } catch (const EFrameworkunifiedStatus& e) { + eStatus = e; + } catch (...) { // LCOV_EXCL_START 8:dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + eStatus = eFrameworkunifiedStatusFail; + } // LCOV_EXCL_STOP + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetDataResetModeFast(EDATARESET_MODE* pDataResetMode) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + void* p_map = MAP_FAILED; + size_t mapSize = 0; + try { + LBM_RAM_t* p_lbm = NULL; + mapSize = SS_SYS_AREA_BOOT_MAX_SIZE; + +// if (EL_mem_getLength(EL_MEM_ID_SYS_BOOT) < SS_SYS_AREA_BOOT_MAX_SIZE) { // LCOV_EXCL_BR_LINE 11:unexpected branch +// mapSize = EL_mem_getLength(EL_MEM_ID_SYS_BOOT); // LCOV_EXCL_BR_LINE 11:unexpected branch +// } + // LCOV_EXCL_BR_START 11:unexpected branch +// p_map = reinterpret_cast(EL_mem_exram_mmap(EL_MEM_TYPE_REGION_SYS, +// EL_mem_getOffset(EL_MEM_ID_SYS_BOOT), +// mapSize, PROT_READ | PROT_WRITE, +// MAP_SHARED, EL_MEM_CACHE_INVALID)); + // LCOV_EXCL_BR_STOP + if (p_map == MAP_FAILED) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed + throw eFrameworkunifiedStatusFail; + } + p_lbm = static_cast(p_map); + if (p_lbm->sts == SYSUP_CND_FACTRESET) { + *pDataResetMode = DATARESET_FACTORY; + } else { + eStatus = GetDataResetMode_sub(pDataResetMode); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + } catch (const EFrameworkunifiedStatus& e) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + eStatus = e; + } catch (...) { // LCOV_EXCL_START 8:dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); + eStatus = eFrameworkunifiedStatusFail; + } // LCOV_EXCL_STOP + + if (p_map != MAP_FAILED) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed +// ROM_ACCESS_ERRNO(0 == EL_mem_exram_munmap(p_map, // LCOV_EXCL_BR_LINE 11:unexpected branch +// mapSize)); + } + return eStatus; // LCOV_EXCL_BR_LINE 11:unexpected branch +} + +EFrameworkunifiedStatus ROM_AccessIf::SetDataResetMode(EDATARESET_MODE dataResetMode) { + EFrameworkunifiedStatus eStatus; + EDATARESET_MODE l_mode = dataResetMode; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + try { + if (m_pBoot == NULL) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because m_pBoot can not be changed + // LCOV_EXCL_BR_START 11:unexpected branch + m_pBoot = new BOOT_AccessIf(BAI_OPEN_RW); + // LCOV_EXCL_BR_STOP + if (eFrameworkunifiedStatusOK != m_pBoot->getBootInfo(&m_nor)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw eFrameworkunifiedStatusFail; + } + } + m_norIsDirty = true; + if (dataResetMode == DATARESET_FACTORY) { + m_nor.sts1 = m_nor.sts2 = m_nor.sts3 = SYSUP_CND_FACTRESET; + l_mode = DATARESET_NONE; + } else { + m_nor.sts1 = m_nor.sts2 = m_nor.sts3 = SYSUP_CND_NORMAL; + } + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_DATARESET_MODE, l_mode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", + eStatus); + // LCOV_EXCL_STOP + } + } catch (const EFrameworkunifiedStatus& e) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + eStatus = e; + } catch (...) { // LCOV_EXCL_START 8:dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); + eStatus = eFrameworkunifiedStatusFail; + } // LCOV_EXCL_STOP + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetResetCount(UI_32* pResetCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_RESET_COUNT, reinterpret_cast(pResetCount), + 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} +EFrameworkunifiedStatus ROM_AccessIf::SetResetCount(UI_32 resetCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (eFrameworkunifiedStatusOK != (eStatus = // LCOV_EXCL_BR_LINE 11:unexpected branch + LBA_Write(INDEX_RESET_COUNT, resetCount))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} +EFrameworkunifiedStatus ROM_AccessIf::GetLastIlgReset(ELASTILGRESET_MODE* pLastIlgReset) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LAST_ILGRESET, + reinterpret_cast(pLastIlgReset), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetLastIlgReset(ELASTILGRESET_MODE lastIlgReset) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_LAST_ILGRESET, lastIlgReset))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetProgUpdateState( + EPROGUPDATE_STATE* pProgUpdateState) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_PROGUPDATE_STATE, + reinterpret_cast(pProgUpdateState), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetProgUpdateState(EPROGUPDATE_STATE progUpdateState) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_PROGUPDATE_STATE, progUpdateState))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetErrLogCount(UI_32* pErrLogCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_ERR_LOG_COUNT, + reinterpret_cast(pErrLogCount), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetErrLogCount(UI_32 errLogCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (eFrameworkunifiedStatusOK != (eStatus = // LCOV_EXCL_BR_LINE 11:unexpected branch + LBA_Write(INDEX_ERR_LOG_COUNT, errLogCount))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetNextWakeupType(ENEXT_WAKEUP_TYPE *pNextWakeupType) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_NEXT_WAKEUP_TYPE, + reinterpret_cast(pNextWakeupType), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetNextWakeupType(ENEXT_WAKEUP_TYPE nextWakeupType) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_NEXT_WAKEUP_TYPE, nextWakeupType))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Write() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetActiveFlashloader( + EACTIVE_FLASHLOADER activeFlashloader) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_ACTIVE_FLASHLOADER, activeFlashloader))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, + __FUNCTION__, + " Error: LBA_Write(%s) errored: 0x%X", + activeFlashloader == NEW_FLASHLOADER ? + "NEW_FLASHLOADER" : "OLD_FLASHLOADER", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_PRODUCT_PRIVATE, reinterpret_cast(buf), + ROM_PRODUCT_PRIVATE_MAX / sizeof(UI_32)))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Read(INDEX_PRODUCT_PRIVATE, reinterpret_cast(buf), + ROM_PRODUCT_PRIVATE_MAX / sizeof(UI_32)))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Read() errored: 0x%X", eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return eStatus; +} diff --git a/system_service.mk b/system_service.mk new file mode 100644 index 00000000..a8a06b06 --- /dev/null +++ b/system_service.mk @@ -0,0 +1,44 @@ +############################################################# +# +# Common Makefile for system_service +# Copyright (C) 2017-2019 TOYOTA MOTOR CORPORATION +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# +############################################################# + +CURRENT_DIR := $(dir $(lastword $(MAKEFILE_LIST))) + +############################################################# +# COMPONENT_NAME must not be blank and be named snake_case + +COMPONENT_NAME := system_service + +############################################################# + + + +############################################################# +# You can add several flags and libraries. +# When you add -I or -L path, DO NOT USE relative path. +# Instead, use $(CURRENT_DIR) variable +# that indicates the path this .mk file is stored. + +COMPONENT_CFLAGS := +COMPONENT_CXXFLAGS := +COMPONENT_LDLIBS := +COMPONENT_LDFLAGS := + +############################################################## + +include $(SDKTARGETSYSROOT)/usr/agl/share/agl.mk -- cgit 1.2.3-korg