| // Copyright 2022 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/graphics/display/drivers/intel-i915/registers-pipe-scaler.h" |
| |
| #include <lib/mmio/mmio-buffer.h> |
| |
| #include <cmath> |
| #include <limits> |
| |
| #include <gtest/gtest.h> |
| #include <hwreg/bitfields.h> |
| #include <mock-mmio-range/mock-mmio-range.h> |
| |
| #include "src/graphics/display/drivers/intel-i915/hardware-common.h" |
| |
| namespace i915 { |
| |
| namespace { |
| |
| TEST(PipeScalerControlTigerLake, SetYPlaneBinding) { |
| // Valid values |
| EXPECT_NO_FATAL_FAILURE({ |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(6); |
| }); |
| EXPECT_NO_FATAL_FAILURE({ |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(7); |
| }); |
| // Invalid values |
| EXPECT_DEATH_IF_SUPPORTED( |
| { |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(0); |
| }, |
| "non-Y plane"); |
| EXPECT_DEATH_IF_SUPPORTED( |
| { |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(1); |
| }, |
| "non-Y plane"); |
| EXPECT_DEATH_IF_SUPPORTED( |
| { |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(2); |
| }, |
| "non-Y plane"); |
| EXPECT_DEATH_IF_SUPPORTED( |
| { |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(3); |
| }, |
| "non-Y plane"); |
| EXPECT_DEATH_IF_SUPPORTED( |
| { |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(4); |
| }, |
| "non-Y plane"); |
| EXPECT_DEATH_IF_SUPPORTED( |
| { |
| registers::PipeScalerControlTigerLake pipe_scaler_control; |
| pipe_scaler_control.set_y_plane_binding(5); |
| }, |
| "non-Y plane"); |
| } |
| |
| TEST(PipeScalerScalingFactor, ToFloat) { |
| // All the comparisons must be exact equal, since ToFloat() is not |
| // supposed to lose any precision when using C float type. |
| |
| // Integer part |
| { |
| registers::PipeScalerScalingFactor zero; |
| zero.set_integer_part(0).set_fraction_part(0); |
| EXPECT_EQ(zero.ToFloat(), 0.0f); |
| } |
| |
| { |
| registers::PipeScalerScalingFactor five; |
| five.set_integer_part(5).set_fraction_part(0); |
| EXPECT_EQ(five.ToFloat(), 5.0f); |
| } |
| |
| { |
| registers::PipeScalerScalingFactor seven; |
| seven.set_integer_part(7).set_fraction_part(0); |
| EXPECT_EQ(seven.ToFloat(), 7.0f); |
| } |
| |
| // Fraction part |
| { |
| registers::PipeScalerScalingFactor decimal_0_25; |
| decimal_0_25.set_integer_part(0).set_fraction_part(0b010'000'000'000'000); |
| EXPECT_EQ(decimal_0_25.ToFloat(), 0.25f); |
| } |
| |
| { |
| registers::PipeScalerScalingFactor min_positive_decimal; |
| min_positive_decimal.set_integer_part(0).set_fraction_part(0b000'000'000'000'001); |
| EXPECT_EQ(min_positive_decimal.ToFloat(), 1.0f / 32768.0f); |
| } |
| |
| { |
| registers::PipeScalerScalingFactor max_decimal_less_than_1; |
| max_decimal_less_than_1.set_integer_part(0).set_fraction_part(0b111'111'111'111'111); |
| EXPECT_EQ(max_decimal_less_than_1.ToFloat(), 32767.0f / 32768.0f); |
| } |
| |
| { |
| registers::PipeScalerScalingFactor max_decimal; |
| max_decimal.set_integer_part(0b111).set_fraction_part(0b111'111'111'111'111); |
| EXPECT_EQ(max_decimal.ToFloat(), 7.0f + 32767.0f / 32768.0f); |
| } |
| } |
| |
| TEST(PipeScalerInitialPhase, HorizontalPhaseUvValidity) { |
| // Valid values should be between -0.5 and 1.5 (inclusive on both ends). |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(0.25f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(-0.5f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(0.0f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(0.5f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(1.0f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(1.5f)); |
| } |
| |
| // Values out of range, NaN and infinite values are invalid. |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetUvInitialPhase(std::numeric_limits<float>::quiet_NaN()), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetUvInitialPhase(std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetUvInitialPhase(-std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetUvInitialPhase(-0.6f), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetUvInitialPhase(1.6f), ""); |
| } |
| } |
| |
| TEST(PipeScalerInitialPhase, HorizontalPhaseYValidity) { |
| // Valid values should be between -0.5 and 1.5 (inclusive on both ends). |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(0.25f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(-0.5f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(0.0f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(0.5f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(1.0f)); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(1.5f)); |
| } |
| |
| // Values out of range, NaN and infinite values are invalid. |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetYInitialPhase(std::numeric_limits<float>::quiet_NaN()), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetYInitialPhase(std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetYInitialPhase(-std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetYInitialPhase(-0.6f), ""); |
| } |
| |
| { |
| registers::PipeScalerHorizontalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetYInitialPhase(1.6f), ""); |
| } |
| } |
| |
| TEST(PipeScalerInitialPhase, HorizontalPhaseValue) { |
| // YUV 420 Chroma Siting = Top Left |
| // Horizontal Phase = 0.25 |
| { |
| registers::PipeScalerHorizontalInitialPhase phase_top_left; |
| phase_top_left.SetUvInitialPhase(0.25f); |
| EXPECT_EQ(phase_top_left.uv_initial_phase_fraction(), 1u << 11); |
| EXPECT_EQ(phase_top_left.uv_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_top_left.uv_initial_phase_trip_enabled(), true); |
| |
| phase_top_left.SetYInitialPhase(0.25f); |
| EXPECT_EQ(phase_top_left.y_initial_phase_fraction(), 1u << 11); |
| EXPECT_EQ(phase_top_left.y_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_top_left.y_initial_phase_trip_enabled(), true); |
| } |
| |
| // YUV 420 Chroma Siting = Bottom Right |
| // Horizontal Phase = -0.25 |
| { |
| registers::PipeScalerHorizontalInitialPhase phase_bottom_right; |
| phase_bottom_right.SetUvInitialPhase(-0.25f); |
| EXPECT_EQ(phase_bottom_right.uv_initial_phase_fraction(), 3u << 11); |
| EXPECT_EQ(phase_bottom_right.uv_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_bottom_right.uv_initial_phase_trip_enabled(), false); |
| |
| phase_bottom_right.SetYInitialPhase(-0.25f); |
| EXPECT_EQ(phase_bottom_right.y_initial_phase_fraction(), 3u << 11); |
| EXPECT_EQ(phase_bottom_right.y_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_bottom_right.y_initial_phase_trip_enabled(), false); |
| } |
| |
| // YUV 420 Chroma Siting = Bottom Center |
| // Horizontal Phase = 0 |
| { |
| registers::PipeScalerHorizontalInitialPhase phase_bottom_center; |
| phase_bottom_center.SetUvInitialPhase(0.0f); |
| EXPECT_EQ(phase_bottom_center.uv_initial_phase_fraction(), 0u); |
| EXPECT_EQ(phase_bottom_center.uv_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_bottom_center.uv_initial_phase_trip_enabled(), true); |
| |
| phase_bottom_center.SetYInitialPhase(0.0f); |
| EXPECT_EQ(phase_bottom_center.y_initial_phase_fraction(), 0u); |
| EXPECT_EQ(phase_bottom_center.y_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_bottom_center.y_initial_phase_trip_enabled(), true); |
| } |
| } |
| |
| TEST(PipeScalerInitialPhase, VerticalPhaseUvValidity) { |
| // Valid values should be between -0.5 and 1.5 (inclusive on both ends). |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(0.25f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(-0.5f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(0.0f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(0.5f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(1.0f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetUvInitialPhase(1.5f)); |
| } |
| |
| // Values out of range, NaN and infinite values are invalid. |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetUvInitialPhase(std::numeric_limits<float>::quiet_NaN()), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetUvInitialPhase(std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetUvInitialPhase(-std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetUvInitialPhase(-0.6f), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetUvInitialPhase(1.6f), ""); |
| } |
| } |
| |
| TEST(PipeScalerInitialPhase, VerticalPhaseYValidity) { |
| // Valid values should be between -0.5 and 1.5 (inclusive on both ends). |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(0.25f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(-0.5f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(0.0f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(0.5f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(1.0f)); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase valid_phase; |
| EXPECT_NO_FATAL_FAILURE(valid_phase.SetYInitialPhase(1.5f)); |
| } |
| |
| // Values out of range, NaN and infinite values are invalid. |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetYInitialPhase(std::numeric_limits<float>::quiet_NaN()), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetYInitialPhase(std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED( |
| invalid_phase.SetYInitialPhase(-std::numeric_limits<float>::infinity()), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetYInitialPhase(-0.6f), ""); |
| } |
| |
| { |
| registers::PipeScalerVerticalInitialPhase invalid_phase; |
| EXPECT_DEATH_IF_SUPPORTED(invalid_phase.SetYInitialPhase(1.6f), ""); |
| } |
| } |
| |
| TEST(PipeScalerInitialPhase, VerticalPhaseValue) { |
| // YUV 420 Chroma Siting = Top Left |
| // Vertical Phase = 0.25 |
| { |
| registers::PipeScalerVerticalInitialPhase phase_top_left; |
| phase_top_left.SetUvInitialPhase(0.25f); |
| EXPECT_EQ(phase_top_left.uv_initial_phase_fraction(), 1u << 11); |
| EXPECT_EQ(phase_top_left.uv_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_top_left.uv_initial_phase_trip_enabled(), true); |
| |
| phase_top_left.SetYInitialPhase(0.25f); |
| EXPECT_EQ(phase_top_left.y_initial_phase_fraction(), 1u << 11); |
| EXPECT_EQ(phase_top_left.y_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_top_left.y_initial_phase_trip_enabled(), true); |
| } |
| |
| // YUV 420 Chroma Siting = Bottom Right / Bottom Center |
| // Vertical Phase = -0.25 |
| { |
| registers::PipeScalerVerticalInitialPhase phase_bottom_right; |
| phase_bottom_right.SetUvInitialPhase(-0.25f); |
| EXPECT_EQ(phase_bottom_right.uv_initial_phase_fraction(), 3u << 11); |
| EXPECT_EQ(phase_bottom_right.uv_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_bottom_right.uv_initial_phase_trip_enabled(), false); |
| |
| phase_bottom_right.SetYInitialPhase(-0.25f); |
| EXPECT_EQ(phase_bottom_right.y_initial_phase_fraction(), 3u << 11); |
| EXPECT_EQ(phase_bottom_right.y_initial_phase_int(), 0u); |
| EXPECT_EQ(phase_bottom_right.y_initial_phase_trip_enabled(), false); |
| } |
| } |
| |
| TEST(PipeScalerCoefficientDataFormat, ToCanonical) { |
| { |
| registers::PipeScalerCoefficientFormat zero; |
| zero.set_is_negative(false).set_exponent(1).set_mantissa(0); |
| EXPECT_EQ(zero.x2048(), 0); |
| } |
| |
| { |
| registers::PipeScalerCoefficientFormat one; |
| one.set_is_negative(false).set_exponent(0).set_mantissa(0b100'000'000); |
| EXPECT_EQ(one.x2048(), 2048); |
| } |
| |
| { |
| registers::PipeScalerCoefficientFormat minus_one; |
| minus_one.set_is_negative(true).set_exponent(0).set_mantissa(0b100'000'000); |
| EXPECT_EQ(minus_one.x2048(), -2048); |
| } |
| |
| { |
| registers::PipeScalerCoefficientFormat half; |
| half.set_is_negative(false).set_exponent(1).set_mantissa(0b100'000'000); |
| EXPECT_EQ(half.x2048(), 1024); |
| } |
| |
| { |
| // Minimum positive: (0.00000000001) = 1 / 2048 |
| registers::PipeScalerCoefficientFormat minimum_positive; |
| minimum_positive.set_is_negative(false).set_exponent(3).set_mantissa(1); |
| EXPECT_EQ(minimum_positive.x2048(), 1); |
| } |
| |
| { |
| // Maximum positive: (1.11111111)b = 511 / 256 = 4088 / 2048 |
| registers::PipeScalerCoefficientFormat minimum_positive; |
| minimum_positive.set_is_negative(false).set_exponent(0).set_mantissa(0b111'111'111); |
| EXPECT_EQ(minimum_positive.x2048(), 4088); |
| } |
| } |
| |
| TEST(PipeScalerCoefficients, Write) { |
| constexpr uint16_t kNumCoefficients = 17 * 7; |
| std::vector<registers::PipeScalerCoefficientFormat> coefficients(kNumCoefficients); |
| for (uint16_t i = 0; i < kNumCoefficients; i++) { |
| coefficients[i].set_is_negative(0).set_mantissa(i).set_exponent(0); |
| } |
| |
| std::vector<ddk_mock::MockMmioRange::Access> expected_access_list = { |
| {.address = 0x68198, .value = 0x00000400, .write = true}, |
| }; |
| for (size_t i = 0; i < kNumCoefficients; i += 2) { |
| uint32_t value = 0u; |
| if (i + 1 < kNumCoefficients) { |
| value |= ((coefficients[i + 1].reg_value()) & 0xffffu) << 16; |
| } |
| value |= (coefficients[i].reg_value()) & 0xffffu; |
| expected_access_list.push_back({.address = 0x6819C, .value = value, .write = true}); |
| } |
| |
| constexpr static int kMmioRangeSize = 0x140000; |
| ddk_mock::MockMmioRange mmio_range{kMmioRangeSize, ddk_mock::MockMmioRange::Size::k32}; |
| mmio_range.Expect(expected_access_list); |
| fdf::MmioBuffer mmio_buffer(mmio_range.GetMmioBuffer()); |
| |
| registers::PipeScalerRegs pipe_scaler_regs(PipeId::PIPE_A, /* scaler_index= */ 0); |
| auto pipe_scaler_coefficients = pipe_scaler_regs.PipeScalerCoefficients(); |
| |
| pipe_scaler_coefficients.WriteToRegister(coefficients, &mmio_buffer); |
| } |
| |
| TEST(PipeScalerCoefficients, Read) { |
| constexpr uint16_t kNumCoefficients = 17 * 7; |
| std::vector<registers::PipeScalerCoefficientFormat> expected_coefficients(kNumCoefficients); |
| for (uint16_t i = 0; i < kNumCoefficients; i++) { |
| expected_coefficients[i].set_is_negative(0).set_mantissa(i).set_exponent(0); |
| } |
| |
| std::vector<ddk_mock::MockMmioRange::Access> expected_access_list = { |
| {.address = 0x68198, .value = 0x00000400, .write = true}, |
| }; |
| for (size_t i = 0; i < kNumCoefficients; i += 2) { |
| uint32_t value = 0u; |
| if (i + 1 < kNumCoefficients) { |
| value |= ((expected_coefficients[i + 1].reg_value()) & 0xffffu) << 16; |
| } |
| value |= (expected_coefficients[i].reg_value()) & 0xffffu; |
| expected_access_list.push_back({.address = 0x6819C, .value = value}); |
| } |
| |
| constexpr static int kMmioRangeSize = 0x140000; |
| ddk_mock::MockMmioRange mmio_range{kMmioRangeSize, ddk_mock::MockMmioRange::Size::k32}; |
| mmio_range.Expect(expected_access_list); |
| fdf::MmioBuffer mmio_buffer(mmio_range.GetMmioBuffer()); |
| |
| registers::PipeScalerRegs pipe_scaler_regs(PipeId::PIPE_A, /* scaler_index= */ 0); |
| auto pipe_scaler_coefficients = pipe_scaler_regs.PipeScalerCoefficients(); |
| |
| auto coefficients_read = pipe_scaler_coefficients.ReadFromRegister(&mmio_buffer); |
| EXPECT_EQ(coefficients_read.size(), kNumCoefficients); |
| for (size_t i = 0; i < kNumCoefficients; i++) { |
| EXPECT_EQ(coefficients_read[i].reg_value(), expected_coefficients[i].reg_value()); |
| } |
| } |
| |
| } // namespace |
| |
| } // namespace i915 |