From 644100b3146ac05355ba396ca82d74938f0219c6 Mon Sep 17 00:00:00 2001 From: Cristian Marussi Date: Thu, 4 Aug 2022 00:02:30 +0100 Subject: [PATCH 1/5] Add missing SCMI v3.1 command definitions Many testcases covers the scenario in which invalid SCMI command IDs are used: these are generally defined as one-off the last valid known command ID; now that SCMIv3.1 spec is published all valid v3.1. commands, for all the protocols supported by this suite, should be enumerated properly to avoid using by mistake a valid command ID as an invalid one in case the SCMI backend server under test already supported it. Signed-off-by: Cristian Marussi --- val/include/val_interface.h | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/val/include/val_interface.h b/val/include/val_interface.h index 29c2842..48d743d 100644 --- a/val/include/val_interface.h +++ b/val/include/val_interface.h @@ -192,6 +192,7 @@ typedef enum { POWER_STATE_GET, POWER_STATE_NOTIFY, POWER_STATE_CHANGE_REQUESTED_NOTIFY, + POWER_STATE_DOMAIN_NAME_GET, POWER_PROTOCOL_INVALID_COMMAND } POWER_DOMAIN_COMMANDS; @@ -264,6 +265,7 @@ typedef enum { PERFORMANCE_NOTIFY_LIMITS, PERFORMANCE_NOTIFY_LEVEL, PERFORMANCE_DESCRIBE_FASTCHANNEL, + PERFORMANCE_DOMAIN_NAME_GET, PERFORMANCE_INVALID_COMMAND } PERFORMANCE_COMMANDS; @@ -304,6 +306,9 @@ typedef enum { CLOCK_RATE_SET, CLOCK_RATE_GET, CLOCK_CONFIG_SET, + CLOCK_NAME_GET, + CLOCK_RATE_NOTIFY, + CLOCK_RATE_CHANGE_REQUESTED_NOTIFY, CLOCK_INVALID_COMMAND } CLOCK_COMMANDS; @@ -342,6 +347,8 @@ typedef enum { SENSOR_CONFIG_GET, SENSOR_CONFIG_SET, SENSOR_CONTINUOUS_UPDATE_NOTIFY, + SENSOR_NAME_GET, + SENSOR_AXIS_NAME_GET, SENSOR_INVALID_COMMAND, } SENSOR_COMMANDS; @@ -388,6 +395,7 @@ typedef enum { RESET_DOMAIN_ATTRIBUTES, RESET_PROTOCOL_RESET, RESET_PROTOCOL_NOTIFY, + RESET_DOMAIN_NAME_GET, RESET_INVALID_COMMAND } RESET_COMMANDS; @@ -421,6 +429,7 @@ typedef enum { VOLTAGE_CONFIG_GET, VOLTAGE_LEVEL_SET, VOLTAGE_LEVEL_GET, + VOLTAGE_DOMAIN_NAME_GET, VOLTAGE_INVALID_COMMAND } VOLTAGE_COMMANDS; -- GitLab From b2e6c192befc4c262a44fcfee1a6dc18d77f0a61 Mon Sep 17 00:00:00 2001 From: Cristian Marussi Date: Fri, 8 Jul 2022 17:24:26 +0100 Subject: [PATCH 2/5] Save obtained protocol list before possibly bailing out When querying number of supported protocols and number of agents supported by the backend SCMI server under test take care to save such information before any comparison is made against the expected values for the specific target at hand. This will allow us to possibly define a new target platform with relaxed expectations and just proceed to test any supported protocols it is found. Signed-off-by: Cristian Marussi --- test_pool/base/test_b002.c | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/test_pool/base/test_b002.c b/test_pool/base/test_b002.c index c224da1..2418b6d 100644 --- a/test_pool/base/test_b002.c +++ b/test_pool/base/test_b002.c @@ -57,18 +57,17 @@ uint32_t base_query_protocol_attributes(void) return VAL_STATUS_FAIL; num_agents = VAL_EXTRACT_BITS(attributes, 8, 15); - if (val_compare("NUM AGENTS", num_agents, val_base_get_expected_num_agents())) - return VAL_STATUS_FAIL; + /* Save the number of agents */ + val_base_save_info(BASE_NUM_AGENTS, VAL_EXTRACT_BITS(attributes, 8, 15)); num_protocols = VAL_EXTRACT_BITS(attributes, 0, 7); + /* Save the protocols implemented */ + val_base_save_info(BASE_NUM_PROTOCOLS, VAL_EXTRACT_BITS(attributes, 0, 7)); + + if (val_compare("NUM AGENTS", num_agents, val_base_get_expected_num_agents())) + return VAL_STATUS_FAIL; if (val_compare("NUM PROTOCOLS", num_protocols, val_base_get_expected_num_protocols())) return VAL_STATUS_FAIL; - /* Save the number of agents */ - val_base_save_info(BASE_NUM_AGENTS, VAL_EXTRACT_BITS(attributes, 8, 15)); - - /* Save the protocols implemented */ - val_base_save_info(BASE_NUM_PROTOCOLS, VAL_EXTRACT_BITS(attributes, 0, 7)); - return VAL_STATUS_PASS; } -- GitLab From 130ee09f771a447bb3e34676d12347c82ece9722 Mon Sep 17 00:00:00 2001 From: Cristian Marussi Date: Thu, 11 Aug 2022 15:07:10 +0100 Subject: [PATCH 3/5] Fix test_m005_v3 sensor descriptor parsing SCMIv3.0 Sensor descriptors have variable lengths based on the presence or not of extended attributes; the presence of extended attributes is NOT mandatory though even in SCMIv3.0 messages, so that, within the same reply you could received a mix of sensor descriptors carrying or NOT the extended attributes: as a consequence the array of sensor descriptors is composed of variable length elements and as such must be parsed. Signed-off-by: Cristian Marussi --- test_pool/sensor/test_m005_v3.c | 113 ++++++++++++++++---------------- 1 file changed, 58 insertions(+), 55 deletions(-) diff --git a/test_pool/sensor/test_m005_v3.c b/test_pool/sensor/test_m005_v3.c index d064520..67f5432 100755 --- a/test_pool/sensor/test_m005_v3.c +++ b/test_pool/sensor/test_m005_v3.c @@ -38,7 +38,7 @@ uint32_t sensor_query_description_get_scmi_v3(void) uint32_t i, desc_index = 0, sensor_id; uint32_t async_support, num_trip_points, cont_update_notify_support; uint32_t timestamp_support, ext_attr_support; - uint32_t *sensor_desc, num_sensor_flag; + uint32_t *sensor_desc, num_sensor_flag, last_sdesc_size; uint32_t num_axis, unit_exponent, axis_support; uint32_t sensor_type; @@ -71,95 +71,98 @@ uint32_t sensor_query_description_get_scmi_v3(void) val_print(VAL_PRINT_DEBUG, "\n NUM OF REMAINING DESC : %d", num_remaining_desc); if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(num_sensor_flag, 12, 15)) != - VAL_STATUS_PASS) + VAL_STATUS_PASS) return VAL_STATUS_FAIL; num_desc_retured = VAL_EXTRACT_BITS(num_sensor_flag, 0, 11); val_print(VAL_PRINT_DEBUG, "\n NUM OF DESC RETURNED : %d", num_desc_retured); + last_sdesc_size = 0; /* Sensor desc start from return_values[1] */ sensor_desc = &return_values[DESC_OFFSET]; for (i = 0; i < num_desc_retured; i++) { val_print(VAL_PRINT_TEST, "\n Sensor description "); - sensor_id = sensor_desc[i * SENSOR_DESC_LEN]; + sensor_desc += last_sdesc_size; + sensor_id = sensor_desc[NUM_SENSOR_FLAG_OFFSET]; val_print(VAL_PRINT_DEBUG, "\n Sensor id : %d", sensor_id); /* sensor_attributes_low */ - async_support = VAL_EXTRACT_BITS(sensor_desc[1 + (i * SENSOR_DESC_LEN)], 31, 31); + async_support = VAL_EXTRACT_BITS(sensor_desc[1], 31, 31); val_print(VAL_PRINT_DEBUG, "\n Async read support : %d", async_support); - cont_update_notify_support = VAL_EXTRACT_BITS(sensor_desc[1 + (i * SENSOR_DESC_LEN)], 30, 30); + cont_update_notify_support = VAL_EXTRACT_BITS(sensor_desc[1], 30, 30); val_print(VAL_PRINT_DEBUG, "\n Cont Update Notify Sup : %d", cont_update_notify_support); - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS( - sensor_desc[1 + (i * SENSOR_DESC_LEN)], 15, 29)) != VAL_STATUS_PASS) + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(sensor_desc[1], 15, 29)) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; val_print(VAL_PRINT_DEBUG, "\n Timestamp exponent : %d", - VAL_EXTRACT_BITS(sensor_desc[1 + (i * SENSOR_DESC_LEN)], 10, 14)); + VAL_EXTRACT_BITS(sensor_desc[1], 10, 14)); - timestamp_support = VAL_EXTRACT_BITS(sensor_desc[1 + (i * SENSOR_DESC_LEN)], 9, 9); + timestamp_support = VAL_EXTRACT_BITS(sensor_desc[1], 9, 9); val_print(VAL_PRINT_DEBUG, "\n Time stamp support : %d", timestamp_support); - ext_attr_support = VAL_EXTRACT_BITS(sensor_desc[1 + (i * SENSOR_DESC_LEN)], 8, 8); + ext_attr_support = VAL_EXTRACT_BITS(sensor_desc[1], 8, 8); val_print(VAL_PRINT_DEBUG, "\n Extended Attr Support : %d", ext_attr_support); - num_trip_points = VAL_EXTRACT_BITS(sensor_desc[1 + (i * SENSOR_DESC_LEN)], 0, 7); + num_trip_points = VAL_EXTRACT_BITS(sensor_desc[1], 0, 7); val_print(VAL_PRINT_DEBUG, "\n Number of trip points : %d", num_trip_points); - val_print(VAL_PRINT_TEST, "\n [Check 2] Check Extended attributes from Sensors"); - if (val_compare("Extended Attr Support ", ext_attr_support, EXTENDED_ATTR_SUPPORTED)) + /* sensor_attributes_high */ + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(sensor_desc[2], 22, 31)) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; - /* sensor_attributes_high */ - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS( - sensor_desc[2 + (i * SENSOR_DESC_LEN)], 22, 31)) != VAL_STATUS_PASS) + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(sensor_desc[2], 9, 10)) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; - num_axis = VAL_EXTRACT_BITS(sensor_desc[2 + (i * SENSOR_DESC_LEN)], 16, 21); - val_print(VAL_PRINT_DEBUG, "\n Number of Axis : %d", num_axis); + axis_support = VAL_EXTRACT_BITS(sensor_desc[2], 8, 8); + val_print(VAL_PRINT_DEBUG, "\n Sensor Axis Support : %d", axis_support); + + last_sdesc_size = 7; + val_print(VAL_PRINT_TEST, "\n [Check 2] Check Extended attributes from Sensors"); + if (ext_attr_support == EXTENDED_ATTR_SUPPORTED) { - unit_exponent = VAL_EXTRACT_BITS(sensor_desc[2 + (i * SENSOR_DESC_LEN)], 11, 15); - val_print(VAL_PRINT_DEBUG, "\n Sensor Unit Exponent : %d", unit_exponent); + num_axis = VAL_EXTRACT_BITS(sensor_desc[2], 16, 21); + val_print(VAL_PRINT_DEBUG, "\n Number of Axis : %d", num_axis); - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS( - sensor_desc[2 + (i * SENSOR_DESC_LEN)], 9, 10)) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; + /* Sensor Name */ + val_print(VAL_PRINT_DEBUG, "\n Sensor name : %s", + &sensor_desc[3]); - axis_support = VAL_EXTRACT_BITS(sensor_desc[2 + (i * SENSOR_DESC_LEN)], 8, 8); - val_print(VAL_PRINT_DEBUG, "\n Sensor Axis Support : %d", axis_support); + /* Sensor Power */ + val_print(VAL_PRINT_DEBUG, "\n Sensor Power : %d", + sensor_desc[7]); - sensor_type = VAL_EXTRACT_BITS(sensor_desc[2 + (i * SENSOR_DESC_LEN)], 0, 7); - val_print(VAL_PRINT_DEBUG, "\n Sensor Type : %d", sensor_type); + /* sensor resolution */ + val_print(VAL_PRINT_DEBUG, "\n Sensor Resolution exp : %d", + VAL_EXTRACT_BITS(sensor_desc[8], 27, 31)); - /* Sensor Name */ - val_print(VAL_PRINT_DEBUG, "\n Sensor name : %s", - &sensor_desc[3 + (i * SENSOR_DESC_LEN)]); + val_print(VAL_PRINT_DEBUG, "\n Sensor Resolution : %d", + VAL_EXTRACT_BITS(sensor_desc[8], 0, 26)); - /* Sensor Power */ - val_print(VAL_PRINT_DEBUG, "\n Sensor Power : %d", - sensor_desc[7 + (i * SENSOR_DESC_LEN)]); + /* Sensor Min Range */ + val_print(VAL_PRINT_DEBUG, "\n Sensor Min Range Low : %d", + sensor_desc[9]); + val_print(VAL_PRINT_DEBUG, "\n Sensor Min Range High : %d", + sensor_desc[10]); - /* sensor resolution */ - val_print(VAL_PRINT_DEBUG, "\n Sensor Resolution exp : %d", - VAL_EXTRACT_BITS(sensor_desc[8 + (i * SENSOR_DESC_LEN)], 27, 31)); + /* Sensor Max Range */ + val_print(VAL_PRINT_DEBUG, "\n Sensor Max Range Low : %d", + sensor_desc[11]); + val_print(VAL_PRINT_DEBUG, "\n Sensor Max Range High : %d", + sensor_desc[12]); - val_print(VAL_PRINT_DEBUG, "\n Sensor Resolution : %d", - VAL_EXTRACT_BITS(sensor_desc[8 + (i * SENSOR_DESC_LEN)], 0, 26)); + last_sdesc_size += 6; + } else { + unit_exponent = VAL_EXTRACT_BITS(sensor_desc[2], 11, 15); + val_print(VAL_PRINT_DEBUG, "\n Sensor Unit Exponent : %d", unit_exponent); - /* Sensor Min Range */ - val_print(VAL_PRINT_DEBUG, "\n Sensor Min Range Low : %d", - sensor_desc[9 + (i * SENSOR_DESC_LEN)]); - val_print(VAL_PRINT_DEBUG, "\n Sensor Min Range High : %d", - sensor_desc[10 + (i * SENSOR_DESC_LEN)]); + sensor_type = VAL_EXTRACT_BITS(sensor_desc[2], 0, 7); + val_print(VAL_PRINT_DEBUG, "\n Sensor Type : %d", sensor_type); - /* Sensor Max Range */ - val_print(VAL_PRINT_DEBUG, "\n Sensor Max Range Low : %d", - sensor_desc[11 + (i * SENSOR_DESC_LEN)]); - val_print(VAL_PRINT_DEBUG, "\n Sensor Max Range High : %d", - sensor_desc[12 + (i * SENSOR_DESC_LEN)]); + } /* Save sensor information */ val_sensor_save_desc_info(SENSOR_NUM_OF_TRIP_POINTS, sensor_id, num_trip_points); @@ -170,20 +173,20 @@ uint32_t sensor_query_description_get_scmi_v3(void) sensor_id, cont_update_notify_support); val_sensor_ext_save_desc_info(SENSOR_TIMESTAMP_SUPPORT, sensor_id, timestamp_support); + val_sensor_ext_save_desc_info(SENSOR_NUM_OF_AXIS, sensor_id, num_axis); val_sensor_ext_save_desc_info(SENSOR_AXIS_SUPPORT, sensor_id, axis_support); /* Ensure sensor description indicates sensor identifiers start from 0 and are sequential*/ - val_print(VAL_PRINT_TEST, "\n [Check 3] Ensure sensor IDs start from 0"); + val_print(VAL_PRINT_TEST, "\n [Check 3] Ensure sensor IDs start from 0 and are sequential"); /* Get sensor ID for first returned sensor.*/ - if (total_sensors == 0 && i == 0) - { - if (val_compare("START SENSOR ID ", sensor_id, START_SENSOR_ID)) - return VAL_STATUS_FAIL; + if (total_sensors == 0 && i == 0) { + if (val_compare("START SENSOR ID ", sensor_id, START_SENSOR_ID)) + return VAL_STATUS_FAIL; - val_print(VAL_PRINT_DEBUG, "\n Start Sensor : %s, has ID 0", - &sensor_desc[3 + (i * SENSOR_DESC_LEN)]); + val_print(VAL_PRINT_DEBUG, "\n Start Sensor : %s, has ID 0", + &sensor_desc[3 + (i * SENSOR_DESC_LEN)]); } /* Check sensor IDs are sequential. */ if (val_compare("SENSOR ID SEQUENCE", sensor_id, i+total_sensors)) -- GitLab From 7552172285e09870de3c41c9f2ad33f784a03598 Mon Sep 17 00:00:00 2001 From: Cristian Marussi Date: Thu, 11 Aug 2022 15:11:19 +0100 Subject: [PATCH 4/5] Fix Sensor protocol tests ordering and dependencies Some tests depends on others since they depends on sensor data collected by early tests; moreover some tests require a minimum major protocol version to be run but they can also be run successfully on any following newer major protocol version. Fix ordering of tests and minimum version requirements. Signed-off-by: Cristian Marussi --- val/val_sensor.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/val/val_sensor.c b/val/val_sensor.c index cb21373..26757c2 100644 --- a/val/val_sensor.c +++ b/val/val_sensor.c @@ -39,6 +39,12 @@ uint32_t val_sensor_execute_tests(void) RUN_TEST(sensor_query_protocol_attributes()); RUN_TEST(sensor_query_mandatory_command_support()); RUN_TEST(sensor_invalid_messageid_call()); + + if (version == SENSOR_PROTOCOL_VERSION_1) + RUN_TEST(sensor_query_description_get()); + else if (version >= SENSOR_PROTOCOL_VERSION_2) + RUN_TEST(sensor_query_description_get_scmi_v3()); + RUN_TEST(sensor_trip_point_nfy_event_ctrl_check()); RUN_TEST(sensor_trip_point_nfy_invalid_id_check()); RUN_TEST(sensor_trip_point_config_invalid_param_check()); @@ -50,11 +56,7 @@ uint32_t val_sensor_execute_tests(void) RUN_TEST(sensor_reading_get_async_mode()); RUN_TEST(sensor_reading_get_async_mode_not_supported()); - if (version == SENSOR_PROTOCOL_VERSION_1) - RUN_TEST(sensor_query_description_get()); - - if (version == SENSOR_PROTOCOL_VERSION_2) { - RUN_TEST(sensor_query_description_get_scmi_v3()); + if (version >= SENSOR_PROTOCOL_VERSION_2) { RUN_TEST(sensor_axis_description_check()); RUN_TEST(sensor_axis_desc_invalid_id_check()); RUN_TEST(sensor_supported_update_intervals_check()); -- GitLab From 63d8da8d5436b746a742697097c471b677c1a3b8 Mon Sep 17 00:00:00 2001 From: Cristian Marussi Date: Fri, 19 Aug 2022 17:09:20 +0100 Subject: [PATCH 5/5] Add optional support for relaxed protocol versioning checks Add an optional mechanism for relaxed protocol versioning checks in order to let some testcases be run also against an SCMI server platform which advertises a specific protocol version greater than the one currently supported by the test suite. Relaxed version checks support is currently optionally configurable only for linux platform using a command option. Note that, by default, strict version checking is instead carried on, as it was before. Optional relaxed protocol versioning checks support is then added to Base, Performance, Power and Reset Signed-off-by: Cristian Marussi --- baremetal_app/app.c | 2 ++ docs/user_guide.md | 3 +++ linux_app/app.c | 16 ++++++++++++++++ mocker_app/app.c | 2 ++ val/include/val_interface.h | 5 ++++- val/val_base.c | 9 ++++----- val/val_interface.c | 28 ++++++++++++++++++++++++++++ val/val_performance.c | 8 ++++---- val/val_power_domain.c | 4 ++-- val/val_reset.c | 2 +- val/val_sensor.c | 8 +++++--- 11 files changed, 71 insertions(+), 16 deletions(-) diff --git a/baremetal_app/app.c b/baremetal_app/app.c index 2c2c82e..0f6f2d8 100644 --- a/baremetal_app/app.c +++ b/baremetal_app/app.c @@ -17,6 +17,8 @@ #include "val_interface.h" +bool relaxed_version_checks; + /** @brief Entry point to SCMI suite 1. Caller - Platform layer. diff --git a/docs/user_guide.md b/docs/user_guide.md index 40fde81..159c07b 100644 --- a/docs/user_guide.md +++ b/docs/user_guide.md @@ -101,6 +101,9 @@ In addition to building the library, the build also enables the SCMI test suite The output will be libscmi_test.a and scmi_test_agent for the Linux platform in the ``. +The scmi_test_agent app supports the command-line option '-r' to optionally enable relaxed protocol versioning checks: when enabled the relevant testcases are run even if the SCMI Server under test advertised to implement a greater protocol version (i.e. newer) than the one officially supported by the current test-suite for that test-case and, in such a case, the protocol version mismatch is logged. +This behaviour could possibly lead to false positives if the newer protocol version specification introduced some non-backward compatible change: for this reason the relaxed checks are off by default andhave to be explicitly enabled using the '-r' switch. + **NOTE**: * You must rebuild the Linux kernel and device trees for LINUX by following the [Guide to test SCMI on LINUX]. diff --git a/linux_app/app.c b/linux_app/app.c index e23f23f..0d1b9db 100644 --- a/linux_app/app.c +++ b/linux_app/app.c @@ -15,8 +15,11 @@ * limitations under the License. **/ +#include #include "val_interface.h" +bool relaxed_version_checks; + /** @brief Entry point to SCMI suite 1. Caller - Platform layer. @@ -27,10 +30,23 @@ int main(int argc, char *argv[]) { + int opt; uint32_t num_pass; uint32_t num_fail; uint32_t num_skip; + while ((opt = getopt(argc, argv, "r")) != -1) { + switch (opt) { + case 'r': + relaxed_version_checks = true; + break; + default: /* '?' */ + fprintf(stderr, "Usage: %s [-r]\n", + argv[0]); + exit(EXIT_FAILURE); + } + } + val_print(VAL_PRINT_ERR, "\n\n **** SCMI Compliance Suite **** "); if (val_initialize_system((void *) NULL)) { diff --git a/mocker_app/app.c b/mocker_app/app.c index e23f23f..7087525 100644 --- a/mocker_app/app.c +++ b/mocker_app/app.c @@ -17,6 +17,8 @@ #include "val_interface.h" +bool relaxed_version_checks; + /** @brief Entry point to SCMI suite 1. Caller - Platform layer. diff --git a/val/include/val_interface.h b/val/include/val_interface.h index 48d743d..07a0a28 100644 --- a/val/include/val_interface.h +++ b/val/include/val_interface.h @@ -110,7 +110,8 @@ typedef enum { uint32_t val_strcpy(uint8_t *dst_ptr, uint8_t *src_ptr); uint32_t val_strcmp(uint8_t *dst_ptr, uint8_t *src_ptr, uint32_t len); uint32_t val_compare_msg_hdr(uint32_t sent_msg_hdr, uint32_t rsp_msg_hdr); -uint32_t val_protocol_version_check(uint32_t exp_version, uint32_t version); +bool val_protocol_version_strict(uint32_t version, uint32_t exp_version); +bool val_protocol_version_relaxed(uint32_t protocol, uint32_t version, uint32_t exp_version); uint32_t val_reserved_bits_check_is_zero(uint32_t reserved_bits); void val_print(uint32_t level, const char *string, ...); void val_memset(void *ptr, int value, size_t length); @@ -144,6 +145,8 @@ uint32_t val_get_test_skipped(void); uint32_t val_compare(char *parameter, uint32_t rcvd_val, uint32_t exp_val); uint32_t val_compare_str(char *parameter, char *rcvd_val, char *exp_val, uint32_t len); +extern bool relaxed_version_checks; + /* BASE VAL APIs */ typedef enum { diff --git a/val/val_base.c b/val/val_base.c index 2a9e225..6f11305 100644 --- a/val/val_base.c +++ b/val/val_base.c @@ -41,15 +41,14 @@ uint32_t val_base_execute_tests(void) RUN_TEST(base_query_subvendor_info()); RUN_TEST(base_query_implementation_version()); RUN_TEST(base_query_protocol_list()); - if (version == BASE_PROTOCOL_VERSION_1) { + if (val_protocol_version_strict(version, BASE_PROTOCOL_VERSION_1)) RUN_TEST(base_discover_agent_v1()); - } - if (version == BASE_PROTOCOL_VERSION_2) { + else if (val_protocol_version_relaxed(BASE_PROTOCOL, version, BASE_PROTOCOL_VERSION_2)) RUN_TEST(base_discover_agent()); - } + RUN_TEST(base_query_notify_error_support()); - if (version == BASE_PROTOCOL_VERSION_2) { + if (val_protocol_version_relaxed(BASE_PROTOCOL, version, BASE_PROTOCOL_VERSION_2)) { RUN_TEST(base_set_device_permissions_check()); RUN_TEST(base_deny_restore_device_access()); RUN_TEST(base_set_protocol_permissions_check()); diff --git a/val/val_interface.c b/val/val_interface.c index 52e0c98..136878f 100644 --- a/val/val_interface.c +++ b/val/val_interface.c @@ -571,3 +571,31 @@ uint32_t val_get_test_skipped(void) { return g_test_skip; } + +/** + @brief This API returns a boolean to report if the version is supported + @return true if an exact match is found between expected and actual version +**/ +bool val_protocol_version_strict(uint32_t version, uint32_t exp_version) +{ + return version == exp_version; +} + +/** + @brief This API returns a boolean to report if the version is supported + @return true if a possibly relaxed match is found between expected and actual version +**/ +bool val_protocol_version_relaxed(uint32_t protocol, uint32_t version, + uint32_t exp_version) +{ + if (!relaxed_version_checks) + return val_protocol_version_strict(version, exp_version); + + /* Warn and carry-on if found protocol version is greater than expected */ + if (version > exp_version) + val_print(VAL_PRINT_WARN, + "\n--- Protocol 0x%X Version MISMATCH - Expected:0x%X Actual:0x%X", + protocol, exp_version, version); + + return version >= exp_version; +} diff --git a/val/val_performance.c b/val/val_performance.c index dfe2d81..28b6fd3 100644 --- a/val/val_performance.c +++ b/val/val_performance.c @@ -38,13 +38,13 @@ uint32_t val_performance_execute_tests(void) RUN_TEST(performance_query_protocol_attributes()); - if (version == PERFORMANCE_PROTOCOL_VERSION_1) { + if (val_protocol_version_strict(version, PERFORMANCE_PROTOCOL_VERSION_1)) { RUN_TEST(performance_query_mandatory_command_support_v1()); RUN_TEST(performance_invalid_messageid_call()); RUN_TEST(performance_query_domain_attributes_v1()); } - if (version == PERFORMANCE_PROTOCOL_VERSION_2) { + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, PERFORMANCE_PROTOCOL_VERSION_2)) { RUN_TEST(performance_query_mandatory_command_support()); RUN_TEST(performance_invalid_messageid_call()); RUN_TEST(performance_query_domain_attributes()); @@ -65,7 +65,7 @@ uint32_t val_performance_execute_tests(void) RUN_TEST(performance_query_notify_level_invalid_parameters()); RUN_TEST(performance_query_notify_level_invalid_domain()); - if (version == PERFORMANCE_PROTOCOL_VERSION_2) { + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, PERFORMANCE_PROTOCOL_VERSION_2)) { RUN_TEST(performance_query_describe_fast_channel()); RUN_TEST(performance_query_describe_fast_channel_invalid_domain()); RUN_TEST(performance_query_describe_fast_channel_invalid_message()); @@ -75,7 +75,7 @@ uint32_t val_performance_execute_tests(void) RUN_TEST(performance_limit_set_async()); RUN_TEST(performance_level_set_async()); - if (version == PERFORMANCE_PROTOCOL_VERSION_2) { + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, PERFORMANCE_PROTOCOL_VERSION_2)) { RUN_TEST(performance_level_get_fast_channel()); RUN_TEST(performance_limits_get_fast_channel()); } diff --git a/val/val_power_domain.c b/val/val_power_domain.c index 6a26cb7..0f0b198 100644 --- a/val/val_power_domain.c +++ b/val/val_power_domain.c @@ -50,11 +50,11 @@ uint32_t val_power_domain_execute_tests(void) RUN_TEST(power_domain_power_state_notify_unspported_domain_check()); RUN_TEST(power_domain_power_state_notify_invalid_domain_check()); - if (version == POWER_PROTOCOL_VERSION_2) { + if (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, POWER_PROTOCOL_VERSION_2)) { RUN_TEST(power_domain_power_state_change_requested_notify_check()); RUN_TEST(power_domain_power_state_change_requested_notify_invalid_domain_check()); } - if (version == POWER_PROTOCOL_VERSION_2_1) { + if (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, POWER_PROTOCOL_VERSION_2_1)) { RUN_TEST(power_domain_query_domain_attributes_scmi_v3()); } } diff --git a/val/val_reset.c b/val/val_reset.c index 8cd11fb..3cef948 100644 --- a/val/val_reset.c +++ b/val/val_reset.c @@ -47,7 +47,7 @@ uint32_t val_reset_execute_tests(void) RUN_TEST(reset_query_notify_invalid_id()); RUN_TEST(reset_query_invalid_notify_enable()); - if (version == RESET_PROTOCOL_VERSION_2) { + if (val_protocol_version_relaxed(PROTOCOL_RESET, version, RESET_PROTOCOL_VERSION_2)) { RUN_TEST(reset_query_domain_attributes_scmi_v3()); } } diff --git a/val/val_sensor.c b/val/val_sensor.c index 26757c2..6368f55 100644 --- a/val/val_sensor.c +++ b/val/val_sensor.c @@ -40,9 +40,10 @@ uint32_t val_sensor_execute_tests(void) RUN_TEST(sensor_query_mandatory_command_support()); RUN_TEST(sensor_invalid_messageid_call()); - if (version == SENSOR_PROTOCOL_VERSION_1) + if (val_protocol_version_strict(version, SENSOR_PROTOCOL_VERSION_1)) RUN_TEST(sensor_query_description_get()); - else if (version >= SENSOR_PROTOCOL_VERSION_2) + else if (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_2)) RUN_TEST(sensor_query_description_get_scmi_v3()); RUN_TEST(sensor_trip_point_nfy_event_ctrl_check()); @@ -56,7 +57,8 @@ uint32_t val_sensor_execute_tests(void) RUN_TEST(sensor_reading_get_async_mode()); RUN_TEST(sensor_reading_get_async_mode_not_supported()); - if (version >= SENSOR_PROTOCOL_VERSION_2) { + if (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_2)) { RUN_TEST(sensor_axis_description_check()); RUN_TEST(sensor_axis_desc_invalid_id_check()); RUN_TEST(sensor_supported_update_intervals_check()); -- GitLab