| /* |
| * SPDX-FileCopyrightText: Copyright (c) 2023-2024 NVIDIA CORPORATION & |
| * AFFILIATES. All rights reserved. SPDX-License-Identifier: Apache-2.0 |
| * |
| * 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 DIAGNOSTICS_H |
| #define DIAGNOSTICS_H |
| |
| #ifdef __cplusplus |
| extern "C" { |
| #endif |
| |
| #include "base.h" |
| |
| typedef uint8_t enum8; |
| |
| enum diagnostics_command { |
| NSM_GET_DEVICE_RESET_STATISTICS = 0x00, |
| NSM_GET_DEVICE_DIAGNOSTICS = 0x40, |
| NSM_GET_NETWORK_DEVICE_DEBUG_INFO = 0x50, |
| NSM_ERASE_TRACE = 0x51, |
| NSM_GET_NETWORK_DEVICE_LOG_INFO = 0x52, |
| NSM_RESET_NETWORK_DEVICE = 0x53, |
| NSM_ERASE_DEBUG_INFO = 0x59, |
| NSM_ENABLE_DISABLE_WP = 0x65 |
| }; |
| |
| enum diagnostics_enable_disable_wp_data_index { |
| RETIMER_EEPROM = 128, |
| BASEBOARD_FRU_EEPROM = 129, |
| PEX_SW_EEPROM = 130, |
| NVSW_EEPROM_BOTH = 131, |
| NVSW_EEPROM_1 = 133, |
| NVSW_EEPROM_2 = 134, |
| GPU_1_4_SPI_FLASH = 160, |
| GPU_5_8_SPI_FLASH = 161, |
| GPU_SPI_FLASH_1 = 162, |
| GPU_SPI_FLASH_2 = 163, |
| GPU_SPI_FLASH_3 = 164, |
| GPU_SPI_FLASH_4 = 165, |
| GPU_SPI_FLASH_5 = 166, |
| GPU_SPI_FLASH_6 = 167, |
| GPU_SPI_FLASH_7 = 168, |
| GPU_SPI_FLASH_8 = 169, |
| GPU_SPI_FLASH = 170, |
| HMC_SPI_FLASH = 176, |
| CX8_SPI_FLASH = 183, |
| RETIMER_EEPROM_1 = 192, |
| RETIMER_EEPROM_2 = 193, |
| RETIMER_EEPROM_3 = 194, |
| RETIMER_EEPROM_4 = 195, |
| RETIMER_EEPROM_5 = 196, |
| RETIMER_EEPROM_6 = 197, |
| RETIMER_EEPROM_7 = 198, |
| RETIMER_EEPROM_8 = 199, |
| CPU_SPI_FLASH_1 = 224, |
| CPU_SPI_FLASH_2 = 225, |
| CPU_SPI_FLASH_3 = 226, |
| CPU_SPI_FLASH_4 = 227, |
| CPU_SPI_FLASH_5 = 228, |
| CPU_SPI_FLASH_6 = 229, |
| CPU_SPI_FLASH_7 = 230, |
| CPU_SPI_FLASH_8 = 231, |
| CX7_FRU_EEPROM = 232, |
| HMC_FRU_EEPROM = 233, |
| }; |
| |
| /** @brief Modes allowed on reset network device cmd |
| */ |
| enum reset_network_device_mode { |
| START_AFTER_RESPONSE = 0, |
| ALL_HOST_PERST_LOW = 1, |
| ALL_HOST_PCIE_LINK_DISABLE = 2, |
| ALLOWED_BY_ALL_HOST = 3 |
| }; |
| |
| enum nsm_debug_information_type { |
| INFO_TYPE_DEVICE_INFO = 0, |
| INFO_TYPE_FW_RUNTIME_INFO = 1, |
| INFO_TYPE_FW_SAVED_INFO = 2, |
| INFO_TYPE_DEVICE_DUMP = 3 |
| }; |
| |
| enum nsm_erase_information_type { INFO_TYPE_FW_SAVED_DUMP_INFO = 0 }; |
| |
| /** @struct nsm_get_device_diagnostics_req |
| * |
| * Structure representing NSM get device diagnostics request. |
| */ |
| struct nsm_get_device_diagnostics_req { |
| struct nsm_common_req hdr; |
| uint8_t segment_id; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_get_device_diagnostics_resp |
| * |
| * Structure representing NSM get device diagnostics response. |
| */ |
| struct nsm_get_device_diagnostics_resp { |
| struct nsm_common_resp hdr; |
| uint8_t next_segment_id; |
| uint8_t segment_data[1]; |
| } __attribute__((packed)); |
| |
| enum nsm_erase_trace_status { |
| ERASE_TRACE_NO_DATA_ERASED = 0, |
| ERASE_TRACE_DATA_ERASED = 1, |
| ERASE_TRACE_DATA_ERASE_INPROGRESS = 2 |
| }; |
| |
| enum nsm_log_info_time_synced { |
| SYNCED_TIME_TYPE_BOOT = 0, |
| SYNCED_TIME_TYPE_SYNCED = 1 |
| }; |
| |
| /** @struct nsm_reset_network_device_req |
| * |
| * Structure representing NSM reset network device request. |
| */ |
| struct nsm_reset_network_device_req { |
| struct nsm_common_req hdr; |
| uint8_t mode; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_reset_network_device_resp |
| * |
| * Structure representing NSM reset network device response. |
| */ |
| typedef struct nsm_common_resp nsm_reset_network_device_resp; |
| |
| /** @struct nsm_enable_disable_wp_req |
| * |
| * Structure representing Diagnostics Enable/Disable WP request. |
| */ |
| struct nsm_enable_disable_wp_req { |
| struct nsm_common_req hdr; |
| uint8_t data_index; |
| uint8_t value; // 0 - disable, 1 - enable |
| } __attribute__((packed)); |
| |
| /** @struct nsm_get_network_device_debug_info_req |
| * |
| * Structure representing NSM get network device debug info request. |
| */ |
| struct nsm_get_network_device_debug_info_req { |
| struct nsm_common_req hdr; |
| uint8_t debug_info_type; |
| uint8_t reserved; |
| uint32_t record_handle; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_get_network_device_debug_info_resp |
| * |
| * Structure representing NSM get network device debug info response. |
| */ |
| struct nsm_get_network_device_debug_info_resp { |
| struct nsm_common_resp hdr; |
| uint32_t next_record_handle; |
| uint8_t segment_data[1]; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_erase_trace_req |
| * |
| * Structure representing NSM Erase trace request. |
| */ |
| struct nsm_erase_trace_req { |
| struct nsm_common_req hdr; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_erase_trace_resp |
| * |
| * Structure representing NSM Erase trace response. |
| */ |
| struct nsm_erase_trace_resp { |
| struct nsm_common_resp hdr; |
| uint8_t result_status; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_get_network_device_log_info_req |
| * |
| * Structure representing NSM get network device log info request. |
| */ |
| struct nsm_get_network_device_log_info_req { |
| struct nsm_common_req hdr; |
| uint32_t record_handle; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_get_network_device_debug_info_resp |
| * |
| * Structure representing NSM get network device log info response. |
| */ |
| |
| // TODO: Spec specifies 2 fields with NVU24 data type which is not supported as |
| // per spec, but with our understand it is NVU32 type which combines 2 fields |
| // one NVU24 and one NVU8. Have raised question on spec once we get confirmation |
| // we might have to update, and if things are as per our understanding then no |
| // change required. JIRA: https://jirasw.nvidia.com/browse/DGXOPENBMC-13373 |
| struct nsm_device_log_info_breakdown { |
| uint8_t lost_events : 4; |
| uint8_t unused : 3; |
| uint8_t synced_time : 1; |
| |
| uint8_t reserved1; |
| uint16_t reserved2; |
| |
| uint32_t time_low; |
| uint32_t time_high; |
| |
| uint32_t entry_prefix : 24; |
| uint32_t length : 8; |
| |
| uint64_t entry_suffix; |
| } __attribute__((packed)); |
| |
| struct nsm_device_log_info { |
| uint8_t lost_events_and_synced_time; |
| uint8_t reserved1; |
| uint16_t reserved2; |
| uint32_t time_low; |
| uint32_t time_high; |
| uint32_t entry_prefix_and_length; |
| uint64_t entry_suffix; |
| } __attribute__((packed)); |
| |
| struct nsm_get_network_device_log_info_resp { |
| struct nsm_common_resp hdr; |
| uint32_t next_record_handle; |
| struct nsm_device_log_info log_info; |
| uint8_t log_data[1]; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_erase_debug_info_req |
| * |
| * Structure representing NSM Erase debug info request. |
| */ |
| struct nsm_erase_debug_info_req { |
| struct nsm_common_req hdr; |
| uint8_t debug_info_type; |
| uint8_t reserved; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_erase_debug_info_resp |
| * |
| * Structure representing NSM Erase debug info response. |
| */ |
| struct nsm_erase_debug_info_resp { |
| struct nsm_common_resp hdr; |
| uint8_t result_status; |
| uint8_t reserved; |
| } __attribute__((packed)); |
| |
| /** @struct nsm_boot_reason_type_breakdown |
| * |
| * Structure representing NSM Boot Reason Type breakdown. |
| */ |
| struct nsm_boot_reason_type_breakdown { |
| uint64_t wake_up : 1; |
| uint64_t power_on : 1; |
| uint64_t voltage_detect : 1; |
| uint64_t reserved3 : 1; |
| uint64_t warm_reset : 1; |
| uint64_t fatal_error : 1; |
| uint64_t reserved6 : 1; |
| uint64_t reserved7 : 1; |
| uint64_t pin : 1; |
| uint64_t debug_access_port : 1; |
| uint64_t reset_timeout : 1; |
| uint64_t low_power_acknowledge_timeout : 1; |
| uint64_t system_clock_generator : 1; |
| uint64_t windowed_watchdog_0 : 1; |
| uint64_t software : 1; |
| uint64_t lockup_reset : 1; |
| uint64_t cpu1 : 1; |
| uint64_t reserved17to23 : 7; |
| uint64_t vbat : 1; |
| uint64_t windowed_watchdog_1 : 1; |
| uint64_t code_watchdog_0 : 1; |
| uint64_t code_watchdog_1 : 1; |
| uint64_t jtag : 1; |
| uint64_t reserved29 : 1; |
| uint64_t security_violation : 1; |
| uint64_t tamper : 1; |
| uint64_t iaccviol : 1; |
| uint64_t daccviol : 1; |
| uint64_t reserved34 : 1; |
| uint64_t munstkerr : 1; |
| uint64_t mstkerr : 1; |
| uint64_t reserved37to38 : 2; |
| uint64_t mmfarvalid : 1; |
| uint64_t bfarvalid : 1; |
| uint64_t reserved41to42 : 2; |
| uint64_t stkerr : 1; |
| uint64_t unstkerr : 1; |
| uint64_t imprecise_error : 1; |
| uint64_t precise_error : 1; |
| uint64_t ibuserr : 1; |
| uint64_t undefinstr : 1; |
| uint64_t invstate : 1; |
| uint64_t invpc : 1; |
| uint64_t nocp : 1; |
| uint64_t reserved52to55 : 4; |
| uint64_t unaligned : 1; |
| uint64_t devbyzero : 1; |
| uint64_t reserved58to64 : 7; |
| uint64_t vecttbl : 1; |
| uint64_t reserved66to93 : 28; |
| uint64_t forced : 1; |
| uint64_t debugevt : 1; |
| uint64_t mctp : 1; |
| uint64_t i2c : 1; |
| uint64_t i3c : 1; |
| uint64_t pldm : 1; |
| uint64_t usb : 1; |
| uint64_t flash : 1; |
| uint64_t logger : 1; |
| uint64_t spdm : 1; |
| uint64_t reserved104to127 : 24; |
| uint64_t reserved128to191 : 64; |
| uint64_t reserved192to255 : 64; |
| } __attribute__((packed)); |
| |
| /** @brief Encode a Get device diagnostics request message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] segment_id - segment ID |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_get_device_diagnostics_req(uint8_t instance_id, uint8_t segment_id, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Get device diagnostics request message |
| * |
| * @param[in] msg - request message |
| * @param[in] msg_len - Length of request message |
| * @param[out] segment_id - segment ID |
| * @return nsm_completion_codes |
| */ |
| int decode_get_device_diagnostics_req(const struct nsm_msg *msg, size_t msg_len, |
| uint8_t *segment_id); |
| |
| /** @brief Encode a Get device diagnostics response message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] cc - pointer to response message completion code |
| * @param[in] reason_code - NSM reason code |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_get_device_diagnostics_resp(uint8_t instance_id, uint8_t cc, |
| uint16_t reason_code, |
| const uint8_t *seg_data, |
| const uint16_t seg_data_size, |
| const uint8_t next_segment_id, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Get device diagnostics response message |
| * |
| * @param[in] msg - response message |
| * @param[in] msg_len - Length of response message |
| * @param[out] cc - pointer to response message completion code |
| * @param[out] reason_code - NSM reason code |
| * @param[out] seg_data - segment data |
| * @param[out] seg_data_size - segment data size |
| * @param[out] next_segment_id - next segment ID |
| * @return nsm_completion_codes |
| */ |
| int decode_get_device_diagnostics_resp(const struct nsm_msg *msg, |
| size_t msg_len, uint8_t *cc, |
| uint16_t *reason_code, uint8_t *seg_data, |
| uint16_t *seg_data_size, |
| uint8_t *next_segment_id); |
| |
| /** |
| * @brief Encode a request message for the Get Device Reset Statistics command. |
| * |
| * This function encodes the request for the Get Device Reset Statistics |
| * command, which retrieves statistics related to device resets. The request |
| * message consists of only the header and does not require additional payload. |
| * |
| * @param[in] instance_id - NSM instance ID to specify the target instance. |
| * @param[out] msg - Pointer to the message buffer where the encoded request |
| * will be stored. |
| * |
| * @return nsm_completion_codes - Returns NSM_SW_SUCCESS on success, or an error |
| * code (e.g., NSM_SW_ERROR_NULL, NSM_SW_ERROR_DATA) on failure. |
| */ |
| int encode_get_device_reset_statistics_req(uint8_t instance_id, |
| struct nsm_msg *msg); |
| |
| /** @brief Encode a Diagnostics Enable/Disable WP request message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] data_index - data index |
| * @param[in] value - Enable/Disable value |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_enable_disable_wp_req( |
| uint8_t instance_id, |
| enum diagnostics_enable_disable_wp_data_index data_index, uint8_t value, |
| struct nsm_msg *msg); |
| |
| /** @brief Encode Reset network device request message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] mode - Mode |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_reset_network_device_req(uint8_t instance_id, uint8_t mode, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode Reset network device request message |
| * |
| * @param[in] msg - request message |
| * @param[in] msg_len - Length of request message |
| * @param[out] mode - Mode |
| * @return nsm_completion_codes |
| */ |
| int decode_reset_network_device_req(const struct nsm_msg *msg, size_t msg_len, |
| uint8_t *mode); |
| |
| /** @brief Encode a NSM Reset network device response message |
| * |
| * @param[in] cc - NSM Completion Code |
| * @param[in] reason_code - Reason Code |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_reset_network_device_resp(uint8_t instance, uint16_t reason_code, |
| struct nsm_msg *req); |
| |
| /** @brief Decode a NSM Reset network device response message |
| * |
| * @param[in] resp - Response message |
| * @param[in] respLen - Length of response message |
| * @param[out] cc - Completion Code |
| * @param[out] reason_code - Reason Code |
| * @return nsm_completion_codes |
| */ |
| int decode_reset_network_device_resp(const struct nsm_msg *msg, size_t msgLen, |
| uint8_t *cc, uint16_t *reason_code); |
| |
| /** @brief Decode a Diagnostics Enable/Disable WP request message |
| * |
| * @param[in] msg - request message |
| * @param[in] msg_len - Length of request message |
| * @param[out] data_index - data index |
| * @param[out] value - Enable/Disable value |
| * @return nsm_completion_codes |
| */ |
| int decode_enable_disable_wp_req( |
| const struct nsm_msg *msg, size_t msg_len, |
| enum diagnostics_enable_disable_wp_data_index *data_index, uint8_t *value); |
| |
| /** @brief Encode a Diagnostics Enable/Disable WP response message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] cc - pointer to response message completion code |
| * @param[in] reason_code - NSM reason code |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_enable_disable_wp_resp(uint8_t instance_id, uint8_t cc, |
| uint16_t reason_code, struct nsm_msg *msg); |
| |
| /** @brief Decode a Diagnostics Enable/Disable WP response message |
| * |
| * @param[in] msg - response message |
| * @param[in] msg_len - Length of response message |
| * @param[out] cc - pointer to response message completion code |
| * @return nsm_completion_codes |
| */ |
| int decode_enable_disable_wp_resp(const struct nsm_msg *msg, size_t msg_len, |
| uint8_t *cc, uint16_t *reason_code); |
| |
| /** @brief Encode a Get network device debug info request message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] debug_type - debug information type to fetch |
| * @param[in] handle - record handle |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_get_network_device_debug_info_req(uint8_t instance_id, |
| uint8_t debug_type, |
| uint32_t handle, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Get network device debug info request message |
| * |
| * @param[in] msg - request message |
| * @param[in] msg_len - Length of request message |
| * @param[in] debug_type - debug information type to fetch |
| * @param[in] handle - record handle |
| * @return nsm_completion_codes |
| */ |
| int decode_get_network_device_debug_info_req(const struct nsm_msg *msg, |
| size_t msg_len, |
| uint8_t *debug_type, |
| uint32_t *handle); |
| |
| /** @brief Encode a Get network device debug info response message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] cc - pointer to response message completion code |
| * @param[in] reason_code - NSM reason code |
| * @param[in] seg_data - network device debug info segment |
| * @param[in] seg_data_size - segment size in bytes |
| * @param[in] next_handle - next record handle |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_get_network_device_debug_info_resp(uint8_t instance_id, uint8_t cc, |
| uint16_t reason_code, |
| const uint8_t *seg_data, |
| const uint16_t seg_data_size, |
| const uint32_t next_handle, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Get network device debug info response message |
| * |
| * @param[in] msg - response message |
| * @param[in] msg_len - Length of response message |
| * @param[out] cc - pointer to response message completion code |
| * @param[out] reason_code - pointer to reason code |
| * @param[out] seg_data - data size in bytes |
| * @param[out] seg_data_size - network device debug info segement data |
| * @param[out] next_handle - next record handle |
| * @return nsm_completion_codes |
| */ |
| int decode_get_network_device_debug_info_resp(const struct nsm_msg *msg, |
| size_t msg_len, uint8_t *cc, |
| uint16_t *reason_code, |
| uint16_t *seg_data_size, |
| uint8_t *seg_data, |
| uint32_t *next_handle); |
| |
| /** @brief Encode a Erase Trace request message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_erase_trace_req(uint8_t instance_id, struct nsm_msg *msg); |
| |
| /** @brief Decode a Erase Trace request message |
| * |
| * @param[in] msg - request message |
| * @param[in] msg_len - Length of request message |
| * @return nsm_completion_codes |
| */ |
| int decode_erase_trace_req(const struct nsm_msg *msg, size_t msg_len); |
| |
| /** @brief Encode a Erase Trace response message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] cc - pointer to response message completion code |
| * @param[in] reason_code - NSM reason code |
| * @param[in] result_status - erase trace result status |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_erase_trace_resp(uint8_t instance_id, uint8_t cc, |
| uint16_t reason_code, uint8_t result_status, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Erase Trace response message |
| * |
| * @param[in] msg - response message |
| * @param[in] msg_len - Length of response message |
| * @param[out] cc - pointer to response message completion code |
| * @param[out] reason_code - pointer to reason code |
| * @param[out] result_status - erase trace result status |
| * @return nsm_completion_codes |
| */ |
| int decode_erase_trace_resp(const struct nsm_msg *msg, size_t msg_len, |
| uint8_t *cc, uint16_t *reason_code, |
| uint8_t *result_status); |
| |
| /** @brief Encode a Get network device log info request message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] record_handle - record handle |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_get_network_device_log_info_req(uint8_t instance_id, |
| uint32_t record_handle, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Get network device log info request message |
| * |
| * @param[in] msg - request message |
| * @param[in] msg_len - Length of request message |
| * @param[out] record_handle - record handle |
| * @return nsm_completion_codes |
| */ |
| int decode_get_network_device_log_info_req(const struct nsm_msg *msg, |
| size_t msg_len, |
| uint32_t *record_handle); |
| |
| /** @brief Encode a Get network device logs info response message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] cc - pointer to response message completion code |
| * @param[in] reason_code - NSM reason code |
| * @param[in] seg_data - network device debug info segment |
| * @param[in] seg_data_size - segment size in bytes |
| * @param[in] next_handle - next record handle |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_get_network_device_log_info_resp( |
| uint8_t instance_id, uint8_t cc, uint16_t reason_code, |
| const uint32_t next_handle, struct nsm_device_log_info_breakdown log_info, |
| const uint8_t *log_data, const uint16_t log_data_size, struct nsm_msg *msg); |
| |
| /** @brief Decode a Get network device logs info response message |
| * |
| * @param[in] msg - response message |
| * @param[in] msg_len - Length of response message |
| * @param[out] cc - pointer to response message completion code |
| * @param[out] reason_code - pointer to reason code |
| * @param[out] seg_data - data size in bytes |
| * @param[out] seg_data_size - network device debug info segement data |
| * @param[out] next_handle - next record handle |
| * @return nsm_completion_codes |
| */ |
| int decode_get_network_device_log_info_resp( |
| const struct nsm_msg *msg, size_t msg_len, uint8_t *cc, |
| uint16_t *reason_code, uint32_t *next_handle, |
| struct nsm_device_log_info_breakdown *log_info, uint8_t *log_data, |
| uint16_t *log_data_size); |
| |
| /** @brief Encode a Erase Debug Info request message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] info_type - Information type to erase |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_erase_debug_info_req(uint8_t instance_id, uint8_t info_type, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Erase Debug Info request message |
| * |
| * @param[in] msg - request message |
| * @param[in] msg_len - Length of request message |
| * @param[out] info_type - Information type to erase |
| * @return nsm_completion_codes |
| */ |
| int decode_erase_debug_info_req(const struct nsm_msg *msg, size_t msg_len, |
| uint8_t *info_type); |
| |
| /** @brief Encode a Erase Debug Info response message |
| * |
| * @param[in] instance_id - NSM instance ID |
| * @param[in] cc - pointer to response message completion code |
| * @param[in] reason_code - NSM reason code |
| * @param[in] result_status - erase trace result status |
| * @param[out] msg - Message will be written to this |
| * @return nsm_completion_codes |
| */ |
| int encode_erase_debug_info_resp(uint8_t instance_id, uint8_t cc, |
| uint16_t reason_code, uint8_t result_status, |
| struct nsm_msg *msg); |
| |
| /** @brief Decode a Erase Debug Info response message |
| * |
| * @param[in] msg - response message |
| * @param[in] msg_len - Length of response message |
| * @param[out] cc - pointer to response message completion code |
| * @param[out] reason_code - pointer to reason code |
| * @param[out] result_status - erase trace result status |
| * @return nsm_completion_codes |
| */ |
| int decode_erase_debug_info_resp(const struct nsm_msg *msg, size_t msg_len, |
| uint8_t *cc, uint16_t *reason_code, |
| uint8_t *result_status); |
| |
| /** |
| * @brief Encodes a reset type enumeration into a byte array. |
| * |
| * @param[in] resetType - Reset type as uint8_t. |
| * @param[out] data - Encoded byte array. |
| * @param[out] data_len - Length of the encoded data. |
| * |
| * @return NSM_SW_SUCCESS on success, or appropriate error code. |
| */ |
| int encode_reset_enum_data(uint8_t resetType, uint8_t *data, size_t *data_len); |
| |
| /** |
| * @brief Decodes a reset type enumeration from a byte array. |
| * |
| * @param[in] data - Encoded byte array. |
| * @param[in] data_len - Length of the encoded data. |
| * @param[out] resetType - Decoded reset type as uint8_t. |
| * |
| * @return NSM_SW_SUCCESS on success, or appropriate error code. |
| */ |
| int decode_reset_enum_data(const uint8_t *data, size_t data_len, |
| uint8_t *resetType); |
| |
| /** |
| * @brief Encodes a reset count (e.g., ResetEntryCount) into a byte array. |
| * |
| * @param[in] count - Reset count as uint16_t. |
| * @param[out] data - Encoded byte array. |
| * @param[out] data_len - Length of the encoded data. |
| * |
| * @return NSM_SW_SUCCESS on success, or appropriate error code. |
| */ |
| int encode_reset_count_data(uint16_t count, uint8_t *data, size_t *data_len); |
| |
| /** |
| * @brief Decodes a reset count (e.g., ResetEntryCount) from a byte array. |
| * |
| * @param[in] data - Encoded byte array. |
| * @param[in] data_len - Length of the encoded data. |
| * @param[out] count - Decoded reset count as uint16_t. |
| * |
| * @return NSM_SW_SUCCESS on success, or appropriate error code. |
| */ |
| int decode_reset_count_data(const uint8_t *data, size_t data_len, |
| uint16_t *count); |
| |
| /** |
| * @brief Encodes a uint64 reset count into a byte array. |
| * |
| * @param[in] count - Reset count as uint64_t array. |
| * @param[out] data - Encoded byte array. |
| * @param[out] data_len - Length of the encoded data. |
| * |
| * @return NSM_SW_SUCCESS on success, or appropriate error code. |
| */ |
| int encode_reset_count_256data(const uint64_t *count, uint8_t *data, |
| size_t *data_len); |
| |
| /** |
| * @brief Decodes a uint64 reset count from a byte array. |
| * |
| * @param[in] data - Encoded byte array. |
| * @param[in] data_len - Length of the encoded data. |
| * @param[out] count - Decoded reset count as uint64_t. |
| * @param[in] count_len - Length of the decoded count. |
| * |
| * @return NSM_SW_SUCCESS on success, or appropriate error code. |
| */ |
| int decode_reset_count_256data(const uint8_t *data, size_t data_len, |
| uint64_t *count, size_t count_len); |
| |
| /** |
| * @brief Decodes a "Get Device Reset Statistics" request message. |
| * |
| * Validates the message structure and ensures it adheres to the expected |
| * format. |
| * |
| * @param[in] msg - Pointer to the NSM message structure. |
| * @param[in] msg_len - Length of the NSM message. |
| * |
| * @return NSM_SW_SUCCESS on successful decoding. |
| * NSM_SW_ERROR_NULL if the msg pointer is null. |
| * NSM_SW_ERROR_LENGTH if the message length is invalid. |
| * NSM_SW_ERROR_DATA if the data size in the message is unexpected. |
| */ |
| int decode_get_device_reset_statistics_req(const struct nsm_msg *msg, |
| size_t msg_len); |
| |
| #ifdef __cplusplus |
| } |
| #endif |
| #endif |
