diff --git a/Makefile b/Makefile index 7726ce627b9ab52ae833e5f8dee9698c9cbba02d..4e5e560c868ad20e003e8d912413ac8a531829f9 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,5 @@ #/** @file -# * Copyright (c) 2019-2023, Arm Limited or its affiliates. All rights reserved. +# * Copyright (c) 2019-2024, Arm Limited or its affiliates. All rights reserved. # * SPDX-License-Identifier : Apache-2.0 # * # * Licensed under the Apache License, Version 2.0 (the "License"); @@ -26,6 +26,8 @@ MOCKER=mocker LINUX=linux SGM776=sgm776 TC=tc +TC3=tc3 +TC4=tc4 JUNO=juno GENERIC_SCMI=generic_scmi COMMON=common @@ -48,7 +50,7 @@ ifeq ($(PLAT),$(LINUX)) DIR=platform/$(LINUX) ifeq ($(TARGET),$(SGM776)) PLAT_DIR=$(DIR)/$(SGM776) $(DIR)/$(COMMON) - else ifeq ($(TARGET),$(TC)) + else ifeq ($(TARGET),$(filter $(TARGET),$(TC) $(TC3) $(TC4))) PLAT_DIR=$(DIR)/$(TC) $(DIR)/$(COMMON) else ifeq ($(TARGET),$(JUNO)) PLAT_DIR=$(DIR)/$(JUNO) $(DIR)/$(COMMON) @@ -60,6 +62,12 @@ ifeq ($(PLAT),$(LINUX)) TARGET_UPPER=$(shell echo $(TARGET) | tr '[:lower:]' '[:upper:]') endif +ifeq ($(TARGET),$(TC3)) + CFLAGS+=-DTC3 +else ifeq ($(TARGET),$(TC4)) + CFLAGS+=-DTC4 +endif + # Set VERBOSE to default(TEST) if not set ifndef VERBOSE VERBOSE=3 diff --git a/README.md b/README.md index 15ce06335d5001192e1a44f95c3874522c68f05d..4ba6a187f6464efc5d6f5e55dec086d70a05022d 100644 --- a/README.md +++ b/README.md @@ -19,8 +19,8 @@ For more information, download the [SCMI Platform Design Document](https://devel SCMI compliance suite is a collection of self-checking, portable C tests. SCMI compliance suite enables adopters of SCMI Platform Design Document \(PDD\) to test their own implementations. It provides a predefined library of tests and a test framework to execute these tests. The test suite can be adapted to different platforms. It also enables the extension of the current test library to include platform-specific custom commands and custom protocols. ## Release details - - Code quality: REL v3.2 BETA-0. - - The tests are written for version 3.2 BETA-2 of the SCMI PDD. + - Code quality: REL v3.2 BET-1. + - The tests are written for version 3.2 of the SCMI PDD. - The compliance suite maintains backward compatibility with version 3.1, 3.0, 2.0 and 1.0 of the SCMI PDD. - The compliance suite is not a substitute for design verification. - The compliance suite is verified against [SCP-firmware](https://github.com/ARM-software/SCP-firmware). diff --git a/docs/arm_system_control_and_management_interface_test_suite_test_scenario.pdf b/docs/arm_system_control_and_management_interface_test_suite_test_scenario.pdf index 1adc5a25e6ab188aef098957afb7ec075773d3c6..ff94a7ea9a2d41f96ed2b9d5f3255314837b840c 100644 Binary files a/docs/arm_system_control_and_management_interface_test_suite_test_scenario.pdf and b/docs/arm_system_control_and_management_interface_test_suite_test_scenario.pdf differ diff --git a/docs/arm_system_control_and_management_interface_test_suite_validation_methodology_101871_0302_02_en.pdf b/docs/arm_system_control_and_management_interface_test_suite_validation_methodology_101871_0302_02_en.pdf new file mode 100644 index 0000000000000000000000000000000000000000..6074ccb25408571059baeae3f85ee1da2eeefe85 Binary files /dev/null and b/docs/arm_system_control_and_management_interface_test_suite_validation_methodology_101871_0302_02_en.pdf differ diff --git a/platform/linux/common/common.c b/platform/linux/common/common.c index 75a79940212dcde8ca5944463c7e4136ca8f1d09..7893bd65d20849eadf2acadd6cd3eeb196961fd6 100644 --- a/platform/linux/common/common.c +++ b/platform/linux/common/common.c @@ -45,7 +45,7 @@ int linux_map_phys_to_virt(unsigned long paddr, size_t length, unsigned long *va map_base = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, (paddr & ~map_mask)); close(fd); - if (map_base == (void *) - 1) + if (map_base == (void *) -1) return -1; *vaddr = (unsigned long)map_base + (paddr & map_mask); diff --git a/platform/linux/common/transport_mailbox.c b/platform/linux/common/transport_mailbox.c index 711e83f1b31f60160ae7c8efa65b288666eafa7e..5faae6075f71c7eb1a4fccce29651f9ea1823350 100644 --- a/platform/linux/common/transport_mailbox.c +++ b/platform/linux/common/transport_mailbox.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -34,13 +34,8 @@ #define NO_ERROR 0 #define ERROR 5 -#if defined TARGET_TC - #define MB_SIGNAL_FILE "/sys/kernel/debug/6000000.mailbox-test/signal" - #define MB_MESSAGE_FILE "/sys/kernel/debug/6000000.mailbox-test/message" -#elif defined TARGET_SGM776 - #define MB_SIGNAL_FILE "/sys/kernel/debug/mailbox/signal" - #define MB_MESSAGE_FILE "/sys/kernel/debug/mailbox/message" -#else +#if !defined (TARGET_TC2) && !defined (TARGET_TC4) && \ + !defined (TARGET_SGM776) #error "TARGET unsupported with mailbox transport !" #endif @@ -133,7 +128,7 @@ int32_t linux_send_message(uint32_t message_header_send, size_t parameter_count, /* Send message to the mailbox driver interface * defined by the MB_MESSAGE_FILE macro * */ - fd_message = open(MB_MESSAGE_FILE, 0x0002); + fd_message = open(MB_MESSAGE_FILE, O_RDWR); if (fd_message < 0) { free(buffer); return ERROR; @@ -143,7 +138,7 @@ int32_t linux_send_message(uint32_t message_header_send, size_t parameter_count, /* Send Signal to the mailbox driver interface * defined by the MB_SIGNAL_FILE macro * */ - fd_signal = open(MB_SIGNAL_FILE, 0x0001); + fd_signal = open(MB_SIGNAL_FILE, O_WRONLY); if (fd_signal < 0) { free(buffer); return ERROR; @@ -246,7 +241,7 @@ int linux_wait_for_response(uint32_t *message_header_rcv, /* Send message to the mailbox driver interface * defined by the MB_MESSAGE_FILE macro * */ - fd_message = open(MB_MESSAGE_FILE, 0x0002); + fd_message = open(MB_MESSAGE_FILE, O_RDWR); if (fd_message < 0) { free(buffer); return ERROR; @@ -332,7 +327,11 @@ int linux_wait_for_notification(uint32_t *message_header_rcv, /* Send message to the mailbox driver interface * defined by the MB_MESSAGE_FILE macro * */ - fd_message = open(MB_MESSAGE_FILE, 0x0002); +#ifdef TC4 + fd_message = open(MB_NOTIFY_FILE, O_RDONLY); +#else + fd_message = open(MB_MESSAGE_FILE, O_RDWR); +#endif if (fd_message < 0) { free(buffer); return ERROR; @@ -365,8 +364,8 @@ int linux_wait_for_notification(uint32_t *message_header_rcv, else { // extract payload // plus 1 to skip the Length - // return_values starts from 0, hence subtract 2 here - return_values[(counter - 2)] = *(header_payload_length + 1 + counter); + // return_values starts from 0, hence subtract 1 here + return_values[(counter - 1)] = *(header_payload_length + 1 + counter); (*return_values_count)++; } } diff --git a/platform/linux/sgm776/include/pal_platform.h b/platform/linux/sgm776/include/pal_platform.h index 971dafc7403088cb6bbddef5212cac26a8a35e28..d42e7405f032ebf10fd87abd8b0f801ac5e628b2 100644 --- a/platform/linux/sgm776/include/pal_platform.h +++ b/platform/linux/sgm776/include/pal_platform.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021-2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -41,6 +41,9 @@ #define TIMEOUT 100 +#define MB_SIGNAL_FILE "/sys/kernel/debug/mailbox/signal" +#define MB_MESSAGE_FILE "/sys/kernel/debug/mailbox/message" + int linux_map_phys_to_virt(unsigned long paddr, size_t length, unsigned long *vaddr); diff --git a/platform/linux/tc/include/pal_base_expected.h b/platform/linux/tc/include/pal_base_expected.h index b39b5cd07cc3b908178a3bf2a7779e67ea67139f..f6fa8c91d4cf23a90411aa131261261e0f2f7235 100644 --- a/platform/linux/tc/include/pal_base_expected.h +++ b/platform/linux/tc/include/pal_base_expected.h @@ -37,6 +37,11 @@ static char *agents[] = { static char *vendor_name = "arm"; static char *subvendor_name = "arm"; -static uint32_t implementation_version = VERSION_ENCODE32(2, 12, 0); +#ifdef TC4 +#define VERSION_MINOR 14 +#else +#define VERSION_MINOR 12 +#endif +static uint32_t implementation_version = VERSION_ENCODE32(2, VERSION_MINOR, 0); #endif /* __PAL_BASE_EXPECTED_H__ */ diff --git a/platform/linux/tc/include/pal_clock_expected.h b/platform/linux/tc/include/pal_clock_expected.h index 628412721873435b621743659f99b530357e3fc9..f32f57ef225f0057ddfbf9a4fbce886677675527 100644 --- a/platform/linux/tc/include/pal_clock_expected.h +++ b/platform/linux/tc/include/pal_clock_expected.h @@ -21,7 +21,8 @@ /* Expected CLOCK parameters */ #ifdef CLOCK_PROTOCOL -#define UNSUPPORTED 1 +/* The clock requests from OSPM are all allowed */ +#define SUPPORTED 0 static uint32_t num_clocks = 0x03; static uint32_t num_of_clock_rates[] = { diff --git a/platform/linux/tc/include/pal_performance_expected.h b/platform/linux/tc/include/pal_performance_expected.h index d1ac5fadfd3bae180f3e2af4c9f5b13bdf708940..11fd6216354e79fe9a1be50b8d5db867adc10855 100644 --- a/platform/linux/tc/include/pal_performance_expected.h +++ b/platform/linux/tc/include/pal_performance_expected.h @@ -23,18 +23,33 @@ static uint32_t num_perf_domains = 0x04; static uint32_t perf_num_performance_levels[] = { +#if defined(TC4) + 5, /* CPU_GROUP_CORTEX_A520 */ + 5, /* CPU_GROUP_CORTEX_A720 */ + 5, /* CPU_GROUP_CORTEX_X4 */ + 2 /* GPU */ +#else 5, /* CPU_GROUP_CORTEX_A520 */ 5, /* CPU_GROUP_CORTEX_A720 */ 5, /* CPU_GROUP_CORTEX_X4 */ 4 /* GPU */ +#endif }; - +#if defined(TC4) +static char *performance_domain_names[] = { + "CPU_GROUP_NEVIS", + "CPU_GROUP_GELAS", + "CPU_GROUP_TRAVIS", + "GPU" +}; +#else static char *performance_domain_names[] = { "CPU_GROUP_CORTEX_A520", "CPU_GROUP_CORTEX_A720", "CPU_GROUP_CORTEX_X4", "GPU" }; +#endif uint32_t statistics_address_low_perf = 0; uint32_t statistics_address_len_perf = 0; diff --git a/platform/linux/tc/include/pal_platform.h b/platform/linux/tc/include/pal_platform.h index 40f571cfec2827d8a96f16203905f9e0cacea445..9bda63a04b77e86e1cd458be5c2cedaf332dd096 100644 --- a/platform/linux/tc/include/pal_platform.h +++ b/platform/linux/tc/include/pal_platform.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021-2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -41,6 +41,10 @@ #define TIMEOUT 100 +#define MB_SIGNAL_FILE "/sys/kernel/debug/6000000.mailbox-test/signal" +#define MB_MESSAGE_FILE "/sys/kernel/debug/6000000.mailbox-test/message" +#define MB_NOTIFY_FILE "/sys/kernel/debug/6000000.mailbox-test/notify" + int linux_map_phys_to_virt(unsigned long paddr, size_t length, unsigned long *vaddr); diff --git a/platform/linux/tc/include/pal_power_domain_expected.h b/platform/linux/tc/include/pal_power_domain_expected.h index 4e10f94d2974e0bc8a2e9123bb92e4fd394b9cfe..dfd9fa049a0bf096ebac4512abbcb1768fe49b6d 100644 --- a/platform/linux/tc/include/pal_power_domain_expected.h +++ b/platform/linux/tc/include/pal_power_domain_expected.h @@ -20,7 +20,12 @@ /* Expected POWER DOMAIN parameters */ #ifdef POWER_DOMAIN_PROTOCOL +#ifdef TC4 +static uint32_t num_power_domains = 0x0a; +#else static uint32_t num_power_domains = 0x0b; +#endif + uint32_t statistics_address_low_pow = 0; uint32_t statistics_address_len_pow = 0; diff --git a/platform/linux/tc/pal_clock.c b/platform/linux/tc/pal_clock.c index ac4e8ea0945f8b42d10dc2c797b2bfd64d8058c3..be055ee3eaf610d8afcb68f5be3e93fac146d481 100644 --- a/platform/linux/tc/pal_clock.c +++ b/platform/linux/tc/pal_clock.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -56,7 +56,7 @@ uint32_t pal_clock_get_expected_number_of_rates(uint32_t clock_id) **/ uint32_t pal_check_clock_config_change_support(uint32_t clock_id) { - return UNSUPPORTED; + return SUPPORTED; } #endif diff --git a/platform/mocker/include/pal_base_expected.h b/platform/mocker/include/pal_base_expected.h index 617939a203c1bb7b79934068e35c22556919e1ed..a67aa9fae6845187a6a1c3a0283069f9e04a3f20 100644 --- a/platform/mocker/include/pal_base_expected.h +++ b/platform/mocker/include/pal_base_expected.h @@ -32,6 +32,12 @@ static uint8_t supported_protocols[] = { PIN_CONTROL_PROTOCOL_ID }; +static uint32_t supported_base_protocols[] = { + SUPPORTED_BASE_VERSION_1, + SUPPORTED_BASE_VERSION_2, + SUPPORTED_BASE_VERSION_2P1 +}; + /* Expected BASE parameters */ static char *agents[] = { diff --git a/platform/mocker/include/pal_clock_expected.h b/platform/mocker/include/pal_clock_expected.h index 9a9022af59c9d239786a59e579911736f0f2b2cd..8e41e684c72c86f0545925c14361ff08258cb045 100644 --- a/platform/mocker/include/pal_clock_expected.h +++ b/platform/mocker/include/pal_clock_expected.h @@ -18,6 +18,8 @@ #ifndef __PAL_CLOCK_EXPECTED_H__ #define __PAL_CLOCK_EXPECTED_H__ +#include + /* Expected CLOCK parameters */ static uint32_t max_num_pending_async_rate_chg_supported = 0; @@ -27,6 +29,12 @@ static uint32_t num_of_clock_rates[] = { 0x05, /* Clock 2 */ }; +static uint32_t supported_clock_protocols[] = { + SUPPORTED_CLOCK_VERSION_1, + SUPPORTED_CLOCK_VERSION_2, + SUPPORTED_CLOCK_VERSION_3 +}; + static uint32_t num_clocks = sizeof(num_of_clock_rates) / sizeof(num_of_clock_rates[0]); static uint32_t clock_parent_support[] = {0, 1, 1}; diff --git a/platform/mocker/include/pal_performance_expected.h b/platform/mocker/include/pal_performance_expected.h index 078e3e74c8c32521fbcfbbf822e1bf64c28c8c51..d53273bb91318f2472f7f5ff262918978d84fa58 100644 --- a/platform/mocker/include/pal_performance_expected.h +++ b/platform/mocker/include/pal_performance_expected.h @@ -18,6 +18,8 @@ #ifndef __PAL_PERFORMANCE_EXPECTED_H__ #define __PAL_PERFORMANCE_EXPECTED_H__ +#include + /* Expected PERFORMANCE parameters */ #define PERF_EXPECTED_NUM_OF_DOMAIN 4 static uint32_t num_performance_domains = PERF_EXPECTED_NUM_OF_DOMAIN; @@ -515,4 +517,10 @@ static uint32_t * perf_performance_fast_chan_doorbell_preserve_mask_high[] = { }, }; +static uint32_t supported_performance_protocols[] = { + SUPPORTED_PERFORMANCE_VERSION_1, + SUPPORTED_PERFORMANCE_VERSION_2, + SUPPORTED_PERFORMANCE_VERSION_3, + SUPPORTED_PERFORMANCE_VERSION_4, +}; #endif /* __PAL_PERFORMANCE_EXPECTED_H__ */ diff --git a/platform/mocker/include/pal_pin_control_expected.h b/platform/mocker/include/pal_pin_control_expected.h index d670ba9b9aefc2f8cdb1381ac798d33e4eea1efc..94d2a9194b8450e809a1f67014475b286365ba27 100644 --- a/platform/mocker/include/pal_pin_control_expected.h +++ b/platform/mocker/include/pal_pin_control_expected.h @@ -28,6 +28,18 @@ static uint32_t num_functions = 2; static uint16_t num_pins_in_group[] = {1, 2}; static uint16_t num_groups_in_function[] = {1, 1}; +static uint32_t pins_enabled_function[] = { + 0, + 1, + 0xFFFFFFFF, + 0xFFFFFFFF +}; + +static uint32_t groups_enabled_function[] = { + 0xFFFFFFFF, + 0xFFFFFFFF +}; + static uint32_t *group_associations[] = { (uint32_t[]) { /* GROUP 0 */ 1, @@ -53,4 +65,8 @@ static uint32_t *pin_control_extended_name_support[] = { (uint32_t []) {1, 0} /* Function Extended Name support */ }; +static uint32_t supported_pin_control_protocols[] = { + SUPPORTED_PIN_CONTROL_VERSION_1, +}; + #endif /* __PAL_PIN_CONTROL_EXPECTED_H__ */ diff --git a/platform/mocker/include/pal_platform.h b/platform/mocker/include/pal_platform.h index 8fe8807ad38aa4a35cedcace35b8055c2f9981c7..127718a97c28b8e05904288594d7b3ddf0d0e9b6 100644 --- a/platform/mocker/include/pal_platform.h +++ b/platform/mocker/include/pal_platform.h @@ -33,6 +33,48 @@ #define POWERCAP_PROTOCOL_ID 0x18 #define PIN_CONTROL_PROTOCOL_ID 0x19 +#define SUPPORTED_BASE_VERSION_1 0x00010000 +#define SUPPORTED_BASE_VERSION_2 0x00020000 +#define SUPPORTED_BASE_VERSION_2P1 0x00020001 + +#define SUPPORTED_CLOCK_VERSION_1 0x00010000 +#define SUPPORTED_CLOCK_VERSION_2 0x00020000 +#define SUPPORTED_CLOCK_VERSION_3 0x00030000 + +#define SUPPORTED_POWERCAP_VERSION_1 0x00010000 +#define SUPPORTED_POWERCAP_VERSION_2 0x00020000 + +#define SUPPORTED_RESET_VERSION_1 0x00010000 +#define SUPPORTED_RESET_VERSION_2 0x00020000 +#define SUPPORTED_RESET_VERSION_3 0x00030000 +#define SUPPORTED_RESET_VERSION_3P1 0x00030001 + +#define SUPPORTED_SENSOR_VERSION_1 0x00010000 +#define SUPPORTED_SENSOR_VERSION_2 0x00020000 +#define SUPPORTED_SENSOR_VERSION_3 0x00030000 +#define SUPPORTED_SENSOR_VERSION_3P1 0x00030001 + +#define SUPPORTED_VOLTAGE_VERSION_1 0x00010000 +#define SUPPORTED_VOLTAGE_VERSION_2 0x00020000 +#define SUPPORTED_VOLTAGE_VERSION_2P1 0x00020001 + +#define SUPPORTED_PERFORMANCE_VERSION_1 0x00010000 +#define SUPPORTED_PERFORMANCE_VERSION_2 0x00020000 +#define SUPPORTED_PERFORMANCE_VERSION_3 0x00030000 +#define SUPPORTED_PERFORMANCE_VERSION_4 0x00040000 + +#define SUPPORTED_PIN_CONTROL_VERSION_1 0x00010000 + +#define SUPPORTED_POWER_DOMAIN_VERSION_1 0x00010000 +#define SUPPORTED_POWER_DOMAIN_VERSION_2 0x00020000 +#define SUPPORTED_POWER_DOMAIN_VERSION_2P1 0x00020001 +#define SUPPORTED_POWER_DOMAIN_VERSION_3 0x00030000 +#define SUPPORTED_POWER_DOMAIN_VERSION_3P1 0x00030001 + +#define SUPPORTED_SYSTEM_POWER_VERSION_1 0x00010000 +#define SUPPORTED_SYSTEM_POWER_VERSION_2 0x00020000 +#define SUPPORTED_SYSTEM_POWER_VERSION_2P1 0x00020001 + enum BITS_HEADER { RESERVED_LOW = 28, RESERVED_HIGH = 31, @@ -102,6 +144,7 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, void fill_base_protocol(void); void fill_power_protocol(void); +void fill_system_power_protocol(void); void fill_clock_protocol(void); void fill_sensor_protocol(void); void fill_performance_protocol(void); diff --git a/platform/mocker/include/pal_power_domain_expected.h b/platform/mocker/include/pal_power_domain_expected.h index f7c1e41abf246d6f2b4eaff465b64f4b101099a5..91b519463d3a7209b2c1dee9dd90a9e40d243ed2 100644 --- a/platform/mocker/include/pal_power_domain_expected.h +++ b/platform/mocker/include/pal_power_domain_expected.h @@ -27,4 +27,13 @@ static uint32_t statistics_address_low_pow = 0x1234; static uint32_t statistics_address_len_pow = 0xFF; static uint32_t power_synchronous_support[] ={1, 1, 0}; static uint32_t power_asynchronous_support[] ={1, 1, 0}; + +static uint32_t supported_power_domain_protocols[] = { + SUPPORTED_POWER_DOMAIN_VERSION_1, + SUPPORTED_POWER_DOMAIN_VERSION_2, + SUPPORTED_POWER_DOMAIN_VERSION_2P1, + SUPPORTED_POWER_DOMAIN_VERSION_3, + SUPPORTED_POWER_DOMAIN_VERSION_3P1, +}; + #endif /* __PAL_POWER_DOMAIN_EXPECTED_H__ */ diff --git a/platform/mocker/include/pal_powercap_expected.h b/platform/mocker/include/pal_powercap_expected.h index 06966539ab13bb66a8222f5057c4b474de18a6a8..648b8991d6761fd782e58f326e51cb5f0e49c4f5 100644 --- a/platform/mocker/include/pal_powercap_expected.h +++ b/platform/mocker/include/pal_powercap_expected.h @@ -18,6 +18,7 @@ #ifndef __PAL_POWERCAP_EXPECTED_H__ #define __PAL_POWERCAP_EXPECTED_H__ +#include static uint32_t num_powercap_domain = 0x02; @@ -38,6 +39,10 @@ static uint32_t power_cap[] = {150, 200}; static uint32_t avg_power[] = {200, 400}; static uint32_t powercap_extended_name_support[] ={1, 0}; +static uint32_t supported_powercap_protocols[] = { + SUPPORTED_POWERCAP_VERSION_1, + SUPPORTED_POWERCAP_VERSION_2, +}; #endif /* __PAL_POWERCAP_EXPECTED_H__ */ diff --git a/platform/mocker/include/pal_reset_expected.h b/platform/mocker/include/pal_reset_expected.h index b22a91ac4f041dea36d80e09e799a48a5f2cb5d0..eeb28e1615c87515a60c6739952846941617ffc4 100644 --- a/platform/mocker/include/pal_reset_expected.h +++ b/platform/mocker/include/pal_reset_expected.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,6 +18,8 @@ #ifndef __PAL_RESET_EXPECTED_H__ #define __PAL_RESET_EXPECTED_H__ +#include + /* Expected RESET parameters */ /* Rest Mocker defines*/ @@ -58,4 +60,11 @@ static uint32_t reset_latency[] = 2000000, }; +static uint32_t supported_reset_protocols[] = { + SUPPORTED_RESET_VERSION_1, + SUPPORTED_RESET_VERSION_2, + SUPPORTED_RESET_VERSION_3, + SUPPORTED_RESET_VERSION_3P1, +}; + #endif /* __PAL_RESET_EXPECTED_H__ */ diff --git a/platform/mocker/include/pal_sensor_expected.h b/platform/mocker/include/pal_sensor_expected.h index 283302a4a7178d82161f51ae70c212a2a765c834..0b012945f623d1cfc764940d29ff4ce3a01566e5 100644 --- a/platform/mocker/include/pal_sensor_expected.h +++ b/platform/mocker/include/pal_sensor_expected.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,6 +18,8 @@ #ifndef __PAL_SENSOR_EXPECTED_H__ #define __PAL_SENSOR_EXPECTED_H__ +#include + /* Expected SENSOR parameters */ #define NUM_OF_SENSORS_SUPPORTED 2 #define SENOR_ASYNC_READ_SUPPORTED 1 @@ -112,4 +114,11 @@ static uint32_t num_sensors = NUM_OF_SENSORS_SUPPORTED; static uint32_t statistics_address_low_snsr = 0x1234; static uint32_t statistics_address_len_snsr = 0xFF; +static uint32_t supported_sensor_protocols[] = { + SUPPORTED_SENSOR_VERSION_1, + SUPPORTED_SENSOR_VERSION_2, + SUPPORTED_SENSOR_VERSION_3, + SUPPORTED_SENSOR_VERSION_3P1, +}; + #endif /* __PAL_SENSOR_EXPECTED_H__ */ diff --git a/platform/mocker/include/pal_system_power_expected.h b/platform/mocker/include/pal_system_power_expected.h new file mode 100644 index 0000000000000000000000000000000000000000..3e723987f71c6bdb343c309915d97eeffb003a13 --- /dev/null +++ b/platform/mocker/include/pal_system_power_expected.h @@ -0,0 +1,31 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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 __PAL_SYSTEM_POWER_EXPECTED_H__ +#define __PAL_SYSTEM_POWER_EXPECTED_H__ + +#include + +/* Expected SYSTEM POWER parameters */ + +static uint32_t supported_system_power_protocols[] = { + SUPPORTED_SYSTEM_POWER_VERSION_1, + SUPPORTED_SYSTEM_POWER_VERSION_2, + SUPPORTED_SYSTEM_POWER_VERSION_2P1 +}; + +#endif /* __PAL_SYSTEM_POWER_EXPECTED_H__ */ diff --git a/platform/mocker/include/pal_voltage_expected.h b/platform/mocker/include/pal_voltage_expected.h index 74b9c12eefe281f3acb7a788ded5f1c006a2f3e3..0060b770f2c65211d4b0a81aab7ba6f2a2a45559 100644 --- a/platform/mocker/include/pal_voltage_expected.h +++ b/platform/mocker/include/pal_voltage_expected.h @@ -18,6 +18,8 @@ #ifndef __PAL_VOLTAGE_EXPECTED_H__ #define __PAL_VOLTAGE_EXPECTED_H__ +#include + static uint32_t num_voltage_domains = 0x02; static char *voltage_domain_names[] = { @@ -32,4 +34,10 @@ static uint32_t *voltage_describe_levels[] = { static uint32_t operational_level[] = {40, 60}; +static uint32_t supported_voltage_protocols[] = { + SUPPORTED_VOLTAGE_VERSION_1, + SUPPORTED_VOLTAGE_VERSION_2, + SUPPORTED_VOLTAGE_VERSION_2P1, +}; + #endif /* __PAL_VOLTAGE_EXPECTED_H__ */ diff --git a/platform/mocker/mocker/include/base_common.h b/platform/mocker/mocker/include/base_common.h index 3121798d17f70b4b003993c39ce5b6e4a5b4b231..4c8de86357581e6bc580ad01d5bee68fbffe726c 100644 --- a/platform/mocker/mocker/include/base_common.h +++ b/platform/mocker/mocker/include/base_common.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -148,4 +148,9 @@ struct arm_scmi_base_reset_agent_configuration { } flags_bits; }; +struct arm_scmi_base_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /*_BASE_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/base_protocol.h b/platform/mocker/mocker/include/base_protocol.h index 6d6193019f614f49d8be5e3180cd2a39d23389ae..785685991b14f7601bf888143f398f368495ee28 100644 --- a/platform/mocker/mocker/include/base_protocol.h +++ b/platform/mocker/mocker/include/base_protocol.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -23,8 +23,10 @@ #ifdef SCMI_VERSION_1 #define BASE_VERSION 0x00010000 -#else +#elif SCMI_VERSION_2 || SCMI_VERSION_3 || SCMI_VERSION_3P1 #define BASE_VERSION 0x00020000 +#else +#define BASE_VERSION 0x00020001 #endif #define BASE_PROTO_ID 0x10 @@ -40,6 +42,7 @@ #define BASE_SET_DEVICE_PERMISSIONS_MSG_ID 0x9 #define BASE_SET_PROTOCOL_PERMISSIONS_MSG_ID 0xA #define BASE_RESET_AGENT_CONFIGURATION_MSG_ID 0xB +#define BASE_NEGOTIATE_PROTOCOL_MSG_ID 0x10 #define VENDOR_ID_SIZE 16 #define SUB_VENDOR_ID_SIZE 16 diff --git a/platform/mocker/mocker/include/clock_common.h b/platform/mocker/mocker/include/clock_common.h index 24dbbe3bf83a5f66f73573e95c9a3e0f6604d895..17b0e43e84d9381a3ec9d96b4a178bb1161605c0 100644 --- a/platform/mocker/mocker/include/clock_common.h +++ b/platform/mocker/mocker/include/clock_common.h @@ -85,6 +85,36 @@ struct arm_scmi_clock_attributes_v2 { } clk_attributes_bits_v2; }; +struct arm_scmi_clock_attributes_v3 { + struct { + uint32_t clock_id; + } parameters; + struct { + uint32_t attributes; + uint8_t clock_name[SCMI_NAME_STR_SIZE]; + uint32_t clock_enable_delay; + } returns; + + enum { + CLK_ATTRIBUTES_ENABLE_LOW_V3 = 0, + CLK_ATTRIBUTES_ENABLE_HIGH_V3 = 0, + CLK_ATTRIBUTES_RESTRICTED_CLOCK_LOW_V3 = 1, + CLK_ATTRIBUTES_RESTRICTED_CLOCK_HIGH_V3 = 1, + CLK_ATTRIBUTES_RESERVED_LOW_V3 = 2, + CLK_ATTRIBUTES_RESERVED_HIGH_V3 = 26, + CLK_ATTRIBUTES_EXT_CONFIG_SUPP_LOW_V3 = 27, + CLK_ATTRIBUTES_EXT_CONFIG_SUPP_HIGH_V3 = 27, + CLK_ATTRIBUTES_PARENT_SUPPORT_LOW_V3 = 28, + CLK_ATTRIBUTES_PARAENT_SUPPORT_HIGH_V3 = 28, + CLK_ATTRIBUTES_EXT_NAME_SUPPORT_LOW_V3 = 29, + CLK_ATTRIBUTES_EXT_NAME_SUPPORT_HIGH_V3 = 29, + CLK_ATTRIBUTES_CHANGE_REQ_NOTIFY_LOW_V3 = 30, + CLK_ATTRIBUTES_CHANGE_REQ_NOTIFY_HIGH_V3 = 30, + CLK_ATTRIBUTES_CHANGE_NOTIFY_LOW_V3 = 31, + CLK_ATTRIBUTES_CHANGE_NOTIFY_HIGH_V3 =31 + } clk_attributes_bits_v3; +}; + struct arm_scmi_clock_protocol_message_attributes { struct { uint32_t message_id; @@ -198,20 +228,21 @@ struct arm_scmi_clock_parent_set { } parameters; }; -struct arm_scmi_clock_config_set_v4 { +struct arm_scmi_clock_config_set_v3 { struct { uint32_t clock_id; uint32_t attributes; uint32_t oem_config_val; } parameters; enum { - CLK_CONFIGSET_ATTR_ENABLED_V4 = 0, - CLK_CONFIGSET_ATTR_RESERVED0_LOW_V4 = 2, - CLK_CONFIGSET_ATTR_RESERVED0_HIGH_V4 = 15, - CLK_CONFIGSET_ATTR_OEM_CONFIG_LOW_V4 = 16, - CLK_CONFIGSET_ATTR_OEM_CONFIG_HIGH_V4 = 23, - CLK_CONFIGSET_ATTR_RESERVED1_LOW_V4 = 24, - CLK_CONFIGSET_ATTR_RESERVED1_HIGH_V4 = 31, + CLK_CONFIGSET_ATTR_ENABLED_LOW_V3 = 0, + CLK_CONFIGSET_ATTR_ENABLED_HIGH_V3 = 1, + CLK_CONFIGSET_ATTR_RESERVED0_LOW_V3 = 2, + CLK_CONFIGSET_ATTR_RESERVED0_HIGH_V3 = 15, + CLK_CONFIGSET_ATTR_OEM_CONFIG_LOW_V3 = 16, + CLK_CONFIGSET_ATTR_OEM_CONFIG_HIGH_V3 = 23, + CLK_CONFIGSET_ATTR_RESERVED1_LOW_V3 = 24, + CLK_CONFIGSET_ATTR_RESERVED1_HIGH_V3 = 31, } config_set_flags; }; @@ -234,4 +265,30 @@ struct arm_scmi_clock_possible_parents_get { } clock_possible_parents_flags_bits; }; +struct arm_scmi_clock_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; + +struct arm_scmi_clock_get_permissions { + struct { + uint32_t clock_id; + } parameters; + struct { + uint32_t permissions; + } returns; + + enum { + CLK_GET_PERMISSIONS_RESERVED_LOW = 0, + CLK_GET_PERMISSIONS_RESERVED_HIGH = 28, + CLK_GET_PERMISSIONS_RATE_CONTROL_LOW = 29, + CLK_GET_PERMISSIONS_RATE_CONTROL_HIGH = 29, + CLK_GET_PERMISSIONS_PARENT_CONTROL_LOW = 30, + CLK_GET_PERMISSIONS_PARENT_CONTROL_HIGH = 30, + CLK_GET_PERMISSIONS_STATE_CONTROL_LOW = 31, + CLK_GET_PERMISSIONS_STATE_CONTROL_HIGH = 31, + } clk_permissions_bits; +}; + #endif /* CLOCK_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/clock_protocol.h b/platform/mocker/mocker/include/clock_protocol.h index 35fd1c484717142555d629b99d7354375b21d8a2..830013efa193190a39dc76125991fedc6ea714b0 100644 --- a/platform/mocker/mocker/include/clock_protocol.h +++ b/platform/mocker/mocker/include/clock_protocol.h @@ -23,8 +23,10 @@ #ifdef SCMI_VERSION_1 #define CLOCK_VERSION 0x00010000 +#elif SCMI_VERSION_2 || SCMI_VERSION_3 || SCMI_VERSION_3P1 +#define CLOCK_VERSION 0x00020000 #else -#define CLOCK_VERSION 0x00020001 +#define CLOCK_VERSION 0x00030000 #endif #define CLK_PROTO_ID 0x14 @@ -36,10 +38,13 @@ #define CLK_RATE_SET_MSG_ID 0x5 #define CLK_RATE_GET_MSG_ID 0x6 #define CLK_CONFIG_SET_MSG_ID 0x7 -#define CLK_PARENT_GET_MSG_ID 0xE -#define CLK_PARENT_SET_MSG_ID 0xD +#define CLK_RATE_CHANGE_REQ_NOTIFY 0xA #define CLK_CONFIG_GET_MSG_ID 0xB #define CLK_POSSIBLE_PARENT_GET_MSG_ID 0xC +#define CLK_PARENT_SET_MSG_ID 0xD +#define CLK_PARENT_GET_MSG_ID 0xE +#define CLK_GET_PERMISSIONS_MSG_ID 0xF +#define CLK_NEGOTIATE_PROTOCOL_MSG_ID 0x10 #define MAX_NUM_CLOCK 16 #define MAX_NUM_RATES_SUPPORTED 16 diff --git a/platform/mocker/mocker/include/performance_common.h b/platform/mocker/mocker/include/performance_common.h index 90dc2c753ebf3224b846ec2653dc1d1d19a863c7..a749021e695bf20467bcc165be345f49761e1f91 100644 --- a/platform/mocker/mocker/include/performance_common.h +++ b/platform/mocker/mocker/include/performance_common.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019, 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019, 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -243,4 +243,11 @@ struct arm_scmi_performance_describe_fast_channel { PERFORMANCE_DESCRIBE_FAST_CH_ATTR_DOORBELL_SUPPORT = 0, }arm_scmi_performance_describe_fst_ch_attributes_bits; }; + +struct arm_scmi_performance_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; + #endif /* PERFORMANCE_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/performance_protocol.h b/platform/mocker/mocker/include/performance_protocol.h index 424f9e2418b0b1edd2069fbc469d99dc321b258c..b4649a2800ccd82cfb2d89f5a78b23d1b16842bd 100644 --- a/platform/mocker/mocker/include/performance_protocol.h +++ b/platform/mocker/mocker/include/performance_protocol.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2020, 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2020, 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -23,6 +23,10 @@ #ifdef SCMI_VERSION_1 #define PERFORMANCE_VERSION 0x00010000 +#elif SCMI_VERSION_2 || SCMI_VERSION_3 +#define PERFORMANCE_VERSION 0x00020000 +#elif SCMI_VERSION_3P1 +#define PERFORMANCE_VERSION 0x00030000 #else #define PERFORMANCE_VERSION 0x00040000 #endif @@ -40,6 +44,7 @@ #define PERF_NOTIFY_LIMIT_MSG_ID 0x9 #define PERF_NOTIFY_LVL_MSG_ID 0xA #define PERF_DESCRIBE_FASTCHANNEL 0xB +#define PERF_NEGOTIATE_PROTOCOL_MSG_ID 0x10 #define MAX_PERFORMANCE_DOMAIN_COUNT 10 diff --git a/platform/mocker/mocker/include/pin_control_common.h b/platform/mocker/mocker/include/pin_control_common.h index 319c09fb30be48cba7c7b25cbec66a1254981ace..49827a66826f6f590aadd8b855aa48bc5a1b7188 100644 --- a/platform/mocker/mocker/include/pin_control_common.h +++ b/platform/mocker/mocker/include/pin_control_common.h @@ -79,7 +79,11 @@ struct arm_scmi_pin_control_attributes { enum { PINCTRL_ATTRIBUTES_NUM_PINS_GROUPS_LOW = 0, PINCTRL_ATTRIBUTES_NUM_PINS_GROUPS_HIGH = 15, - PINCTRL_ATTRIBUTES_RESERVED_LOW = 16, + PINCTRL_ATTRIBUTES_FUNC_GROUP_SUPPORT_LOW = 16, + PINCTRL_ATTRIBUTES_FUNC_GROUP_SUPPORT_HIGH = 16, + PINCTRL_ATTRIBUTES_FUNC_GPIO_SUPPORT_LOW = 17, + PINCTRL_ATTRIBUTES_FUNC_GPIO_SUPPORT_HIGH = 17, + PINCTRL_ATTRIBUTES_RESERVED_LOW = 18, PINCTRL_ATTRIBUTES_RESERVED_HIGH = 30, PINCTRL_ATTRIBUTES_EXTENDED_NAME_LOW = 31, PINCTRL_ATTRIBUTES_EXTENDED_NAME_HIGH = 31 @@ -114,67 +118,71 @@ struct arm_scmi_pin_control_list_associations { } list_returns_flags_bits; }; -struct arm_scmi_pin_control_config_get { +struct arm_scmi_pin_control_settings_get { struct { uint32_t identifier; uint32_t attributes; } parameters; struct { + uint32_t function_selected; uint32_t num_configs; uint32_t configs[PINCTRL_CONFIG_ENTRY]; } returns; /* enum for attributes */ enum { - PINCTRL_CONFIG_GET_CONFIGTYPE_LOW = 0, - PINCTRL_CONFIG_GET_CONFIGTYPE_HIGH = 7, - PINCTRL_CONFIG_GET_SKIPCONFIGS_LOW = 8, - PINCTRL_CONFIG_GET_SKIPCONFIGS_HIGH = 15, - PINCTRL_CONFIG_GET_SELECTOR_LOW = 16, - PINCTRL_CONFIG_GET_SELECTOR_HIGH = 17, - PINCTRL_CONFIG_GET_ALLCONFIGS_LOW = 18, - PINCTRL_CONFIG_GET_ALLCONFIGS_HIGH = 18, - PINCTRL_CONFIG_GET_RESERVED_LOW = 19, - PINCTRL_CONFIG_GET_RESERVED_HIGH = 31 + PINCTRL_SETTINGS_GET_CONFIGTYPE_LOW = 0, + PINCTRL_SETTINGS_GET_CONFIGTYPE_HIGH = 7, + PINCTRL_SETTINGS_GET_SKIPCONFIGS_LOW = 8, + PINCTRL_SETTINGS_GET_SKIPCONFIGS_HIGH = 15, + PINCTRL_SETTINGS_GET_SELECTOR_LOW = 16, + PINCTRL_SETTINGS_GET_SELECTOR_HIGH = 17, + PINCTRL_SETTINGS_GET_ALLCONFIGS_LOW = 18, + PINCTRL_SETTINGS_GET_ALLCONFIGS_HIGH = 18, + PINCTRL_SETTINGS_GET_RESERVED_LOW = 19, + PINCTRL_SETTINGS_GET_RESERVED_HIGH = 31 } attributes_bits; /* enums for num_configs*/ enum { - PINCTRL_CONFIG_GET_NUM_CONFIGS_LOW = 0, - PINCTRL_CONFIG_GET_NUM_CONFIGS_HIGH = 7, - PINCTRL_CONFIG_GET_NUM_CONFIGS_RESERVED_LOW = 8, - PINCTRL_CONFIG_GET_NUM_CONFIGS_RESERVED_HIGH = 23, - PINCTRL_CONFIG_GET_NUM_REMAINING_CONFIGS_LOW = 24, - PINCTRL_CONFIG_GET_NUM_REMAINING_CONFIGS_HIGH = 31 + PINCTRL_SETTINGS_GET_NUM_CONFIGS_LOW = 0, + PINCTRL_SETTINGS_GET_NUM_CONFIGS_HIGH = 7, + PINCTRL_SETTINGS_GET_NUM_CONFIGS_RESERVED_LOW = 8, + PINCTRL_SETTINGS_GET_NUM_CONFIGS_RESERVED_HIGH = 23, + PINCTRL_SETTINGS_GET_NUM_REMAINING_CONFIGS_LOW = 24, + PINCTRL_SETTINGS_GET_NUM_REMAINING_CONFIGS_HIGH = 31 } num_configs_bits; /* enums for configs entry 0 */ enum { - PINCTRL_CONFIG_GET_CONFIG_TYPE_LOW = 0, - PINCTRL_CONFIG_GET_CONFIG_TYPE_HIGH = 7, - PINCTRL_CONFIG_GET_ENTRY_RESERVED_LOW = 8, - PINCTRL_CONFIG_GET_ENTRY_RESERVED_HIGH = 31 + PINCTRL_SETTINGS_GET_CONFIG_TYPE_LOW = 0, + PINCTRL_SETTINGS_GET_CONFIG_TYPE_HIGH = 7, + PINCTRL_SETTINGS_GET_ENTRY_RESERVED_LOW = 8, + PINCTRL_SETTINGS_GET_ENTRY_RESERVED_HIGH = 31 } get_configs_entry_0_bits; }; -struct arm_scmi_pin_control_config_set { +struct arm_scmi_pin_control_settings_configure { struct { uint32_t identifier; + uint32_t function_id; uint32_t attributes; uint32_t configs[PINCTRL_CONFIG_ENTRY]; } parameters; /* enums for attributes */ enum { - PINCTRL_CONFIG_SET_SELECTOR_LOW = 0, - PINCTRL_CONFIG_SET_SELECTOR_HIGH = 1, - PINCTRL_CONFIG_SET_NUM_CONFIGS_LOW = 2, - PINCTRL_CONFIG_SET_NUM_CONFIGS_HIGH = 9, - PINCTRL_CONFIG_SET_RESERVED_LOW = 10, - PINCTRL_CONFIG_SET_RESERVED_HIGH = 31 + PINCTRL_SETTINGS_CONFIGURE_SELECTOR_LOW = 0, + PINCTRL_SETTINGS_CONFIGURE_SELECTOR_HIGH = 1, + PINCTRL_SETTINGS_CONFIGURE_NUM_CONFIGS_LOW = 2, + PINCTRL_SETTINGS_CONFIGURE_NUM_CONFIGS_HIGH = 9, + PINCTRL_SETTINGS_CONFIGURE_FUNC_ID_LOW = 10, + PINCTRL_SETTINGS_CONFIGURE_FUNC_ID_HIGH = 10, + PINCTRL_SETTINGS_CONFIGURE_RESERVED_LOW = 11, + PINCTRL_SETTINGS_CONFIGURE_RESERVED_HIGH = 31 } set_attributes_bits; /* enums for configs entry 0 */ enum { - PINCTRL_CONFIG_SET_CONFIG_TYPE_LOW = 0, - PINCTRL_CONFIG_SET_CONFIG_TYPE_HIGH = 7, - PINCTRL_CONFIG_SET_ENTRY_RESERVED_LOW = 8, - PINCTRL_CONFIG_SET_ENTRY_RESERVED_HIGH = 31 + PINCTRL_SETTINGS_CONFIGURE_CONFIG_TYPE_LOW = 0, + PINCTRL_SETTINGS_CONFIGURE_CONFIG_TYPE_HIGH = 7, + PINCTRL_SETTINGS_CONFIGURE_ENTRY_RESERVED_LOW = 8, + PINCTRL_SETTINGS_CONFIGURE_ENTRY_RESERVED_HIGH = 31 } set_configs_entry_0_bits; }; @@ -257,4 +265,9 @@ struct arm_scmi_pin_control_name_get { }; +struct arm_scmi_pin_control_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /* PIN_CONTROL_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/pin_control_protocol.h b/platform/mocker/mocker/include/pin_control_protocol.h index ffe3abaa21f9d419f138eea863a2e17b76239b31..59f7733198aefb78bee6550c02391197bf7601d5 100644 --- a/platform/mocker/mocker/include/pin_control_protocol.h +++ b/platform/mocker/mocker/include/pin_control_protocol.h @@ -36,13 +36,14 @@ #define PINCTRL_PROTO_MSG_ATTRIB_MSG_ID 0x2 #define PINCTRL_ATTRIB_MSG_ID 0x3 #define PINCTRL_LIST_ASSOC_MSG_ID 0x4 -#define PINCTRL_CONFIG_GET_MSG_ID 0x5 -#define PINCTRL_CONFIG_SET_MSG_ID 0x6 +#define PINCTRL_SETTINGS_GET_MSG_ID 0x5 +#define PINCTRL_SETTINGS_CONFIGURE_MSG_ID 0x6 #define PINCTRL_FUNC_SELECT_MSG_ID 0x7 #define PINCTRL_REQUEST_MSG_ID 0x8 #define PINCTRL_RELEASE_MSG_ID 0x9 #define PINCTRL_NAME_GET_MSG_ID 0xA #define PINCTRL_SET_PERM_MSG_ID 0xB +#define PINCTRL_NEGOTIATE_PROTOCOL_MSG_ID 0x10 struct arm_scmi_pin_control_config_default { uint32_t type; diff --git a/platform/mocker/mocker/include/power_domain_common.h b/platform/mocker/mocker/include/power_domain_common.h index 05dc1b5de03ef5cb8f5bcfeea707aaab000eccfb..115b0e35b0aecf74ad239dadd9a5e6690b36d2be 100644 --- a/platform/mocker/mocker/include/power_domain_common.h +++ b/platform/mocker/mocker/include/power_domain_common.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -124,5 +124,9 @@ struct arm_scmi_power_state_change_requested_notify { } power_notify_bits; }; - +struct arm_scmi_power_domain_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /* POWER_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/power_domain_protocol.h b/platform/mocker/mocker/include/power_domain_protocol.h index 6d17a22562f93f5cbed0ec49682263246d3b157b..601fffd27668e1534ef0910a01e3d14999f7bf15 100644 --- a/platform/mocker/mocker/include/power_domain_protocol.h +++ b/platform/mocker/mocker/include/power_domain_protocol.h @@ -23,8 +23,14 @@ #ifdef SCMI_VERSION_1 #define POWER_DOMAIN_VERSION 0x00010000 -#else +#elif SCMI_VERSION_2 #define POWER_DOMAIN_VERSION 0x00020000 +#elif SCMI_VERSION_3 +#define POWER_DOMAIN_VERSION 0x00020001 +#elif SCMI_VERSION_3P1 +#define POWER_DOMAIN_VERSION 0x00030000 +#else +#define POWER_DOMAIN_VERSION 0x00030001 #endif #define PWR_PROTO_ID 0x11 @@ -36,6 +42,7 @@ #define PWR_STATE_GET_MSG_ID 0x5 #define PWR_STATE_NOTIFY_MSG_ID 0x6 #define PWR_STATE_CHANGE_REQUESTED_NOTIFY_MSG_ID 0x7 +#define PWR_STATE_NEGOTIATE_PROTOCOL_MSG_ID 0x10 #define PWR_NOTIFY_ENABLE_SET 1 #define PWR_NOTIFY_ENABLE_UNSET 0 diff --git a/platform/mocker/mocker/include/powercap_common.h b/platform/mocker/mocker/include/powercap_common.h index b1dd24f62f8399e175d6ff76ffebee0ee421c99a..c676a2dac27ed37f207888d7d3d87f5dfe22ea28 100644 --- a/platform/mocker/mocker/include/powercap_common.h +++ b/platform/mocker/mocker/include/powercap_common.h @@ -188,4 +188,10 @@ struct arm_scmi_powercap_measurements_notify { POWERCAP_MEASURE_RESERVED_HIGH = 31 } measure_notify_enable_bits; }; + +struct arm_scmi_powercap_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /* POWERCAP_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/powercap_protocol.h b/platform/mocker/mocker/include/powercap_protocol.h index ac1b495de4448ffc85f1559132adc7c50d4be477..929562af32bb544b0a342f2ce881ecc166cf76f0 100644 --- a/platform/mocker/mocker/include/powercap_protocol.h +++ b/platform/mocker/mocker/include/powercap_protocol.h @@ -21,7 +21,11 @@ #include #include +#ifdef SCMI_VERSION_3P1 #define POWERCAP_VERSION 0x00010000 +#else +#define POWERCAP_VERSION 0x00020000 +#endif #define POWERCAP_PROTO_ID 0x18 #define POWERCAP_PROTO_VER_MSG_ID 0x0 @@ -36,6 +40,7 @@ #define POWERCAP_MEASUREMENTS_GET_MSG_ID 0x9 #define POWERCAP_CAP_NOTIFY_MSG_ID 0xA #define POWERCAP_MEASURMENTS_NOTIFY_MSG_ID 0xB +#define POWERCAP_NEGOTIATE_PROTOCOL_MSG_ID 0x10 struct arm_scmi_powercap_protocol { /* diff --git a/platform/mocker/mocker/include/protocol_common.h b/platform/mocker/mocker/include/protocol_common.h index 2a293263d3c42806ee0f2dab4342eecb8930b6ad..8854bdea90afc683317f8755a490e167ba45bbc5 100644 --- a/platform/mocker/mocker/include/protocol_common.h +++ b/platform/mocker/mocker/include/protocol_common.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -29,6 +29,7 @@ #include #include +#define MSG_SIZE 100 #define SCMI_NAME_STR_SIZE 16 #define NUM_ELEMS(x) (sizeof(x) / sizeof((x)[0])) diff --git a/platform/mocker/mocker/include/reset_common.h b/platform/mocker/mocker/include/reset_common.h index 5cd734f4807b6a2398cad200e71d6c33ab6053fb..d7272295034898d3186ab0c9e1f144aea633d13a 100644 --- a/platform/mocker/mocker/include/reset_common.h +++ b/platform/mocker/mocker/include/reset_common.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -96,4 +96,9 @@ struct arm_scmi_reset_protocol_notify_enable { } notify_en_bits; }; +struct arm_scmi_reset_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /* RESET_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/reset_protocol.h b/platform/mocker/mocker/include/reset_protocol.h index fb6445430f3356135ad771d00318deed56e3969f..0414874ce75ba62663db2e1755e3edda7bb01cd1 100644 --- a/platform/mocker/mocker/include/reset_protocol.h +++ b/platform/mocker/mocker/include/reset_protocol.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,15 @@ #include #include +#ifdef SCMI_VERSION_2 +#define RESET_VERSION 0x00010000 +#elif SCMI_VERSION_3 #define RESET_VERSION 0x00020000 +#elif SCMI_VERSION_3P1 +#define RESET_VERSION 0x00030000 +#else +#define RESET_VERSION 0x00030001 +#endif #define RESET_PROTO_ID 0x16 #define RESET_PROTO_VER_MSG_ID 0x0 @@ -30,6 +38,7 @@ #define RESET_PROTO_DOMAIN_ATTRIB_MSG_ID 0x3 #define RESET_PROTO_RESET_MSG_ID 0x4 #define RESET_PROTO_NOTIFY_MSG_ID 0x5 +#define RESET_NEGOTIATE_PROTOCOL_MSG_ID 0x10 struct arm_scmi_reset_protocol { /* diff --git a/platform/mocker/mocker/include/sensor_common.h b/platform/mocker/mocker/include/sensor_common.h index 5ab4f7303675892779e63d630faf1a6d6a8eb514..f6d1ff1214adaa581a088eb5d845b83a427fb8ac 100644 --- a/platform/mocker/mocker/include/sensor_common.h +++ b/platform/mocker/mocker/include/sensor_common.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -314,4 +314,9 @@ struct arm_scmi_cont_update_notify { } sensor_notify_enable_bits; }; +struct arm_scmi_sensor_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /* SENSOR_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/sensor_protocol.h b/platform/mocker/mocker/include/sensor_protocol.h index af5237f44f7f25574185762ab05cea6d10ccddbb..a44772ae6d6526dca99ca8904c957a2ebcb4b644 100644 --- a/platform/mocker/mocker/include/sensor_protocol.h +++ b/platform/mocker/mocker/include/sensor_protocol.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,17 @@ #include #include +#ifdef SCMI_VERSION_1 +#define SENSOR_VERSION 0x00010000 +#elif SCMI_VERSION_2 +#define SENSOR_VERSION 0x00010000 +#elif SCMI_VERSION_3 #define SENSOR_VERSION 0x00020000 +#elif SCMI_VERSION_3P1 +#define SENSOR_VERSION 0x00030000 +#else +#define SENSOR_VERSION 0x00030001 +#endif #define SNSR_PROTO_ID 0x15 @@ -37,6 +47,7 @@ #define SNSR_CONFIG_GET_MSG_ID 0x9 #define SNSR_CONFIG_SET_MSG_ID 0xA #define SNSR_CNT_UPDATE_NOTIFY_MSG_ID 0xB +#define SNSR_NEGOTIATE_PROTOCOL_MSG_ID 0x10 #define MAX_NUMBER_SENSOR 32 #define SENSOR_ASYNC 1 diff --git a/platform/mocker/mocker/include/system_power_common.h b/platform/mocker/mocker/include/system_power_common.h index 8bf02753b86ec97ff3ddcefd505028aa27a83878..3ca379ef3ad5e0b507bbf22a996104c8be220e9b 100644 --- a/platform/mocker/mocker/include/system_power_common.h +++ b/platform/mocker/mocker/include/system_power_common.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -75,4 +75,10 @@ struct arm_scmi_system_power_state_set_notify { SYSTEM_POWER_SET_NOTIFY_RESERVED_HIGH=31, } notify_sys_pwr_set_enable_bits; }; + +struct arm_scmi_system_power_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /* SYSTEM_POWER_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/system_power_protocol.h b/platform/mocker/mocker/include/system_power_protocol.h index 75e9c7e2c25b253701bb4d9f13f4560e380931e7..ee82ffa3896d1324746cca97cbd4f92bfb2e889e 100644 --- a/platform/mocker/mocker/include/system_power_protocol.h +++ b/platform/mocker/mocker/include/system_power_protocol.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,17 @@ #include #include +#ifdef SCMI_VERSION_1 #define SYSTEM_POWER_VERSION 0x00010000 +#elif SCMI_VERSION_2 +#define SYSTEM_POWER_VERSION 0x00010000 +#elif SCMI_VERSION_3 +#define SYSTEM_POWER_VERSION 0x00010000 +#elif SCMI_VERSION_3P1 +#define SYSTEM_POWER_VERSION 0x00020000 +#else +#define SYSTEM_POWER_VERSION 0x00020001 +#endif #define SYSTEM_POWER_PROTO_ID 0x12 #define SYSTEM_POWER_PROTO_VER_MSG_ID 0x0 @@ -30,6 +40,7 @@ #define SYSTEM_POWER_STATE_SET_MSG_ID 0x3 #define SYSTEM_POWER_STATE_GET_MSG_ID 0x4 #define SYSTEM_POWER_STATE_NOTIFY_MSG_ID 0x5 +#define SYSTEM_POWER_NEGOTIATE_PROTOCOL_MSG_ID 0x10 struct arm_scmi_system_power_protocol { /* diff --git a/platform/mocker/mocker/include/voltage_common.h b/platform/mocker/mocker/include/voltage_common.h index f00a432b38259f33a48e034a48ea92ecf6f13565..fcbb6c4337e14965256bc48f440e56d85c8d28a9 100644 --- a/platform/mocker/mocker/include/voltage_common.h +++ b/platform/mocker/mocker/include/voltage_common.h @@ -180,4 +180,9 @@ struct arm_scmi_voltage_domain_name_get { } name_flags_bits; }; +struct arm_scmi_voltage_negotiate_protocol { + struct { + uint32_t version; + } parameters; +}; #endif /* VOLTAGE_COMMON_H_ */ diff --git a/platform/mocker/mocker/include/voltage_protocol.h b/platform/mocker/mocker/include/voltage_protocol.h index 6d0a862b46c617c1e4a3d0cff7160256ffdf30af..77d7730a3814ac6d9712fdd9d14878b68e06c6ae 100644 --- a/platform/mocker/mocker/include/voltage_protocol.h +++ b/platform/mocker/mocker/include/voltage_protocol.h @@ -21,7 +21,13 @@ #include #include +#ifdef SCMI_VERSION_3 +#define VOLTAGE_VERSION 0x00010000 +#elif SCMI_VERSION_3P1 #define VOLTAGE_VERSION 0x00020000 +#else +#define VOLTAGE_VERSION 0x00020001 +#endif #define VOLTAGE_PROTO_ID 0x17 #define VOLTAGE_PROTO_VER_MSG_ID 0x0 @@ -34,6 +40,7 @@ #define VOLTAGE_LEVEL_SET_MSG_ID 0x7 #define VOLTAGE_LEVEL_GET_MSG_ID 0x8 #define VOLTAGE_DOMAIN_NAME_GET_MSG_ID 0x9 +#define VOLTAGE_NEGOTIATE_PROTOCOL_MSG_ID 0x10 struct arm_scmi_voltage_protocol { /* diff --git a/platform/mocker/mocker/transport_base.c b/platform/mocker/mocker/transport_base.c index a80466022e9e8fb70c5b50acae3a3d476881de2b..6530e86e07902de28085e57b4c32ab198e0967ca 100644 --- a/platform/mocker/mocker/transport_base.c +++ b/platform/mocker/mocker/transport_base.c @@ -27,8 +27,8 @@ void fill_base_protocol() { base_protocol.protocol_version = BASE_VERSION; base_protocol.num_protocols_implemented = NUM_ELEMS(supported_protocols); - sprintf(base_protocol.vendor_identifier, "%s", vendor_name); - sprintf(base_protocol.subvendor_identifier, "%s", subvendor_name); + snprintf(base_protocol.vendor_identifier, MSG_SIZE, "%s", vendor_name); + snprintf(base_protocol.subvendor_identifier, MSG_SIZE,"%s", subvendor_name); base_protocol.implementation_version = implementation_version; base_protocol.supported_protocols = (uint32_t *)supported_protocols; /* Setting of base protocol optional cmd support */ @@ -94,7 +94,7 @@ bool protocol_access_permitted (uint32_t protocol_id) uint32_t agent_get_inaccessible_device(uint32_t agent_id) { - return agent1_device_access[NUM_ELEMS(agent1_device_access)].device_id + 1; + return agent1_device_access[NUM_ELEMS(agent1_device_access)].device_id + 3; } @@ -134,7 +134,7 @@ void base_send_message(uint32_t message_id, uint32_t parameter_count, case BASE_PROTO_MSG_ATTR_MSG_ID: parameter_idx = OFFSET_PARAM( struct arm_scmi_base_protocol_message_attributes, message_id); - if(parameters[parameter_idx] > BASE_RESET_AGENT_CONFIGURATION_MSG_ID) { + if(parameters[parameter_idx] > BASE_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; } else if (parameters[parameter_idx] > BASE_DISC_AGENT_MSG_ID) @@ -162,6 +162,10 @@ void base_send_message(uint32_t message_id, uint32_t parameter_count, if (base_protocol.discover_agent_cmd_supported == true) *status = SCMI_STATUS_SUCCESS; break; + case 0x10: + if (base_protocol.discover_agent_cmd_supported == true) + *status = SCMI_STATUS_SUCCESS; + break; default: *status = SCMI_STATUS_SUCCESS; } @@ -176,9 +180,9 @@ void base_send_message(uint32_t message_id, uint32_t parameter_count, break; case BASE_DISC_VENDOR_MSG_ID: *status = SCMI_STATUS_SUCCESS; - sprintf((char *)return_values, "%s", base_protocol.vendor_identifier); + snprintf((char *)return_values, MSG_SIZE, "%s", base_protocol.vendor_identifier); /* Taking max vendor string size to be 25 */ - *return_values_count = strnlen((const char*)return_values, 25); + *return_values_count = strnlen((const char*)return_values, 25); break; case BASE_DISC_SUBVENDOR_MSG_ID: if(base_protocol.subvendor_cmd_supported == false) @@ -187,7 +191,7 @@ void base_send_message(uint32_t message_id, uint32_t parameter_count, break; } *status = SCMI_STATUS_SUCCESS; - sprintf((char *)return_values, "%s", base_protocol.subvendor_identifier); + snprintf((char *)return_values, MSG_SIZE, "%s", base_protocol.subvendor_identifier); /* Taking max subvendor string size to be 25 */ *return_values_count = strnlen((const char*)return_values, 25); break; @@ -234,12 +238,12 @@ void base_send_message(uint32_t message_id, uint32_t parameter_count, if (parameters[parameter_idx] == 0xFFFFFFFF) { return_values[0] = 0; - sprintf((char *)&return_values[1], "%s", agent_name_get(0)); + snprintf((char *)&return_values[1], MSG_SIZE, "%s", agent_name_get(0)); } else { return_values[0] = parameters[parameter_idx]; - sprintf((char *)&return_values[1], "%s", + snprintf((char *)&return_values[1], MSG_SIZE, "%s", (parameters[parameter_idx] == 0 ? "platform_mock" : agent_name_get(parameters[parameter_idx]))); } @@ -352,6 +356,21 @@ void base_send_message(uint32_t message_id, uint32_t parameter_count, } } break; + case BASE_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (base_protocol.protocol_version < 0x00020001) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + flags = OFFSET_PARAM(struct arm_scmi_base_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_base_protocols); i > 0; i--) { + if (supported_base_protocols[i - 1] == parameters[flags]) { + base_protocol.protocol_version = parameters[flags]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; default: *status = SCMI_STATUS_NOT_FOUND; } diff --git a/platform/mocker/mocker/transport_clock.c b/platform/mocker/mocker/transport_clock.c index e057259d4b1e0cab58b35d2913b5112be543a3f2..8028a529dce866ae65af2155aa030f5473fbebb1 100644 --- a/platform/mocker/mocker/transport_clock.c +++ b/platform/mocker/mocker/transport_clock.c @@ -68,8 +68,13 @@ void clock_send_message(uint32_t message_id, uint32_t parameter_count, parameter_idx = OFFSET_PARAM( struct arm_scmi_clock_protocol_message_attributes, message_id); - if((parameters[parameter_idx] > CLK_CONFIG_SET_MSG_ID) && - (parameters[parameter_idx] != CLK_CONFIG_GET_MSG_ID)) + if((parameters[parameter_idx] > CLK_NEGOTIATE_PROTOCOL_MSG_ID) && + (parameters[parameter_idx] != CLK_CONFIG_GET_MSG_ID)) + { + *status = SCMI_STATUS_NOT_FOUND; + return; + } + if (parameters[parameter_idx] == CLK_RATE_CHANGE_REQ_NOTIFY) { *status = SCMI_STATUS_NOT_FOUND; return; @@ -95,17 +100,26 @@ void clock_send_message(uint32_t message_id, uint32_t parameter_count, return_values[return_idx] = clock_status[clock_id] & 0x1; str = (char *) (&return_values[OFFSET_RET(struct arm_scmi_clock_attributes, clock_name)]); - sprintf(str, "CLOCK_%d", parameters[0]); - } else { - *return_values_count = 6; + snprintf(str, MSG_SIZE, "CLOCK_%d", parameters[0]); + } else if (clock_protocol.protocol_version == 0x00020000) { + *return_values_count = 7; return_idx = OFFSET_RET(struct arm_scmi_clock_attributes_v2, attributes); return_values[return_idx] = clock_protocol.clock_parent_support[clock_id] << CLK_ATTRIBUTES_PARENT_SUPPORT_LOW_V2 | (clock_status[clock_id] & 0x1); str = (char *) (&return_values[OFFSET_RET(struct arm_scmi_clock_attributes_v2, clock_name)]); - sprintf(str, "CLOCK_%d", parameters[0]); - } + snprintf(str, MSG_SIZE, "CLOCK_%d", parameters[0]); + } else { + *return_values_count = 7; + return_idx = OFFSET_RET(struct arm_scmi_clock_attributes_v3, attributes); + return_values[return_idx] = clock_protocol.clock_parent_support[clock_id] << + CLK_ATTRIBUTES_PARENT_SUPPORT_LOW_V3 | (clock_status[clock_id] & 0x1); + + str = (char *) (&return_values[OFFSET_RET(struct arm_scmi_clock_attributes_v3, + clock_name)]); + snprintf(str, MSG_SIZE, "CLOCK_%d", parameters[0]); + } break; case CLK_DESC_RATE_MSG_ID: clock_id = parameters[OFFSET_PARAM(struct arm_scmi_clock_describe_rates, @@ -186,30 +200,30 @@ void clock_send_message(uint32_t message_id, uint32_t parameter_count, } break; case CLK_CONFIG_SET_MSG_ID: - if (clock_protocol.protocol_version == 0x20001) + if (clock_protocol.protocol_version == 0x30000) { - parameter_idx = OFFSET_PARAM(struct arm_scmi_clock_config_set_v4, clock_id); + parameter_idx = OFFSET_PARAM(struct arm_scmi_clock_config_set_v3, clock_id); clock_id = parameters[parameter_idx]; if (clock_id >= clock_protocol.number_clocks) { *status = SCMI_STATUS_NOT_FOUND; break; } - parameter_idx = OFFSET_PARAM(struct arm_scmi_clock_config_set_v4, attributes); - if (((parameters[parameter_idx] >> CLK_CONFIGSET_ATTR_ENABLED_V4) & 0x3) > 1) + parameter_idx = OFFSET_PARAM(struct arm_scmi_clock_config_set_v3, attributes); + if (((parameters[parameter_idx] >> CLK_CONFIGSET_ATTR_ENABLED_LOW_V3) & 0x3) > 1) { *status = SCMI_STATUS_INVALID_PARAMETERS; break; } - if (((parameters[parameter_idx] >> CLK_CONFIGSET_ATTR_OEM_CONFIG_LOW_V4) & 0xFF) == 0) - if (((parameters[parameter_idx] >> CLK_CONFIGSET_ATTR_ENABLED_V4) & 0x3) == 3) + if (((parameters[parameter_idx] >> CLK_CONFIGSET_ATTR_OEM_CONFIG_LOW_V3) & 0xFF) == 0) + if (((parameters[parameter_idx] >> CLK_CONFIGSET_ATTR_ENABLED_LOW_V3) & 0x3) == 3) { *status = SCMI_STATUS_INVALID_PARAMETERS; break; } *status = SCMI_STATUS_SUCCESS; clock_status[clock_id] = ((parameters[parameter_idx] >> - CLK_CONFIGSET_ATTR_ENABLED_V4) & 0x3); + CLK_CONFIGSET_ATTR_ENABLED_LOW_V3) & 0x3); } else { parameter_idx = OFFSET_PARAM(struct arm_scmi_clock_config_set, clock_id); clock_id = parameters[parameter_idx]; @@ -242,6 +256,11 @@ void clock_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_INVALID_PARAMETERS; break; } + if ((parameters[parameter_idx] > 0x2) && (parameters[parameter_idx] < 0x80)) + { + *status = SCMI_STATUS_INVALID_PARAMETERS; + break; + } *status = SCMI_STATUS_SUCCESS; return_values[OFFSET_RET(struct arm_scmi_clock_config_get, attributes)] = 0; @@ -328,6 +347,37 @@ void clock_send_message(uint32_t message_id, uint32_t parameter_count, *return_values_count = 1 + j; break; + case CLK_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (clock_protocol.protocol_version < 0x00030000) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + return_idx = OFFSET_PARAM(struct arm_scmi_clock_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_clock_protocols); i > 0; i--) { + if (supported_clock_protocols[i - 1] == parameters[return_idx]) { + clock_protocol.protocol_version = parameters[return_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; + + case CLK_GET_PERMISSIONS_MSG_ID: + parameter_idx = OFFSET_PARAM(struct arm_scmi_clock_get_permissions, clock_id); + clock_id = parameters[parameter_idx]; + if (clock_id >= clock_protocol.number_clocks) + { + *status = SCMI_STATUS_NOT_FOUND; + break; + } + + *return_values_count = 1; + return_values[OFFSET_RET( + struct arm_scmi_clock_get_permissions, permissions)] = 0x0; + *status = SCMI_STATUS_SUCCESS; + break; + default: *status = SCMI_STATUS_NOT_FOUND; } diff --git a/platform/mocker/mocker/transport_performance.c b/platform/mocker/mocker/transport_performance.c index 3c045c958df376f50169ff809e7c9a3ffdb7f124..db36080fe6553e21fa329014b006a875677d2c8c 100644 --- a/platform/mocker/mocker/transport_performance.c +++ b/platform/mocker/mocker/transport_performance.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -113,7 +113,7 @@ void performance_send_message(uint32_t message_id, uint32_t parameter_count, case PERF_MGMT_PROTO_MSG_ATTRIB_MSG_ID: parameter_idx = OFFSET_PARAM( struct arm_scmi_performance_protocol_message_attributes, message_id); - if(parameters[parameter_idx] > PERF_DESCRIBE_FASTCHANNEL) { + if(parameters[parameter_idx] > PERF_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; } else { *status = SCMI_STATUS_SUCCESS; @@ -162,7 +162,7 @@ void performance_send_message(uint32_t message_id, uint32_t parameter_count, (performance_protocol.performance_sustained_freq[domain_id]); str = (char *) (&return_values[OFFSET_RET(struct arm_scmi_performance_domain_attributes_v4, name)]); - sprintf(str, "Domain_%d", domain_id); + snprintf(str, MSG_SIZE, "Domain_%d", domain_id); *return_values_count = 5; } else { @@ -196,7 +196,7 @@ void performance_send_message(uint32_t message_id, uint32_t parameter_count, (performance_protocol.performance_sustained_freq[domain_id]); str = (char *) (&return_values[OFFSET_RET(struct arm_scmi_performance_domain_attributes, name)]); - sprintf(str, "Domain_%d", domain_id); + snprintf(str, MSG_SIZE, "Domain_%d", domain_id); *return_values_count = 5; } break; @@ -284,6 +284,43 @@ void performance_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_DENIED; return; } + + if((parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_max)] == 0) && + (parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_min)] == 0)) + { + *status = SCMI_STATUS_OUT_OF_RANGE; + return; + } + + if (parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_min)] == 0) + { + if((parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_max)] > + performance_protocol.performance_level_value[domain_id] + [performance_protocol.num_performance_levels[domain_id] - 1])) + { + *status = SCMI_STATUS_OUT_OF_RANGE; + return; + } + *status = SCMI_STATUS_SUCCESS; + perf_level_max_limit[domain_id] = + parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_max)]; + return; + } + + if (parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_max)] == 0) + { + if ((parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_min)] < + performance_protocol.performance_level_value[domain_id][0])) + { + *status = SCMI_STATUS_OUT_OF_RANGE; + return; + } + *status = SCMI_STATUS_SUCCESS; + perf_level_min_limit[domain_id] = + parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_min)] ; + return; + } + if((parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_max)] > performance_protocol.performance_level_value[domain_id] [performance_protocol.num_performance_levels[domain_id] - 1]) || @@ -293,6 +330,7 @@ void performance_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_OUT_OF_RANGE; return; } + if((parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_max)]) < (parameters[OFFSET_PARAM(struct arm_scmi_performance_limits_set,range_min)])) { @@ -326,6 +364,10 @@ void performance_send_message(uint32_t message_id, uint32_t parameter_count, return_values[OFFSET_RET(struct arm_scmi_performance_limits_get,range_min)] = performance_protocol.performance_level_value[domain_id][0]; + perf_level_max_limit[domain_id] = + return_values[OFFSET_RET(struct arm_scmi_performance_limits_get,range_max)]; + perf_level_min_limit[domain_id] = + return_values[OFFSET_RET(struct arm_scmi_performance_limits_get,range_min)]; } *return_values_count = 2; break; @@ -484,6 +526,21 @@ void performance_send_message(uint32_t message_id, uint32_t parameter_count, [messageid - PERF_LIMIT_SET_MSG_ID]; *return_values_count = 11; break; + case PERF_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (performance_protocol.protocol_version < 0x00040000) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + return_idx = OFFSET_PARAM(struct arm_scmi_performance_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_performance_protocols); i > 0; i--) { + if (supported_performance_protocols[i - 1] == parameters[return_idx]) { + performance_protocol.protocol_version = parameters[return_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; default: *status = SCMI_STATUS_NOT_FOUND; break; diff --git a/platform/mocker/mocker/transport_pin_control.c b/platform/mocker/mocker/transport_pin_control.c index 01a11ebf0e4cae679c3d5ef8d7e04e4c1255bfe7..11cec738ab736d5d5110aab564e6793e002289dc 100644 --- a/platform/mocker/mocker/transport_pin_control.c +++ b/platform/mocker/mocker/transport_pin_control.c @@ -98,7 +98,7 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, case PINCTRL_PROTO_MSG_ATTRIB_MSG_ID: parameter_idx = OFFSET_PARAM( struct arm_scmi_pin_control_protocol_message_attributes, message_id); - if(parameters[parameter_idx] > PINCTRL_SET_PERM_MSG_ID) { + if(parameters[parameter_idx] > PINCTRL_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; } else { *status = SCMI_STATUS_SUCCESS; @@ -132,15 +132,16 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, return_idx = OFFSET_RET(struct arm_scmi_pin_control_attributes, attributes); return_values[return_idx] = pin_control_protocol.pin_control_extended_name_support[flags][pc_id] << - PINCTRL_ATTRIBUTES_EXTENDED_NAME_LOW; + PINCTRL_ATTRIBUTES_EXTENDED_NAME_LOW | + 1 << PINCTRL_ATTRIBUTES_NUM_PINS_GROUPS_LOW; /* Get name */ return_idx = OFFSET_RET(struct arm_scmi_pin_control_attributes, name); str = (char *)&return_values[return_idx]; if (pin_control_protocol.pin_control_extended_name_support[flags][pc_id]) { - sprintf(name,"pin_ext_uart_n_artx_%d", pc_id); - sprintf(str, "%s", name + strnlen(name, 25) - 16); + snprintf(name, MSG_SIZE, "pin_ext_uart_n_artx_%d", pc_id); + snprintf(str, MSG_SIZE, "%s", name + strnlen(name, 25) - 16); } else - sprintf(str, "pin_x%d", pc_id); + snprintf(str, MSG_SIZE, "pin_x%d", pc_id); /* If flag id group */ } else if (flags == FLAG_GROUPS) { if (pc_id >= pin_control_protocol.number_groups) @@ -160,10 +161,10 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, return_idx = OFFSET_RET(struct arm_scmi_pin_control_attributes, name); str = (char *)&return_values[return_idx]; if (pin_control_protocol.pin_control_extended_name_support[flags][pc_id]) { - sprintf(name,"grp_ext_uart_n_artx_%d", pc_id); - sprintf(str, "%s", name + strnlen(name, 25) - 16); + snprintf(name, MSG_SIZE, "grp_ext_uart_n_artx_%d", pc_id); + snprintf(str, MSG_SIZE, "%s", name + strnlen(name, 25) - 16); } else - sprintf(str, "grp_rxtx_z%d", pc_id); + snprintf(str, MSG_SIZE, "grp_rxtx_z%d", pc_id); /* If flag is function */ } else if (flags == FLAG_FUNCTIONS) { if (pc_id >= pin_control_protocol.number_functions) @@ -183,10 +184,10 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, return_idx = OFFSET_RET(struct arm_scmi_pin_control_attributes, name); str = (char *)&return_values[return_idx]; if (pin_control_protocol.pin_control_extended_name_support[flags][pc_id]) { - sprintf(name,"f_ext_uart_n_artx_%d", pc_id); - sprintf(str, "%s", name + strnlen(name, 25) - 16); + snprintf(name, MSG_SIZE, "f_ext_uart_n_artx_%d", pc_id); + snprintf(str, MSG_SIZE, "%s", name + strnlen(name, 25) - 16); } else - sprintf(str, "f_uart_w%d", pc_id); + snprintf(str, MSG_SIZE, "f_uart_w%d", pc_id); } else { *status = SCMI_STATUS_NOT_FOUND; } @@ -259,14 +260,14 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, return; } break; - case PINCTRL_CONFIG_GET_MSG_ID: + case PINCTRL_SETTINGS_GET_MSG_ID: /* Get pin control id */ - parameter_idx = OFFSET_PARAM(struct arm_scmi_pin_control_config_get, + parameter_idx = OFFSET_PARAM(struct arm_scmi_pin_control_settings_get, identifier); pc_id = parameters[parameter_idx]; - flags = ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_config_get, attributes)] >> - PINCTRL_CONFIG_GET_SELECTOR_LOW) & 0x3); + flags = ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_settings_get, attributes)] >> + PINCTRL_SETTINGS_GET_SELECTOR_LOW) & 0x3); if (flags == FLAG_PINS) { /* Check if pin identifier is valid */ @@ -279,6 +280,8 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, return; } + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, + function_selected)] = pins_enabled_function[pc_id]; *status = SCMI_STATUS_SUCCESS; } else if (flags == FLAG_GROUPS) { @@ -291,52 +294,55 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_DENIED; return; } + + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, + function_selected)] = groups_enabled_function[pc_id]; *status = SCMI_STATUS_SUCCESS; } else { *status = SCMI_STATUS_INVALID_PARAMETERS; return; } - parameter_idx = OFFSET_PARAM(struct arm_scmi_pin_control_config_get, attributes); - all_configs = ((parameters[parameter_idx] >> PINCTRL_CONFIG_GET_ALLCONFIGS_LOW) & 0x1); + parameter_idx = OFFSET_PARAM(struct arm_scmi_pin_control_settings_get, attributes); + all_configs = ((parameters[parameter_idx] >> PINCTRL_SETTINGS_GET_ALLCONFIGS_LOW) & 0x1); if (all_configs == 1) { total_num_configs = 2; - return_idx = OFFSET_RET(struct arm_scmi_pin_control_config_get, num_configs); + return_idx = OFFSET_RET(struct arm_scmi_pin_control_settings_get, num_configs); return_values[return_idx] = total_num_configs; for (i = 0; i < total_num_configs; i++) { - return_values[OFFSET_RET(struct arm_scmi_pin_control_config_get, + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, configs) + i * total_num_configs] = i; - return_values[OFFSET_RET(struct arm_scmi_pin_control_config_get, + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, configs) + i * total_num_configs + 1] = 0; } *return_values_count = 1 + (total_num_configs * 2); } else if (flags == FLAG_PINS) { - return_values[OFFSET_RET(struct arm_scmi_pin_control_config_get, + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, configs) ] = pin_config[pc_id].type; - return_values[OFFSET_RET(struct arm_scmi_pin_control_config_get, + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, configs) + 1] = pin_config[pc_id].value; *return_values_count = 3; } else { - return_values[OFFSET_RET(struct arm_scmi_pin_control_config_get, + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, configs) ] = group_config[pc_id].type; - return_values[OFFSET_RET(struct arm_scmi_pin_control_config_get, + return_values[OFFSET_RET(struct arm_scmi_pin_control_settings_get, configs) + 1] = group_config[pc_id].value; *return_values_count = 3; } break; - case PINCTRL_CONFIG_SET_MSG_ID: + case PINCTRL_SETTINGS_CONFIGURE_MSG_ID: /* Get pin control id */ - parameter_idx = OFFSET_PARAM(struct arm_scmi_pin_control_config_set, + parameter_idx = OFFSET_PARAM(struct arm_scmi_pin_control_settings_configure, identifier); pc_id = parameters[parameter_idx]; - flags = ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_config_set, attributes)] >> - PINCTRL_CONFIG_SET_SELECTOR_LOW) & 0x3); + flags = ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_settings_configure, + attributes)] >> PINCTRL_SETTINGS_CONFIGURE_SELECTOR_LOW) & 0x3); if (flags == FLAG_PINS) { /* Check if pin identifier is valid */ if (pc_id >= pin_control_protocol.number_pins) { @@ -357,30 +363,34 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_INVALID_PARAMETERS; return; } - total_num_configs = ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_config_set, - attributes)] >> PINCTRL_CONFIG_SET_NUM_CONFIGS_LOW) & 0xFF); + total_num_configs = + ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_settings_configure, + attributes)] >> PINCTRL_SETTINGS_CONFIGURE_NUM_CONFIGS_LOW) & 0xFF); if(flags == FLAG_PINS) { - if ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_config_set, configs)] > 20) && - (parameters[OFFSET_PARAM(struct arm_scmi_pin_control_config_set, configs)] < 192)) { + if ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_settings_configure, + configs)] > 20) && + (parameters[OFFSET_PARAM(struct arm_scmi_pin_control_settings_configure, + configs)] < 192)) { *status = SCMI_STATUS_INVALID_PARAMETERS; return; } - pin_config[pc_id].type = parameters[OFFSET_PARAM(struct - arm_scmi_pin_control_config_set, configs)]; - pin_config[pc_id].value = parameters[OFFSET_PARAM(struct - arm_scmi_pin_control_config_set, configs) + 1]; - } - else { - if ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_config_set, configs)] > 20) && - (parameters[OFFSET_PARAM(struct arm_scmi_pin_control_config_set, configs)] < 192)) { + pin_config[pc_id].type = parameters[OFFSET_PARAM(struct + arm_scmi_pin_control_settings_configure, configs)]; + pin_config[pc_id].value = parameters[OFFSET_PARAM(struct + arm_scmi_pin_control_settings_configure, configs) + 1]; + } else { + if ((parameters[OFFSET_PARAM(struct arm_scmi_pin_control_settings_configure, + configs)] > 20) && + (parameters[OFFSET_PARAM(struct arm_scmi_pin_control_settings_configure, + configs)] < 192)) { *status = SCMI_STATUS_INVALID_PARAMETERS; return; } - group_config[pc_id].type = parameters[OFFSET_PARAM(struct - arm_scmi_pin_control_config_set, configs)]; - group_config[pc_id].value = parameters[OFFSET_PARAM(struct - arm_scmi_pin_control_config_set, configs) + 1]; + group_config[pc_id].type = parameters[OFFSET_PARAM(struct + arm_scmi_pin_control_settings_configure, configs)]; + group_config[pc_id].value = parameters[OFFSET_PARAM(struct + arm_scmi_pin_control_settings_configure, configs) + 1]; } break; case PINCTRL_FUNC_SELECT_MSG_ID: @@ -496,7 +506,7 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_NOT_FOUND; return; } - sprintf((char *)&return_values[1], "pin_ext_uart_n_artx_%d", pc_id); + snprintf((char *)&return_values[1], MSG_SIZE, "pin_ext_uart_n_artx_%d", pc_id); /* If flag is group */ } else if (flags == FLAG_GROUPS) { @@ -505,7 +515,7 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_NOT_FOUND; return; } - sprintf((char *)&return_values[1], "grp_ext_uart_n_artx_%d", pc_id); + snprintf((char *)&return_values[1], MSG_SIZE, "grp_ext_uart_n_artx_%d", pc_id); /* If flag is function */ } else if (flags == FLAG_FUNCTIONS) { @@ -514,7 +524,7 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_NOT_FOUND; return; } - sprintf((char *)&return_values[1], "f_ext_uart_n_artx_%d", pc_id); + snprintf((char *)&return_values[1], MSG_SIZE, "f_ext_uart_n_artx_%d", pc_id); } else { *status = SCMI_STATUS_INVALID_PARAMETERS; @@ -566,7 +576,22 @@ void pin_control_send_message(uint32_t message_id, uint32_t parameter_count, } *status = SCMI_STATUS_NOT_FOUND; break; - default: + case PINCTRL_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (pin_control_protocol.protocol_version < 0x00020001) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + flags = OFFSET_PARAM(struct arm_scmi_pin_control_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_pin_control_protocols); i > 0; i--) { + if (supported_pin_control_protocols[i - 1] == parameters[flags]) { + pin_control_protocol.protocol_version = parameters[flags]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; + default: *status = SCMI_STATUS_NOT_FOUND; } } diff --git a/platform/mocker/mocker/transport_power_domain.c b/platform/mocker/mocker/transport_power_domain.c index ad9c0ec10dd40aabfdf9487ded7603f38c72107b..8f81591d139ff2c1fe28af0725bea32a564d7770 100644 --- a/platform/mocker/mocker/transport_power_domain.c +++ b/platform/mocker/mocker/transport_power_domain.c @@ -47,6 +47,7 @@ void power_send_message(uint32_t message_id, uint32_t parameter_count, char * str; int num_power_domains = 3; int stats_low = 0x1234, stats_high = stats_low + 0xff; + uint32_t i; if(device_access_permitted() == false || protocol_access_permitted(POWER_DOMAIN_PROTOCOL_ID) == false) { @@ -80,7 +81,7 @@ void power_send_message(uint32_t message_id, uint32_t parameter_count, case PWR_PROTO_MSG_ATTR_MSG_ID: parameter_idx = OFFSET_PARAM( struct arm_scmi_power_protocol_message_attributes, message_id); - if(parameters[parameter_idx] > PWR_STATE_CHANGE_REQUESTED_NOTIFY_MSG_ID) { + if(parameters[parameter_idx] > PWR_STATE_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; } else { *status = SCMI_STATUS_SUCCESS; @@ -123,7 +124,7 @@ void power_send_message(uint32_t message_id, uint32_t parameter_count, str = (char *) (&return_values[OFFSET_RET( struct arm_scmi_power_domain_attributes, name)]); - sprintf(str, "Domain_%d", parameters[ + snprintf(str, MSG_SIZE, "Domain_%d", parameters[ OFFSET_PARAM(struct arm_scmi_power_domain_attributes, domain_id)]); break; @@ -200,7 +201,23 @@ void power_send_message(uint32_t message_id, uint32_t parameter_count, } *status = SCMI_STATUS_SUCCESS; break; + case PWR_STATE_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (power_protocol.protocol_version < 0x00020001) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + parameter_idx = OFFSET_PARAM(struct arm_scmi_power_domain_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_power_domain_protocols); i > 0; i--) { + if (supported_power_domain_protocols[i - 1] == parameters[parameter_idx]) { + power_protocol.protocol_version = parameters[parameter_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; default: *status = SCMI_STATUS_NOT_FOUND; + break; } } diff --git a/platform/mocker/mocker/transport_powercap.c b/platform/mocker/mocker/transport_powercap.c index 2b66b75ebbf8c305fac3d9d93670c559091c1921..ff1074dd94db0a87fe22608373a56ed0c944b6e5 100644 --- a/platform/mocker/mocker/transport_powercap.c +++ b/platform/mocker/mocker/transport_powercap.c @@ -46,6 +46,8 @@ void powercap_send_message(uint32_t message_id, uint32_t parameter_count, { uint32_t return_idx, parameter_idx, domain_id; char *name; + uint32_t i; + switch(message_id) { case POWERCAP_PROTO_VER_MSG_ID: @@ -71,7 +73,7 @@ void powercap_send_message(uint32_t message_id, uint32_t parameter_count, break; } - if (parameters[parameter_idx] > POWERCAP_PAI_SET_MSG_ID) + if (parameters[parameter_idx] > POWERCAP_NEGOTIATE_PROTOCOL_MSG_ID) *status = SCMI_STATUS_NOT_FOUND; else { *status = SCMI_STATUS_SUCCESS; @@ -103,9 +105,9 @@ void powercap_send_message(uint32_t message_id, uint32_t parameter_count, 0x1 << POWERCAP_DOMAIN_CHANGE_NOTIFY_SUPPORT_LOW; if (powercap_protocol.powercap_extended_name_support[domain_id]) - sprintf((char*)&return_values[1], "%s", name + strnlen(name, 25) - 16); + snprintf((char*)&return_values[1], MSG_SIZE, "%s", name + strnlen(name, 25) - 16); else - sprintf((char *) &return_values[1], "%s", name); + snprintf((char *) &return_values[1], MSG_SIZE, "%s", name); return_idx = OFFSET_RET(struct arm_scmi_powercap_domain_attributes, min_pai); return_values[return_idx] = powercap_protocol.min_pai[domain_id]; @@ -227,7 +229,7 @@ void powercap_send_message(uint32_t message_id, uint32_t parameter_count, if (powercap_protocol.powercap_extended_name_support[domain_id]) { *status = SCMI_STATUS_SUCCESS; name = powercap_protocol.powercap_domain_name[domain_id]; - sprintf((char *)&return_values[1], "%s", name); + snprintf((char *)&return_values[1], MSG_SIZE, "%s", name); } else { *status = SCMI_STATUS_NOT_FOUND; break; @@ -258,6 +260,22 @@ void powercap_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_SUCCESS; break; + case POWERCAP_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (powercap_protocol.protocol_version < 0x00020000) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + return_idx = OFFSET_PARAM(struct arm_scmi_powercap_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_powercap_protocols); i > 0; i--) { + if (supported_powercap_protocols[i - 1] == parameters[return_idx]) { + powercap_protocol.protocol_version = parameters[return_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; + default: *status = SCMI_STATUS_NOT_FOUND;; break; diff --git a/platform/mocker/mocker/transport_reset.c b/platform/mocker/mocker/transport_reset.c index d2b0245d76bd89ab480cd765a2d974bad42fbc3c..43c00dbc00b8ddbaef8929204a2a700d1989d8bf 100644 --- a/platform/mocker/mocker/transport_reset.c +++ b/platform/mocker/mocker/transport_reset.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -38,7 +38,7 @@ void reset_send_message(uint32_t message_id, uint32_t parameter_count, uint32_t parameter_idx, domain_id, return_idx; char * str; - uint32_t reset_flag, reset_state , notify_en; + uint32_t reset_flag, reset_state , notify_en, i; switch(message_id) { @@ -59,7 +59,7 @@ void reset_send_message(uint32_t message_id, uint32_t parameter_count, case RESET_PROTO_MSG_ATTRIB_MSG_ID: parameter_idx = OFFSET_PARAM( struct arm_scmi_reset_protocol_message_attributes, message_id); - if (parameters[parameter_idx] > RESET_PROTO_NOTIFY_MSG_ID) + if (parameters[parameter_idx] > RESET_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; } @@ -99,7 +99,7 @@ void reset_send_message(uint32_t message_id, uint32_t parameter_count, domain_name); str = (char *)&return_values[return_idx]; - sprintf(str, "Reset_%d", domain_id); + snprintf(str, MSG_SIZE, "Reset_%d", domain_id); *status = SCMI_STATUS_SUCCESS; *return_values_count = (return_idx + (SCMI_NAME_STR_SIZE/4)) + 1; @@ -162,6 +162,21 @@ void reset_send_message(uint32_t message_id, uint32_t parameter_count, } *status = SCMI_STATUS_SUCCESS; break; + case RESET_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (reset_protocol.protocol_version < 0x00020001) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + parameter_idx = OFFSET_PARAM(struct arm_scmi_reset_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_reset_protocols); i > 0; i--) { + if (supported_reset_protocols[i - 1] == parameters[parameter_idx]) { + reset_protocol.protocol_version = parameters[parameter_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; default: *status = SCMI_STATUS_NOT_FOUND; break; diff --git a/platform/mocker/mocker/transport_sensor.c b/platform/mocker/mocker/transport_sensor.c index 8214a396563a56c1b2e359d8f0b6eefe02fd9826..241bd602a758e036f5067a1db9a743fa5623b7e7 100644 --- a/platform/mocker/mocker/transport_sensor.c +++ b/platform/mocker/mocker/transport_sensor.c @@ -85,7 +85,7 @@ void sensor_send_message(uint32_t message_id, uint32_t parameter_count, parameter_idx = OFFSET_PARAM( struct arm_scmi_sensor_protocol_message_attributes, message_id); - if(parameters[parameter_idx] > SNSR_READING_GET_MSG_ID) + if(parameters[parameter_idx] > SNSR_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; break; @@ -138,7 +138,7 @@ void sensor_send_message(uint32_t message_id, uint32_t parameter_count, (&return_values[OFFSET_RET( struct arm_scmi_sensor_description_get, sensor_descriptors) + (SENSOR_DESC_LEN * i) + 3]); - sprintf(str, "SENSOR_%d", i); + snprintf(str, MSG_SIZE, "SENSOR_%d", i); return_values[OFFSET_RET( struct arm_scmi_sensor_description_get, @@ -271,7 +271,7 @@ void sensor_send_message(uint32_t message_id, uint32_t parameter_count, str = (char *)(&return_values[OFFSET_RET(struct arm_scmi_sensor_axis_description_get, sensor_axis_descriptors) + (SENSOR_AXIS_DESC_LEN * i) + 3]); - sprintf(str, "SENSOR_%d_AXIS%d", sensor_id, i); + snprintf(str, MSG_SIZE, "SENSOR_%d_AXIS%d", sensor_id, i); return_values[OFFSET_RET( struct arm_scmi_sensor_axis_description_get, @@ -369,7 +369,22 @@ void sensor_send_message(uint32_t message_id, uint32_t parameter_count, } *status = SCMI_STATUS_SUCCESS; break; - default: + case SNSR_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (sensor_protocol.protocol_version < 0x00020001) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + parameter_idx = OFFSET_PARAM(struct arm_scmi_sensor_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_sensor_protocols); i > 0; i--) { + if (supported_sensor_protocols[i - 1] == parameters[parameter_idx]) { + sensor_protocol.protocol_version = parameters[parameter_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; + default: *status = SCMI_STATUS_NOT_FOUND; } } diff --git a/platform/mocker/mocker/transport_system_power.c b/platform/mocker/mocker/transport_system_power.c index eedefe87d8bd1e39e174b5704515e740d9323e57..182f6fca30bdc908c726289e35f28f44fe7147a7 100644 --- a/platform/mocker/mocker/transport_system_power.c +++ b/platform/mocker/mocker/transport_system_power.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -17,15 +17,21 @@ #include #include +#include struct arm_scmi_system_power_protocol system_power_protocol; +void fill_system_power_protocol() +{ + system_power_protocol.protocol_version = SYSTEM_POWER_VERSION; +} + void system_power_send_message(uint32_t message_id, uint32_t parameter_count, const uint32_t *parameters, int32_t *status, size_t *return_values_count, uint32_t *return_values) { - uint32_t parameter_idx; + uint32_t parameter_idx, i; int warm_reset_support = 1, system_suspend_support = 1; switch(message_id) @@ -33,7 +39,7 @@ void system_power_send_message(uint32_t message_id, uint32_t parameter_count, case SYSTEM_POWER_PROTO_VER_MSG_ID: *status = SCMI_STATUS_SUCCESS; *return_values_count = 1; - return_values[0] = 0x00010000; //PROTOCOL_VERSION; + return_values[0] = system_power_protocol.protocol_version; //PROTOCOL_VERSION; break; case SYSTEM_POWER_PROTO_ATTRIB_MSG_ID: *status = SCMI_STATUS_SUCCESS; @@ -43,7 +49,7 @@ void system_power_send_message(uint32_t message_id, uint32_t parameter_count, case SYSTEM_POWER_PROTO_MSG_ATTRIB_MSG_ID: parameter_idx = OFFSET_PARAM(struct arm_scmi_system_power_protocol_message_attributes, message_id); - if (parameters[parameter_idx] > SYSTEM_POWER_STATE_NOTIFY_MSG_ID) { + if (parameters[parameter_idx] > SYSTEM_POWER_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; return; } @@ -97,6 +103,21 @@ void system_power_send_message(uint32_t message_id, uint32_t parameter_count, } *status = SCMI_STATUS_SUCCESS; break; + case SYSTEM_POWER_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (system_power_protocol.protocol_version < 0x00020001) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + parameter_idx = OFFSET_PARAM(struct arm_scmi_system_power_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_system_power_protocols); i > 0; i--) { + if (supported_system_power_protocols[i - 1] == parameters[parameter_idx]) { + system_power_protocol.protocol_version = parameters[parameter_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; default: *status = SCMI_STATUS_NOT_FOUND; } diff --git a/platform/mocker/mocker/transport_voltage.c b/platform/mocker/mocker/transport_voltage.c index 87fca133f33a569b765931489d19ededf5c9447c..c4ad917661eccb781c486fc6642340b12671e0eb 100644 --- a/platform/mocker/mocker/transport_voltage.c +++ b/platform/mocker/mocker/transport_voltage.c @@ -56,7 +56,7 @@ void voltage_send_message(uint32_t message_id, uint32_t parameter_count, case VOLTAGE_PROTO_MSG_ATTR_MSG_ID: parameter_idx = OFFSET_PARAM(struct arm_scmi_voltage_protocol_message_attributes, message_id); - if(parameters[parameter_idx] > VOLTAGE_LEVEL_GET_MSG_ID) { + if(parameters[parameter_idx] > VOLTAGE_NEGOTIATE_PROTOCOL_MSG_ID) { *status = SCMI_STATUS_NOT_FOUND; } else { *status = SCMI_STATUS_SUCCESS; @@ -78,7 +78,7 @@ void voltage_send_message(uint32_t message_id, uint32_t parameter_count, *status = SCMI_STATUS_SUCCESS; return_idx = OFFSET_RET(struct arm_scmi_voltage_domain_attributes, attributes); return_values[return_idx] = 0; - sprintf((char *)&return_values[1], "%s", + snprintf((char *)&return_values[1], MSG_SIZE, "%s", voltage_protocol.voltage_domain_name[domain_id]); *return_values_count = strnlen((const char*)return_values, 25) + 1; break; @@ -96,11 +96,11 @@ void voltage_send_message(uint32_t message_id, uint32_t parameter_count, if (strnlen(name, 25) > 16) { return_idx = OFFSET_RET(struct arm_scmi_voltage_domain_attributes_v2, attributes); return_values[return_idx] = 1 << VOLTAGE_EXTENDED_DOMAIN_NAME_LOW_V2; - sprintf((char *)&return_values[1], "%s", name + strnlen(name, 25) -16); + snprintf((char *)&return_values[1], MSG_SIZE, "%s", name + strnlen(name, 25) -16); } else { return_idx = OFFSET_RET(struct arm_scmi_voltage_domain_attributes_v2, attributes); return_values[return_idx] = 0; - sprintf((char *)&return_values[1], "%s", name); + snprintf((char *)&return_values[1], MSG_SIZE, "%s", name); } *return_values_count = strnlen((const char*)return_values, 25) + 1; break; @@ -214,7 +214,7 @@ void voltage_send_message(uint32_t message_id, uint32_t parameter_count, return_values[return_idx] = 0; if (strnlen(name, 25) > 16) { *status = SCMI_STATUS_SUCCESS; - sprintf((char *)&return_values[1], "%s", name); + snprintf((char *)&return_values[1], MSG_SIZE, "%s", name); } else { *status = SCMI_STATUS_NOT_FOUND; break; @@ -223,6 +223,22 @@ void voltage_send_message(uint32_t message_id, uint32_t parameter_count, *return_values_count = strnlen((const char*)return_values, 25) + 1; break; + case VOLTAGE_NEGOTIATE_PROTOCOL_MSG_ID: + *status = SCMI_STATUS_NOT_SUPPORTED; + if (voltage_protocol.protocol_version < 0x00020001) { + *status = SCMI_STATUS_NOT_SUPPORTED; + break; + } + parameter_idx = OFFSET_PARAM(struct arm_scmi_voltage_negotiate_protocol, version); + for (i = NUM_ELEMS(supported_voltage_protocols); i > 0; i--) { + if (supported_voltage_protocols[i - 1] == parameters[parameter_idx]) { + voltage_protocol.protocol_version = parameters[parameter_idx]; + *status = SCMI_STATUS_SUCCESS; + break; + } + } + break; + default: *status = SCMI_STATUS_NOT_FOUND; break; diff --git a/platform/mocker/pal_base.c b/platform/mocker/pal_base.c index b6c42ef2276ff6e6ce6ca3c0c655fbca2a07f6d6..cde55d0c9dce5ef16c4d9f59403657641140bc87 100644 --- a/platform/mocker/pal_base.c +++ b/platform/mocker/pal_base.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -65,3 +65,7 @@ uint32_t pal_base_get_expected_num_protocols(void) return NUM_ELEMS(supported_protocols); } +uint32_t pal_base_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_base_protocols); +} diff --git a/platform/mocker/pal_clock.c b/platform/mocker/pal_clock.c index 65cf1fab095de9be6fb7cbb823ab6bc3f43bdf01..20ed3c7adebc0170b18c114aadbc73e1bb6ffa52 100644 --- a/platform/mocker/pal_clock.c +++ b/platform/mocker/pal_clock.c @@ -44,3 +44,8 @@ uint32_t pal_clock_get_parent_support(uint32_t clock_id) { return clock_parent_support[clock_id]; } + +uint32_t pal_clock_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_clock_protocols); +} diff --git a/platform/mocker/pal_performance.c b/platform/mocker/pal_performance.c index cefabca18115b6f615fd788222a99f94c7af0d1b..35d689026af971ae5330e632af667a7fd960ff4f 100644 --- a/platform/mocker/pal_performance.c +++ b/platform/mocker/pal_performance.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -216,3 +216,8 @@ uint32_t pal_performance_get_expected_fast_ch_doorbell_preserve_mask_high(uint32 return perf_performance_fast_chan_doorbell_preserve_mask_high[domain_id][message_id-PERF_LIMIT_SET_MSG_ID]; } + +uint32_t pal_performance_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_performance_protocols); +} diff --git a/platform/mocker/pal_pin_control.c b/platform/mocker/pal_pin_control.c index c6849fe4386cceff55cbf38e9bdadddd9514673f..c2233855506b414c24069a90ff1793871a095205 100644 --- a/platform/mocker/pal_pin_control.c +++ b/platform/mocker/pal_pin_control.c @@ -113,3 +113,34 @@ uint32_t pal_pin_control_get_extended_name_support(uint32_t identifier, uint32_t { return pin_control_extended_name_support[identifier][index]; } + +/** + @brief This API is used to get number of supported protocol versions + @param none + @return num of protocol versions supported +**/ + +uint32_t pal_pin_control_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_pin_control_protocols); +} + +/** + @brief This API is used to check if pin is enabled for a function + @param identifier of the pin + @return identifier of functoin that is enabled by pin +**/ +uint32_t pal_pin_control_get_pins_enabled_function(uint32_t identifier) +{ + return pins_enabled_function[identifier]; +} + +/** + @brief This API is used to check if group is enabled for a function + @param identifier of the group + @return identifier of functoin that is enabled by group +**/ +uint32_t pal_pin_control_get_groups_enabled_function(uint32_t identifier) +{ + return groups_enabled_function[identifier]; +} diff --git a/platform/mocker/pal_platform.c b/platform/mocker/pal_platform.c index 4b0379b2fd360e2df8b86a8d28cb3c64eefe0444..0c0915ffe4868f27816dce5c288187dfec0bf286 100644 --- a/platform/mocker/pal_platform.c +++ b/platform/mocker/pal_platform.c @@ -45,6 +45,11 @@ int pal_unmap_phys_to_virt(unsigned long paddr, unsigned long vaddr, size_t leng return 0; } +void pal_print(uint32_t print_level, const char *format, va_list args) +{ + vprintf(format, args); +} + void pal_send_message(uint32_t message_header_send, size_t parameter_count, const uint32_t *parameters, uint32_t *message_header_rcv, int32_t *status, size_t *return_values_count, uint32_t *return_values) @@ -101,7 +106,7 @@ void pal_send_message(uint32_t message_header_send, size_t parameter_count, return_values_count, return_values); break; default: - printf("\nProtocol: %d\n", message_id); + fprintf(stdout, "\nProtocol: %d\n", message_id); assert(!"\nUnknown protocol id\n"); break; } @@ -132,6 +137,7 @@ uint32_t pal_initialize_system(void *info) { fill_base_protocol(); fill_power_protocol(); + fill_system_power_protocol(); fill_performance_protocol(); fill_sensor_protocol(); fill_clock_protocol(); @@ -143,11 +149,6 @@ uint32_t pal_initialize_system(void *info) return PAL_STATUS_PASS; } -void pal_print(uint32_t print_level, const char *format, va_list args) -{ - vprintf(format, args); -} - void *pal_memcpy(void *dest, const void *src, size_t size) { if (dest == NULL || src == NULL || size == 0) diff --git a/platform/mocker/pal_power_domain.c b/platform/mocker/pal_power_domain.c index 2b6b36e0971db2a8ea0351da1822f5f1ec44d066..b59f7f6e14180a62d978cc61ad5d2ed246cb36b5 100644 --- a/platform/mocker/pal_power_domain.c +++ b/platform/mocker/pal_power_domain.c @@ -49,3 +49,8 @@ uint32_t pal_power_get_async_support(uint32_t domain_id) { return power_asynchronous_support[domain_id]; } + +uint32_t pal_power_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_power_domain_protocols); +} diff --git a/platform/mocker/pal_powercap.c b/platform/mocker/pal_powercap.c index f70c1f9d9e8aa005d780c98a407bba2fab69cc47..d9e3d8add1ba67736988e42b3997857aca25e2c8 100644 --- a/platform/mocker/pal_powercap.c +++ b/platform/mocker/pal_powercap.c @@ -157,3 +157,8 @@ uint32_t pal_powercap_get_extended_name_support(uint32_t domain_id) { return powercap_extended_name_support[domain_id]; } + +uint32_t pal_powercap_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_powercap_protocols); +} diff --git a/platform/mocker/pal_reset.c b/platform/mocker/pal_reset.c index eed3440851f1f3fef0a3d67e6c87fe1d9e831a28..391fc668b6777cf15aa0874d345ca573f5a878e9 100644 --- a/platform/mocker/pal_reset.c +++ b/platform/mocker/pal_reset.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -44,3 +44,8 @@ uint32_t pal_reset_get_expected_latency(uint32_t domain_id) { return reset_latency[domain_id]; } + +uint32_t pal_reset_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_reset_protocols); +} diff --git a/platform/mocker/pal_sensor.c b/platform/mocker/pal_sensor.c index cd14b37517e6411318eb6037e4be58e0ca8c50e0..e849fe58ff7b2aa593c68406cc6088d6e1f162d9 100644 --- a/platform/mocker/pal_sensor.c +++ b/platform/mocker/pal_sensor.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -94,3 +94,8 @@ uint8_t pal_sensor_get_sensor_update_interval(uint32_t sensor_id) { return sensor_update_intervals[sensor_id]; } + +uint32_t pal_sensor_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_sensor_protocols); +} diff --git a/platform/mocker/pal_system_power.c b/platform/mocker/pal_system_power.c new file mode 100644 index 0000000000000000000000000000000000000000..a0fdfde7f5b02b243ddfaf3acdc0b66baea68b43 --- /dev/null +++ b/platform/mocker/pal_system_power.c @@ -0,0 +1,26 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include +#include + +/*----------- Common SYSTEM POWER API's across platforms ----------*/ + +uint32_t pal_system_power_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_system_power_protocols); +} diff --git a/platform/mocker/pal_voltage.c b/platform/mocker/pal_voltage.c index 90aa755540b431e34d23e3cd547fc8065e27f2ff..0e1b9d93288da76ddeba8323ac7c74990323a140 100644 --- a/platform/mocker/pal_voltage.c +++ b/platform/mocker/pal_voltage.c @@ -60,3 +60,8 @@ uint32_t pal_voltage_operational_level(uint32_t domain_id) { return operational_level[domain_id]; } + +uint32_t pal_voltage_get_expected_supported_num_protocols(void) +{ + return NUM_ELEMS(supported_voltage_protocols); +} diff --git a/test_pool/base/test_b001.c b/test_pool/base/test_b001.c index 05e6fdf46b8dcbf16722da1a620c953f90f42508..19560f0b896adc15ed703e0abbae24821f781f35 100644 --- a/test_pool/base/test_b001.c +++ b/test_pool/base/test_b001.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -56,7 +56,7 @@ uint32_t base_query_protocol_version(uint32_t *version) return VAL_STATUS_FAIL; *version = return_values[VERSION_OFFSET]; - val_print(VAL_PRINT_ERR, "\n VERSION : 0x%08x ", *version); + val_print(VAL_PRINT_ERR, "\n VERSION : 0x%08x ", *version); return VAL_STATUS_PASS; } diff --git a/test_pool/base/test_b008.c b/test_pool/base/test_b008.c index 28c7e6edd89752eee8a6f91046706701256953b1..e89881ab48e4e3d23f6a9fbc17801dbf78e7179c 100644 --- a/test_pool/base/test_b008.c +++ b/test_pool/base/test_b008.c @@ -85,7 +85,7 @@ uint32_t base_query_protocol_list(void) } while (skip < total_num_protocols); /* Save supported protocol list*/ - val_print(VAL_PRINT_ERR, "\n PROTOCOL LIST : 0x%08x ", protocol_list); + val_print(VAL_PRINT_ERR, "\n PROTOCOL LIST : 0x%08x ", protocol_list); val_agent_set_supported_protocol_list(protocol_list); /* DISCOVER_LIST_PROTOCOLS with invalid skip value should return INVALID PARAMETERS status */ diff --git a/test_pool/base/test_b018.c b/test_pool/base/test_b018.c new file mode 100644 index 0000000000000000000000000000000000000000..a7c48ced6e38f7aaabde8f4ec4ea734b709af1d9 --- /dev/null +++ b/test_pool/base/test_b018.c @@ -0,0 +1,119 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_base.h" + +#define TEST_NUM (SCMI_BASE_TEST_NUM_BASE + 18) +#define TEST_DESC "Base query negotiate protocol version " + +extern uint32_t base_supported_protocols[SUPPORTED_BASE_PROTOCOLS_COUNT]; + +uint32_t base_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = BASE_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_BASE, BASE_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n BASE_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = sizeof(base_supported_protocols)/sizeof(base_supported_protocols[0]); + /* Get index from base_supported_protocols with version as returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (base_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = base_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_BASE, + BASE_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x ", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00020001) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_BASE, + BASE_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/clock/test_c003_v2p1.c b/test_pool/clock/test_c003_v3.c similarity index 98% rename from test_pool/clock/test_c003_v2p1.c rename to test_pool/clock/test_c003_v3.c index 7b212a7c1eb913d6efd905b0257104f14fe3f307..69d61b4cc28d55721291d9a5313ce9223a5aefbd 100644 --- a/test_pool/clock/test_c003_v2p1.c +++ b/test_pool/clock/test_c003_v3.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 3) #define TEST_DESC "Clock msg attributes mandatory cmd check " -uint32_t clock_query_mandatory_command_support_v2p1(void) +uint32_t clock_query_mandatory_command_support_v3(void) { int32_t status; uint32_t rsp_msg_hdr; diff --git a/test_pool/clock/test_c005_v2p1.c b/test_pool/clock/test_c005_v3.c similarity index 87% rename from test_pool/clock/test_c005_v2p1.c rename to test_pool/clock/test_c005_v3.c index 3cb770fc1b51ea5b9276a47a743e15579f139e57..810de706eec064aa97807e421ad6c9b8289d185f 100644 --- a/test_pool/clock/test_c005_v2p1.c +++ b/test_pool/clock/test_c005_v3.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 5) #define TEST_DESC "Clock attributes check " -uint32_t clock_attributes_check_v2p1(void) +uint32_t clock_attributes_check_v3(void) { int32_t status; uint32_t rsp_msg_hdr; @@ -63,7 +63,7 @@ uint32_t clock_attributes_check_v2p1(void) val_print_return_values(return_value_count, return_values); attributes = return_values[ATTRIBUTE_OFFSET]; - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 1, 27) != + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 2, 26) != VAL_STATUS_PASS)) return VAL_STATUS_FAIL; @@ -79,9 +79,13 @@ uint32_t clock_attributes_check_v2p1(void) val_get_clock_attributes_flag(attributes, CLOCK_RATE_CHNG_NOTI_SUPP)); val_print(VAL_PRINT_INFO, "\n Parent Clock Identifier Support: %d", val_get_clock_attributes_flag(attributes, CLOCK_PARENT_IDENTIFIER_SUPPORT)); - val_print(VAL_PRINT_INFO, "\n CLOCK_NAME: %s ", + val_print(VAL_PRINT_INFO, "\n Extended Configuration Support: %d", + val_get_clock_attributes_flag(attributes, CLOCK_EXTENDED_CONFIGURATION_SUPPORT)); + val_print(VAL_PRINT_INFO, "\n Restricted Clock: %d", + val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)); + val_print(VAL_PRINT_INFO, "\n CLOCK_NAME: %s", (uint8_t *) &return_values[NAME_OFFSET]); - val_print(VAL_PRINT_INFO, "\n CLOCK Enable Delay: %d ", + val_print(VAL_PRINT_INFO, "\n CLOCK Enable Delay: %d", return_values[ENABLE_DELAY_OFFSET]); } diff --git a/test_pool/clock/test_c009_v3.c b/test_pool/clock/test_c009_v3.c new file mode 100644 index 0000000000000000000000000000000000000000..2fb71b5f04e39f887ac6629141a72b9538cceea8 --- /dev/null +++ b/test_pool/clock/test_c009_v3.c @@ -0,0 +1,192 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_clock.h" + +#define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 9) +#define TEST_DESC "Clock rate set sync mode check " + +#define PARAMETER_SIZE 4 + +/********* TEST ALGO ******************** + * Check if clock has any restrictions before changing clock rate + * Get the current clock rate + * Find a new rate from previously saved rates + * Set new rate in sync mode + * Get the rate again and compare with newly set rates + * Restore the default rate +*****************************************/ + +uint32_t clock_rate_set_sync_check_v3(void) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t clock_id, num_clocks; + uint32_t parameters[PARAMETER_SIZE], new_rate_low, new_rate_high; + uint64_t current_rate, new_rate; + uint32_t upper_word, lower_word; + uint32_t attributes, clock_rate_control = 0; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + num_clocks = val_clock_get_info(NUM_CLOCKS, 0); + if (num_clocks == 0) { + val_print(VAL_PRINT_ERR, "\n No Clock found"); + return VAL_STATUS_SKIP; + } + val_print(VAL_PRINT_DEBUG, "\n NUM CLOCKS : %d", num_clocks); + + /* Set clock rate for all clocks in sync mode */ + for (clock_id = 0; clock_id < num_clocks; clock_id++) + { + /* Get current rate */ + val_print(VAL_PRINT_TEST, "\n CLOCK ID: %d", clock_id); + + attributes = val_clock_get_info(CLOCK_ATTRIBUTE, clock_id); + + /* Check if current clock id has any restrictions to change clock rate */ + if (val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_GET_PERMISSIONS, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + clock_rate_control = VAL_EXTRACT_BITS(return_values[CLOCK_PERMISSIONS_OFFSET], 29, 29); + } + + val_print(VAL_PRINT_TEST, "\n [Check 1] Get current rate"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_RATE_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + + lower_word = return_values[RATE_LOWER_WORD_OFFSET]; + upper_word = return_values[RATE_UPPER_WORD_OFFSET]; + current_rate = VAL_GET_64BIT_DATA(upper_word, lower_word); + + /* Find a new valid rate from previously saved rates*/ + if (val_clock_get_rate(CLOCK_LOWEST_RATE, clock_id) == current_rate) + new_rate = val_clock_get_rate(CLOCK_HIGHEST_RATE, clock_id); + else + new_rate = val_clock_get_rate(CLOCK_LOWEST_RATE, clock_id); + + /* Set new rate in CLOCK_SET_SYNC_MODE*/ + val_print(VAL_PRINT_TEST, "\n [Check 2] Set new rate"); + val_print(VAL_PRINT_TEST, "\n New clock rate :0x%llX", + new_rate); + + new_rate_low = (uint32_t)(new_rate & MASK_FOR_LOWER_WORD); + new_rate_high = (uint32_t)((new_rate & MASK_FOR_UPPER_WORD) >> 32); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = CLOCK_SET_SYNC_MODE; + parameters[param_count++] = clock_id; + parameters[param_count++] = new_rate_low; + parameters[param_count++] = new_rate_high;; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_RATE_SET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)) + { + if (!clock_rate_control) { + if (val_compare_status(status, SCMI_DENIED) == VAL_STATUS_PASS) + return VAL_STATUS_PASS; + else + return VAL_STATUS_FAIL; + } + } + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + + /* Get the rate for comparing with new rates*/ + val_print(VAL_PRINT_TEST, "\n [Check 3] Get the rates and compare"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_RATE_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + + /* Compare with newly set rate and received rate*/ + if (val_compare("LOWER WORD OF RATE ", + new_rate_low, return_values[RATE_LOWER_WORD_OFFSET])) + return VAL_STATUS_FAIL; + + if (val_compare("UPPER WORD OF RATE ", + new_rate_high, return_values[RATE_UPPER_WORD_OFFSET])) + return VAL_STATUS_FAIL; + + val_print(VAL_PRINT_TEST, "\n [Check 4] Set default rate"); + + /* Restore the default rate */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = CLOCK_SET_SYNC_MODE; + parameters[param_count++] = clock_id; + parameters[param_count++] = (uint32_t)(current_rate & MASK_FOR_LOWER_WORD); + parameters[param_count++] = (uint32_t)((current_rate & MASK_FOR_UPPER_WORD) >> 32); + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_RATE_SET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/clock/test_c010_v3.c b/test_pool/clock/test_c010_v3.c new file mode 100644 index 0000000000000000000000000000000000000000..22738f88baa942baf79765d432fa2d4bbe0daa54 --- /dev/null +++ b/test_pool/clock/test_c010_v3.c @@ -0,0 +1,208 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_clock.h" + +#define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 10) +#define TEST_DESC "Clock rate set async mode check " + +#define PARAMETER_SIZE 4 + +/********* TEST ALGO ******************** + * Check if clock has any restrictions before changing clock rate + * Get the current clock rate + * Find a new rate from previously saved rates + * Set new rate in async mode + * Wait for delayed response & compare with newly set rates + * Restore the default rate +*****************************************/ + +uint32_t clock_rate_set_async_check_v3(void) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t clock_id, num_clocks, num_async; + uint32_t parameters[PARAMETER_SIZE]; + uint64_t current_rate, new_rate; + uint32_t new_rate_low, new_rate_high; + uint32_t upper_word, lower_word; + uint32_t attributes, permissions, clock_rate_control; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* Check whether platform support async mode */ + num_async = val_clock_get_info(CLOCK_MAX_PENDING_ASYNC_CMD, 0); + if (num_async == 0) { + val_print(VAL_PRINT_ERR, "\n Async rate change is not supported "); + return VAL_STATUS_SKIP; + } + + /* Set clock rate for all clocks in async mode */ + num_clocks = val_clock_get_info(NUM_CLOCKS, 0); + if (num_clocks == 0) { + val_print(VAL_PRINT_ERR, "\n No Clock found "); + return VAL_STATUS_SKIP; + } + val_print(VAL_PRINT_DEBUG, "\n NUM CLOCKS : %d", num_clocks); + + for (clock_id = 0; clock_id < num_clocks; clock_id++) + { + /* Get current rate using CLOCK_RATE_GET*/ + val_print(VAL_PRINT_TEST, "\n CLOCK ID: %d", clock_id); + + attributes = val_clock_get_info(CLOCK_ATTRIBUTE, clock_id); + + /* Check if current clock id has any restrictions to change clock rate */ + if (val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_GET_PERMISSIONS, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + permissions = return_values[CLOCK_PERMISSIONS_OFFSET]; + clock_rate_control = VAL_EXTRACT_BITS(permissions, 29, 29); + } + + val_print(VAL_PRINT_TEST, "\n [Check 1] Get current rate"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_RATE_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_DENIED) == VAL_STATUS_PASS) + return VAL_STATUS_PASS; + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + + lower_word = return_values[RATE_LOWER_WORD_OFFSET]; + upper_word = return_values[RATE_UPPER_WORD_OFFSET]; + current_rate = VAL_GET_64BIT_DATA(upper_word, lower_word); + + /* Find a new rate from previously stored rates*/ + if (val_clock_get_rate(CLOCK_LOWEST_RATE, clock_id) == current_rate) + new_rate = val_clock_get_rate(CLOCK_HIGHEST_RATE, clock_id); + else + new_rate = val_clock_get_rate(CLOCK_LOWEST_RATE, clock_id); + + val_print(VAL_PRINT_TEST, "\n [Check 2] Set new rate"); + val_print(VAL_PRINT_TEST, "\n New clock rate :0x%llX", + new_rate); + + new_rate_low = (uint32_t)(new_rate & MASK_FOR_LOWER_WORD); + new_rate_high = (uint32_t)((new_rate & MASK_FOR_UPPER_WORD) >> 32); + + /* Set rate with CLOCK_SET_ASYNC_MODE */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = CLOCK_SET_ASYNC_MODE; + parameters[param_count++] = clock_id; + parameters[param_count++] = new_rate_low; + parameters[param_count++] = new_rate_high; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_RATE_SET, COMMAND_MSG); + val_send_message_async(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (!clock_rate_control) { + if (val_compare_status(status, SCMI_DENIED) == VAL_STATUS_PASS) + return VAL_STATUS_PASS; + else + return VAL_STATUS_FAIL; + } + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + + /* Wait for delayed response */ + val_print(VAL_PRINT_TEST, "\n [Check 3] Wait for delayed response"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + val_receive_delayed_response(&rsp_msg_hdr, &status, &return_value_count, return_values); + + val_print(VAL_PRINT_TEST, "\n NOTIFY MSG HDR : 0x%08x", rsp_msg_hdr); + if (val_compare("PROTOCOL ID", VAL_EXTRACT_BITS(rsp_msg_hdr, 10, 17), + PROTOCOL_CLOCK)) + return VAL_STATUS_FAIL; + if (val_compare("MSG TYPE ", VAL_EXTRACT_BITS(rsp_msg_hdr, 8, 9), + DELAYED_RESPONSE_MSG)) + return VAL_STATUS_FAIL; + if (val_compare("MSG ID ", VAL_EXTRACT_BITS(rsp_msg_hdr, 0, 7), + CLOCK_RATE_SET_COMPLETE)) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + + /* Compare send & received clock id*/ + if (val_compare("CLOCK ID ", + clock_id, return_values[DELAYED_RESP_CLOCK_ID_OFFSET])) + return VAL_STATUS_FAIL; + + /* Compare with new rate & received rate*/ + if (val_compare("LOWER WORD OF RATE ", + new_rate_low, return_values[DELAYED_RESP_RATE_LOWER_OFFSET])) + return VAL_STATUS_FAIL; + + if (val_compare("UPPER WORD OF RATE ", + new_rate_high, return_values[DELAYED_RESP_RATE_UPPER_OFFSET])) + return VAL_STATUS_FAIL; + + /* Restore the default rate */ + val_print(VAL_PRINT_TEST, "\n [Check 4] Set default rate"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = CLOCK_SET_SYNC_MODE; + parameters[param_count++] = clock_id; + parameters[param_count++] = (uint32_t)(current_rate & MASK_FOR_LOWER_WORD); + parameters[param_count++] = (uint32_t)((current_rate & MASK_FOR_UPPER_WORD) >> 32); + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_RATE_SET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/clock/test_c017_v2p1.c b/test_pool/clock/test_c017_v3.c similarity index 83% rename from test_pool/clock/test_c017_v2p1.c rename to test_pool/clock/test_c017_v3.c index 4332eb4eb3cc28c8ca8baced126bd049b89b1a37..9e9c0886f6aa4dece3791d361620ccafa240cb6b 100644 --- a/test_pool/clock/test_c017_v2p1.c +++ b/test_pool/clock/test_c017_v3.c @@ -24,13 +24,14 @@ #define MAX_PARAMETER_SIZE 3 /********* TEST ALGO ******************** + * Check if clock has any restrictions before changing clock state * Find a new attribute from previously saved value * Set new attribute * Get the attribute again and compare with newly set attribute * Restore the default attribute *****************************************/ -uint32_t clock_config_set_check_v2p1(void) +uint32_t clock_config_set_check_v3(void) { int32_t status; uint32_t rsp_msg_hdr; @@ -39,7 +40,7 @@ uint32_t clock_config_set_check_v2p1(void) size_t return_value_count; uint32_t return_values[MAX_RETURNS_SIZE], attributes; uint32_t clock_id, num_clocks, parameters[MAX_PARAMETER_SIZE]; - uint32_t run_flag = 0; + uint32_t run_flag = 0, clock_state_control = 0; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) return VAL_STATUS_SKIP; @@ -53,12 +54,24 @@ uint32_t clock_config_set_check_v2p1(void) for (clock_id = 0; clock_id < num_clocks; clock_id++) { - bool could_be_denied = false; - val_print(VAL_PRINT_TEST, "\n CLOCK ID: %d", clock_id); - if (val_check_clock_config_change_support(clock_id) == 1) - could_be_denied = true; + /* Check if current clock id has any restrictions to change clock config */ + attributes = val_clock_get_info(CLOCK_ATTRIBUTE, clock_id); + if (val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_GET_PERMISSIONS, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + clock_state_control = VAL_EXTRACT_BITS(return_values[CLOCK_PERMISSIONS_OFFSET], 31, 31); + } run_flag = 1; /* Find new attribute from previously stored value */ @@ -82,7 +95,7 @@ uint32_t clock_config_set_check_v2p1(void) if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; - if (could_be_denied && + if ((!clock_state_control) && val_compare_status(status, SCMI_DENIED) == VAL_STATUS_PASS) return VAL_STATUS_PASS; diff --git a/test_pool/clock/test_c018.c b/test_pool/clock/test_c018.c index 56f62fa62753360fcc50c654b2ca4b4972201fe9..ad4e71650bc3c6595c36a3a4abcdc92360c3dea8 100644 --- a/test_pool/clock/test_c018.c +++ b/test_pool/clock/test_c018.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_clock.h" #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 18) -#define TEST_DESC "Clock domain ext name get check " +#define TEST_DESC "Clock domain ext name get check " uint32_t clock_query_ext_domain_name(void) { diff --git a/test_pool/clock/test_c019.c b/test_pool/clock/test_c019.c index 598ecb43303c5eb4ad70141d6d2e6e38bc4ec1a5..ab34ec22b946355d2a9b4d5e79fe3d8600bbc0dd 100644 --- a/test_pool/clock/test_c019.c +++ b/test_pool/clock/test_c019.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -81,7 +81,7 @@ uint32_t clock_query_domain_ext_name_invalid_domain(void) val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, &return_value_count, return_values); - if (val_compare_status(status, SCMI_NOT_FOUND) != VAL_STATUS_PASS) + if (val_compare_status(status, SCMI_NOT_SUPPORTED) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) diff --git a/test_pool/clock/test_c020.c b/test_pool/clock/test_c020.c index d195dc1a1a912ac36039927e04de6c767e0eb5eb..e9cadde04e953abafe15d406361358c3b4f9db52 100644 --- a/test_pool/clock/test_c020.c +++ b/test_pool/clock/test_c020.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 2 #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 20) -#define TEST_DESC "Clock Rate changed notification cmd check " +#define TEST_DESC "Clock Rate changed notification cmd check " uint32_t clock_rate_notification_query(void) { @@ -69,7 +69,7 @@ uint32_t clock_rate_notification_query(void) val_print(VAL_PRINT_TEST, "\n CLOCK : %d", clock_id); val_print(VAL_PRINT_TEST, "\n [Check 2] Query Rate Change Notification Support"); - if (val_get_clock_attribute(num_clocks, CLOCK_RATE_CHNG_NOTI_SUPP) == + if (val_get_clock_attribute(clock_id, CLOCK_RATE_CHNG_NOTI_SUPP) == CLOCK_NOTIFY_NOT_SUPP) { val_print(VAL_PRINT_ERR, "\n Clock doesn't support Rate notify"); continue; diff --git a/test_pool/clock/test_c021.c b/test_pool/clock/test_c021.c index d02660c879c8e17367f9caf7f4bd1548294ed869..2470855d90409491db33038e5238623ec83214a7 100644 --- a/test_pool/clock/test_c021.c +++ b/test_pool/clock/test_c021.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 2 #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 21) -#define TEST_DESC "Clock Rate changed notification invalid cmd check " +#define TEST_DESC "Clock Rate changed notif invalid cmd check " uint32_t clock_rate_notification_invalid_query(void) { diff --git a/test_pool/clock/test_c022.c b/test_pool/clock/test_c022.c index 821e7189011a0f3958c4ea6bed7e14be41a41c79..5e9da5d6497c1bb702f30219bd7579226afc3891 100644 --- a/test_pool/clock/test_c022.c +++ b/test_pool/clock/test_c022.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 2 #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 22) -#define TEST_DESC "Clock Rate chang reqnotification cmd check " +#define TEST_DESC "Clock Rate chang req notification cmd check " uint32_t clock_rate_req_notification_query(void) { @@ -69,7 +69,8 @@ uint32_t clock_rate_req_notification_query(void) val_print(VAL_PRINT_TEST, "\n CLOCK : %d", clock_id); val_print(VAL_PRINT_TEST, "\n [Check 2] Query Rate Change Notification Support"); - if (val_get_clock_attribute(clock_id, CLOCK_RATE_CHNG_REQ_NOTI_SUPP) == CLOCK_NOTIFY_SUPP) { + if (val_get_clock_attribute(clock_id, + CLOCK_RATE_CHNG_REQ_NOTI_SUPP) == CLOCK_NOTIFY_NOT_SUPP) { val_print(VAL_PRINT_ERR, "\n Clock doesn't support Rate notify"); continue; } diff --git a/test_pool/clock/test_c023.c b/test_pool/clock/test_c023.c index ff0f1283d2f868e31b1ac194c771a8568d080a35..626fc9ffd4c3dee9b86f132fb5831e6018b0412c 100644 --- a/test_pool/clock/test_c023.c +++ b/test_pool/clock/test_c023.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 2 #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 23) -#define TEST_DESC "Clock Rate chang req notification invalid cmd check " +#define TEST_DESC "Clock Rate chang req notif invalid cmd check " uint32_t clock_rate_req_notification_invalid_query(void) { diff --git a/test_pool/clock/test_c024.c b/test_pool/clock/test_c024.c index 665529e1f22f50a1b6a82360ee043164174eb213..79e7be09e724afff71617ca309ba8652117863b6 100644 --- a/test_pool/clock/test_c024.c +++ b/test_pool/clock/test_c024.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_clock.h" #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 24) -#define TEST_DESC "Clock parent get invalid clock id check " +#define TEST_DESC "Clock parent get invalid clock id check " uint32_t clock_parent_get_invalid_clock_id_check(void) { diff --git a/test_pool/clock/test_c025.c b/test_pool/clock/test_c025.c index 7d37e913d707f868198314c985d3f507324d792c..e54bd6b5c68650cb42dc33f1757292eafa30af22 100644 --- a/test_pool/clock/test_c025.c +++ b/test_pool/clock/test_c025.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -31,9 +31,9 @@ uint32_t clock_config_get_check(void) uint32_t cmd_msg_hdr; size_t param_count; size_t return_value_count; - uint32_t return_values[MAX_RETURNS_SIZE], flags = 0; + uint32_t return_values[MAX_RETURNS_SIZE]; uint32_t clock_id, num_clocks, parameters[MAX_PARAMETER_SIZE]; - uint32_t attributes, clock_config, oem_config_val; + uint32_t attributes, clock_config, ext_config_val; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) return VAL_STATUS_SKIP; @@ -50,9 +50,10 @@ uint32_t clock_config_get_check(void) { val_print(VAL_PRINT_TEST, "\n CLOCK ID: %d", clock_id); + /* Get clock config status */ VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); parameters[param_count++] = clock_id; - parameters[param_count++] = flags; + parameters[param_count++] = 0; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_CONFIG_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, @@ -78,8 +79,74 @@ uint32_t clock_config_get_check(void) val_print(VAL_PRINT_DEBUG, "\n CLOCK State : %d", VAL_EXTRACT_BITS(clock_config, 0, 0)); - oem_config_val = return_values[CLOCK_CONFIG_OEM_VAL_OFFSET]; - val_print(VAL_PRINT_DEBUG, "\n OEM Config Value : %d", oem_config_val); + /* Check if Extended configuration is supported */ + attributes = val_clock_get_info(CLOCK_ATTRIBUTE, clock_id); + if (!val_get_clock_attributes_flag(attributes, CLOCK_EXTENDED_CONFIGURATION_SUPPORT)) + continue; + + /* Get Duty cycle in extended clock config */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = clock_id; + parameters[param_count++] = CLOCK_DUTY_CYCLE_EXT_CONFIG; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_CONFIG_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + attributes = return_values[ATTRIBUTE_OFFSET]; + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 0, 31) != VAL_STATUS_PASS)) + return VAL_STATUS_FAIL; + + clock_config = return_values[CLOCK_CONFIG_OFFSET]; + + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(clock_config, 1, 31) != + VAL_STATUS_PASS)) + return VAL_STATUS_FAIL; + + val_print(VAL_PRINT_DEBUG, "\n CLOCK State : %d", + VAL_EXTRACT_BITS(clock_config, 0, 0)); + + ext_config_val = return_values[CLOCK_CONFIG_EXT_VAL_OFFSET]; + val_print(VAL_PRINT_DEBUG, "\n Duty Cycle Config Value : %d", ext_config_val); + + /* Get Phase in extended clock config */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = clock_id; + parameters[param_count++] = CLOCK_PHASE_EXT_CONFIG; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_CONFIG_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + attributes = return_values[ATTRIBUTE_OFFSET]; + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 0, 31) != VAL_STATUS_PASS)) + return VAL_STATUS_FAIL; + + clock_config = return_values[CLOCK_CONFIG_OFFSET]; + + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(clock_config, 1, 31) != + VAL_STATUS_PASS)) + return VAL_STATUS_FAIL; + + val_print(VAL_PRINT_DEBUG, "\n CLOCK State : %d", + VAL_EXTRACT_BITS(clock_config, 0, 0)); + + ext_config_val = return_values[CLOCK_CONFIG_EXT_VAL_OFFSET]; + val_print(VAL_PRINT_DEBUG, "\n Phase Config Value : %d", ext_config_val); } return VAL_STATUS_PASS; diff --git a/test_pool/clock/test_c027.c b/test_pool/clock/test_c027.c index e9c61593daca9cfea696f591278a5985b9c7ef4e..85fd15d393f00f2a707f61c2c78c27818b28eb4e 100644 --- a/test_pool/clock/test_c027.c +++ b/test_pool/clock/test_c027.c @@ -25,6 +25,7 @@ /************ TEST ALGO ****************** + * Check if clock has any restrictions before changing clock parent * Get current parent Id. * Choose a new parent Id. * Set new parent ID for current clock. @@ -44,8 +45,8 @@ uint32_t clock_parent_name_support_set_check(void) uint32_t clock_id, num_clocks; uint32_t parent_id; uint32_t default_parent_id, new_parent_id; - uint32_t parent_id_supp; - uint32_t flag = 0; + uint32_t parent_id_supp, attributes; + uint32_t flag = 0, clock_state_control = 0; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) return VAL_STATUS_SKIP; @@ -70,6 +71,29 @@ uint32_t clock_parent_name_support_set_check(void) continue; } + /* Check if current clock id has any restrictions to change clock parent */ + attributes = val_clock_get_info(CLOCK_ATTRIBUTE, clock_id); + if (val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_GET_PERMISSIONS, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + clock_state_control = VAL_EXTRACT_BITS(return_values[CLOCK_PERMISSIONS_OFFSET], 30, 30); + } + + if (clock_state_control) + { + val_print(VAL_PRINT_ERR, "\n Clock parent set is restricted for this agent"); + continue; + } + flag = 1; /*Step:1 Get the parent Id of the current clock */ val_print(VAL_PRINT_TEST, "\n [STEP 1] Get Parent ID"); diff --git a/test_pool/clock/test_c028.c b/test_pool/clock/test_c028.c index 9fa779064b19f3a992a2b7b8909a6b3aa2456235..567c6101d7c39d0ee9ebff618e8289fab3abdbd5 100644 --- a/test_pool/clock/test_c028.c +++ b/test_pool/clock/test_c028.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_clock.h" #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 28) -#define TEST_DESC "Clock parent set invalid check " +#define TEST_DESC "Clock parent set invalid check " #define MAX_PARAMETER_SIZE 2 @@ -32,8 +32,8 @@ uint32_t clock_parent_set_invalid_check(void) size_t return_value_count; uint32_t return_values[MAX_RETURNS_SIZE]; uint32_t parameters[MAX_PARAMETER_SIZE]; - uint32_t clock_id, num_clocks; - uint32_t parent_supp, parent_id = 0; + uint32_t clock_id, num_clocks, attributes; + uint32_t parent_supp, parent_id = 0, clock_state_control = 0; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) return VAL_STATUS_SKIP; @@ -46,6 +46,29 @@ uint32_t clock_parent_set_invalid_check(void) } val_print(VAL_PRINT_DEBUG, "\n NUM Clocks : %d", num_clocks); + /* Check if current clock id has any restrictions to change clock parent */ + attributes = val_clock_get_info(CLOCK_ATTRIBUTE, clock_id); + if (val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_GET_PERMISSIONS, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + clock_state_control = VAL_EXTRACT_BITS(return_values[CLOCK_PERMISSIONS_OFFSET], 30, 30); + } + + if (clock_state_control) + { + val_print(VAL_PRINT_ERR, "\n Clock parent change is restricted for this agent"); + return VAL_STATUS_SKIP; + } + /* Set Invalid parent ID */ clock_id = 0; parent_id = val_clock_get_info(NUM_CLOCKS, 0) + 1; diff --git a/test_pool/clock/test_c029.c b/test_pool/clock/test_c029.c index 8681d210b9753092e2983ebe5fcba221a3515d64..e075bc2a13741b0d7e9fae87b98bc1ab17e2b727 100644 --- a/test_pool/clock/test_c029.c +++ b/test_pool/clock/test_c029.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_clock.h" #define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 29) -#define TEST_DESC "Clock parent set invalid clock id check " +#define TEST_DESC "Clock parent set invalid clock id check " #define MAX_PARAMETER_SIZE 2 @@ -32,12 +32,29 @@ uint32_t clock_parent_set_invalid_clock_id_check(void) size_t return_value_count; uint32_t return_values[MAX_RETURNS_SIZE]; uint32_t parameters[MAX_PARAMETER_SIZE]; - uint32_t clock_id; - uint32_t parent_id = 0; + uint32_t clock_id, attributes; + uint32_t parent_id = 0, clock_state_control = 0; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) return VAL_STATUS_SKIP; + /* Check if current clock id has any restrictions to change clock parent */ + attributes = val_clock_get_info(CLOCK_ATTRIBUTE, clock_id); + if (val_get_clock_attributes_flag(attributes, CLOCK_RESTRICTED)) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_GET_PERMISSIONS, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + clock_state_control = VAL_EXTRACT_BITS(return_values[CLOCK_PERMISSIONS_OFFSET], 30, 30); + } + /* Get parent name for invalid clock */ clock_id = val_clock_get_info(NUM_CLOCKS, 0) + 1; val_print(VAL_PRINT_TEST, "\n [Check 1] Query with invalid clock_id "); @@ -50,6 +67,9 @@ uint32_t clock_parent_set_invalid_clock_id_check(void) val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); + if ((clock_state_control) && val_compare_status(status, SCMI_DENIED) == VAL_STATUS_PASS) + return VAL_STATUS_PASS; + if (val_compare_status(status, SCMI_NOT_FOUND) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; diff --git a/test_pool/clock/test_c033.c b/test_pool/clock/test_c033.c new file mode 100644 index 0000000000000000000000000000000000000000..9b0399ffc143e6322cd736c412bbd98cf2eb399e --- /dev/null +++ b/test_pool/clock/test_c033.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_clock.h" + +#define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 33) +#define TEST_DESC "Clock query negotiate protocol version " + +extern uint32_t clock_supported_protocols[SUPPORTED_CLOCK_PROTOCOLS_COUNT]; + +uint32_t clock_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = CLOCK_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, + CLOCK_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n CLOCK_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(clock_supported_protocols)/sizeof(clock_supported_protocols[0]); + /* Get index from clock_supported_protocols with version as returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (clock_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = clock_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, + CLOCK_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00030000) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, + CLOCK_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/clock/test_c034.c b/test_pool/clock/test_c034.c new file mode 100644 index 0000000000000000000000000000000000000000..b789b8292de9e3232e2e39566f44dae11ce4b941 --- /dev/null +++ b/test_pool/clock/test_c034.c @@ -0,0 +1,79 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_clock.h" + +#define TEST_NUM (SCMI_CLOCK_TEST_NUM_BASE + 34) +#define TEST_DESC "Clock get permissions check " + +uint32_t clock_get_permissions_check(void) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t clock_id, num_clocks, permissions; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* Get clock permissions for all clocks */ + num_clocks = val_clock_get_info(NUM_CLOCKS, 0); + if (num_clocks == 0) { + val_print(VAL_PRINT_ERR, "\n No Clock found "); + return VAL_STATUS_SKIP; + } + val_print(VAL_PRINT_DEBUG, "\n NUM CLOCKS : %d", num_clocks); + + for (clock_id = 0; clock_id < num_clocks; clock_id++) + { + val_print(VAL_PRINT_TEST, "\n CLOCK ID: %d", clock_id); + val_print(VAL_PRINT_TEST, "\n [Check 1] Query clock permissions"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + param_count++; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_CLOCK, CLOCK_GET_PERMISSIONS, + COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &clock_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + val_print_return_values(return_value_count, return_values); + + permissions = return_values[PERMISSION_OFFSET]; + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(permissions, 0, 28) != + VAL_STATUS_PASS)) + return VAL_STATUS_FAIL; + + val_print(VAL_PRINT_INFO, "\n Clock rate control %d", + VAL_EXTRACT_BITS(permissions, 29, 29)); + val_print(VAL_PRINT_INFO, "\n Clock parent control %d", + VAL_EXTRACT_BITS(permissions, 30, 30)); + val_print(VAL_PRINT_INFO, "\n Clock state control %d", + VAL_EXTRACT_BITS(permissions, 31, 31)); + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/performance/test_d031.c b/test_pool/performance/test_d031.c index 7d10acf4755cec844c201e87ee2e7844416d1eb5..7af23ccd07411fa21ed8905e647993b4ee6073b3 100644 --- a/test_pool/performance/test_d031.c +++ b/test_pool/performance/test_d031.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_performance.h" #define TEST_NUM (SCMI_PERFORMANCE_TEST_NUM_BASE + 31) -#define TEST_DESC "Performance get ext name for invalid domain " +#define TEST_DESC "Performance get ext name for invalid domain " uint32_t performance_query_domain_name_invalid_domain(void) { diff --git a/test_pool/performance/test_d032.c b/test_pool/performance/test_d032.c new file mode 100644 index 0000000000000000000000000000000000000000..0ba63ff0327f1a2db65a1b99fb5f7ccd6e120fc6 --- /dev/null +++ b/test_pool/performance/test_d032.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_performance.h" + +#define TEST_NUM (SCMI_PERFORMANCE_TEST_NUM_BASE + 32) +#define TEST_DESC "Performance query negotiate protocol version " + +extern uint32_t performance_supported_protocols[SUPPORTED_PERFORMANCE_PROTOCOLS_COUNT]; + +uint32_t performance_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = PERFORMANCE_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PERFORMANCE, + PERFORMANCE_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n PERFORMANCE_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(performance_supported_protocols)/sizeof(performance_supported_protocols[0]); + /* Get index from performance_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (performance_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = performance_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PERFORMANCE, + PERFORMANCE_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00040000) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PERFORMANCE, + PERFORMANCE_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/pin_control/test_pi003.c b/test_pool/pin_control/test_pi003.c index dd48904058e67a3c3d95e78594ff7dae932b6050..f5658060618c8a9ac7574f71822ab964f8aa0ddd 100644 --- a/test_pool/pin_control/test_pi003.c +++ b/test_pool/pin_control/test_pi003.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -58,7 +58,7 @@ uint32_t pin_control_query_mandatory_command_support(void) val_print(VAL_PRINT_TEST, "\n [Check 2] PIN CONTROL CONFIG GET support"); VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - message_id = PIN_CONTROL_CONFIG_GET; + message_id = PIN_CONTROL_SETTINGS_GET; param_count++; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, PIN_CONTROL_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); @@ -79,7 +79,7 @@ uint32_t pin_control_query_mandatory_command_support(void) val_print(VAL_PRINT_TEST, "\n [Check 3] PIN CONTROL CONFIG SET support"); VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - message_id = PIN_CONTROL_CONFIG_SET; + message_id = PIN_CONTROL_SETTINGS_CONFIGURE; param_count++; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, PIN_CONTROL_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); diff --git a/test_pool/pin_control/test_pi005.c b/test_pool/pin_control/test_pi005.c index 24d59a35bbd94dc3f9e530c67e7463dc5881344a..12898d8db02bdfa7f370a6258bc7726749d3974a 100644 --- a/test_pool/pin_control/test_pi005.c +++ b/test_pool/pin_control/test_pi005.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -68,12 +68,11 @@ uint32_t pin_control_attributes_check(void) val_print_return_values(return_value_count, return_values); attributes = return_values[ATTRIBUTE_OFFSET]; - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 16, 30) != + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 18, 30) != VAL_STATUS_PASS)) return VAL_STATUS_FAIL; - /* If flag parameter is set to PIN, then this value should be 0 */ - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 0, 15) != - VAL_STATUS_PASS)) + /* If flag parameter is set to PIN, then this value should be 1 */ + if (VAL_EXTRACT_BITS(attributes, 0, 15) != 1) return VAL_STATUS_FAIL; val_print(VAL_PRINT_INFO, "\n Extended Name Support: %d", @@ -89,54 +88,54 @@ uint32_t pin_control_attributes_check(void) num_groups = val_pin_control_get_info(0, PC_NUM_GROUPS); if (num_groups == 0) { val_print(VAL_PRINT_ERR, "\n No Groups found "); - return VAL_STATUS_SKIP; - } - val_print(VAL_PRINT_DEBUG, "\n NUM GROUPS : %d", num_groups); - - for (identifier = 0; identifier < num_groups; identifier++) - { - val_print(VAL_PRINT_TEST, "\n GROUP ID: %d", identifier); - val_print(VAL_PRINT_TEST, "\n [Check 1] Query Pin Control attribute"); - - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = identifier; - parameters[param_count++] = GROUP_SELECTOR; - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, PIN_CONTROL_ATTRIBUTES, + } else { + val_print(VAL_PRINT_DEBUG, "\n NUM GROUPS : %d", num_groups); + + for (identifier = 0; identifier < num_groups; identifier++) + { + val_print(VAL_PRINT_TEST, "\n GROUP ID: %d", identifier); + val_print(VAL_PRINT_TEST, "\n [Check 1] Query Pin Control attribute"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = identifier; + parameters[param_count++] = GROUP_SELECTOR; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, PIN_CONTROL_ATTRIBUTES, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; - val_print_return_values(return_value_count, return_values); + val_print_return_values(return_value_count, return_values); - attributes = return_values[ATTRIBUTE_OFFSET]; - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 16, 30) != + attributes = return_values[ATTRIBUTE_OFFSET]; + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 18, 30) != VAL_STATUS_PASS)) - return VAL_STATUS_FAIL; + return VAL_STATUS_FAIL; - if (val_compare("NUM OF PINS IN GROUP", + if (val_compare("NUM OF PINS IN GROUP", VAL_EXTRACT_BITS(attributes, 0, 15), val_pin_control_get_expected_pins_in_group(identifier))) - return VAL_STATUS_FAIL; + return VAL_STATUS_FAIL; - val_print(VAL_PRINT_TEST, "\n NUM OF PINS IN THE GROUP: %d", - VAL_EXTRACT_BITS(attributes, 0, 15)); + val_print(VAL_PRINT_TEST, "\n NUM OF PINS IN THE GROUP: %d", + VAL_EXTRACT_BITS(attributes, 0, 15)); - val_pin_control_save_info(PC_NUM_PINS_IN_GROUP, identifier, - VAL_EXTRACT_BITS(attributes, 0, 15)); + val_pin_control_save_info(PC_NUM_PINS_IN_GROUP, identifier, + VAL_EXTRACT_BITS(attributes, 0, 15)); - val_print(VAL_PRINT_INFO, "\n Extended Name Support: %d", - VAL_EXTRACT_BITS(attributes, 31, 31)); - val_pin_control_save_ext_name_info(PC_GROUP_NAME, identifier, - VAL_EXTRACT_BITS(attributes, 31, 31)); + val_print(VAL_PRINT_INFO, "\n Extended Name Support: %d", + VAL_EXTRACT_BITS(attributes, 31, 31)); + val_pin_control_save_ext_name_info(PC_GROUP_NAME, identifier, + VAL_EXTRACT_BITS(attributes, 31, 31)); - val_print(VAL_PRINT_INFO, "\n GROUP_NAME: %s ", - (uint8_t *) &return_values[NAME_OFFSET]); + val_print(VAL_PRINT_INFO, "\n GROUP_NAME: %s ", + (uint8_t *) &return_values[NAME_OFFSET]); + } } /* Discover pin control attributes for all functions */ @@ -169,14 +168,24 @@ uint32_t pin_control_attributes_check(void) val_print_return_values(return_value_count, return_values); attributes = return_values[ATTRIBUTE_OFFSET]; - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 16, 30) != + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attributes, 18, 30) != VAL_STATUS_PASS)) return VAL_STATUS_FAIL; - if (val_compare("NUM OF GROUPS IN FUNCTION", + val_print(VAL_PRINT_TEST, "\n FUNCTION SUPPORTS GPIO: %d", + VAL_EXTRACT_BITS(attributes, 17, 17)); + val_pin_control_save_info(PC_FUNCTION_GPIO_SUPPORT, identifier, + VAL_EXTRACT_BITS(attributes, 17, 17)); + + val_print(VAL_PRINT_TEST, "\n FUNCTION IS SUPPORTED BY GROUP: %d", + VAL_EXTRACT_BITS(attributes, 16, 16)); + val_pin_control_save_info(PC_FUNCTION_GROUP_SUPPORT, identifier, + VAL_EXTRACT_BITS(attributes, 16, 16)); + + if (val_compare("NUM OF GROUPS IN FUNCTION", VAL_EXTRACT_BITS(attributes, 0, 15), val_pin_control_get_expected_groups_in_func(identifier))) - return VAL_STATUS_FAIL; + return VAL_STATUS_FAIL; val_print(VAL_PRINT_TEST, "\n NUM OF GROUPS IN THE FUNCTION: %d", VAL_EXTRACT_BITS(attributes, 0, 15)); diff --git a/test_pool/pin_control/test_pi009.c b/test_pool/pin_control/test_pi009.c index e0ea210fd6d9cb53b05c9295298968162d883fa2..5f19f473ff90f86cc10bfd86fd1afb76b325c344 100644 --- a/test_pool/pin_control/test_pi009.c +++ b/test_pool/pin_control/test_pi009.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,10 +19,10 @@ #include "val_pin_control.h" #define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 9) -#define TEST_DESC "pin ctrl config get check " +#define TEST_DESC "pin ctrl settings get check " #define PARAMETER_SIZE 2 -uint32_t pin_control_query_config_get_check(void) +uint32_t pin_control_query_settings_get_check(void) { int32_t status; uint32_t rsp_msg_hdr; @@ -33,11 +33,11 @@ uint32_t pin_control_query_config_get_check(void) uint32_t parameters[PARAMETER_SIZE]; uint32_t attributes = 0; uint32_t num_groups = 0, num_pins = 0; - uint32_t pc_id = 0; + uint32_t pc_id = 0, skip_configs = 0;; uint32_t num_remaining_configs, num_configs_returned; uint32_t i, *pin_configs_array; - uint32_t configs_count; uint32_t entry_0, entry_1; + uint32_t function_selected; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) return VAL_STATUS_SKIP; @@ -55,7 +55,7 @@ uint32_t pin_control_query_config_get_check(void) { num_remaining_configs = 0; num_configs_returned = 0; - configs_count = 0; + skip_configs = 0; val_print(VAL_PRINT_TEST, "\n PIN CONTROL PIN ID: %d", pc_id); val_print(VAL_PRINT_TEST, "\n [Check 1] Query config get"); @@ -65,12 +65,13 @@ uint32_t pin_control_query_config_get_check(void) { VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); parameters[param_count++] = pc_id; - attributes = (GET_ALL_CONFIGS << GET_ALL_CONFIGS_LOW) + - (PIN_SELECTOR << SELECTOR_LOW); + attributes = (GET_ALL_CONFIGS << GET_ALL_CONFIGS_LOW) | + (PIN_SELECTOR << SELECTOR_LOW) | + (skip_configs << SKIP_CONFIGS_LOW); parameters[param_count++] = attributes; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); @@ -82,6 +83,12 @@ uint32_t pin_control_query_config_get_check(void) val_print_return_values(return_value_count, return_values); + function_selected = return_values[RET_FUNCTION_SELECTED_OFFSET]; + if (function_selected != NO_FUNCTION_ENABLED) { + val_print(VAL_PRINT_DEBUG, "\n PIN ENABLES FUNCTION: %d", + function_selected); + } + num_remaining_configs = VAL_EXTRACT_BITS(return_values[RET_NUM_CONFIGS_OFFSET], 24, 31); val_print(VAL_PRINT_DEBUG, "\n NUM OF REMAINING PIN CONFIGS: %d", @@ -107,7 +114,7 @@ uint32_t pin_control_query_config_get_check(void) entry_1 = pin_configs_array[(i * 2) + 1]; val_print(VAL_PRINT_DEBUG, "\n CONFIG VALUE: %d", entry_1); } - configs_count += num_configs_returned; + skip_configs += num_configs_returned; val_print(VAL_PRINT_DEBUG, "\n num_remaining_configs: %d", num_remaining_configs); } while (num_remaining_configs > 0); @@ -127,7 +134,7 @@ uint32_t pin_control_query_config_get_check(void) { num_remaining_configs = 0; num_configs_returned = 0; - configs_count = 0; + skip_configs = 0; val_print(VAL_PRINT_TEST, "\n PIN CONTROL GROUP ID: %d", pc_id); val_print(VAL_PRINT_TEST, "\n [Check 1] Query config get"); @@ -142,7 +149,7 @@ uint32_t pin_control_query_config_get_check(void) parameters[param_count++] = attributes; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); @@ -164,6 +171,13 @@ uint32_t pin_control_query_config_get_check(void) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; + function_selected = return_values[RET_FUNCTION_SELECTED_OFFSET]; + if (function_selected != NO_FUNCTION_ENABLED) { + val_print(VAL_PRINT_DEBUG, "\n GROUP ENABLES FUNCTION: %d", + function_selected); + } + + num_configs_returned = VAL_EXTRACT_BITS(return_values[RET_NUM_CONFIGS_OFFSET], 0, 7); val_print(VAL_PRINT_DEBUG, "\n NUM OF GROUP CONFIGS RETURNED : %d", @@ -179,7 +193,7 @@ uint32_t pin_control_query_config_get_check(void) entry_1 = pin_configs_array[(i * 2) + 1]; val_print(VAL_PRINT_DEBUG, "\n CONFIG VALUE: %d", entry_0); } - configs_count += num_configs_returned; + skip_configs += num_configs_returned; val_print(VAL_PRINT_DEBUG, "\n num_remaining_configs: %d", num_remaining_configs); } while (num_remaining_configs > 0); diff --git a/test_pool/pin_control/test_pi010.c b/test_pool/pin_control/test_pi010.c index d6db95187be4b05a1cf4bd1019a8cc30e948fcba..6cc0669c7d94096945252eaabdd806b6b421e046 100644 --- a/test_pool/pin_control/test_pi010.c +++ b/test_pool/pin_control/test_pi010.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,10 +19,10 @@ #include "val_pin_control.h" #define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 10) -#define TEST_DESC "pin ctrl config get invalid id check " +#define TEST_DESC "pin ctrl settings get invalid id check " #define PARAMETER_SIZE 2 -uint32_t pin_control_config_get_invalid_id_check(void) +uint32_t pin_control_settings_get_invalid_id_check(void) { int32_t status; uint32_t rsp_msg_hdr; @@ -50,7 +50,7 @@ uint32_t pin_control_config_get_invalid_id_check(void) (GROUP_SELECTOR << SELECTOR_LOW);; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); diff --git a/test_pool/pin_control/test_pi011.c b/test_pool/pin_control/test_pi011.c index 245a2b4515dd85ef1cf868fe481b9f0096bb6dff..924cdd8739f9788476b542c1b2a871534f9b32db 100644 --- a/test_pool/pin_control/test_pi011.c +++ b/test_pool/pin_control/test_pi011.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -20,20 +20,20 @@ #define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 11) #define TEST_DESC "pin ctrl config set check " -#define PARAMETER_SIZE 4 +#define PARAMETER_SIZE 5 #define CONFIG_ENABLE 1 #define CONFIG_DISABLE 0 /************ TEST ALGO ****************** - * Get current Config Values - * Choose a different values for Config Type - * Set new config values for Config type - * Check new config values has been set. - * Restore the default config values + * Get current settings config values + * Choose a different values for config type + * Set new settings configure values for config type + * Check new settings configure values has been set. + * Restore the default settings config values *****************************************/ -uint32_t pin_control_query_config_set_check(void) +uint32_t pin_control_query_settings_configure_check(void) { int32_t status; uint32_t rsp_msg_hdr; @@ -47,13 +47,13 @@ uint32_t pin_control_query_config_set_check(void) uint32_t pc_id = 0; uint32_t *pin_configs_array; uint32_t config_type, default_config_value; - uint32_t new_config_value; + uint32_t new_config_value, function_selected = 0; uint32_t entry_0, entry_1; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) return VAL_STATUS_SKIP; - /* Query pin control config set for pin identifiers */ + /* Query pin control settings configure for pin identifiers */ num_pins = val_pin_control_get_info(0, PC_NUM_PINS); if (num_pins == 0) { val_print(VAL_PRINT_ERR, "\n No pin control pin identifiers found"); @@ -66,117 +66,131 @@ uint32_t pin_control_query_config_set_check(void) { /* STEP 1:Reading pin configuration */ val_print(VAL_PRINT_TEST, "\n PIN CONTROL PIN ID: %d", pc_id); - val_print(VAL_PRINT_TEST, "\n [STEP 1] Get Pin config "); + val_print(VAL_PRINT_TEST, "\n [STEP 1] Get Pin settings config "); /* Get all the available configs for each pin identifier */ - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = ((PIN_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); - parameters[param_count++] = attributes; - - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, - &return_value_count, return_values); - - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; - /* Print the pin id's associated with the group */ - config_type = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); - val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG TYPE : %d", config_type); - - default_config_value = pin_configs_array[1]; - val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG VALUE: %d", - default_config_value); - - /* STEP:2 SET Different Config Values for the Config Type */ - val_print(VAL_PRINT_TEST, "\n [Step 2] Choose new config value for pin"); - - if (default_config_value == CONFIG_DISABLE) - new_config_value = CONFIG_ENABLE; - else - new_config_value = CONFIG_DISABLE; - - /*STEP:3 Setting new config value for pin*/ - val_print(VAL_PRINT_TEST, "\n [Step 3] Set new config value"); - val_print(VAL_PRINT_DEBUG, "\n CONFIG TYPE : %d", - VAL_EXTRACT_BITS(config_type, 0, 7)); - val_print(VAL_PRINT_DEBUG, "\n NEW CONFIG VALUE: %d", new_config_value); - - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = (1 << SET_CONFIGS_LOW) + PIN_SELECTOR; - parameters[param_count++] = attributes; - parameters[param_count++] = config_type; - parameters[param_count++] = new_config_value; - - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_SET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, - &return_value_count, return_values); - - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_SKIP; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - /* STEP 4 : Verify new config_value has been set */ - val_print(VAL_PRINT_TEST, "\n [Step 4] Verify new config value "); - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = ((PIN_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); - parameters[param_count++] = attributes; - - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, - &return_value_count, return_values); - - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; - val_print_return_values(return_value_count, return_values); - - entry_0 = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); - if (val_compare("Config Type ", entry_0, config_type)) - return VAL_STATUS_FAIL; - - entry_1 = pin_configs_array[1]; - if (val_compare("New Config Value ", entry_1, new_config_value)) - return VAL_STATUS_FAIL; - - /* STEP 5 : Set default config value back */ - val_print(VAL_PRINT_TEST, "\n [Step 5] Set default config value"); - - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = (1 << SET_CONFIGS_LOW) + PIN_SELECTOR; - parameters[param_count++] = attributes; - parameters[param_count++] = config_type; - parameters[param_count++] = default_config_value; - - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_SET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, - &return_value_count, return_values); - - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - } + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + attributes = ((PIN_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); + parameters[param_count++] = attributes; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + function_selected = return_values[RET_FUNCTION_SELECTED_OFFSET]; + if (function_selected != NO_FUNCTION_ENABLED) { + val_print(VAL_PRINT_DEBUG, "\n PIN ENABLES FUNCTION: %d", + function_selected); + } + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; + /* Print the pin id's associated with the group */ + config_type = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); + val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG TYPE : %d", config_type); + + default_config_value = pin_configs_array[1]; + val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG VALUE: %d", + default_config_value); + + /* STEP:2 SET Different Config Values for the Config Type */ + val_print(VAL_PRINT_TEST, "\n [Step 2] Choose new config value for pin"); + + if (default_config_value == CONFIG_DISABLE) + new_config_value = CONFIG_ENABLE; + else + new_config_value = CONFIG_DISABLE; + + /*STEP:3 Setting new config value for pin*/ + val_print(VAL_PRINT_TEST, "\n [Step 3] Set new config value"); + val_print(VAL_PRINT_DEBUG, "\n CONFIG TYPE : %d", + VAL_EXTRACT_BITS(config_type, 0, 7)); + val_print(VAL_PRINT_DEBUG, "\n NEW CONFIG VALUE: %d", new_config_value); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + parameters[param_count++] = function_selected; + attributes = (1 << SET_CONFIGS_LOW) + PIN_SELECTOR; + parameters[param_count++] = attributes; + parameters[param_count++] = config_type; + parameters[param_count++] = new_config_value; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_CONFIGURE, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + /* STEP 4 : Verify new config_value has been set */ + val_print(VAL_PRINT_TEST, "\n [Step 4] Verify new config value "); + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + attributes = ((PIN_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); + parameters[param_count++] = attributes; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + function_selected = return_values[RET_FUNCTION_SELECTED_OFFSET]; + if (function_selected != NO_FUNCTION_ENABLED) { + val_print(VAL_PRINT_DEBUG, "\n PIN ENABLES FUNCTION: %d", + function_selected); + } + + pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; + val_print_return_values(return_value_count, return_values); + + entry_0 = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); + if (val_compare("Config Type ", entry_0, config_type)) + return VAL_STATUS_FAIL; + + entry_1 = pin_configs_array[1]; + if (val_compare("New Config Value ", entry_1, new_config_value)) + return VAL_STATUS_FAIL; + + /* STEP 5 : Set default config value back */ + val_print(VAL_PRINT_TEST, "\n [Step 5] Set default config value"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + parameters[param_count++] = function_selected; + attributes = (1 << SET_CONFIGS_LOW) + PIN_SELECTOR; + parameters[param_count++] = attributes; + parameters[param_count++] = config_type; + parameters[param_count++] = default_config_value; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_CONFIGURE, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + } } /* Query pin control config set for group identifiers */ @@ -195,113 +209,127 @@ uint32_t pin_control_query_config_set_check(void) /* Get all the available configs for each group identifier */ - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = ((GROUP_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); - parameters[param_count++] = attributes; + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + attributes = ((GROUP_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); + parameters[param_count++] = attributes; - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; - /* Print the pin id's associated with the group */ - config_type = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); - val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG TYPE : %d", config_type); - - default_config_value = pin_configs_array[1]; - val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG VALUE: %d", - default_config_value); - - /* STEP:2 SET Different Config Values for the Config Type */ - val_print(VAL_PRINT_TEST, "\n [Step 2] Choose new config value for group"); - if (default_config_value == CONFIG_DISABLE) - new_config_value = CONFIG_ENABLE; - else - new_config_value = CONFIG_DISABLE; - - /*STEP:3 Setting new config value for group*/ - val_print(VAL_PRINT_TEST, "\n [Step 3] Set new config value"); - val_print(VAL_PRINT_DEBUG, "\n CONFIG TYPE : %d", - VAL_EXTRACT_BITS(config_type, 0, 7)); - val_print(VAL_PRINT_DEBUG, "\n NEW CONFIG VALUE: %d", new_config_value); - - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = (1 << SET_CONFIGS_LOW) + GROUP_SELECTOR; - parameters[param_count++] = attributes; - parameters[param_count++] = config_type; - parameters[param_count++] = new_config_value; - - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_SET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, - &return_value_count, return_values); - - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_SKIP; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - /* STEP 4 : Verify new config_value has been set */ - val_print(VAL_PRINT_TEST, "\n [Step 4] Verify new config value "); - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = ((GROUP_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); - parameters[param_count++] = attributes; - - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, - &return_value_count, return_values); - - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; - val_print_return_values(return_value_count, return_values); - - entry_0 = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); - if (val_compare("Config Type ", entry_0, config_type)) - return VAL_STATUS_FAIL; - - entry_1 = pin_configs_array[1]; - if (val_compare("New Config Value ", entry_1, new_config_value)) - return VAL_STATUS_FAIL; - - /* STEP 5 : Set default config value back */ - val_print(VAL_PRINT_TEST, "\n [Step 5] Set default config value"); - - VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); - parameters[param_count++] = pc_id; - attributes = (1 << SET_CONFIGS_LOW) + GROUP_SELECTOR; - parameters[param_count++] = attributes; - parameters[param_count++] = config_type; - parameters[param_count++] = default_config_value; - - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_SET, COMMAND_MSG); - val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, - &return_value_count, return_values); - - if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) - return VAL_STATUS_FAIL; - - } + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + function_selected = return_values[RET_FUNCTION_SELECTED_OFFSET]; + if (function_selected != NO_FUNCTION_ENABLED) { + val_print(VAL_PRINT_DEBUG, "\n PIN ENABLES FUNCTION: %d", + function_selected); + } + + pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; + /* Print the pin id's associated with the group */ + config_type = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); + val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG TYPE : %d", config_type); + + default_config_value = pin_configs_array[1]; + val_print(VAL_PRINT_DEBUG, "\n DEFAULT CONFIG VALUE: %d", + default_config_value); + + /* STEP:2 SET Different Config Values for the Config Type */ + val_print(VAL_PRINT_TEST, "\n [Step 2] Choose new config value for group"); + if (default_config_value == CONFIG_DISABLE) + new_config_value = CONFIG_ENABLE; + else + new_config_value = CONFIG_DISABLE; + + /*STEP:3 Setting new config value for group*/ + val_print(VAL_PRINT_TEST, "\n [Step 3] Set new config value"); + val_print(VAL_PRINT_DEBUG, "\n CONFIG TYPE : %d", + VAL_EXTRACT_BITS(config_type, 0, 7)); + val_print(VAL_PRINT_DEBUG, "\n NEW CONFIG VALUE: %d", new_config_value); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + parameters[param_count++] = function_selected; + attributes = (1 << SET_CONFIGS_LOW) + GROUP_SELECTOR; + parameters[param_count++] = attributes; + parameters[param_count++] = config_type; + parameters[param_count++] = new_config_value; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_CONFIGURE, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + /* STEP 4 : Verify new config_value has been set */ + val_print(VAL_PRINT_TEST, "\n [Step 4] Verify new config value "); + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + attributes = ((GROUP_SELECTOR << SELECTOR_LOW) + DEFAULT_CONFIG_TYPE); + parameters[param_count++] = attributes; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + function_selected = return_values[RET_FUNCTION_SELECTED_OFFSET]; + if (function_selected != NO_FUNCTION_ENABLED) { + val_print(VAL_PRINT_DEBUG, "\n PIN ENABLES FUNCTION: %d", + function_selected); + } + + pin_configs_array = &return_values[RET_CONFIGS_ARRAY_OFFSET]; + val_print_return_values(return_value_count, return_values); + + entry_0 = VAL_EXTRACT_BITS(pin_configs_array[0], 0, 7); + if (val_compare("Config Type ", entry_0, config_type)) + return VAL_STATUS_FAIL; + + entry_1 = pin_configs_array[1]; + if (val_compare("New Config Value ", entry_1, new_config_value)) + return VAL_STATUS_FAIL; + + /* STEP 5 : Set default config value back */ + val_print(VAL_PRINT_TEST, "\n [Step 5] Set default config value"); + + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters[param_count++] = pc_id; + parameters[param_count++] = function_selected; + attributes = (1 << SET_CONFIGS_LOW) + GROUP_SELECTOR; + parameters[param_count++] = attributes; + parameters[param_count++] = config_type; + parameters[param_count++] = default_config_value; + + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_SETTINGS_CONFIGURE, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_status(status, SCMI_SUCCESS) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + } } -return VAL_STATUS_PASS; + + return VAL_STATUS_PASS; } diff --git a/test_pool/pin_control/test_pi012.c b/test_pool/pin_control/test_pi012.c index 69e343ee3e1d377f48ce32a71f34ec05d2cb2cd3..5e8caf9c63a938512dcadbe91aa75407e0b1d773 100644 --- a/test_pool/pin_control/test_pi012.c +++ b/test_pool/pin_control/test_pi012.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,14 +19,14 @@ #include "val_pin_control.h" #define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 12) -#define TEST_DESC "pin ctrl config set invalid param check " +#define TEST_DESC "pin ctrl settings config invalid param check " -#define PARAMETER_SIZE 4 +#define PARAMETER_SIZE 5 #define CONFIG_NUM_SET 1 #define CONFIG_ENABLE 1 -uint32_t pin_control_config_set_invalid_param_check(void) +uint32_t pin_control_settings_configure_invalid_param_check(void) { int32_t status; uint32_t rsp_msg_hdr; @@ -37,7 +37,7 @@ uint32_t pin_control_config_set_invalid_param_check(void) uint32_t parameters[PARAMETER_SIZE]; uint32_t attributes = 0; uint32_t num_pins = 0; - uint32_t pc_id = 0; + uint32_t pc_id = 0, function_selected = 0; uint32_t config_value, config_type; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) @@ -62,13 +62,14 @@ uint32_t pin_control_config_set_invalid_param_check(void) /* Query with invalid config type should fail with INVALID_PARAMETERS*/ VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); parameters[param_count++] = pc_id; + parameters[param_count++] = function_selected; attributes = (CONFIG_NUM_SET << SET_CONFIGS_LOW) + PIN_SELECTOR; parameters[param_count++] = attributes; parameters[param_count++] = config_type; parameters[param_count++] = config_value; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_SET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_CONFIGURE, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); @@ -83,11 +84,12 @@ uint32_t pin_control_config_set_invalid_param_check(void) /* Query with invalid attribute should fail with INVALID_PARAMETERS*/ VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); parameters[param_count++] = pc_id; + parameters[param_count++] = function_selected; parameters[param_count++] = PINCTRL_SET_INVALID_ATTIBUTE; parameters[param_count++] = config_type; parameters[param_count++] = config_value; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_SET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_CONFIGURE, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); diff --git a/test_pool/pin_control/test_pi013.c b/test_pool/pin_control/test_pi013.c index 56a6947f06b1ef0d1faa2edf25d33abc75492fe5..39ea9ea446c698fa789b66290eecbc5d8bd7d50b 100644 --- a/test_pool/pin_control/test_pi013.c +++ b/test_pool/pin_control/test_pi013.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,14 +19,14 @@ #include "val_pin_control.h" #define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 13) -#define TEST_DESC "pin ctrl config set invalid id check " +#define TEST_DESC "pin ctrl settings config invalid id check " -#define PARAMETER_SIZE 4 +#define PARAMETER_SIZE 5 #define CONFIG_NUM_SET 1 #define CONFIG_ENABLE 1 -uint32_t pin_control_config_set_invalid_id_check(void) +uint32_t pin_control_settings_configure_invalid_id_check(void) { int32_t status; uint32_t rsp_msg_hdr; @@ -36,7 +36,7 @@ uint32_t pin_control_config_set_invalid_id_check(void) uint32_t return_values[MAX_RETURNS_SIZE]; uint32_t parameters[PARAMETER_SIZE]; uint32_t attributes = 0; - uint32_t pc_id = 0; + uint32_t pc_id = 0, function_selected = 0; uint32_t config_value, config_type; if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) @@ -52,6 +52,7 @@ uint32_t pin_control_config_set_invalid_id_check(void) VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); parameters[param_count++] = pc_id; + parameters[param_count++] = function_selected; attributes = (CONFIG_NUM_SET << SET_CONFIGS_LOW) + GROUP_SELECTOR; parameters[param_count++] = attributes; @@ -62,7 +63,7 @@ uint32_t pin_control_config_set_invalid_id_check(void) parameters[param_count++] = config_value; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_SET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_CONFIGURE, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameters, &rsp_msg_hdr, &status, &return_value_count, return_values); diff --git a/test_pool/pin_control/test_pi017.c b/test_pool/pin_control/test_pi017.c index 728f4e8769063181f7b83d53879e36634b6ff0f1..af82be54661d599764fc6ab800f9f043c8097238 100644 --- a/test_pool/pin_control/test_pi017.c +++ b/test_pool/pin_control/test_pi017.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_pin_control.h" #define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 17) -#define TEST_DESC "pin ctrl request invalid case check " +#define TEST_DESC "pin ctrl request invalid case check " #define PARAMETER_SIZE 2 uint32_t pin_control_query_request_invalid_case_check(void) diff --git a/test_pool/pin_control/test_pi021.c b/test_pool/pin_control/test_pi021.c index edfba380d65d2753f77dcac1b64144e9c2e350ec..a923e9e1e4d70de212b91a7572e6282e1fbc024d 100644 --- a/test_pool/pin_control/test_pi021.c +++ b/test_pool/pin_control/test_pi021.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_pin_control.h" #define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 21) -#define TEST_DESC "pin ctrl set permissions check " +#define TEST_DESC "pin ctrl set permissions check " #define PARAMETER_SIZE 3 @@ -111,7 +111,7 @@ uint32_t pin_control_set_permissions_check(void) parameter[param_count++] = attributes; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameter, &rsp_msg_hdr, &status, &return_value_count, return_values); @@ -157,7 +157,7 @@ uint32_t pin_control_set_permissions_check(void) parameter[param_count++] = attributes; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameter, &rsp_msg_hdr, &status, &return_value_count, return_values); @@ -218,7 +218,7 @@ uint32_t pin_control_set_permissions_check(void) parameter[param_count++] = attributes; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameter, &rsp_msg_hdr, &status, &return_value_count, return_values); @@ -264,7 +264,7 @@ uint32_t pin_control_set_permissions_check(void) parameter[param_count++] = attributes; cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, - PIN_CONTROL_CONFIG_GET, COMMAND_MSG); + PIN_CONTROL_SETTINGS_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, parameter, &rsp_msg_hdr, &status, &return_value_count, return_values); diff --git a/test_pool/pin_control/test_pi024.c b/test_pool/pin_control/test_pi024.c new file mode 100644 index 0000000000000000000000000000000000000000..1e85a949b91548c580f7a51db9bc2581c8b59201 --- /dev/null +++ b/test_pool/pin_control/test_pi024.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_pin_control.h" + +#define TEST_NUM (SCMI_PIN_CONTROL_TEST_NUM_BASE + 24) +#define TEST_DESC "Pin Control query negotiate protocol version " + +extern uint32_t pin_control_supported_protocols[SUPPORTED_PIN_CONTROL_PROTOCOLS_COUNT]; + +uint32_t pin_control_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = PIN_CONTROL_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n PIN_CONTROL_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(pin_control_supported_protocols)/sizeof(pin_control_supported_protocols[0]); + /* Get index from pin_control_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (pin_control_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = pin_control_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00010000) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_PIN_CONTROL, + PIN_CONTROL_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/power_domain/test_p005_v3.c b/test_pool/power_domain/test_p005_v3.c index 2ebcb6dab02be83c107740c6e056ea3e7f0240c6..27307c61d11591a15594073749e5b146f92dbf7e 100644 --- a/test_pool/power_domain/test_p005_v3.c +++ b/test_pool/power_domain/test_p005_v3.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -63,7 +63,7 @@ uint32_t power_domain_query_domain_attributes_scmi_v3(void) val_print_return_values(return_value_count, return_values); attribute = return_values[ATTRIBUTE_OFFSET]; - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attribute, 0, 28)) != VAL_STATUS_PASS) + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attribute, 0, 27)) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; val_print(VAL_PRINT_DEBUG, "\n POWER STATE CHANGE NOTIFICATIONS SUPPORT: %d", diff --git a/test_pool/power_domain/test_p005_v3_1.c b/test_pool/power_domain/test_p005_v3_1.c index d97d49bf475a5068dc18d69ac5d0d1cd2fe824d1..b1783bf5cbbe6e6b29eaaf3a62c742941381c246 100644 --- a/test_pool/power_domain/test_p005_v3_1.c +++ b/test_pool/power_domain/test_p005_v3_1.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -63,7 +63,7 @@ uint32_t power_domain_query_domain_attributes_scmi_v3_1(void) val_print_return_values(return_value_count, return_values); attribute = return_values[ATTRIBUTE_OFFSET]; - if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attribute, 0, 28)) != VAL_STATUS_PASS) + if (val_reserved_bits_check_is_zero(VAL_EXTRACT_BITS(attribute, 0, 26)) != VAL_STATUS_PASS) return VAL_STATUS_FAIL; val_print(VAL_PRINT_DEBUG, "\n POWER STATE CHANGE NOTIFICATIONS SUPPORT: %d", diff --git a/test_pool/power_domain/test_p018.c b/test_pool/power_domain/test_p018.c index 6d486d2afed873d57987d53f004a0ad26ac02307..3e851b6e185d25fa881dc2672687fd76d491a9e9 100644 --- a/test_pool/power_domain/test_p018.c +++ b/test_pool/power_domain/test_p018.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_power_domain.h" #define TEST_NUM (SCMI_POWER_DOMAIN_TEST_NUM_BASE + 18) -#define TEST_DESC "Power get extended name for invalid domain " +#define TEST_DESC "Power get extended name for invalid domain " uint32_t power_query_ext_domain_name_invalid_domain(void) { @@ -77,7 +77,7 @@ uint32_t power_query_ext_domain_name_invalid_domain(void) VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); param_count++; - cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWERCAP, POWER_DOMAIN_NAME_GET, COMMAND_MSG); + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWER_DOMAIN, POWER_DOMAIN_NAME_GET, COMMAND_MSG); val_send_message(cmd_msg_hdr, param_count, &domain_id, &rsp_msg_hdr, &status, &return_value_count, return_values); diff --git a/test_pool/power_domain/test_p019.c b/test_pool/power_domain/test_p019.c new file mode 100644 index 0000000000000000000000000000000000000000..bb0886f25de8d8ce12c0ac857205cfb519fb3ee8 --- /dev/null +++ b/test_pool/power_domain/test_p019.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_power_domain.h" + +#define TEST_NUM (SCMI_POWER_DOMAIN_TEST_NUM_BASE + 19) +#define TEST_DESC "Power Domain query negotiate protocol version" + +extern uint32_t power_supported_protocols[SUPPORTED_POWER_PROTOCOLS_COUNT]; + +uint32_t power_domain_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = POWER_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWER_DOMAIN, + PD_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n POWER_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(power_supported_protocols)/sizeof(power_supported_protocols[0]); + /* Get index from power_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (power_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = power_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWER_DOMAIN, + POWER_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00030001) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWER_DOMAIN, + POWER_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/powercap/test_pc001.c b/test_pool/powercap/test_pc001.c index c16cd3ad5ca00394914f2876d4ef52b7e3b80b54..0d950165bb23c98dd5993d59cc310bba086663a2 100644 --- a/test_pool/powercap/test_pc001.c +++ b/test_pool/powercap/test_pc001.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_base.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 1) -#define TEST_DESC "Powercap protocol version check " +#define TEST_DESC "Powercap protocol version check " #define RETURN_VALUE_COUNT 1 uint32_t powercap_query_protocol_version(uint32_t *version) diff --git a/test_pool/powercap/test_pc002.c b/test_pool/powercap/test_pc002.c index 1b19008cd1195c59ae566c2d10b1578270da3edf..0653158074be2ec38f12c1f5997367c3801fabf0 100644 --- a/test_pool/powercap/test_pc002.c +++ b/test_pool/powercap/test_pc002.c @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 2) -#define TEST_DESC "Powercap protocol attributes check " +#define TEST_DESC "Powercap protocol attributes check " #define RETURN_VALUE_COUNT 1 diff --git a/test_pool/powercap/test_pc003.c b/test_pool/powercap/test_pc003.c index 20a6a177003934e985ee8a3ed2f31fd1bb27d18d..1691b7a0009b4c45175d09bd6d0e97633c43a1b6 100644 --- a/test_pool/powercap/test_pc003.c +++ b/test_pool/powercap/test_pc003.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 3) -#define TEST_DESC "Powercap msg attributes mandatory cmd check " +#define TEST_DESC "Powercap msg attributes mandatory cmd check " uint32_t powercap_query_mandatory_command_support(void) { diff --git a/test_pool/powercap/test_pc004.c b/test_pool/powercap/test_pc004.c index 02110378e8fd379b9fc773a54c1681b5e5601307..4e5f3287b424ae80db194bfe6ed030c84205f5b1 100644 --- a/test_pool/powercap/test_pc004.c +++ b/test_pool/powercap/test_pc004.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 4) -#define TEST_DESC "Powercap msg attributes invalid msg id check " +#define TEST_DESC "Powercap msg attributes invalid msg id check " uint32_t powercap_invalid_messageid_call(void) { diff --git a/test_pool/powercap/test_pc005.c b/test_pool/powercap/test_pc005.c index 9e4c2ac45240448d68a04f0ca84b622baf327b6b..56b5cce8a5a4da5f2997607c92807fb1897ac24e 100644 --- a/test_pool/powercap/test_pc005.c +++ b/test_pool/powercap/test_pc005.c @@ -21,7 +21,7 @@ #define NAME_OFFSET 1 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 5) -#define TEST_DESC "Powercap domain attributes check " +#define TEST_DESC "Powercap domain attributes check " uint32_t powercap_query_domain_attributes(void) { diff --git a/test_pool/powercap/test_pc005_v2.c b/test_pool/powercap/test_pc005_v2.c index 0a43724b503a1f867ff7b42a0ec146c273f3e91b..ee30a4da23c8e23bb8e4deeb26f67941c1011b02 100644 --- a/test_pool/powercap/test_pc005_v2.c +++ b/test_pool/powercap/test_pc005_v2.c @@ -21,7 +21,7 @@ #define NAME_OFFSET 1 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 5) -#define TEST_DESC "Powercap domain attributes check " +#define TEST_DESC "Powercap domain attributes check " uint32_t powercap_query_domain_attributes_v2(void) { @@ -115,7 +115,7 @@ uint32_t powercap_query_domain_attributes_v2(void) /* Domain name */ if (ext_name_supp) { - if (val_compare_str("DOMAIN NAME", (char *)&return_values[NAME_OFFSET], + if (val_compare_str("DOMAIN NAME", (char *)&return_values[NAME_OFFSET] - 16, name + strnlen(name, SCMI_NAME_STR_SIZE) - 16, SCMI_NAME_STR_SIZE)) return VAL_STATUS_FAIL; } else { diff --git a/test_pool/powercap/test_pc006.c b/test_pool/powercap/test_pc006.c index 7fdd99c6d9bbb6243ae8e097c63f9f1d7a0173df..0d1cd78121f35ae5cc5f06a101940aaaa123c48e 100644 --- a/test_pool/powercap/test_pc006.c +++ b/test_pool/powercap/test_pc006.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 6) -#define TEST_DESC "Powercap Domain attributes invalid domain id check " +#define TEST_DESC "Powercap Domain attri invalid domain id check" uint32_t powercap_query_domain_attributes_invalid_id(void) { diff --git a/test_pool/powercap/test_pc007.c b/test_pool/powercap/test_pc007.c index caaa30107ab3512bf1c9458e3f84bd3cd8bc8929..813c7e513ad1906bf1e14474fd575abac0cf9c5e 100644 --- a/test_pool/powercap/test_pc007.c +++ b/test_pool/powercap/test_pc007.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 7) -#define TEST_DESC "Powercap domain get value check " +#define TEST_DESC "Powercap domain get value check " uint32_t powercap_query_get_powercap_value(void) { diff --git a/test_pool/powercap/test_pc008.c b/test_pool/powercap/test_pc008.c index a44c68d7d65fdd26cfd0b1f3a647e5a2810aa1d6..bae91107e738c0747a5ea2fdf092964ee37cc76e 100644 --- a/test_pool/powercap/test_pc008.c +++ b/test_pool/powercap/test_pc008.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 8) -#define TEST_DESC "Powercap invalid domain id check " +#define TEST_DESC "Powercap invalid domain id check " uint32_t powercap_query_invalid_domain_id(void) { diff --git a/test_pool/powercap/test_pc009.c b/test_pool/powercap/test_pc009.c index 4ea09d320a7edceaf1bf8077fdba416a03caa0b8..040712768677d727e2d7c2b6f102d5835d84de01 100644 --- a/test_pool/powercap/test_pc009.c +++ b/test_pool/powercap/test_pc009.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 9) -#define TEST_DESC "Powercap set value check " +#define TEST_DESC "Powercap set value check " #define PARAMETER_SIZE 3 diff --git a/test_pool/powercap/test_pc010.c b/test_pool/powercap/test_pc010.c index 8eafd83e0aea6475b141e913b9a3e95e592d423f..c4bda71ae8af591e350c985a71d1cd6527b8d039 100644 --- a/test_pool/powercap/test_pc010.c +++ b/test_pool/powercap/test_pc010.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 3 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 10) -#define TEST_DESC "Powercap set value invalid id " +#define TEST_DESC "Powercap set value invalid id " uint32_t powercap_invalid_domain_set_power_cap_value(void) { diff --git a/test_pool/powercap/test_pc011.c b/test_pool/powercap/test_pc011.c index 68a34da90d538885076db5357cfbf52c3406102a..43bffda8edeb284b1acb4d714c8bd529847ed1f6 100644 --- a/test_pool/powercap/test_pc011.c +++ b/test_pool/powercap/test_pc011.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 3 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 11) -#define TEST_DESC "Powercap set power cap invalid values " +#define TEST_DESC "Powercap set power cap invalid values " uint32_t powercap_invalid_data_set_power_cap_value(void) { diff --git a/test_pool/powercap/test_pc012.c b/test_pool/powercap/test_pc012.c index 07069e0a16dc6c01ed3163f2d54b3ab1364db322..a00de8f2a9c11ec76817006c5d04632756c7019e 100644 --- a/test_pool/powercap/test_pc012.c +++ b/test_pool/powercap/test_pc012.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 12) -#define TEST_DESC "Powercap domain get PAI value check " +#define TEST_DESC "Powercap domain get PAI value check " uint32_t powercap_query_get_pai_value(void) { diff --git a/test_pool/powercap/test_pc013.c b/test_pool/powercap/test_pc013.c index 3925bcd427c9be2499192c07748c867698afae6d..aeec318f732df01dd582ef1234ea08e076bdc237 100644 --- a/test_pool/powercap/test_pc013.c +++ b/test_pool/powercap/test_pc013.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 13) -#define TEST_DESC "Powercap invalid domain id pai check " +#define TEST_DESC "Powercap invalid domain id pai check " uint32_t powercap_query_pai_invalid_domain_id(void) { diff --git a/test_pool/powercap/test_pc014.c b/test_pool/powercap/test_pc014.c index 6748a0582cd41205c114a63d2d9e6dadc2c78a02..fd45618ce8b18e197644236b905af4406a09f35f 100644 --- a/test_pool/powercap/test_pc014.c +++ b/test_pool/powercap/test_pc014.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 14) -#define TEST_DESC "Powercap set value check " +#define TEST_DESC "Powercap set value check " #define PARAMETER_SIZE 3 diff --git a/test_pool/powercap/test_pc015.c b/test_pool/powercap/test_pc015.c index d376bce8f6e31acce9c5c93c0d0a8f3eb851316e..54d4d922fafb1071209a2ec70174f5d9cb3bd14e 100644 --- a/test_pool/powercap/test_pc015.c +++ b/test_pool/powercap/test_pc015.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 3 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 15) -#define TEST_DESC "Powercap set pai invalid id " +#define TEST_DESC "Powercap set pai invalid id " uint32_t powercap_invalid_domain_set_pai_value(void) { diff --git a/test_pool/powercap/test_pc016.c b/test_pool/powercap/test_pc016.c index 6f410de2c56b0cf0c8e40f546956e0b06fafd515..c09bffb6b84f1444b2fe1d060051c5e4cd0a4ee0 100644 --- a/test_pool/powercap/test_pc016.c +++ b/test_pool/powercap/test_pc016.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 3 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 16) -#define TEST_DESC "Powercap set pai invalid values " +#define TEST_DESC "Powercap set pai invalid values " uint32_t powercap_invalid_data_set_pai_value(void) { diff --git a/test_pool/powercap/test_pc017.c b/test_pool/powercap/test_pc017.c index f892ea5aee41e66b674233e5499ebae3acd125ae..bcbaf2220a1cc5a8354400018199c625de9fc3e9 100644 --- a/test_pool/powercap/test_pc017.c +++ b/test_pool/powercap/test_pc017.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 17) -#define TEST_DESC "Powercap domain name get check " +#define TEST_DESC "Powercap domain name get check " uint32_t powercap_query_domain_name(void) { diff --git a/test_pool/powercap/test_pc018.c b/test_pool/powercap/test_pc018.c index 9765848a743276cf535d7748bc7560967f9e9caf..0463bf1398fabbc0e37d63f6fc3558cba68ee5a4 100644 --- a/test_pool/powercap/test_pc018.c +++ b/test_pool/powercap/test_pc018.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 18) -#define TEST_DESC "Powercap get name for invalid domain " +#define TEST_DESC "Powercap get name for invalid domain " uint32_t powercap_query_domain_name_invalid_domain(void) { diff --git a/test_pool/powercap/test_pc020.c b/test_pool/powercap/test_pc020.c index 7d27401430e0c845ca97953da4e72e8de1e8713e..3131cf1ea529add0237dd3825b436e3506b7f916 100644 --- a/test_pool/powercap/test_pc020.c +++ b/test_pool/powercap/test_pc020.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 2 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 20) -#define TEST_DESC "Powercap cap changed notification cmd check " +#define TEST_DESC "Powercap cap changed notification cmd check " uint32_t powercap_cap_notification_query(void) { diff --git a/test_pool/powercap/test_pc021.c b/test_pool/powercap/test_pc021.c index 42d6ac84c82449ffbb21f2ce3b7b043e8ccd3e7c..6c7d6a58bfba4bce915e7536716edf4676815cb0 100644 --- a/test_pool/powercap/test_pc021.c +++ b/test_pool/powercap/test_pc021.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 2 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 21) -#define TEST_DESC "Powercap cap changed notification invalid cmd check " +#define TEST_DESC "Powercap cap changed notifi invalid check " uint32_t powercap_cap_notification_invalid_query(void) { diff --git a/test_pool/powercap/test_pc022.c b/test_pool/powercap/test_pc022.c index 487fa56507785b2181264e9be062043011b7d943..2d2732c31c46965ed88230af797588e51f6a5195 100644 --- a/test_pool/powercap/test_pc022.c +++ b/test_pool/powercap/test_pc022.c @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 4 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 22) -#define TEST_DESC "Powercap measurement changed notification cmd check " +#define TEST_DESC "Powercap measurement changed notif cmd check " uint32_t powercap_measurement_notification_query(void) { diff --git a/test_pool/powercap/test_pc023.c b/test_pool/powercap/test_pc023.c index 094968b075987b0b1b71ddd89c941f5d5a21bf1b..787f490ab74ceeab57512723034369e825c83eb2 100644 --- a/test_pool/powercap/test_pc023.c +++ b/test_pool/powercap/test_pc023.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 4 #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 23) -#define TEST_DESC "Powercap measurement changed notification invalid cmd check " +#define TEST_DESC "Powercap measure changed notif invalid check " uint32_t powercap_measurement_notification_invalid_query(void) { diff --git a/test_pool/powercap/test_pc024.c b/test_pool/powercap/test_pc024.c index b2c556a23d768afd3058914d0306dd6e9c88056f..18098a53b9dd6bb2caa6711e5c4aefc7262e601b 100644 --- a/test_pool/powercap/test_pc024.c +++ b/test_pool/powercap/test_pc024.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 24) -#define TEST_DESC "Powercap describe fast channel check " +#define TEST_DESC "Powercap describe fast channel check " #define PARAMETER_COUNT 2 diff --git a/test_pool/powercap/test_pc025.c b/test_pool/powercap/test_pc025.c index 3bb0ee06d658c00e2ca714409aad7d445ad81862..f7058ca266c7a5d96cdc0f3fb62cdb4d92c13f22 100644 --- a/test_pool/powercap/test_pc025.c +++ b/test_pool/powercap/test_pc025.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 25) -#define TEST_DESC "Powercap describe fast chl invalid domain check " +#define TEST_DESC "Powercap desc fast chl invalid domain check " #define PARAMETER_SIZE 2 diff --git a/test_pool/powercap/test_pc027.c b/test_pool/powercap/test_pc027.c index 5661dbd643234457929cc940b52a7948647dd1a1..881c770d2652f71f1a3bcc2ca20ad1fa79627116 100644 --- a/test_pool/powercap/test_pc027.c +++ b/test_pool/powercap/test_pc027.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_powercap.h" #define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 27) -#define TEST_DESC "Powercap desc fast chl unsupported domain check " +#define TEST_DESC "Powercap desc fast chl unsupp domain check " #define PARAMETER_SIZE 2 diff --git a/test_pool/powercap/test_pc028.c b/test_pool/powercap/test_pc028.c new file mode 100644 index 0000000000000000000000000000000000000000..204c7218a09986ff3128491ecb4b60b97aa07a7f --- /dev/null +++ b/test_pool/powercap/test_pc028.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_powercap.h" + +#define TEST_NUM (SCMI_POWERCAP_TEST_NUM_BASE + 28) +#define TEST_DESC "Powercap query negotiate protocol version " + +extern uint32_t powercap_supported_protocols[SUPPORTED_POWERCAP_PROTOCOLS_COUNT]; + +uint32_t powercap_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = POWERCAP_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWERCAP, + POWERCAP_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n POWERCAP_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(powercap_supported_protocols)/sizeof(powercap_supported_protocols[0]); + /* Get index from powercap_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (powercap_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = powercap_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWERCAP, + POWERCAP_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00020000) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_POWERCAP, + POWERCAP_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/reset/test_r012.c b/test_pool/reset/test_r012.c index 9f13de550e7b9b0b797b572d1e8540a64442ecea..604d58c5ebf2a27a37dbeb3291a725d1139dcb98 100644 --- a/test_pool/reset/test_r012.c +++ b/test_pool/reset/test_r012.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,7 +18,7 @@ #include "val_interface.h" #include "val_reset.h" -#define TEST_NUM (SCMI_RESET_TEST_NUM_BASE + 17) +#define TEST_NUM (SCMI_RESET_TEST_NUM_BASE + 12) #define TEST_DESC "Reset domain ext name get check " uint32_t reset_query_ext_domain_name(void) diff --git a/test_pool/reset/test_r013.c b/test_pool/reset/test_r013.c index e7d8907a75bca79c3867c65bb993cf727b5827b9..b5a3deb3c0df02c287fadea439a4990a69b88a81 100644 --- a/test_pool/reset/test_r013.c +++ b/test_pool/reset/test_r013.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,7 +18,7 @@ #include "val_interface.h" #include "val_reset.h" -#define TEST_NUM (SCMI_RESET_TEST_NUM_BASE + 18) +#define TEST_NUM (SCMI_RESET_TEST_NUM_BASE + 13) #define TEST_DESC "Reset get ext name for invalid domain " uint32_t reset_query_ext_domain_name_invalid_domain(void) diff --git a/test_pool/reset/test_r014.c b/test_pool/reset/test_r014.c new file mode 100644 index 0000000000000000000000000000000000000000..19d3c6e7af493b119d1bd193ec401846772fea81 --- /dev/null +++ b/test_pool/reset/test_r014.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_reset.h" + +#define TEST_NUM (SCMI_RESET_TEST_NUM_BASE + 14) +#define TEST_DESC "Reset query negotiate protocol version " + +extern uint32_t reset_supported_protocols[SUPPORTED_RESET_PROTOCOLS_COUNT]; + +uint32_t reset_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = RESET_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_RESET, + RESET_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n RESET_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(reset_supported_protocols)/sizeof(reset_supported_protocols[0]); + /* Get index from reset_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (reset_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = reset_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_RESET, + RESET_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00030001) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_RESET, + RESET_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/sensor/test_m006.c b/test_pool/sensor/test_m006.c index 4d13d1f4741e7ae6e338ea365e73d7c42d24d6b5..b69caebf0d8255369ab1a14ed3ed489b204eeb91 100644 --- a/test_pool/sensor/test_m006.c +++ b/test_pool/sensor/test_m006.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020-2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 6) -#define TEST_DESC "Sensor trip point notify invalid event_ctrl chk" +#define TEST_DESC "Sensor trip point notify invalid event_ctrl " #define MAX_PARAMETER_SIZE 2 diff --git a/test_pool/sensor/test_m017.c b/test_pool/sensor/test_m017.c index 2c063ebb7d1c2cd283699ec9598a5aaa0b8a2fb9..d20a3feda92009f8caf807ccf6a3368e7bcdb1d6 100644 --- a/test_pool/sensor/test_m017.c +++ b/test_pool/sensor/test_m017.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 17) -#define TEST_DESC "Sensor get axis description for invalid sensor ID" +#define TEST_DESC "Sensor get axis desc for invalid sensor ID " #define MAX_PARAMETER_SIZE 2 diff --git a/test_pool/sensor/test_m018.c b/test_pool/sensor/test_m018.c index db9f14b07050cd3af2b857e1c690a8620fb2ed5b..cbc60281c7899fb3c6b427cbee6657da7ebb7d83 100644 --- a/test_pool/sensor/test_m018.c +++ b/test_pool/sensor/test_m018.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 18) -#define TEST_DESC "Sensor Get supported update intervals check " +#define TEST_DESC "Sensor Get supported update intervals check " #define MAX_PARAMETER_SIZE 2 diff --git a/test_pool/sensor/test_m019.c b/test_pool/sensor/test_m019.c index c934326bd1f47942da2f4a7922cfbb9c1c061246..0a837bc6f16013aa27c25ba3baccc673c8837de5 100644 --- a/test_pool/sensor/test_m019.c +++ b/test_pool/sensor/test_m019.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 19) -#define TEST_DESC "Sensor get update interval invalid sensor ID" +#define TEST_DESC "Sensor get update interval invalid sensor ID " #define MAX_PARAMETER_SIZE 2 diff --git a/test_pool/sensor/test_m020.c b/test_pool/sensor/test_m020.c index c7f7cac8947c76c7ef1c3cc48c79c1db01757f96..2de8ce48a154fe8797144e21951a867e5e36b541 100644 --- a/test_pool/sensor/test_m020.c +++ b/test_pool/sensor/test_m020.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 20) -#define TEST_DESC "Sensor read configuration check " +#define TEST_DESC "Sensor read configuration check " #define MAX_PARAMETER_SIZE 1 diff --git a/test_pool/sensor/test_m021.c b/test_pool/sensor/test_m021.c index c36902653e934f6d9a5abdb0b15a7f7903239118..8b1c8ae572fb07342e8be516454564d296e60480 100644 --- a/test_pool/sensor/test_m021.c +++ b/test_pool/sensor/test_m021.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 21) -#define TEST_DESC "Sensor read configuration for invalid sensor ID" +#define TEST_DESC "Sensor read config for invalid sensor ID " #define MAX_PARAMETER_SIZE 1 diff --git a/test_pool/sensor/test_m022.c b/test_pool/sensor/test_m022.c index 7fd04850b8740047c0df965bb5e023a717e40a4f..0ad826df4a01afdaa9e7f9d6753599a18c6bf059 100644 --- a/test_pool/sensor/test_m022.c +++ b/test_pool/sensor/test_m022.c @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 22) -#define TEST_DESC "Sensor configuration setting check " +#define TEST_DESC "Sensor configuration setting check " #define MAX_PARAMETER_SIZE 2 diff --git a/test_pool/sensor/test_m023.c b/test_pool/sensor/test_m023.c index 407efb64d981b1dcd07619b70f150f0bf4aa8ca5..4a8806f0fbfca7e19c7251f23cade806f2a36ea5 100644 --- a/test_pool/sensor/test_m023.c +++ b/test_pool/sensor/test_m023.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,8 +18,8 @@ #include "val_interface.h" #include "val_sensor.h" -#define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 21) -#define TEST_DESC "Sensor set configuration for invalid sensor ID" +#define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 23) +#define TEST_DESC "Sensor set config for invalid sensor ID " #define MAX_PARAMETER_SIZE 1 diff --git a/test_pool/sensor/test_m025.c b/test_pool/sensor/test_m025.c index 0c4a070735c7da402c74e784bbd0707704fda6f7..c80986a2d43cb50f5cdaae485f975cb1d7fec5c5 100644 --- a/test_pool/sensor/test_m025.c +++ b/test_pool/sensor/test_m025.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,8 +18,8 @@ #include "val_interface.h" #include "val_sensor.h" -#define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 19) -#define TEST_DESC "Sensor request update notification for invalid sensor ID" +#define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 25) +#define TEST_DESC "Sensor req update notif for invalid sensor ID" #define MAX_PARAMETER_SIZE 2 diff --git a/test_pool/sensor/test_m027.c b/test_pool/sensor/test_m027.c index bc610bc7ee76835de040679575a8d740f3fd735a..926d87f0d4e7fdbdd8e6b0a260d863549157b278 100644 --- a/test_pool/sensor/test_m027.c +++ b/test_pool/sensor/test_m027.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_sensor.h" #define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 27) -#define TEST_DESC "Sensor get ext name for invalid ID " +#define TEST_DESC "Sensor get ext name for invalid ID " uint32_t sensor_query_domain_ext_name_invalid_domain(void) { diff --git a/test_pool/sensor/test_m028.c b/test_pool/sensor/test_m028.c new file mode 100644 index 0000000000000000000000000000000000000000..356f1711f3d06db9e0bdf2b0d91ab40cd0dc43fc --- /dev/null +++ b/test_pool/sensor/test_m028.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_sensor.h" + +#define TEST_NUM (SCMI_SENSOR_TEST_NUM_BASE + 28) +#define TEST_DESC "Sensor query negotiate protocol version " + +extern uint32_t sensor_supported_protocols[SUPPORTED_SENSOR_PROTOCOLS_COUNT]; + +uint32_t sensor_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = SENSOR_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_SENSOR, + SENSOR_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n SENSOR_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(sensor_supported_protocols)/sizeof(sensor_supported_protocols[0]); + /* Get index from sensor_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (sensor_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = sensor_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_SENSOR, + SENSOR_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00030001) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_SENSOR, + SENSOR_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/system_power/test_s008.c b/test_pool/system_power/test_s008.c new file mode 100644 index 0000000000000000000000000000000000000000..ae4e1603355f618642b93c5fba809cef6879a8f5 --- /dev/null +++ b/test_pool/system_power/test_s008.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_system_power.h" + +#define TEST_NUM (SCMI_SYSTEM_POWER_TEST_NUM_BASE + 8) +#define TEST_DESC "System Power query negotiate protocol version" + +extern uint32_t system_power_supported_protocols[SUPPORTED_SYSTEM_POWER_PROTOCOLS_COUNT]; + +uint32_t system_power_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = SYSTEM_POWER_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_SYSTEM_POWER, + SYSTEM_POWER_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n SYSTEM_POWER_NEGOTIATE_PROTOCOL_VERSION not supported"); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(system_power_supported_protocols)/sizeof(system_power_supported_protocols[0]); + /* Get index from system_power_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (system_power_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = system_power_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_SYSTEM_POWER, + SYSTEM_POWER_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00020001) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_SYSTEM_POWER, + SYSTEM_POWER_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/test_pool/voltage/test_v002.c b/test_pool/voltage/test_v002.c index 970d05c9968ac02a11310ccf81d66e6f13e2fc49..077830a089729c3d9615c6c4698849fff99ae61a 100644 --- a/test_pool/voltage/test_v002.c +++ b/test_pool/voltage/test_v002.c @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 2) -#define TEST_DESC "Voltage protocol attributes check " +#define TEST_DESC "Voltage protocol attributes check " #define RETURN_VALUE_COUNT 1 diff --git a/test_pool/voltage/test_v003.c b/test_pool/voltage/test_v003.c index cb616aa86d1272aea8be2508260c2a8780f67b98..39966904eeaa28ccbf602cc4de0faee646e65964 100644 --- a/test_pool/voltage/test_v003.c +++ b/test_pool/voltage/test_v003.c @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 3) -#define TEST_DESC "Voltage msg attributes mandatory cmd check " +#define TEST_DESC "Voltage msg attributes mandatory cmd check " uint32_t voltage_query_mandatory_command_support(void) { diff --git a/test_pool/voltage/test_v004.c b/test_pool/voltage/test_v004.c index ac5033ab7e2930af20b05625a953a436a7267e58..6031049bd8042f7551d0ca9ec3efb6f1310911bb 100644 --- a/test_pool/voltage/test_v004.c +++ b/test_pool/voltage/test_v004.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 4) -#define TEST_DESC "Voltage msg attributes invalid msg id check " +#define TEST_DESC "Voltage msg attributes invalid msg id check " uint32_t voltage_invalid_messageid_call(void) { diff --git a/test_pool/voltage/test_v005.c b/test_pool/voltage/test_v005.c index aff9d348144938ab192840208e2173b13a76dbc9..72f50107ffc27ea524183c28b98edffa480cb707 100644 --- a/test_pool/voltage/test_v005.c +++ b/test_pool/voltage/test_v005.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define NAME_OFFSET 1 #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 5) -#define TEST_DESC "Voltage domain attributes check " +#define TEST_DESC "Voltage domain attributes check " uint32_t voltage_query_domain_attributes(void) { diff --git a/test_pool/voltage/test_v005_v2.c b/test_pool/voltage/test_v005_v2.c index a62feef15bb22acdd7821ee7f030dcfea02eb829..a6ad379e38f4f2c18209a9a717e71b1e4436641e 100644 --- a/test_pool/voltage/test_v005_v2.c +++ b/test_pool/voltage/test_v005_v2.c @@ -21,7 +21,7 @@ #define NAME_OFFSET 1 #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 5) -#define TEST_DESC "Voltage domain attributes check " +#define TEST_DESC "Voltage domain attributes check " uint32_t voltage_query_domain_attributes_v2(void) { @@ -80,7 +80,7 @@ uint32_t voltage_query_domain_attributes_v2(void) val_voltage_save_info(VOLTAGE_ATTRIBUTES, domain_id, attribute); if (ext_name_supp) { - if (val_compare_str("DOMAIN NAME", (char *)&return_values[NAME_OFFSET], + if (val_compare_str("DOMAIN NAME", (char *)&return_values[NAME_OFFSET] - 16, name + strnlen(name, SCMI_NAME_STR_SIZE) - 16, SCMI_NAME_STR_SIZE)) return VAL_STATUS_FAIL; } else { diff --git a/test_pool/voltage/test_v007.c b/test_pool/voltage/test_v007.c index ab6bdadf0f02fef83c35880e83e1084f2377c2b7..1ba8fe8c4fa250a9415ea5872ca43117adb4dae0 100644 --- a/test_pool/voltage/test_v007.c +++ b/test_pool/voltage/test_v007.c @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 7) -#define TEST_DESC "Voltage describe levels check " +#define TEST_DESC "Voltage describe levels check " #define PARAMETER_SIZE 2 diff --git a/test_pool/voltage/test_v008.c b/test_pool/voltage/test_v008.c index 56d161828a936b464c0d4f1dc83762d827a1078a..0bfd8f4ec07b52dad4607194ff5f7ad8b8c44a46 100644 --- a/test_pool/voltage/test_v008.c +++ b/test_pool/voltage/test_v008.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 8) -#define TEST_DESC "Voltage describe level invalid domain id check " +#define TEST_DESC "Voltage describe level invalid domain check " #define PARAMETER_SIZE 2 diff --git a/test_pool/voltage/test_v009.c b/test_pool/voltage/test_v009.c index 90ef02225c768ed4eb62c5780768f0c8e9869f09..df6be9b46d43c0fb4881a55617d5ed3b088d8616 100644 --- a/test_pool/voltage/test_v009.c +++ b/test_pool/voltage/test_v009.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 9) -#define TEST_DESC "Voltage set operating mode " +#define TEST_DESC "Voltage set operating mode " #define PARAMETER_SIZE 2 diff --git a/test_pool/voltage/test_v010.c b/test_pool/voltage/test_v010.c index eb716aebbe1dd6d1b1bff6a9d0c352edbb94b457..2d9bd062d7d6a264c6511d683dc65faf5fb25ed9 100644 --- a/test_pool/voltage/test_v010.c +++ b/test_pool/voltage/test_v010.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 3 #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 10) -#define TEST_DESC "Voltage set operating mode invalid id " +#define TEST_DESC "Voltage set operating mode invalid id " uint32_t voltage_invalid_domain_set_operating_mode(void) { diff --git a/test_pool/voltage/test_v011.c b/test_pool/voltage/test_v011.c index 44f4ce4f688d749f23892ebd364790d06f3f0e20..c8063ba8f720724b013180690ab03826f7211413 100644 --- a/test_pool/voltage/test_v011.c +++ b/test_pool/voltage/test_v011.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 11) -#define TEST_DESC "Voltage get operating mode " +#define TEST_DESC "Voltage get operating mode " #define RETURN_VALUE_COUNT 1 #define PARAMETER_SIZE 2 diff --git a/test_pool/voltage/test_v012.c b/test_pool/voltage/test_v012.c index 4c064c1e7d62b01cbce7630809ede1a79d383fe6..8bb07c931a9284f9b06c32b6adf8579494ee0db7 100644 --- a/test_pool/voltage/test_v012.c +++ b/test_pool/voltage/test_v012.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 12) -#define TEST_DESC "Voltage set new voltage level " +#define TEST_DESC "Voltage set new voltage level " #define RETURN_VALUE_COUNT 1 #define PARAMETER_SIZE 3 diff --git a/test_pool/voltage/test_v012_v2.c b/test_pool/voltage/test_v012_v2.c index 1efc6e63ae38e0a84558e2353177806026903873..0159cc9db27e89d4dd93ccfcabc2292de445e7ed 100644 --- a/test_pool/voltage/test_v012_v2.c +++ b/test_pool/voltage/test_v012_v2.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 12) -#define TEST_DESC "Voltage set new voltage level " +#define TEST_DESC "Voltage set new voltage level " #define RETURN_VALUE_COUNT 1 #define PARAMETER_SIZE 3 diff --git a/test_pool/voltage/test_v013.c b/test_pool/voltage/test_v013.c index 43f898eae4bb8f36bee88e49b206086b00239683..c1b431ef7bdefda55b0df4ab1b04f383e22950ff 100644 --- a/test_pool/voltage/test_v013.c +++ b/test_pool/voltage/test_v013.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 13) -#define TEST_DESC "Voltage set voltage for invalid domain " +#define TEST_DESC "Voltage set voltage for invalid domain " #define RETURN_VALUE_COUNT 1 #define PARAMETER_SIZE 3 diff --git a/test_pool/voltage/test_v014.c b/test_pool/voltage/test_v014.c index efdd8be69105ad0cb9d27c5ccf392a837fbe388d..b237a737bb2850cb9aec652eb5ad307bd3100902 100644 --- a/test_pool/voltage/test_v014.c +++ b/test_pool/voltage/test_v014.c @@ -19,7 +19,7 @@ #include "val_voltage.h" #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 14) -#define TEST_DESC "Voltage set invalid voltage level " +#define TEST_DESC "Voltage set invalid voltage level " #define RETURN_VALUE_COUNT 1 #define PARAMETER_SIZE 3 diff --git a/test_pool/voltage/test_v015.c b/test_pool/voltage/test_v015.c index 1ff8cca5cfe42ab5d31908fff529d372150967f1..1d7c87ebf43e29dd1cfc946024efcc74d3a2860c 100644 --- a/test_pool/voltage/test_v015.c +++ b/test_pool/voltage/test_v015.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,7 +21,7 @@ #define PARAMETER_SIZE 2 #define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 15) -#define TEST_DESC "Voltage get current level " +#define TEST_DESC "Voltage get current level " #define RETURN_VALUE_COUNT 1 diff --git a/test_pool/voltage/test_v016.c b/test_pool/voltage/test_v016.c index a383b55083b483098dafe824d9b523eb91315ccd..0a89ef4eae15684db943eee2c979cdd15564b133 100644 --- a/test_pool/voltage/test_v016.c +++ b/test_pool/voltage/test_v016.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,8 +18,8 @@ #include "val_interface.h" #include "val_voltage.h" -#define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 17) -#define TEST_DESC "Voltage domain ext name get check " +#define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 16) +#define TEST_DESC "Voltage domain ext name get check " uint32_t voltage_query_ext_domain_name(void) { diff --git a/test_pool/voltage/test_v017.c b/test_pool/voltage/test_v017.c index f8ebf4471b3010db2100fcb459ceba2420ae5a79..86c6ba92ed7d46eb01517ae31f093d8e620471d0 100644 --- a/test_pool/voltage/test_v017.c +++ b/test_pool/voltage/test_v017.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -18,8 +18,8 @@ #include "val_interface.h" #include "val_voltage.h" -#define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 18) -#define TEST_DESC "Voltage get ext name for invalid domain " +#define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 17) +#define TEST_DESC "Voltage get ext name for invalid domain " uint32_t voltage_query_domain_ext_name_invalid_domain(void) { diff --git a/test_pool/voltage/test_v018.c b/test_pool/voltage/test_v018.c new file mode 100644 index 0000000000000000000000000000000000000000..3c5f6f2b5e1883b68797c08de869cb20475c423f --- /dev/null +++ b/test_pool/voltage/test_v018.c @@ -0,0 +1,121 @@ +/** @file + * Copyright (c) 2024, Arm Limited or its 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. +**/ + +#include "val_interface.h" +#include "val_voltage.h" + +#define TEST_NUM (SCMI_VOLTAGE_TEST_NUM_BASE + 18) +#define TEST_DESC "Voltage query negotiate protocol version " + +extern uint32_t voltage_supported_protocols[SUPPORTED_VOLTAGE_PROTOCOLS_COUNT]; + +uint32_t voltage_query_negotiate_protocol_version(uint32_t *version) +{ + int32_t status; + uint32_t rsp_msg_hdr; + uint32_t cmd_msg_hdr; + size_t param_count; + size_t return_value_count; + uint32_t return_values[MAX_RETURNS_SIZE]; + uint32_t message_id; + uint32_t parameters; + uint32_t index; + uint32_t num_supported_protocols; + int32_t negotiate_flag = VAL_STATUS_FAIL; + uint32_t curr_version = *version; + + if (val_test_initialize(TEST_NUM, TEST_DESC) != VAL_STATUS_PASS) + return VAL_STATUS_SKIP; + + /* If NEGOTIATE_PROTOCOL_VERSION cmds not supported, skip the test */ + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + message_id = VOLTAGE_NEGOTIATE_PROTOCOL_VERSION; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_VOLTAGE, + VOLTAGE_PROTOCOL_MESSAGE_ATTRIBUTES, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, &message_id, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (status == SCMI_NOT_FOUND) { + val_print(VAL_PRINT_ERR, "\n VOLTAGE_NEGOTIATE_PROTOCOL_VERSION not supported "); + return VAL_STATUS_SKIP; + } + + /* Query the negotiate protocol version that agent intends to use */ + val_print(VAL_PRINT_TEST, "\n [Check 1] Query negotiate protocol version"); + + num_supported_protocols = + sizeof(voltage_supported_protocols)/sizeof(voltage_supported_protocols[0]); + /* Get index from voltage_supported_protocols with version returned by protocol version */ + for (index = num_supported_protocols; index > 0; index--) { + if (voltage_supported_protocols[index - 1] < *version) { + val_print(VAL_PRINT_DEBUG, "\n Negotiating with version 0x%08X"); + break; + } + } + + /* Corner case: If the version returned from the protocol version command is not supported */ + if (index == 0) { + val_print(VAL_PRINT_ERR, "\n Not able to get version to negotiate"); + return VAL_STATUS_SKIP; + } + + /* Start negotiating with supported protocols */ + while (index > 0) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = voltage_supported_protocols[--index]; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_VOLTAGE, + VOLTAGE_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_SUCCESS) == VAL_STATUS_PASS) { + negotiate_flag = VAL_STATUS_PASS; + break; + } + } + + if (negotiate_flag == VAL_STATUS_PASS) { + *version = parameters; + val_print(VAL_PRINT_ERR, "\n NEGOTIATED VERSION : 0x%08x", *version); + /* If negotiated version is lower than supported, check NOT_SUPPORTED is returned */ + if (*version < 0x00020001) { + VAL_INIT_TEST_PARAM(param_count, rsp_msg_hdr, return_value_count, status); + parameters = curr_version; + param_count = 1; + cmd_msg_hdr = val_msg_hdr_create(PROTOCOL_VOLTAGE, + VOLTAGE_NEGOTIATE_PROTOCOL_VERSION, COMMAND_MSG); + val_send_message(cmd_msg_hdr, param_count, ¶meters, &rsp_msg_hdr, &status, + &return_value_count, return_values); + + if (val_compare_msg_hdr(cmd_msg_hdr, rsp_msg_hdr) != VAL_STATUS_PASS) + return VAL_STATUS_FAIL; + + if (val_compare_status(status, SCMI_NOT_SUPPORTED) == VAL_STATUS_PASS) { + return VAL_STATUS_PASS; + } + } + } else { + val_print(VAL_PRINT_ERR, "\n Failed to negotiate version", 0); + return VAL_STATUS_SKIP; + } + + return VAL_STATUS_PASS; +} diff --git a/val/include/val_base.h b/val/include/val_base.h index 13e271a6b83b3b012be93167d06db7e231d19819..e1ca229ce0a23f02e08a56ac074aadd4697895e4 100644 --- a/val/include/val_base.h +++ b/val/include/val_base.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -69,6 +69,9 @@ uint32_t base_restore_protocol_access_with_reset_agent_configuration(void); uint32_t base_deny_restore_device_access(void); uint32_t base_restore_device_access_with_reset_agent_configuration(void); +/* v2.1 specific tests */ +uint32_t base_query_negotiate_protocol_version(uint32_t *version); + /* Expected Values */ char *val_base_get_expected_vendor_name(void); char *val_base_get_expected_subvendor_name(void); diff --git a/val/include/val_clock.h b/val/include/val_clock.h index b80c57bcd47c29d97933572ef5d1dc7932f8b02d..44dc0e700d244a3de788c443ce8309131a350eaa 100644 --- a/val/include/val_clock.h +++ b/val/include/val_clock.h @@ -28,11 +28,13 @@ #define RATE_UPPER_WORD_OFFSET 1 #define CLOCK_EXT_NAME_OFFSET 1 #define CLOCK_CONFIG_OFFSET 1 -#define CLOCK_CONFIG_OEM_VAL_OFFSET 2 +#define CLOCK_CONFIG_EXT_VAL_OFFSET 2 #define CLOCK_PARENT_NAME_OFFSET 0 #define CLOCK_PARENTS_FLAGS_OFFSET 0 #define CLOCK_PARENT_START_OFFSET 0 #define CLOCK_PARENTS_ARRAY_OFFSET 1 +#define CLOCK_PERMISSIONS_OFFSET 0 +#define PERMISSION_OFFSET 0 #define DELAYED_RESP_CLOCK_ID_OFFSET 0 #define DELAYED_RESP_RATE_LOWER_OFFSET 1 @@ -49,6 +51,8 @@ #define MASK_FOR_UPPER_WORD 0xFFFFFFFF00000000LL #define CLOCK_RATE_FMT_ARRAY 0x0 #define CLOCK_RATE_FMT_STEP_SIZE 0x1 +#define CLOCK_DUTY_CYCLE_EXT_CONFIG 0x1 +#define CLOCK_PHASE_EXT_CONFIG 0x2 #define MAX_NUM_OF_CLOCKS 10 @@ -97,18 +101,22 @@ uint32_t clock_rate_req_notification_query(void); uint32_t clock_rate_req_notification_invalid_query(void); uint32_t clock_parent_get_invalid_clock_id_check(void); -/* V2.1 Test cases */ -uint32_t clock_query_mandatory_command_support_v2p1(void); -uint32_t clock_config_set_check_v2p1(void); +/* V3 Test cases */ +uint32_t clock_query_mandatory_command_support_v3(void); +uint32_t clock_config_set_check_v3(void); uint32_t clock_parent_name_support_get_check(void); uint32_t clock_parent_name_support_set_check(void); uint32_t clock_parent_set_invalid_check(void); uint32_t clock_parent_set_invalid_clock_id_check(void); -uint32_t clock_attributes_check_v2p1(void); +uint32_t clock_attributes_check_v3(void); uint32_t clock_config_get_check(void); uint32_t clock_config_get_invalid_clock_id_check(void); uint32_t clock_possible_parents_get_check(void); uint32_t clock_possible_parents_get_invalid_id_check(void); +uint32_t clock_rate_set_sync_check_v3(void); +uint32_t clock_rate_set_async_check_v3(void); +uint32_t clock_query_negotiate_protocol_version(uint32_t *version); +uint32_t clock_get_permissions_check(void); /* expected values */ uint32_t val_clock_get_expected_num_clocks(void); diff --git a/val/include/val_interface.h b/val/include/val_interface.h index 6acbbffadee0f36fa0128b2705b1a5a91339e39d..fe4f2b2e6aefca2725f7c587feb184e8c7434f83 100644 --- a/val/include/val_interface.h +++ b/val/include/val_interface.h @@ -39,8 +39,20 @@ #define SCMI_POWERCAP_TEST_NUM_BASE 900 #define SCMI_PIN_CONTROL_TEST_NUM_BASE 1000 +#define SUPPORTED_BASE_PROTOCOLS_COUNT 3 +#define SUPPORTED_POWER_PROTOCOLS_COUNT 5 +#define SUPPORTED_SYSTEM_POWER_PROTOCOLS_COUNT 3 +#define SUPPORTED_PERFORMANCE_PROTOCOLS_COUNT 4 +#define SUPPORTED_CLOCK_PROTOCOLS_COUNT 3 +#define SUPPORTED_SENSOR_PROTOCOLS_COUNT 4 +#define SUPPORTED_RESET_PROTOCOLS_COUNT 4 +#define SUPPORTED_VOLTAGE_PROTOCOLS_COUNT 3 +#define SUPPORTED_POWERCAP_PROTOCOLS_COUNT 2 +#define SUPPORTED_PIN_CONTROL_PROTOCOLS_COUNT 1 + #define BASE_PROTOCOL_VERSION_1 0x00010000 #define BASE_PROTOCOL_VERSION_2 0x00020000 +#define BASE_PROTOCOL_VERSION_2P1 0x00020001 #define PERFORMANCE_PROTOCOL_VERSION_1 0x00010000 #define PERFORMANCE_PROTOCOL_VERSION_2 0x00020000 @@ -49,26 +61,33 @@ #define RESET_PROTOCOL_VERSION_1 0x00010000 #define RESET_PROTOCOL_VERSION_2 0x00020000 -#define RESET_PROTOCOL_VERSION_3 0x00010000 +#define RESET_PROTOCOL_VERSION_3 0x00030000 +#define RESET_PROTOCOL_VERSION_3P1 0x00030001 +#define POWER_PROTOCOL_VERSION_1 0x00010000 #define POWER_PROTOCOL_VERSION_2 0x00020000 -#define POWER_PROTOCOL_VERSION_2_1 0x00021000 -#define POWER_PROTOCOL_VERSION_3 0x00300000 +#define POWER_PROTOCOL_VERSION_2P1 0x00020001 +#define POWER_PROTOCOL_VERSION_3 0x00030000 +#define POWER_PROTOCOL_VERSION_3P1 0x00030001 #define SENSOR_PROTOCOL_VERSION_1 0x00010000 #define SENSOR_PROTOCOL_VERSION_2 0x00020000 #define SENSOR_PROTOCOL_VERSION_3 0x00030000 +#define SENSOR_PROTOCOL_VERSION_3P1 0x00030001 #define SYSTEM_POWER_VERSION_1 0x00010000 #define SYSTEM_POWER_VERSION_2 0x00020000 +#define SYSTEM_POWER_VERSION_2P1 0x00020001 #define CLOCK_PROTOCOL_VERSION_1 0x00010000 #define CLOCK_PROTOCOL_VERSION_2 0x00020000 -#define CLOCK_PROTOCOL_VERSION_2_1 0x00020001 +#define CLOCK_PROTOCOL_VERSION_3 0x00030000 #define VOLTAGE_PROTOCOL_VERSION_1 0x00010000 #define VOLTAGE_PROTOCOL_VERSION_2 0x00020000 +#define VOLTAGE_PROTOCOL_VERSION_2P1 0x00020001 +#define POWERCAP_PROTOCOL_VERSION_1 0x00010000 #define POWERCAP_PROTOCOL_VERSION_2 0x00020000 #define PIN_CONTROL_PROTOCOL_VERSION_1 0x00010000 @@ -192,6 +211,7 @@ typedef enum { BASE_SET_DEVICE_PERMISSIONS, BASE_SET_PROTOCOL_PERMISSIONS, BASE_RESET_AGENT_CONFIGURATION, + BASE_NEGOTIATE_PROTOCOL_VERSION = 0x10, BASE_INVALID_COMMAND } BASE_COMMANDS; @@ -227,6 +247,7 @@ typedef enum { POWER_STATE_NOTIFY, POWER_STATE_CHANGE_REQUESTED_NOTIFY, POWER_DOMAIN_NAME_GET, + POWER_NEGOTIATE_PROTOCOL_VERSION = 0x10, POWER_PROTOCOL_INVALID_COMMAND } POWER_DOMAIN_COMMANDS; @@ -266,6 +287,7 @@ typedef enum { SYSTEM_POWER_STATE_SET, SYSTEM_POWER_STATE_GET, SYSTEM_POWER_STATE_NOTIFY, + SYSTEM_POWER_NEGOTIATE_PROTOCOL_VERSION = 0x10, SYSTEM_POWER_INVALID_COMMAND } SYSTEM_POWER_COMMANDS; @@ -306,6 +328,7 @@ typedef enum { PERFORMANCE_NOTIFY_LEVEL, PERFORMANCE_DESCRIBE_FASTCHANNEL, PERFORMANCE_DOMAIN_NAME_GET, + PERFORMANCE_NEGOTIATE_PROTOCOL_VERSION = 0x10, PERFORMANCE_INVALID_COMMAND } PERFORMANCE_COMMANDS; @@ -360,6 +383,8 @@ typedef enum { CLOCK_POSSIBLE_PARENTS_GET, CLOCK_PARENT_SET, CLOCK_PARENT_GET, + CLOCK_GET_PERMISSIONS, + CLOCK_NEGOTIATE_PROTOCOL_VERSION = 0x10, CLOCK_INVALID_COMMAND } CLOCK_COMMANDS; @@ -395,6 +420,8 @@ typedef enum { CLOCK_RATE_CHNG_REQ_NOTI_SUPP, CLOCK_EXTENDED_NAME_SUPPORT, CLOCK_PARENT_IDENTIFIER_SUPPORT, + CLOCK_EXTENDED_CONFIGURATION_SUPPORT, + CLOCK_RESTRICTED, CLOCK_ENABLE, } CLOCK_ATTRIBUTES_FLAG; @@ -426,6 +453,7 @@ typedef enum { SENSOR_CONTINUOUS_UPDATE_NOTIFY, SENSOR_NAME_GET, SENSOR_AXIS_NAME_GET, + SENSOR_NEGOTIATE_PROTOCOL_VERSION = 0x10, SENSOR_INVALID_COMMAND, } SENSOR_COMMANDS; @@ -489,6 +517,7 @@ typedef enum { RESET_PROTOCOL_RESET, RESET_PROTOCOL_NOTIFY, RESET_DOMAIN_NAME_GET, + RESET_NEGOTIATE_PROTOCOL_VERSION = 0x10, RESET_INVALID_COMMAND } RESET_COMMANDS; @@ -529,6 +558,7 @@ typedef enum { VOLTAGE_LEVEL_SET, VOLTAGE_LEVEL_GET, VOLTAGE_DOMAIN_NAME_GET, + VOLTAGE_NEGOTIATE_PROTOCOL_VERSION = 0x10, VOLTAGE_INVALID_COMMAND } VOLTAGE_COMMANDS; @@ -595,6 +625,7 @@ typedef enum { POWERCAP_CAP_NOTIFY, POWERCAP_MEASUREMENTS_NOTIFY, POWERCAP_DESCRIBE_FASTCHANNEL, + POWERCAP_NEGOTIATE_PROTOCOL_VERSION = 0x10, POWERCAP_INVALID_COMMAND } POWERCAP_COMMANDS; @@ -665,13 +696,14 @@ typedef enum { PIN_CONTROL_PROTOCOL_MESSAGE_ATTRIBUTES, PIN_CONTROL_ATTRIBUTES, PIN_CONTROL_LIST_ASSOCIATIONS, - PIN_CONTROL_CONFIG_GET, - PIN_CONTROL_CONFIG_SET, + PIN_CONTROL_SETTINGS_GET, + PIN_CONTROL_SETTINGS_CONFIGURE, PIN_CONTROL_FUNCTION_SELECT, PIN_CONTROL_REQUEST, PIN_CONTROL_RELEASE, PIN_CONTROL_NAME_GET, PIN_CONTROL_SET_PERMISSIONS, + PIN_CONTROL_NEGOTIATE_PROTOCOL_VERSION = 0x10, PIN_CONTROL_INVALID_COMMAND } PIN_CONTROL_COMMANDS; @@ -683,7 +715,9 @@ typedef enum { PC_NUM_GROUPS_IN_FUNCTION, PC_PIN_NAME, PC_GROUP_NAME, - PC_FUNCTION_NAME + PC_FUNCTION_NAME, + PC_FUNCTION_GROUP_SUPPORT, + PC_FUNCTION_GPIO_SUPPORT } PIN_CONTROL_INFO; uint32_t val_pin_control_execute_tests(void); diff --git a/val/include/val_performance.h b/val/include/val_performance.h index b15d2f196b598b56e55bb02a3fb3f01b71aab26a..7ae250094df842c611dab66619ef16c1851adb5e 100644 --- a/val/include/val_performance.h +++ b/val/include/val_performance.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2020, 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2020, 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -136,6 +136,7 @@ uint32_t performance_query_domain_attributes_v4(void); uint32_t performance_query_describe_levels_v4(void); uint32_t performance_query_set_level_v4(void); uint32_t performance_level_get_fast_channel_v4(void); +uint32_t performance_query_negotiate_protocol_version(uint32_t *version); /* Get expected*/ uint32_t val_performance_get_expected_num_domains(void); diff --git a/val/include/val_pin_control.h b/val/include/val_pin_control.h index 4e0d87f1ab2038ab3d0bd274b96600ba45b95172..5d5c55b946e2d153ba7ac869ce002dcb5c0de795 100644 --- a/val/include/val_pin_control.h +++ b/val/include/val_pin_control.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -25,6 +25,7 @@ #define GROUP_SELECTOR 1 #define FUNCTION_SELECTOR 2 #define GET_ALL_CONFIGS 1 +#define NO_FUNCTION_ENABLED 0xFFFFFFFF #define VERSION_OFFSET 0 #define ATTRIBUTES_LOW_OFFSET 0 @@ -33,8 +34,9 @@ #define NAME_OFFSET 1 #define RET_FLAGS_OFFSET 0 #define PIN_CONTROL_IDS_ARRAY_OFFSET 1 -#define RET_NUM_CONFIGS_OFFSET 0 -#define RET_CONFIGS_ARRAY_OFFSET 1 +#define RET_FUNCTION_SELECTED_OFFSET 0 +#define RET_NUM_CONFIGS_OFFSET 1 +#define RET_CONFIGS_ARRAY_OFFSET 2 #define FUNCTION_SELECT_FLAGS_RESERVED_LOW 2 #define REQUEST_FLAGS_RESERVED_LOW 2 #define RELEASE_FLAGS_RESERVED_LOW 2 @@ -42,6 +44,7 @@ #define GET_ALL_CONFIGS_LOW 18 #define SELECTOR_LOW 16 +#define SKIP_CONFIGS_LOW 8 #define SET_CONFIGS_LOW 2 #define PINCTRL_ACCESS_DENY 0 #define PINCTRL_ACCESS_ALLOW 1 @@ -64,6 +67,8 @@ typedef struct { uint32_t pin_ext_name_support[MAX_PIN_IDENTIFIERS]; uint32_t group_ext_name_support[MAX_GROUP_IDENTIFIERS]; uint32_t function_ext_name_support[MAX_FUNCTIONS_IDENTIFIERS]; + uint32_t function_supports_gpio[MAX_FUNCTIONS_IDENTIFIERS]; + uint32_t function_supports_group[MAX_FUNCTIONS_IDENTIFIERS]; } PIN_CONTROL_INFO_s; /* Tests*/ @@ -75,11 +80,11 @@ uint32_t pin_control_attributes_check(void); uint32_t pin_control_attributes_invalid_param_check(void); uint32_t pin_control_query_list_associations(void); uint32_t pin_control_query_list_associations_invalid_id_check(void); -uint32_t pin_control_query_config_get_check(void); -uint32_t pin_control_config_get_invalid_id_check(void); -uint32_t pin_control_query_config_set_check(void); -uint32_t pin_control_config_set_invalid_param_check(void); -uint32_t pin_control_config_set_invalid_id_check(void); +uint32_t pin_control_query_settings_get_check(void); +uint32_t pin_control_settings_get_invalid_id_check(void); +uint32_t pin_control_query_settings_configure_check(void); +uint32_t pin_control_settings_configure_invalid_param_check(void); +uint32_t pin_control_settings_configure_invalid_id_check(void); uint32_t pin_control_query_function_select_check(void); uint32_t pin_control_query_function_select_invalid_case_check(void); uint32_t pin_control_request_control_check(void); @@ -90,6 +95,7 @@ uint32_t pin_control_query_ext_name_get_invalid_case_check(void); uint32_t pin_control_set_permission_invalid_param_check(void); uint32_t pin_control_set_permission_invalid_id_check(void); uint32_t pin_control_set_permissions_check(void); +uint32_t pin_control_query_negotiate_protocol_version(uint32_t *version); uint32_t val_pin_control_get_expected_num_pins(void); uint32_t val_pin_control_get_expected_num_groups(void); diff --git a/val/include/val_power_domain.h b/val/include/val_power_domain.h index e7546eb0c83996e4121e2a0e5c7f7ce5de1f7498..dc5f18f51b9c00b5294f6b984d193500fcf679c2 100644 --- a/val/include/val_power_domain.h +++ b/val/include/val_power_domain.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -76,6 +76,7 @@ uint32_t power_domain_query_domain_attributes_scmi_v3(void); uint32_t power_domain_query_domain_attributes_scmi_v3_1(void); uint32_t power_query_ext_domain_name(void); uint32_t power_query_ext_domain_name_invalid_domain(void); +uint32_t power_domain_query_negotiate_protocol_version(uint32_t *version); uint32_t val_power_get_expected_num_domains(void); uint32_t val_power_get_expected_stats_addr_low(void); diff --git a/val/include/val_powercap.h b/val/include/val_powercap.h index 7df8a40c86b1264e95ca03e24672bab9e3678e3a..3336d6a1ad188d27a021882bc0e22b643b92bf8b 100644 --- a/val/include/val_powercap.h +++ b/val/include/val_powercap.h @@ -109,6 +109,7 @@ uint32_t powercap_invalid_data_set_power_cap_value(void); /* Version 2 */ uint32_t powercap_query_domain_attributes_v2(void); +uint32_t powercap_query_negotiate_protocol_version(uint32_t *version); /* VAL Apis used in tests */ uint32_t val_powercap_get_expected_num_domains(void); diff --git a/val/include/val_reset.h b/val/include/val_reset.h index 5bf564f0a1a1748ac9548bc6be301920e734251f..779136758df46ddb77d4838f2d92b8e9b3238c9e 100644 --- a/val/include/val_reset.h +++ b/val/include/val_reset.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -69,6 +69,7 @@ uint32_t reset_query_domain_attributes_scmi_v3(void); uint32_t reset_query_domain_attributes_scmi_v3_1(void); uint32_t reset_query_ext_domain_name(void); uint32_t reset_query_ext_domain_name_invalid_domain(void); +uint32_t reset_query_negotiate_protocol_version(uint32_t *version); uint32_t val_reset_get_expected_num_domains(void); uint8_t *val_reset_get_expected_name(uint32_t domain_id); diff --git a/val/include/val_sensor.h b/val/include/val_sensor.h index d5ae6374f82139e996b415a64805cec1dc91bd68..e7e3c519777f996a585b82070dd452045d7ba0e5 100644 --- a/val/include/val_sensor.h +++ b/val/include/val_sensor.h @@ -117,6 +117,9 @@ uint32_t sensor_query_description_get_scmi_v3_1(void); uint32_t sensor_query_ext_domain_name(void); uint32_t sensor_query_domain_ext_name_invalid_domain(void); +/* V3.1 Test cases*/ +uint32_t sensor_query_negotiate_protocol_version(uint32_t *version); + uint32_t val_sensor_get_expected_num_sensors(void); uint32_t val_sensor_get_expected_stats_addr_low(void); uint32_t val_sensor_get_expected_stats_addr_high(void); diff --git a/val/include/val_system_power.h b/val/include/val_system_power.h index 9cf6658dc578dcc8d9f270d072620b0f373d2d11..c59342d16d041441def57ea9c8ab414c6e6578ac 100644 --- a/val/include/val_system_power.h +++ b/val/include/val_system_power.h @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -38,4 +38,7 @@ uint32_t system_power_state_get_check(void); uint32_t system_power_state_set_invalid_parameters(void); uint32_t system_power_state_notify_invalid_parameters(void); +/* V2.1 Tests */ +uint32_t system_power_query_negotiate_protocol_version(uint32_t *version); + #endif diff --git a/val/include/val_voltage.h b/val/include/val_voltage.h index dcf99e704c792ecb1af0d7d813361fbc653ea3e6..042f1df66f2d03940be18a8b8c05ef6ce52fbf64 100644 --- a/val/include/val_voltage.h +++ b/val/include/val_voltage.h @@ -1,6 +1,6 @@ /** @file - * Copyright (c) 2021, 2023, Arm Limited or its affiliates. All rights reserved. - * SPDX-License-Identifier :Apache-2.0 + * Copyright (c) 2021, 2023-2024, Arm Limited or its 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. @@ -71,6 +71,9 @@ uint32_t voltage_query_domain_ext_name_invalid_domain(void); uint32_t voltage_query_ext_domain_name(void); uint32_t voltage_set_voltage_level_v2(void); +/* V2.1 Tests*/ +uint32_t voltage_query_negotiate_protocol_version(uint32_t *version); + uint32_t val_voltage_get_expected_num_domains(void); uint8_t *val_voltage_get_expected_name(uint32_t domain_id); uint32_t val_get_domain_voltage_attribute(uint32_t domain_id, uint32_t flag); diff --git a/val/val_base.c b/val/val_base.c index 6f1130592fb1883d38015fa744b11dfd1918c8ce..4a7717f8409d9ea13cdba72c4155b72537d99f43 100644 --- a/val/val_base.c +++ b/val/val_base.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -20,6 +20,12 @@ BASE_INFO_s g_base_info_table; +uint32_t base_supported_protocols[SUPPORTED_BASE_PROTOCOLS_COUNT] = { + BASE_PROTOCOL_VERSION_1, + BASE_PROTOCOL_VERSION_2, + BASE_PROTOCOL_VERSION_2P1 +}; + /** @brief This API is called from app layer to execute base tests @param none @@ -41,14 +47,17 @@ 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 (val_protocol_version_strict(version, BASE_PROTOCOL_VERSION_1)) RUN_TEST(base_discover_agent_v1()); - else if (val_protocol_version_relaxed(BASE_PROTOCOL, version, BASE_PROTOCOL_VERSION_2)) + else if (val_protocol_version_relaxed(PROTOCOL_BASE, version, BASE_PROTOCOL_VERSION_2) || + val_protocol_version_relaxed(PROTOCOL_BASE, version, BASE_PROTOCOL_VERSION_2P1)) RUN_TEST(base_discover_agent()); RUN_TEST(base_query_notify_error_support()); - if (val_protocol_version_relaxed(BASE_PROTOCOL, version, BASE_PROTOCOL_VERSION_2)) { + if (val_protocol_version_relaxed(PROTOCOL_BASE, version, BASE_PROTOCOL_VERSION_2) || + val_protocol_version_relaxed(PROTOCOL_BASE, version, BASE_PROTOCOL_VERSION_2P1)) { RUN_TEST(base_set_device_permissions_check()); RUN_TEST(base_deny_restore_device_access()); RUN_TEST(base_set_protocol_permissions_check()); @@ -58,6 +67,9 @@ uint32_t val_base_execute_tests(void) RUN_TEST(base_restore_protocol_access_with_reset_agent_configuration()); } + if (val_protocol_version_relaxed(PROTOCOL_BASE, version, BASE_PROTOCOL_VERSION_2P1)) + RUN_TEST(base_query_negotiate_protocol_version(&version)); + return VAL_STATUS_PASS; } diff --git a/val/val_clock.c b/val/val_clock.c index f16cfdd4c47f0664f8942b36ca8a1a3f9fee419f..e886cd26662720701bb06a4b035fd6abedd7a15a 100644 --- a/val/val_clock.c +++ b/val/val_clock.c @@ -21,6 +21,12 @@ static CLOCK_INFO_s g_clock_info_table; +uint32_t clock_supported_protocols[SUPPORTED_CLOCK_PROTOCOLS_COUNT] = { + CLOCK_PROTOCOL_VERSION_1, + CLOCK_PROTOCOL_VERSION_2, + CLOCK_PROTOCOL_VERSION_3 +}; + /** @brief This API is called from app layer to execute clock tests @param none @@ -38,25 +44,32 @@ uint32_t val_clock_execute_tests(void) RUN_TEST(clock_query_protocol_attributes()); - if (version < CLOCK_PROTOCOL_VERSION_2_1) + if (version < CLOCK_PROTOCOL_VERSION_3) RUN_TEST(clock_query_mandatory_command_support()); else - RUN_TEST(clock_query_mandatory_command_support_v2p1()); + RUN_TEST(clock_query_mandatory_command_support_v3()); RUN_TEST(clock_invalid_messageid_call()); - if (version >= CLOCK_PROTOCOL_VERSION_2_1) - RUN_TEST(clock_attributes_check_v2p1()); - else if (version >= CLOCK_PROTOCOL_VERSION_2) + if (version == CLOCK_PROTOCOL_VERSION_1) + RUN_TEST(clock_attributes_check()); + else if (version == CLOCK_PROTOCOL_VERSION_2) RUN_TEST(clock_attributes_check_v2()); else - RUN_TEST(clock_attributes_check()); + RUN_TEST(clock_attributes_check_v3()); RUN_TEST(clock_attributes_check_invalid_clock_id()); RUN_TEST(clock_query_describe_rates()); RUN_TEST(clock_query_describe_rates_invalid_clock_id()); - RUN_TEST(clock_rate_set_sync_check()); - RUN_TEST(clock_rate_set_async_check()); + + if (version >= CLOCK_PROTOCOL_VERSION_3) { + RUN_TEST(clock_rate_set_sync_check_v3()); + RUN_TEST(clock_rate_set_async_check_v3()); + } else { + RUN_TEST(clock_rate_set_sync_check()); + RUN_TEST(clock_rate_set_async_check()); + } + RUN_TEST(clock_rate_set_invalid_param_check()); RUN_TEST(clock_rate_set_invalid_clock_id_check()); RUN_TEST(clock_rate_get_check()); @@ -64,13 +77,12 @@ uint32_t val_clock_execute_tests(void) RUN_TEST(clock_config_set_invalid_attr_check()); RUN_TEST(clock_config_set_invalid_clock_id_check()); - if (version >= CLOCK_PROTOCOL_VERSION_2_1) - RUN_TEST(clock_config_set_check_v2p1()); + if (version >= CLOCK_PROTOCOL_VERSION_3) + RUN_TEST(clock_config_set_check_v3()); else RUN_TEST(clock_config_set_check()); - if (val_protocol_version_relaxed(PROTOCOL_CLOCK, version, - CLOCK_PROTOCOL_VERSION_2)) { + if (version >= CLOCK_PROTOCOL_VERSION_2) { RUN_TEST(clock_query_ext_domain_name()); RUN_TEST(clock_query_domain_ext_name_invalid_domain()); RUN_TEST(clock_rate_notification_query()); @@ -79,18 +91,20 @@ uint32_t val_clock_execute_tests(void) RUN_TEST(clock_rate_req_notification_invalid_query()); } - if (version == CLOCK_PROTOCOL_VERSION_2_1) + if (version == CLOCK_PROTOCOL_VERSION_3) { - RUN_TEST(clock_parent_get_invalid_clock_id_check()); - RUN_TEST(clock_config_get_check()); - RUN_TEST(clock_possible_parents_get_check()); - RUN_TEST(clock_possible_parents_get_invalid_id_check()); - RUN_TEST(clock_parent_name_support_get_check()); - RUN_TEST(clock_parent_name_support_set_check()); - RUN_TEST(clock_parent_set_invalid_check()); - RUN_TEST(clock_parent_set_invalid_clock_id_check()); - RUN_TEST(clock_config_get_invalid_clock_id_check()); - } + RUN_TEST(clock_parent_get_invalid_clock_id_check()); + RUN_TEST(clock_config_get_check()); + RUN_TEST(clock_parent_name_support_get_check()); + RUN_TEST(clock_parent_name_support_set_check()); + RUN_TEST(clock_parent_set_invalid_check()); + RUN_TEST(clock_parent_set_invalid_clock_id_check()); + RUN_TEST(clock_config_get_invalid_clock_id_check()); + RUN_TEST(clock_possible_parents_get_check()); + RUN_TEST(clock_possible_parents_get_invalid_id_check()); + RUN_TEST(clock_query_negotiate_protocol_version(&version)); + RUN_TEST(clock_get_permissions_check()); + } } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to CLOCK protocol"); @@ -290,6 +304,12 @@ uint32_t val_get_clock_attributes_flag(uint32_t attribute, uint32_t flag) case CLOCK_PARENT_IDENTIFIER_SUPPORT: flag_value = VAL_EXTRACT_BITS(attribute, 28, 28); break; + case CLOCK_EXTENDED_CONFIGURATION_SUPPORT: + flag_value = VAL_EXTRACT_BITS(attribute, 27, 27); + break; + case CLOCK_RESTRICTED: + flag_value = VAL_EXTRACT_BITS(attribute, 1, 1); + break; case CLOCK_ENABLE: flag_value = VAL_EXTRACT_BITS(attribute, 0, 0); break; diff --git a/val/val_performance.c b/val/val_performance.c index 4fab1d8332feb049d08b2909c5a38a37f72c00fc..da007f21404e9db15226f0f0cf98382ba7108fce 100644 --- a/val/val_performance.c +++ b/val/val_performance.c @@ -21,6 +21,14 @@ static PERFORMANCE_INFO_s g_performance_info_table; +uint32_t performance_supported_protocols[SUPPORTED_PERFORMANCE_PROTOCOLS_COUNT] = { + PERFORMANCE_PROTOCOL_VERSION_1, + PERFORMANCE_PROTOCOL_VERSION_2, + PERFORMANCE_PROTOCOL_VERSION_3, + PERFORMANCE_PROTOCOL_VERSION_4 +}; + + /** @brief This API is called from app layer to execute performance tests @param none @@ -38,34 +46,60 @@ uint32_t val_performance_execute_tests(void) RUN_TEST(performance_query_protocol_attributes()); - if (version == PERFORMANCE_PROTOCOL_VERSION_4) - RUN_TEST(performance_query_domain_attributes_v4()); - 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 (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, - PERFORMANCE_PROTOCOL_VERSION_2)) { + if ((val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_2)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4))) { RUN_TEST(performance_query_mandatory_command_support()); RUN_TEST(performance_invalid_messageid_call()); - RUN_TEST(performance_query_domain_attributes()); } - RUN_TEST(performance_query_domain_attributes_invalid_domain()); - if (version < PERFORMANCE_PROTOCOL_VERSION_4) - RUN_TEST(performance_query_describe_levels()); + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4)) + RUN_TEST(performance_query_domain_attributes_v4()); + else if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_3)) + RUN_TEST(performance_query_domain_attributes_v3()); else + RUN_TEST(performance_query_domain_attributes()); + + RUN_TEST(performance_query_domain_attributes_invalid_domain()); + + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4)) RUN_TEST(performance_query_describe_levels_v4()); + else + RUN_TEST(performance_query_describe_levels()); RUN_TEST(performance_query_describe_levels_invalid_domain()); + + if ((val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4))) + RUN_TEST(performance_query_set_limit_v3()); + else RUN_TEST(performance_query_set_limit()); + RUN_TEST(performance_query_set_limit_invalid_range()); RUN_TEST(performance_query_set_limit_invalid_domain()); RUN_TEST(performance_query_get_limit_invalid_domain()); - RUN_TEST(performance_query_set_level()); + + + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4)) + RUN_TEST(performance_query_set_level_v4()); + else + RUN_TEST(performance_query_set_level()); + RUN_TEST(performance_query_set_level_invalid_range()); RUN_TEST(performance_query_set_level_invalid_domain()); RUN_TEST(performance_query_get_level_invalid_domain()); @@ -74,34 +108,54 @@ uint32_t val_performance_execute_tests(void) RUN_TEST(performance_query_notify_level_invalid_parameters()); RUN_TEST(performance_query_notify_level_invalid_domain()); - if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, - PERFORMANCE_PROTOCOL_VERSION_2)) { + if ((val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_2)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4))) { 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()); RUN_TEST(performance_query_describe_fast_channel_unsupported_domain()); RUN_TEST(performance_query_describe_fast_channel_unsupported_message()); } + RUN_TEST(performance_limit_set_async()); RUN_TEST(performance_level_set_async()); - if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, - PERFORMANCE_PROTOCOL_VERSION_2)) { + if ((val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_2)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_3))) { RUN_TEST(performance_level_get_fast_channel()); - RUN_TEST(performance_limits_get_fast_channel()); } + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, - PERFORMANCE_PROTOCOL_VERSION_3)) { - RUN_TEST(performance_query_domain_attributes_v3()); + PERFORMANCE_PROTOCOL_VERSION_4)) { + RUN_TEST(performance_level_get_fast_channel_v4()); + } + + if ((val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_2)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4))) { + RUN_TEST(performance_limits_get_fast_channel()); + } + + if ((val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4))) { RUN_TEST(performance_query_ext_domain_name()); RUN_TEST(performance_query_domain_name_invalid_domain()); - RUN_TEST(performance_query_set_limit_v3()); } - if (version == PERFORMANCE_PROTOCOL_VERSION_4) { - RUN_TEST(performance_query_domain_attributes_v4()); - RUN_TEST(performance_query_set_level_v4()); - RUN_TEST(performance_level_get_fast_channel_v4()); + if (val_protocol_version_relaxed(PROTOCOL_PERFORMANCE, version, + PERFORMANCE_PROTOCOL_VERSION_4)) { + RUN_TEST(performance_query_negotiate_protocol_version(&version)); } } else diff --git a/val/val_pin_control.c b/val/val_pin_control.c index 1a074c4cdc372b473f71febdb47aa39e1a239617..ad7bf0b691924561281d48be8bb1dffd0cb1b1c4 100644 --- a/val/val_pin_control.c +++ b/val/val_pin_control.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2023, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2023-2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,6 +21,10 @@ static PIN_CONTROL_INFO_s g_pin_control_info_table; +uint32_t pin_control_supported_protocols[SUPPORTED_PIN_CONTROL_PROTOCOLS_COUNT] = { + PIN_CONTROL_PROTOCOL_VERSION_1, +}; + /** @brief This API is called from app layer to execute power domain tests @param none @@ -36,7 +40,6 @@ uint32_t val_pin_control_execute_tests(void) if (RUN_TEST(pin_control_query_protocol_version(&version))) return VAL_STATUS_FAIL; - /* TODO add tests here */ RUN_TEST(pin_control_query_protocol_attributes()); RUN_TEST(pin_control_query_mandatory_command_support()); RUN_TEST(pin_control_invalid_messageid_call()); @@ -44,11 +47,11 @@ uint32_t val_pin_control_execute_tests(void) RUN_TEST(pin_control_attributes_invalid_param_check()); RUN_TEST(pin_control_query_list_associations()); RUN_TEST(pin_control_query_list_associations_invalid_id_check()); - RUN_TEST(pin_control_query_config_get_check()); - RUN_TEST(pin_control_config_get_invalid_id_check()); - RUN_TEST(pin_control_query_config_set_check()); - RUN_TEST(pin_control_config_set_invalid_param_check()); - RUN_TEST(pin_control_config_set_invalid_id_check()); + RUN_TEST(pin_control_query_settings_get_check()); + RUN_TEST(pin_control_settings_get_invalid_id_check()); + RUN_TEST(pin_control_query_settings_configure_check()); + RUN_TEST(pin_control_settings_configure_invalid_param_check()); + RUN_TEST(pin_control_settings_configure_invalid_id_check()); RUN_TEST(pin_control_query_function_select_check()); RUN_TEST(pin_control_query_function_select_invalid_case_check()); RUN_TEST(pin_control_request_control_check()); @@ -59,6 +62,7 @@ uint32_t val_pin_control_execute_tests(void) RUN_TEST(pin_control_set_permissions_check()); RUN_TEST(pin_control_set_permission_invalid_param_check()); RUN_TEST(pin_control_set_permission_invalid_id_check()); + RUN_TEST(pin_control_query_negotiate_protocol_version(&version)); } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to PIN CONTROL protocol"); @@ -94,6 +98,12 @@ void val_pin_control_save_info(uint32_t param_identifier, uint32_t pc_id, uint32 case PC_NUM_GROUPS_IN_FUNCTION: g_pin_control_info_table.num_groups_in_function[pc_id] = param_value; break; + case PC_FUNCTION_GPIO_SUPPORT: + g_pin_control_info_table.function_supports_gpio[pc_id] = param_value; + break; + case PC_FUNCTION_GROUP_SUPPORT: + g_pin_control_info_table.function_supports_group[pc_id] = param_value; + break; default: val_print(VAL_PRINT_WARN, "\nUnidentified parameter %d", param_identifier); } @@ -128,6 +138,12 @@ uint32_t val_pin_control_get_info(uint32_t pc_id, uint32_t param_identifier) case PC_NUM_GROUPS_IN_FUNCTION: param_value = g_pin_control_info_table.num_groups_in_function[pc_id]; break; + case PC_FUNCTION_GPIO_SUPPORT: + param_value = g_pin_control_info_table.function_supports_gpio[pc_id]; + break; + case PC_FUNCTION_GROUP_SUPPORT: + param_value = g_pin_control_info_table.function_supports_group[pc_id]; + break; default: val_print(VAL_PRINT_WARN, "\nUnidentified parameter %d", param_identifier); } diff --git a/val/val_power_domain.c b/val/val_power_domain.c index 63000461c58fb083c099ecda1bdcb3c3d1022c5f..6a17611d0da240509831ae658e2b348585c2f57f 100644 --- a/val/val_power_domain.c +++ b/val/val_power_domain.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,6 +21,13 @@ static POWER_DOMAIN_INFO_s g_power_domain_info_table; +uint32_t power_supported_protocols[SUPPORTED_POWER_PROTOCOLS_COUNT] = { + POWER_PROTOCOL_VERSION_1, + POWER_PROTOCOL_VERSION_2, + POWER_PROTOCOL_VERSION_2P1, + POWER_PROTOCOL_VERSION_3, + POWER_PROTOCOL_VERSION_3P1 +}; /** @brief This API is called from app layer to execute power domain tests @param none @@ -39,7 +46,26 @@ uint32_t val_power_domain_execute_tests(void) RUN_TEST(power_domain_query_protocol_attributes()); RUN_TEST(power_domain_query_mandatory_command_support()); RUN_TEST(power_domain_invalid_messageid_call()); - RUN_TEST(power_domain_query_domain_attributes()); + + if ((val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_1)) || + (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_2))) { + RUN_TEST(power_domain_query_domain_attributes()); + } + + if (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_2P1)) { + RUN_TEST(power_domain_query_domain_attributes_scmi_v3()); + } + + if ((val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_3P1))) { + RUN_TEST(power_domain_query_domain_attributes_scmi_v3_1()); + } + RUN_TEST(power_domain_query_domain_attributes_invalid_doamin()); RUN_TEST(power_domain_set_power_state_check()); RUN_TEST(power_domain_set_power_state_unsupported_domain_check()); @@ -50,20 +76,30 @@ 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 (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, - POWER_PROTOCOL_VERSION_2)) { + if ((val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_2)) || + (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_2P1)) || + (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_3P1))) { RUN_TEST(power_domain_power_state_change_requested_notify_check()); RUN_TEST(power_domain_power_state_change_requested_notify_invalid_domain_check()); } - if (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, - POWER_PROTOCOL_VERSION_2_1)) { - RUN_TEST(power_domain_query_domain_attributes_scmi_v3()); - } - if (version == POWER_PROTOCOL_VERSION_3) { - RUN_TEST(power_domain_query_domain_attributes_scmi_v3_1()); + + if ((val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_3P1))) { RUN_TEST(power_query_ext_domain_name()); RUN_TEST(power_query_ext_domain_name_invalid_domain()); } + + if (val_protocol_version_relaxed(PROTOCOL_POWER_DOMAIN, version, + POWER_PROTOCOL_VERSION_3P1)) { + RUN_TEST(power_domain_query_negotiate_protocol_version(&version)); + } } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to POWER DOMAIN protocol"); diff --git a/val/val_powercap.c b/val/val_powercap.c index 35afb09530a7ee827313aaf0f94c5c0adc94554b..2530111a5f22f62a56b26d12004165603ca5ec6d 100644 --- a/val/val_powercap.c +++ b/val/val_powercap.c @@ -22,6 +22,11 @@ static POWERCAP_INFO_s g_powercap_info_table; +uint32_t powercap_supported_protocols[SUPPORTED_POWERCAP_PROTOCOLS_COUNT] = { + POWERCAP_PROTOCOL_VERSION_1, + POWERCAP_PROTOCOL_VERSION_2 +}; + /** @brief This API is called from app layer to execute powercap tests @param none @@ -54,19 +59,21 @@ uint32_t val_powercap_execute_tests(void) RUN_TEST(powercap_query_pai_invalid_domain_id()); RUN_TEST(powercap_set_pai_value()); RUN_TEST(powercap_invalid_domain_set_pai_value()); + RUN_TEST(powercap_invalid_data_set_pai_value()); RUN_TEST(powercap_query_domain_name()); + RUN_TEST(powercap_query_domain_name_invalid_domain()); RUN_TEST(powercap_query_measurement()); RUN_TEST(powercap_cap_notification_query()); + RUN_TEST(powercap_cap_notification_invalid_query()); RUN_TEST(powercap_measurement_notification_query()); + RUN_TEST(powercap_measurement_notification_invalid_query()); RUN_TEST(powercap_query_describe_fast_channel()); RUN_TEST(powercap_query_describe_fast_channel_invalid_domain()); RUN_TEST(powercap_query_describe_fast_channel_invalid_message()); RUN_TEST(powercap_query_describe_fast_channel_unsupported_domain()); - RUN_TEST(powercap_invalid_data_set_pai_value()); - RUN_TEST(powercap_query_domain_name_invalid_domain()); - RUN_TEST(powercap_cap_notification_invalid_query()); - RUN_TEST(powercap_measurement_notification_invalid_query()); + if (version >= POWERCAP_PROTOCOL_VERSION_2) + RUN_TEST(powercap_query_negotiate_protocol_version(&version)); } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to Powercap protocol"); diff --git a/val/val_reset.c b/val/val_reset.c index 3d478e6418d581a9811b5a0e858556883fcbdb38..36cd033bbf5a42d4a253996dd7f93bcbe31cdfc7 100644 --- a/val/val_reset.c +++ b/val/val_reset.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,6 +21,12 @@ static RESET_INFO_s g_reset_info_table; +uint32_t reset_supported_protocols[SUPPORTED_RESET_PROTOCOLS_COUNT] = { + RESET_PROTOCOL_VERSION_1, + RESET_PROTOCOL_VERSION_2, + RESET_PROTOCOL_VERSION_3, + RESET_PROTOCOL_VERSION_3P1 +}; /** @brief This API is called from app layer to execute reset domain tests @param none @@ -39,7 +45,14 @@ uint32_t val_reset_execute_tests(void) RUN_TEST(reset_query_protocol_attributes()); RUN_TEST(reset_query_mandatory_command_support()); RUN_TEST(reset_invalid_messageid_call()); - RUN_TEST(reset_query_domain_attributes()); + + if (version >= RESET_PROTOCOL_VERSION_3) + RUN_TEST(reset_query_domain_attributes_scmi_v3_1()); + else if (version == RESET_PROTOCOL_VERSION_2) + RUN_TEST(reset_query_domain_attributes_scmi_v3()); + else + RUN_TEST(reset_query_domain_attributes()); + RUN_TEST(reset_query_domain_attributes_invalid_id()); RUN_TEST(reset_query_reset_command_invalid_id()); RUN_TEST(reset_query_reset_command_invalid_flag()); @@ -47,15 +60,14 @@ uint32_t val_reset_execute_tests(void) RUN_TEST(reset_query_notify_invalid_id()); RUN_TEST(reset_query_invalid_notify_enable()); - if (val_protocol_version_relaxed(PROTOCOL_RESET, version, RESET_PROTOCOL_VERSION_2)) { - RUN_TEST(reset_query_domain_attributes_scmi_v3()); - } - - if (version == RESET_PROTOCOL_VERSION_3) { - RUN_TEST(reset_query_domain_attributes_scmi_v3_1()); + if (version >= RESET_PROTOCOL_VERSION_3) { RUN_TEST(reset_query_ext_domain_name()); RUN_TEST(reset_query_ext_domain_name_invalid_domain()); } + + if (version >= RESET_PROTOCOL_VERSION_3P1) { + RUN_TEST(reset_query_negotiate_protocol_version(&version)); + } } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to RESET protocol"); diff --git a/val/val_sensor.c b/val/val_sensor.c index 1cf34bf70f0456e9916be4d01747f0f423f450d8..13dc56543b1556c17763806de082d47facd8558a 100644 --- a/val/val_sensor.c +++ b/val/val_sensor.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2021, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2021, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,6 +21,12 @@ static SENSOR_INFO_s g_sensor_info_table; +uint32_t sensor_supported_protocols[SUPPORTED_SENSOR_PROTOCOLS_COUNT] = { + SENSOR_PROTOCOL_VERSION_1, + SENSOR_PROTOCOL_VERSION_2, + SENSOR_PROTOCOL_VERSION_3, + SENSOR_PROTOCOL_VERSION_3P1 +}; /** @brief This API is called from app layer to execute sensor domain tests @param none @@ -45,6 +51,11 @@ uint32_t val_sensor_execute_tests(void) else if (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, SENSOR_PROTOCOL_VERSION_2)) RUN_TEST(sensor_query_description_get_scmi_v3()); + else if ((val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_3P1))) + RUN_TEST(sensor_query_description_get_scmi_v3_1()); RUN_TEST(sensor_trip_point_nfy_event_ctrl_check()); RUN_TEST(sensor_trip_point_nfy_invalid_id_check()); @@ -57,8 +68,12 @@ uint32_t val_sensor_execute_tests(void) RUN_TEST(sensor_reading_get_async_mode()); RUN_TEST(sensor_reading_get_async_mode_not_supported()); - if (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, - SENSOR_PROTOCOL_VERSION_2)) { + if ((val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_2)) || + (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_3P1))) { RUN_TEST(sensor_axis_description_check()); RUN_TEST(sensor_axis_desc_invalid_id_check()); RUN_TEST(sensor_supported_update_intervals_check()); @@ -70,12 +85,19 @@ uint32_t val_sensor_execute_tests(void) RUN_TEST(sensor_request_sensor_notification_check()); RUN_TEST(sensor_request_notification_invalid_id_check()); } - if (version == SENSOR_PROTOCOL_VERSION_3) { - RUN_TEST(sensor_query_description_get_scmi_v3_1()); + + if ((val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_3)) || + (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_3P1))) { RUN_TEST(sensor_query_ext_domain_name()); RUN_TEST(sensor_query_domain_ext_name_invalid_domain()); } + if (val_protocol_version_relaxed(PROTOCOL_SENSOR, version, + SENSOR_PROTOCOL_VERSION_3P1)) { + RUN_TEST(sensor_query_negotiate_protocol_version(&version)); + } } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to SENSOR protocol"); diff --git a/val/val_system_power.c b/val/val_system_power.c index 96355b0f0363ac2cc4be80e5f410f88fa606d94e..977e20d29fe9ee70271764dca5b8d26dd7ac7051 100644 --- a/val/val_system_power.c +++ b/val/val_system_power.c @@ -1,5 +1,5 @@ /** @file - * Copyright (c) 2019-2020, Arm Limited or its affiliates. All rights reserved. + * Copyright (c) 2019-2020, 2024, Arm Limited or its affiliates. All rights reserved. * SPDX-License-Identifier : Apache-2.0 * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -21,6 +21,11 @@ static SYSTEM_POWER_INFO_s g_system_power_info_table; +uint32_t system_power_supported_protocols[SUPPORTED_SYSTEM_POWER_PROTOCOLS_COUNT] = { + SYSTEM_POWER_VERSION_1, + SYSTEM_POWER_VERSION_2, + SYSTEM_POWER_VERSION_2P1 +}; /** @brief This API is called from app layer to execute system power tests @param none @@ -42,6 +47,9 @@ uint32_t val_system_power_execute_tests(void) RUN_TEST(system_power_state_set_invalid_parameters()); RUN_TEST(system_power_state_get_check()); RUN_TEST(system_power_state_notify_invalid_parameters()); + + if (val_protocol_version_relaxed(PROTOCOL_SYSTEM_POWER, version, SYSTEM_POWER_VERSION_2P1)) + RUN_TEST(system_power_query_negotiate_protocol_version(&version)); } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to SYSTEM POWER protocol"); diff --git a/val/val_voltage.c b/val/val_voltage.c index 3188ec1e0410e437d915f2f98e636c1417030e26..fb2b311d230f4b22df0112563f0073914684ffd5 100644 --- a/val/val_voltage.c +++ b/val/val_voltage.c @@ -22,6 +22,11 @@ static VOLTAGE_INFO_s g_voltage_info_table; +uint32_t voltage_supported_protocols[SUPPORTED_VOLTAGE_PROTOCOLS_COUNT] = { + VOLTAGE_PROTOCOL_VERSION_1, + VOLTAGE_PROTOCOL_VERSION_2, + VOLTAGE_PROTOCOL_VERSION_2P1 +}; /** @brief This API is called from app layer to execute voltage tests @param none @@ -38,7 +43,8 @@ uint32_t val_voltage_execute_tests(void) RUN_TEST(voltage_query_protocol_attributes()); RUN_TEST(voltage_query_mandatory_command_support()); RUN_TEST(voltage_invalid_messageid_call()); - if (version == VOLTAGE_PROTOCOL_VERSION_2) + + if (version >= VOLTAGE_PROTOCOL_VERSION_2) RUN_TEST(voltage_query_domain_attributes_v2()); else RUN_TEST(voltage_query_domain_attributes()); @@ -49,17 +55,24 @@ uint32_t val_voltage_execute_tests(void) RUN_TEST(voltage_set_operating_mode()); RUN_TEST(voltage_invalid_domain_set_operating_mode()); RUN_TEST(voltage_query_config_operating_mode()); - RUN_TEST(voltage_set_voltage_level()); + + if (version >= VOLTAGE_PROTOCOL_VERSION_2) + RUN_TEST(voltage_set_voltage_level_v2()); + else + RUN_TEST(voltage_set_voltage_level()); + RUN_TEST(voltage_set_voltage_invalid_domain()); RUN_TEST(voltage_set_invalid_voltage_level()); RUN_TEST(voltage_query_current_level()); - if (version == VOLTAGE_PROTOCOL_VERSION_2) { - RUN_TEST(voltage_query_domain_ext_name_invalid_domain()); + if (version >= VOLTAGE_PROTOCOL_VERSION_2) { RUN_TEST(voltage_query_ext_domain_name()); - RUN_TEST(voltage_set_voltage_level_v2()); + RUN_TEST(voltage_query_domain_ext_name_invalid_domain()); } + if (version >= VOLTAGE_PROTOCOL_VERSION_2P1) { + RUN_TEST(voltage_query_negotiate_protocol_version(&version)); + } } else val_print(VAL_PRINT_ERR, "\n Calling agent have no access to Voltage protocol");