From: Harry Wentland <harry.wentland@amd.com>
To: dri-devel@lists.freedesktop.org
Subject: [PATCH 06/29] drm/amd/dal: Adapter Service
Date: Thu, 11 Feb 2016 12:19:46 -0500 [thread overview]
Message-ID: <1455211209-26733-7-git-send-email-harry.wentland@amd.com> (raw)
In-Reply-To: <1455211209-26733-1-git-send-email-harry.wentland@amd.com>
Provides information about ASIC features and capabilities. Also provides
access to ASIC resources such as VBIOS, GPIO and I2cAux Manager
Signed-off-by: Harry Wentland <harry.wentland@amd.com>
Reviewed-by: Alex Deucher <alexander.deucher@amd.com>
---
drivers/gpu/drm/amd/dal/dc/adapter/Makefile | 24 +
.../gpu/drm/amd/dal/dc/adapter/adapter_service.c | 2089 ++++++++++++++++++++
.../gpu/drm/amd/dal/dc/adapter/adapter_service.h | 71 +
.../adapter/dce110/hw_ctx_adapter_service_dce110.c | 304 +++
.../adapter/dce110/hw_ctx_adapter_service_dce110.h | 40 +
.../diagnostics/hw_ctx_adapter_service_diag.c | 133 ++
.../diagnostics/hw_ctx_adapter_service_diag.h | 33 +
.../amd/dal/dc/adapter/hw_ctx_adapter_service.c | 164 ++
.../amd/dal/dc/adapter/hw_ctx_adapter_service.h | 86 +
.../drm/amd/dal/dc/adapter/wireless_data_source.c | 208 ++
.../drm/amd/dal/dc/adapter/wireless_data_source.h | 80 +
11 files changed, 3232 insertions(+)
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/Makefile
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.c
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.h
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.c
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.h
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.c
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.h
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.c
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.h
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.c
create mode 100644 drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.h
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/Makefile b/drivers/gpu/drm/amd/dal/dc/adapter/Makefile
new file mode 100644
index 000000000000..2c6ca7a513bd
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/Makefile
@@ -0,0 +1,24 @@
+#
+# Makefile for the 'adapter' sub-component of DAL.
+# It provides the control and status of HW adapter.
+
+ADAPTER = adapter_service.o hw_ctx_adapter_service.o wireless_data_source.o
+
+AMD_DAL_ADAPTER = $(addprefix $(AMDDALPATH)/dc/adapter/,$(ADAPTER))
+
+AMD_DAL_FILES += $(AMD_DAL_ADAPTER)
+
+
+###############################################################################
+# DCE 11x
+###############################################################################
+
+ifdef CONFIG_DRM_AMD_DAL_DCE11_0
+AMD_DAL_FILES += $(AMDDALPATH)/dc/adapter/dce110/hw_ctx_adapter_service_dce110.o
+endif
+
+###############################################################################
+# FPGA Diagnositcs
+###############################################################################
+
+AMD_DAL_FILES += $(AMDDALPATH)/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.o
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.c b/drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.c
new file mode 100644
index 000000000000..dd2f931fe9a1
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.c
@@ -0,0 +1,2089 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#include "dm_services.h"
+
+#include "dc_bios_types.h"
+
+#include "include/adapter_service_interface.h"
+#include "include/i2caux_interface.h"
+#include "include/asic_capability_types.h"
+#include "include/gpio_service_interface.h"
+#include "include/asic_capability_interface.h"
+#include "include/logger_interface.h"
+
+#include "adapter_service.h"
+
+#include "hw_ctx_adapter_service.h"
+#include "wireless_data_source.h"
+
+#include "atom.h"
+
+#if defined(CONFIG_DRM_AMD_DAL_DCE11_0)
+#include "dce110/hw_ctx_adapter_service_dce110.h"
+#endif
+
+#include "diagnostics/hw_ctx_adapter_service_diag.h"
+
+/*
+ * Adapter service feature entry table.
+ *
+ * This is an array of features that is used to generate feature set. Each
+ * entry consists three element:
+ *
+ * Feature name, default value, and if this feature is a boolean type. A
+ * feature can only be a boolean or int type.
+ *
+ * Example 1: a boolean type feature
+ * FEATURE_ENABLE_HW_EDID_POLLING, false, true
+ *
+ * First element is feature name: EATURE_ENABLE_HW_EDID_POLLING, it has a
+ * default value 0, and it is a boolean feature.
+ *
+ * Example 2: an int type feature
+ * FEATURE_DCP_PROGRAMMING_WA, 0x1FF7, false
+ *
+ * In this case, the default value is 0x1FF7 and not a boolean type, which
+ * makes it an int type.
+ */
+
+static struct feature_source_entry feature_entry_table[] = {
+ /* Feature name | default value | is boolean type */
+ {FEATURE_ENABLE_HW_EDID_POLLING, false, true},
+ {FEATURE_DP_SINK_DETECT_POLL_DATA_PIN, false, true},
+ {FEATURE_UNDERFLOW_INTERRUPT, false, true},
+ {FEATURE_ALLOW_WATERMARK_ADJUSTMENT, false, true},
+ {FEATURE_LIGHT_SLEEP, false, true},
+ {FEATURE_DCP_DITHER_FRAME_RANDOM_ENABLE, false, true},
+ {FEATURE_DCP_DITHER_RGB_RANDOM_ENABLE, false, true},
+ {FEATURE_DCP_DITHER_HIGH_PASS_RANDOM_ENABLE, false, true},
+ {FEATURE_LINE_BUFFER_ENHANCED_PIXEL_DEPTH, false, true},
+ {FEATURE_MAXIMIZE_URGENCY_WATERMARKS, false, true},
+ {FEATURE_MAXIMIZE_STUTTER_MARKS, false, true},
+ {FEATURE_MAXIMIZE_NBP_MARKS, false, true},
+ /*
+ * We meet HW I2C issue when test S3 resume on KB.
+ * An EPR is created for debug the issue.
+ * Make Test has already been implemented
+ * with HW I2C. The work load for revert back to SW I2C in make test
+ * is big. Below is workaround for this issue.
+ * Driver uses SW I2C.
+ * Make Test uses HW I2C.
+ */
+ {FEATURE_RESTORE_USAGE_I2C_SW_ENGINE, false, true},
+ {FEATURE_USE_MAX_DISPLAY_CLK, false, true},
+ {FEATURE_ALLOW_EDP_RESOURCE_SHARING, false, true},
+ {FEATURE_SUPPORT_DP_YUV, false, true},
+ {FEATURE_SUPPORT_DP_Y_ONLY, false, true},
+ {FEATURE_DISABLE_DP_GTC_SYNC, true, true},
+ {FEATURE_MODIFY_TIMINGS_FOR_WIRELESS, false, true},
+ {FEATURE_DCP_BIT_DEPTH_REDUCTION_MODE, 0, false},
+ {FEATURE_DCP_DITHER_MODE, 0, false},
+ {FEATURE_DCP_PROGRAMMING_WA, 0, false},
+ {FEATURE_NO_HPD_LOW_POLLING_VCC_OFF, false, true},
+ {FEATURE_ENABLE_DFS_BYPASS, false, true},
+ {FEATURE_WIRELESS_FULL_TIMING_ADJUSTMENT, false, true},
+ {FEATURE_MAX_COFUNC_NON_DP_DISPLAYS, 2, false},
+ {FEATURE_WIRELESS_LIMIT_720P, false, true},
+ {FEATURE_MODIFY_TIMINGS_FOR_WIRELESS, false, true},
+ {FEATURE_SUPPORTED_HDMI_CONNECTION_NUM, 0, false},
+ {FEATURE_DETECT_REQUIRE_HPD_HIGH, false, true},
+ {FEATURE_NO_HPD_LOW_POLLING_VCC_OFF, false, true},
+ {FEATURE_LB_HIGH_RESOLUTION, false, true},
+ {FEATURE_MAX_CONTROLLER_NUM, 0, false},
+ {FEATURE_DRR_SUPPORT, AS_DRR_SUPPORT_ENABLED, false},
+ {FEATURE_STUTTER_MODE, 15, false},
+ {FEATURE_DP_DISPLAY_FORCE_SS_ENABLE, false, true},
+ {FEATURE_REPORT_CE_MODE_ONLY, false, true},
+ {FEATURE_ALLOW_OPTIMIZED_MODE_AS_DEFAULT, false, true},
+ {FEATURE_DDC_READ_FORCE_REPEATED_START, false, true},
+ {FEATURE_FORCE_TIMING_RESYNC, false, true},
+ {FEATURE_TMDS_DISABLE_DITHERING, false, true},
+ {FEATURE_HDMI_DISABLE_DITHERING, false, true},
+ {FEATURE_DP_DISABLE_DITHERING, false, true},
+ {FEATURE_EMBEDDED_DISABLE_DITHERING, true, true},
+ {FEATURE_ALLOW_SELF_REFRESH, false, true},
+ {FEATURE_ALLOW_DYNAMIC_PIXEL_ENCODING_CHANGE, false, true},
+ {FEATURE_ALLOW_HSYNC_VSYNC_ADJUSTMENT, false, true},
+ {FEATURE_FORCE_PSR, false, true},
+ {FEATURE_PSR_SETUP_TIME_TEST, 0, false},
+ {FEATURE_POWER_GATING_PIPE_IN_TILE, true, true},
+ {FEATURE_POWER_GATING_LB_PORTION, true, true},
+ {FEATURE_PREFER_3D_TIMING, false, true},
+ {FEATURE_VARI_BRIGHT_ENABLE, true, true},
+ {FEATURE_PSR_ENABLE, false, true},
+ {FEATURE_WIRELESS_ENABLE_COMPRESSED_AUDIO, false, true},
+ {FEATURE_WIRELESS_INCLUDE_UNVERIFIED_TIMINGS, true, true},
+ {FEATURE_EDID_STRESS_READ, false, true},
+ {FEATURE_DP_FRAME_PACK_STEREO3D, false, true},
+ {FEATURE_DISPLAY_PREFERRED_VIEW, 0, false},
+ {FEATURE_ALLOW_HDMI_WITHOUT_AUDIO, false, true},
+ {FEATURE_ABM_2_0, false, true},
+ {FEATURE_SUPPORT_MIRABILIS, false, true},
+ {FEATURE_OPTIMIZATION, 0xFFFF, false},
+ {FEATURE_PERF_MEASURE, 0, false},
+ {FEATURE_MIN_BACKLIGHT_LEVEL, 0, false},
+ {FEATURE_MAX_BACKLIGHT_LEVEL, 255, false},
+ {FEATURE_LOAD_DMCU_FIRMWARE, true, true},
+ {FEATURE_DISABLE_AZ_CLOCK_GATING, false, true},
+ {FEATURE_ENABLE_GPU_SCALING, false, true},
+ {FEATURE_DONGLE_SINK_COUNT_CHECK, true, true},
+ {FEATURE_INSTANT_UP_SCALE_DOWN_SCALE, false, true},
+ {FEATURE_TILED_DISPLAY, false, true},
+ {FEATURE_PREFERRED_ABM_CONFIG_SET, 0, false},
+ {FEATURE_CHANGE_SW_I2C_SPEED, 50, false},
+ {FEATURE_CHANGE_HW_I2C_SPEED, 50, false},
+ {FEATURE_CHANGE_I2C_SPEED_CONTROL, false, true},
+ {FEATURE_DEFAULT_PSR_LEVEL, 0, false},
+ {FEATURE_MAX_CLOCK_SOURCE_NUM, 0, false},
+ {FEATURE_REPORT_SINGLE_SELECTED_TIMING, false, true},
+ {FEATURE_ALLOW_HDMI_HIGH_CLK_DP_DONGLE, true, true},
+ {FEATURE_SUPPORT_EXTERNAL_PANEL_DRR, false, true},
+ {FEATURE_LVDS_SAFE_PIXEL_CLOCK_RANGE, 0, false},
+ {FEATURE_ABM_CONFIG, 0, false},
+ {FEATURE_WIRELESS_ENABLE, false, true},
+ {FEATURE_ALLOW_DIRECT_MEMORY_ACCESS_TRIG, false, true},
+ {FEATURE_FORCE_STATIC_SCREEN_EVENT_TRIGGERS, 0, false},
+ {FEATURE_USE_PPLIB, true, true},
+ {FEATURE_DISABLE_LPT_SUPPORT, false, true},
+ {FEATURE_DUMMY_FBC_BACKEND, false, true},
+ {FEATURE_DPMS_AUDIO_ENDPOINT_CONTROL, true, true},
+ {FEATURE_DISABLE_FBC_COMP_CLK_GATE, false, true},
+ {FEATURE_PIXEL_PERFECT_OUTPUT, false, true},
+ {FEATURE_8BPP_SUPPORTED, false, true}
+};
+
+
+/* Stores entire ASIC features by sets */
+uint32_t adapter_feature_set[FEATURE_MAXIMUM/32];
+
+enum {
+ LEGACY_MAX_NUM_OF_CONTROLLERS = 2,
+ DEFAULT_NUM_COFUNC_NON_DP_DISPLAYS = 2
+};
+
+/*
+ * get_feature_entries_num
+ *
+ * Get number of feature entries
+ */
+static inline uint32_t get_feature_entries_num(void)
+{
+ return ARRAY_SIZE(feature_entry_table);
+}
+
+static void get_platform_info_methods(
+ struct adapter_service *as)
+{
+ struct platform_info_params params;
+ uint32_t mask = 0;
+
+ params.data = &mask;
+ params.method = PM_GET_AVAILABLE_METHODS;
+
+ if (dm_get_platform_info(as->ctx, ¶ms))
+ as->platform_methods_mask = mask;
+
+
+}
+
+static void initialize_backlight_caps(
+ struct adapter_service *as)
+{
+ struct firmware_info fw_info;
+ struct embedded_panel_info panel_info;
+ struct platform_info_ext_brightness_caps caps;
+ struct platform_info_params params;
+ bool custom_curve_present = false;
+ bool custom_min_max_present = false;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (!(PM_GET_EXTENDED_BRIGHNESS_CAPS & as->platform_methods_mask)) {
+ dal_logger_write(as->ctx->logger,
+ LOG_MAJOR_BACKLIGHT,
+ LOG_MINOR_BACKLIGHT_BRIGHTESS_CAPS,
+ "This method is not supported\n");
+ return;
+ }
+
+ if (dcb->funcs->get_firmware_info(dcb, &fw_info) != BP_RESULT_OK ||
+ dcb->funcs->get_embedded_panel_info(dcb, &panel_info) != BP_RESULT_OK)
+ return;
+
+ params.data = ∩︀
+ params.method = PM_GET_EXTENDED_BRIGHNESS_CAPS;
+
+ if (dm_get_platform_info(as->ctx, ¶ms)) {
+ as->ac_level_percentage = caps.basic_caps.ac_level_percentage;
+ as->dc_level_percentage = caps.basic_caps.dc_level_percentage;
+ custom_curve_present = (caps.data_points_num > 0);
+ custom_min_max_present = true;
+ } else
+ return;
+ /* Choose minimum backlight level base on priority:
+ * extended caps,VBIOS,default */
+ if (custom_min_max_present)
+ as->backlight_8bit_lut[0] = caps.min_input_signal;
+
+ else if (fw_info.min_allowed_bl_level > 0)
+ as->backlight_8bit_lut[0] = fw_info.min_allowed_bl_level;
+
+ else
+ as->backlight_8bit_lut[0] = DEFAULT_MIN_BACKLIGHT;
+
+ /* Choose maximum backlight level base on priority:
+ * extended caps,default */
+ if (custom_min_max_present)
+ as->backlight_8bit_lut[100] = caps.max_input_signal;
+
+ else
+ as->backlight_8bit_lut[100] = DEFAULT_MAX_BACKLIGHT;
+
+ if (as->backlight_8bit_lut[100] > ABSOLUTE_BACKLIGHT_MAX)
+ as->backlight_8bit_lut[100] = ABSOLUTE_BACKLIGHT_MAX;
+
+ if (as->backlight_8bit_lut[0] > as->backlight_8bit_lut[100])
+ as->backlight_8bit_lut[0] = as->backlight_8bit_lut[100];
+
+ if (custom_curve_present) {
+ uint16_t index = 1;
+ uint16_t i;
+ uint16_t num_of_data_points = (caps.data_points_num <= 99 ?
+ caps.data_points_num : 99);
+ /* Filling translation table from data points -
+ * between every two provided data points we
+ * lineary interpolate missing values
+ */
+ for (i = 0 ; i < num_of_data_points; i++) {
+ uint16_t luminance = caps.data_points[i].luminance;
+ uint16_t signal_level =
+ caps.data_points[i].signal_level;
+
+ if (signal_level < as->backlight_8bit_lut[0])
+ signal_level = as->backlight_8bit_lut[0];
+
+ if (signal_level > as->backlight_8bit_lut[100])
+ signal_level = as->backlight_8bit_lut[100];
+
+ /* Lineary interpolate missing values */
+ if (index < luminance) {
+ uint16_t base_value =
+ as->backlight_8bit_lut[index-1];
+ uint16_t delta_signal =
+ signal_level - base_value;
+ uint16_t delta_luma = luminance - index + 1;
+ uint16_t step = delta_signal;
+
+ for (; index < luminance ; index++) {
+ as->backlight_8bit_lut[index] =
+ base_value +
+ (step / delta_luma);
+ step += delta_signal;
+ }
+ }
+ /* Now [index == luminance], so we can add
+ * data point to the translation table */
+ as->backlight_8bit_lut[index++] = signal_level;
+ }
+ /* Complete the final segment of interpolation -
+ * between last datapoint and maximum value */
+ if (index < 100) {
+ uint16_t base_value = as->backlight_8bit_lut[index-1];
+ uint16_t delta_signal =
+ as->backlight_8bit_lut[100]-base_value;
+ uint16_t delta_luma = 100 - index + 1;
+ uint16_t step = delta_signal;
+
+ for (; index < 100 ; index++) {
+ as->backlight_8bit_lut[index] = base_value +
+ (step / delta_luma);
+ step += delta_signal;
+ }
+ }
+ }
+ /* build backlight translation table based on default curve */
+ else {
+ /* Default backlight curve can be defined by
+ * polinomial F(x) = A(x*x) + Bx + C.
+ * Backlight curve should always satisfy
+ * F(0) = min, F(100) = max, so polinomial coefficients are:
+ * A is 0.0255 - B/100 - min/10000 -
+ * (255-max)/10000 = (max - min)/10000 - B/100
+ * B is adjustable factor to modify the curve.
+ * Bigger B results in less concave curve.
+ * B range is [0..(max-min)/100]
+ * C is backlight minimum
+ */
+ uint16_t delta = as->backlight_8bit_lut[100] -
+ as->backlight_8bit_lut[0];
+ uint16_t coeffc = as->backlight_8bit_lut[0];
+ uint16_t coeffb = (BACKLIGHT_CURVE_COEFFB < delta ?
+ BACKLIGHT_CURVE_COEFFB : delta);
+ uint16_t coeffa = delta - coeffb;
+ uint16_t i;
+ uint32_t temp;
+
+ for (i = 1; i < 100 ; i++) {
+ temp = (coeffa * i * i) / BACKLIGHT_CURVE_COEFFA_FACTOR;
+ as->backlight_8bit_lut[i] = temp + (coeffb * i) /
+ BACKLIGHT_CURVE_COEFFB_FACTOR + coeffc;
+ }
+ }
+ as->backlight_caps_initialized = true;
+}
+
+static void log_overriden_features(
+ struct adapter_service *as,
+ const char *feature_name,
+ enum adapter_feature_id id,
+ bool bool_feature,
+ uint32_t value)
+{
+ if (bool_feature)
+ dal_logger_write(as->ctx->logger,
+ LOG_MAJOR_FEATURE_OVERRIDE,
+ LOG_MINOR_FEATURE_OVERRIDE,
+ "Overridden %s is %s now\n",
+ feature_name,
+ (value == 0) ? "disabled" : "enabled");
+ else
+ dal_logger_write(as->ctx->logger,
+ LOG_MAJOR_FEATURE_OVERRIDE,
+ LOG_MINOR_FEATURE_OVERRIDE,
+ "Overridden %s new value: %d\n",
+ feature_name,
+ value);
+}
+
+/*************************************
+ * Local static functions definition *
+ *************************************/
+
+#define check_bool_feature(feature) \
+case FEATURE_ ## feature: \
+ if (param->bool_param_enable_mask & \
+ (1 << DAL_PARAM_ ## feature)) { \
+ *data = param->bool_param_values & \
+ (1 << DAL_PARAM_ ## feature); \
+ ret = true; \
+ feature_name = "FEATURE_" #feature; \
+ } \
+ break
+
+#define check_int_feature(feature) \
+case FEATURE_ ## feature: \
+ if (param->int_param_values[DAL_PARAM_ ## feature] != \
+ DAL_PARAM_INVALID_INT) { \
+ *data = param->int_param_values[DAL_PARAM_ ## feature];\
+ ret = true;\
+ bool_feature = false;\
+ feature_name = "FEATURE_" #feature;\
+ } \
+ break
+
+/*
+ * override_default_parameters
+ *
+ * Override features (from runtime parameter)
+ * corresponding to Adapter Service Feature ID
+ */
+static bool override_default_parameters(
+ struct adapter_service *as,
+ const struct dal_override_parameters *param,
+ const uint32_t idx,
+ uint32_t *data)
+{
+ bool ret = false;
+ bool bool_feature = true;
+ char *feature_name;
+
+ if (idx >= get_feature_entries_num()) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ switch (feature_entry_table[idx].feature_id) {
+ check_int_feature(MAX_COFUNC_NON_DP_DISPLAYS);
+ check_int_feature(DRR_SUPPORT);
+ check_bool_feature(LIGHT_SLEEP);
+ check_bool_feature(MAXIMIZE_STUTTER_MARKS);
+ check_bool_feature(MAXIMIZE_URGENCY_WATERMARKS);
+ check_bool_feature(USE_MAX_DISPLAY_CLK);
+ check_bool_feature(ENABLE_DFS_BYPASS);
+ check_bool_feature(POWER_GATING_PIPE_IN_TILE);
+ check_bool_feature(POWER_GATING_LB_PORTION);
+ check_bool_feature(PSR_ENABLE);
+ check_bool_feature(VARI_BRIGHT_ENABLE);
+ check_bool_feature(USE_PPLIB);
+ check_bool_feature(DISABLE_LPT_SUPPORT);
+ check_bool_feature(DUMMY_FBC_BACKEND);
+ check_bool_feature(ENABLE_GPU_SCALING);
+ default:
+ return false;
+ }
+ if (ret)
+ log_overriden_features(
+ as,
+ feature_name,
+ feature_entry_table[idx].feature_id,
+ bool_feature,
+ *data);
+
+ return ret;
+}
+
+/*
+ * get_feature_value_from_data_sources
+ *
+ * For a given feature, determine its value from ASIC cap and wireless
+ * data source.
+ * idx : index of feature_entry_table for the feature id.
+ */
+static bool get_feature_value_from_data_sources(
+ const struct adapter_service *as,
+ const uint32_t idx,
+ uint32_t *data)
+{
+ if (idx >= get_feature_entries_num()) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ switch (feature_entry_table[idx].feature_id) {
+ case FEATURE_MAX_COFUNC_NON_DP_DISPLAYS:
+ *data = as->asic_cap->data[ASIC_DATA_MAX_COFUNC_NONDP_DISPLAYS];
+ break;
+
+ case FEATURE_WIRELESS_LIMIT_720P:
+ *data = as->asic_cap->caps.WIRELESS_LIMIT_TO_720P;
+ break;
+
+ case FEATURE_WIRELESS_FULL_TIMING_ADJUSTMENT:
+ *data = as->asic_cap->caps.WIRELESS_FULL_TIMING_ADJUSTMENT;
+ break;
+
+ case FEATURE_MODIFY_TIMINGS_FOR_WIRELESS:
+ *data = as->asic_cap->caps.WIRELESS_TIMING_ADJUSTMENT;
+ break;
+
+ case FEATURE_SUPPORTED_HDMI_CONNECTION_NUM:
+ *data =
+ as->asic_cap->data[ASIC_DATA_SUPPORTED_HDMI_CONNECTION_NUM];
+ break;
+
+ case FEATURE_DETECT_REQUIRE_HPD_HIGH:
+ *data = as->asic_cap->caps.HPD_CHECK_FOR_EDID;
+ break;
+
+ case FEATURE_NO_HPD_LOW_POLLING_VCC_OFF:
+ *data = as->asic_cap->caps.NO_VCC_OFF_HPD_POLLING;
+ break;
+
+ case FEATURE_STUTTER_MODE:
+ *data = as->asic_cap->data[ASIC_DATA_STUTTERMODE];
+ break;
+
+ case FEATURE_WIRELESS_ENABLE:
+ *data = as->wireless_data.wireless_enable;
+ break;
+
+ case FEATURE_8BPP_SUPPORTED:
+ *data = as->asic_cap->caps.SUPPORT_8BPP;
+ break;
+
+ default:
+ return false;
+ }
+
+ return true;
+}
+
+/* get_bool_value
+ *
+ * Get the boolean value of a given feature
+ */
+static bool get_bool_value(
+ const uint32_t set,
+ const uint32_t idx)
+{
+ if (idx >= 32) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ return ((set & (1 << idx)) != 0);
+}
+
+/*
+ * get_hpd_info
+ *
+ * Get HPD information from BIOS
+ */
+static bool get_hpd_info(struct adapter_service *as,
+ struct graphics_object_id id,
+ struct graphics_object_hpd_info *info)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ return BP_RESULT_OK == dcb->funcs->get_hpd_info(dcb, id, info);
+}
+
+/*
+ * lookup_feature_entry
+ *
+ * Find the entry index of a given feature in feature table
+ */
+static uint32_t lookup_feature_entry(
+ enum adapter_feature_id feature_id)
+{
+ uint32_t entries_num = get_feature_entries_num();
+ uint32_t i = 0;
+
+ while (i != entries_num) {
+ if (feature_entry_table[i].feature_id == feature_id)
+ break;
+
+ ++i;
+ }
+
+ return i;
+}
+
+/*
+ * set_bool_value
+ *
+ * Set the boolean value of a given feature
+ */
+static void set_bool_value(
+ uint32_t *set,
+ const uint32_t idx,
+ bool value)
+{
+ if (idx >= 32) {
+ ASSERT_CRITICAL(false);
+ return;
+ }
+
+ if (value)
+ *set |= (1 << idx);
+ else
+ *set &= ~(1 << idx);
+}
+
+/*
+ * generate_feature_set
+ *
+ * Generate the internal feature set from multiple data sources
+ */
+static bool generate_feature_set(
+ struct adapter_service *as,
+ const struct dal_override_parameters *param)
+{
+ uint32_t i = 0;
+ uint32_t value = 0;
+ uint32_t set_idx = 0;
+ uint32_t internal_idx = 0;
+ uint32_t entry_num = 0;
+ const struct feature_source_entry *entry = NULL;
+
+ dm_memset(adapter_feature_set, 0, sizeof(adapter_feature_set));
+ entry_num = get_feature_entries_num();
+
+
+ while (i != entry_num) {
+ entry = &feature_entry_table[i];
+
+ if (entry->feature_id <= FEATURE_UNKNOWN ||
+ entry->feature_id >= FEATURE_MAXIMUM) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ set_idx = (uint32_t)((entry->feature_id - 1) / 32);
+ internal_idx = (uint32_t)((entry->feature_id - 1) % 32);
+
+ /* TODO: wireless, runtime parameter, vbios */
+ if (!override_default_parameters(as, param, i, &value)) {
+ if (!get_feature_value_from_data_sources(
+ as, i, &value)) {
+ /*
+ * Can't find feature values from
+ * above data sources
+ * Assign default value
+ */
+ value = entry->default_value;
+ }
+ }
+
+ if (entry->is_boolean_type)
+ set_bool_value(&adapter_feature_set[set_idx],
+ internal_idx,
+ value != 0);
+ else
+ adapter_feature_set[set_idx] = value;
+
+ i++;
+ }
+
+ return true;
+}
+
+
+/*
+ * create_hw_ctx
+ *
+ * Create HW context for adapter service. This is DCE specific.
+ */
+static struct hw_ctx_adapter_service *create_hw_ctx(
+ enum dce_version dce_version,
+ enum dce_environment dce_environment,
+ struct dc_context *ctx)
+{
+ if (IS_FPGA_MAXIMUS_DC(dce_environment))
+ return dal_adapter_service_create_hw_ctx_diag(ctx);
+
+ switch (dce_version) {
+#if defined(CONFIG_DRM_AMD_DAL_DCE10_0)
+ case DCE_VERSION_10_0:
+ return dal_adapter_service_create_hw_ctx_dce110(ctx);
+#endif
+#if defined(CONFIG_DRM_AMD_DAL_DCE11_0)
+ case DCE_VERSION_11_0:
+ return dal_adapter_service_create_hw_ctx_dce110(ctx);
+#endif
+ default:
+ ASSERT_CRITICAL(false);
+ return NULL;
+ }
+}
+
+/*
+ * adapter_service_destruct
+ *
+ * Release memory of objects in adapter service
+ */
+static void adapter_service_destruct(
+ struct adapter_service *as)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ dal_adapter_service_destroy_hw_ctx(&as->hw_ctx);
+ dal_i2caux_destroy(&as->i2caux);
+ dal_gpio_service_destroy(&as->gpio_service);
+ dal_asic_capability_destroy(&as->asic_cap);
+
+ dcb->funcs->destroy_integrated_info(dcb, &as->integrated_info);
+
+ if (as->dcb_internal) {
+ /* We are responsible only for destruction of Internal BIOS.
+ * The External one will be destroyed by its creator. */
+ dal_bios_parser_destroy(&as->dcb_internal);
+ }
+}
+
+/*
+ * adapter_service_construct
+ *
+ * Construct the derived type of adapter service
+ */
+static bool adapter_service_construct(
+ struct adapter_service *as,
+ struct as_init_data *init_data)
+{
+ struct dc_bios *dcb;
+ enum dce_version dce_version;
+
+ if (!init_data)
+ return false;
+
+ /* Create ASIC capability */
+ as->ctx = init_data->ctx;
+ as->asic_cap = dal_asic_capability_create(
+ &init_data->hw_init_data, as->ctx);
+
+ if (!as->asic_cap) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+#if defined(CONFIG_DRM_AMD_DAL_DCE11_0)
+ if (dal_adapter_service_get_dce_version(as) == DCE_VERSION_11_0) {
+ uint32_t i;
+
+ for (i = 0; i < ARRAY_SIZE(feature_entry_table); i++) {
+ enum adapter_feature_id id =
+ feature_entry_table[i].feature_id;
+ if (id == FEATURE_MAXIMIZE_URGENCY_WATERMARKS ||
+ id == FEATURE_MAXIMIZE_STUTTER_MARKS ||
+ id == FEATURE_MAXIMIZE_NBP_MARKS)
+ feature_entry_table[i].default_value = true;
+ }
+ }
+#endif
+
+ /* Generate feature set table */
+ if (!generate_feature_set(as, init_data->display_param)) {
+ ASSERT_CRITICAL(false);
+ goto failed_to_generate_features;
+ }
+
+ as->dce_environment = init_data->dce_environment;
+
+ if (init_data->vbios_override)
+ as->dcb_override = init_data->vbios_override;
+ else {
+ /* Create BIOS parser */
+ init_data->bp_init_data.ctx = init_data->ctx;
+
+ as->dcb_internal = dal_bios_parser_create(
+ &init_data->bp_init_data, as);
+
+ if (!as->dcb_internal) {
+ ASSERT_CRITICAL(false);
+ goto failed_to_create_bios_parser;
+ }
+ }
+
+ dcb = dal_adapter_service_get_bios_parser(as);
+
+ dce_version = dal_adapter_service_get_dce_version(as);
+
+ /* Create GPIO service */
+ as->gpio_service = dal_gpio_service_create(
+ dce_version,
+ as->dce_environment,
+ as->ctx);
+
+ if (!as->gpio_service) {
+ ASSERT_CRITICAL(false);
+ goto failed_to_create_gpio_service;
+ }
+
+ /* Create I2C AUX */
+ as->i2caux = dal_i2caux_create(as, as->ctx);
+
+ if (!as->i2caux) {
+ ASSERT_CRITICAL(false);
+ goto failed_to_create_i2caux;
+ }
+
+ /* Create Adapter Service HW Context*/
+ as->hw_ctx = create_hw_ctx(
+ dce_version,
+ as->dce_environment,
+ as->ctx);
+
+ if (!as->hw_ctx) {
+ ASSERT_CRITICAL(false);
+ goto failed_to_create_hw_ctx;
+ }
+
+ /* Avoid wireless encoder creation in upstream branch. */
+
+ /* Integrated info is not provided on discrete ASIC. NULL is allowed */
+ as->integrated_info = dcb->funcs->create_integrated_info(dcb);
+
+ dcb->funcs->post_init(dcb);
+
+ /* Generate backlight translation table and initializes
+ other brightness properties */
+ as->backlight_caps_initialized = false;
+
+ get_platform_info_methods(as);
+
+ initialize_backlight_caps(as);
+
+ return true;
+
+failed_to_generate_features:
+ dal_adapter_service_destroy_hw_ctx(&as->hw_ctx);
+
+failed_to_create_hw_ctx:
+ dal_i2caux_destroy(&as->i2caux);
+
+failed_to_create_i2caux:
+ dal_gpio_service_destroy(&as->gpio_service);
+
+failed_to_create_gpio_service:
+ if (as->dcb_internal)
+ dal_bios_parser_destroy(&as->dcb_internal);
+
+failed_to_create_bios_parser:
+ dal_asic_capability_destroy(&as->asic_cap);
+
+ return false;
+}
+
+/*
+ * Global function definition
+ */
+
+/*
+ * dal_adapter_service_create
+ *
+ * Create adapter service
+ */
+struct adapter_service *dal_adapter_service_create(
+ struct as_init_data *init_data)
+{
+ struct adapter_service *as;
+
+ as = dm_alloc(init_data->ctx, sizeof(struct adapter_service));
+
+ if (!as) {
+ ASSERT_CRITICAL(false);
+ return NULL;
+ }
+
+ if (adapter_service_construct(as, init_data))
+ return as;
+
+ ASSERT_CRITICAL(false);
+
+ dm_free(init_data->ctx, as);
+
+ return NULL;
+}
+
+/*
+ * dal_adapter_service_destroy
+ *
+ * Destroy adapter service and objects it contains
+ */
+void dal_adapter_service_destroy(
+ struct adapter_service **as)
+{
+ if (!as) {
+ ASSERT_CRITICAL(false);
+ return;
+ }
+
+ if (!*as) {
+ ASSERT_CRITICAL(false);
+ return;
+ }
+
+ adapter_service_destruct(*as);
+
+ dm_free((*as)->ctx, *as);
+
+ *as = NULL;
+}
+
+/*
+ * dal_adapter_service_get_dce_version
+ *
+ * Get the DCE version of current ASIC
+ */
+enum dce_version dal_adapter_service_get_dce_version(
+ const struct adapter_service *as)
+{
+ uint32_t version = as->asic_cap->data[ASIC_DATA_DCE_VERSION];
+
+ switch (version) {
+#if defined(CONFIG_DRM_AMD_DAL_DCE10_0)
+ case 0x100:
+ return DCE_VERSION_10_0;
+#endif
+#if defined(CONFIG_DRM_AMD_DAL_DCE11_0)
+ case 0x110:
+ return DCE_VERSION_11_0;
+#endif
+ default:
+ ASSERT_CRITICAL(false);
+ return DCE_VERSION_UNKNOWN;
+ }
+}
+
+enum dce_environment dal_adapter_service_get_dce_environment(
+ const struct adapter_service *as)
+{
+ return as->dce_environment;
+}
+
+
+/*
+ * dal_adapter_service_get_controllers_num
+ *
+ * Get number of controllers
+ */
+uint8_t dal_adapter_service_get_controllers_num(
+ struct adapter_service *as)
+{
+ uint32_t result = as->asic_cap->data[ASIC_DATA_CONTROLLERS_NUM];
+
+ /* Check the "max num of controllers" feature,
+ * use it for debugging purposes only */
+ /* TODO implement
+ * dal_adapter_service_get_feature_value(as, ) */
+
+ return result;
+}
+
+/** Get total number of connectors.
+ *
+ * \param as Adapter Service
+ *
+ * \return Total number of connectors. It is up-to-the caller to decide
+ * if the number is valid.
+ */
+uint8_t dal_adapter_service_get_connectors_num(
+ struct adapter_service *as)
+{
+ uint8_t vbios_connectors_num = 0;
+ uint8_t wireless_connectors_num = 0;
+ struct dc_bios *dcb;
+
+ dcb = dal_adapter_service_get_bios_parser(as);
+
+ vbios_connectors_num = dcb->funcs->get_connectors_number(dcb);
+
+ wireless_connectors_num = wireless_get_connectors_num(as);
+
+ return vbios_connectors_num + wireless_connectors_num;
+}
+
+static bool is_wireless_object(struct graphics_object_id id)
+{
+ if ((id.type == OBJECT_TYPE_ENCODER &&
+ id.id == ENCODER_ID_INTERNAL_WIRELESS) ||
+ (id.type == OBJECT_TYPE_CONNECTOR && id.id ==
+ CONNECTOR_ID_WIRELESS) ||
+ (id.type == OBJECT_TYPE_CONNECTOR && id.id ==
+ CONNECTOR_ID_MIRACAST))
+ return true;
+ return false;
+}
+
+/**
+ * Get the number of source objects of an object
+ *
+ * \param [in] as: Adapter Service
+ *
+ * \param [in] id: The graphics object id
+ *
+ * \return
+ * The number of the source objects of an object
+ */
+uint32_t dal_adapter_service_get_src_num(
+ struct adapter_service *as, struct graphics_object_id id)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (is_wireless_object(id))
+ return wireless_get_srcs_num(as, id);
+ else
+ return dcb->funcs->get_src_number(dcb, id);
+}
+
+/**
+ * Get the source objects of an object
+ *
+ * \param [in] id The graphics object id
+ * \param [in] index Enumerating index which starts at 0
+ *
+ * \return If enumerating successfully, return the VALID source object id,
+ * otherwise, returns "zeroed out" object id.
+ * Client should call dal_graphics_object_id_is_valid() to check
+ * weather the id is valid.
+ */
+struct graphics_object_id dal_adapter_service_get_src_obj(
+ struct adapter_service *as,
+ struct graphics_object_id id,
+ uint32_t index)
+{
+ struct graphics_object_id src_object_id;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (is_wireless_object(id))
+ src_object_id = wireless_get_src_obj_id(as, id, index);
+ else {
+ if (BP_RESULT_OK != dcb->funcs->get_src_obj(dcb, id, index,
+ &src_object_id)) {
+ src_object_id =
+ dal_graphics_object_id_init(
+ 0,
+ ENUM_ID_UNKNOWN,
+ OBJECT_TYPE_UNKNOWN);
+ }
+ }
+
+ return src_object_id;
+}
+
+/** Get connector object id associated with a connector index.
+ *
+ * \param as Adapter Service
+ *
+ * \param connector_index Index of connector between zero and total number
+ * returned by dal_adapter_service_get_connectors_num()
+ *
+ * \return graphics object id corresponding to the connector_index.
+ */
+struct graphics_object_id dal_adapter_service_get_connector_obj_id(
+ struct adapter_service *as,
+ uint8_t connector_index)
+{
+ struct dc_bios *dcb;
+ uint8_t bios_connectors_num;
+
+ dcb = dal_adapter_service_get_bios_parser(as);
+
+ bios_connectors_num = dcb->funcs->get_connectors_number(dcb);
+
+ if (connector_index >= bios_connectors_num)
+ return wireless_get_connector_id(as, connector_index);
+ else
+ return dcb->funcs->get_connector_id(dcb, connector_index);
+}
+
+bool dal_adapter_service_get_device_tag(
+ struct adapter_service *as,
+ struct graphics_object_id connector_object_id,
+ uint32_t device_tag_index,
+ struct connector_device_tag_info *info)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (BP_RESULT_OK == dcb->funcs->get_device_tag(dcb,
+ connector_object_id, device_tag_index, info))
+ return true;
+ else
+ return false;
+}
+
+/* Check if DeviceId is supported by ATOM_OBJECT_HEADER support info */
+bool dal_adapter_service_is_device_id_supported(struct adapter_service *as,
+ struct device_id id)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ return dcb->funcs->is_device_id_supported(dcb, id);
+}
+
+bool dal_adapter_service_is_meet_underscan_req(struct adapter_service *as)
+{
+ struct firmware_info fw_info;
+ enum bp_result bp_result = dal_adapter_service_get_firmware_info(
+ as, &fw_info);
+ uint32_t disp_clk_limit =
+ as->asic_cap->data[ASIC_DATA_MIN_DISPCLK_FOR_UNDERSCAN];
+ if (BP_RESULT_OK == bp_result) {
+ dal_logger_write(as->ctx->logger,
+ LOG_MAJOR_ERROR,
+ LOG_MINOR_COMPONENT_ADAPTER_SERVICE,
+ "Read firmware is NULL");
+ return false;
+ }
+ if (fw_info.default_display_engine_pll_frequency < disp_clk_limit)
+ return false;
+ return true;
+}
+
+bool dal_adapter_service_underscan_for_hdmi_only(struct adapter_service *as)
+{
+ return as->asic_cap->caps.UNDERSCAN_FOR_HDMI_ONLY;
+}
+/*
+ * dal_adapter_service_get_clock_sources_num
+ *
+ * Get number of clock sources
+ */
+uint8_t dal_adapter_service_get_clock_sources_num(
+ struct adapter_service *as)
+{
+ struct firmware_info fw_info;
+ uint32_t max_clk_src = 0;
+ uint32_t num = as->asic_cap->data[ASIC_DATA_CLOCKSOURCES_NUM];
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ /*
+ * Check is system supports the use of the External clock source
+ * as a clock source for DP
+ */
+ enum bp_result bp_result = dcb->funcs->get_firmware_info(dcb, &fw_info);
+
+ if (BP_RESULT_OK == bp_result &&
+ fw_info.external_clock_source_frequency_for_dp != 0)
+ ++num;
+
+ /*
+ * Add clock source for wireless if supported
+ */
+ num += (uint32_t)wireless_get_clocks_num(as);
+
+ /* Check the "max number of clock sources" feature */
+ if (dal_adapter_service_get_feature_value(
+ FEATURE_MAX_CLOCK_SOURCE_NUM,
+ &max_clk_src,
+ sizeof(uint32_t)))
+ if ((max_clk_src != 0) && (max_clk_src < num))
+ num = max_clk_src;
+
+ return num;
+}
+
+/*
+ * dal_adapter_service_get_func_controllers_num
+ *
+ * Get number of controllers
+ */
+uint8_t dal_adapter_service_get_func_controllers_num(
+ struct adapter_service *as)
+{
+ uint32_t result =
+ as->asic_cap->data[ASIC_DATA_FUNCTIONAL_CONTROLLERS_NUM];
+
+ /* Check the "max num of controllers" feature,
+ * use it for debugging purposes only */
+
+ /* Limit number of controllers by OS */
+
+ struct asic_feature_flags flags;
+
+ flags.raw = as->asic_cap->data[ASIC_DATA_FEATURE_FLAGS];
+
+ if (flags.bits.LEGACY_CLIENT &&
+ (result > LEGACY_MAX_NUM_OF_CONTROLLERS))
+ result = LEGACY_MAX_NUM_OF_CONTROLLERS;
+
+ return result;
+}
+
+/*
+ * dal_adapter_service_is_feature_supported
+ *
+ * Return if a given feature is supported by the ASIC. The feature has to be
+ * a boolean type.
+ */
+bool dal_adapter_service_is_feature_supported(
+ enum adapter_feature_id feature_id)
+{
+ bool data = 0;
+
+ dal_adapter_service_get_feature_value(feature_id, &data, sizeof(bool));
+
+ return data;
+}
+
+/**
+ * Reports maximum number of confunctional non-DP displays.
+ * Value can be overriden if FEATURE_REPORT_SINGLE_SELECTED_TIMING feature is
+ * enabled.
+ *
+ * \return
+ * Maximum number of confunctional non-DP displays
+ */
+uint32_t dal_adapter_service_get_max_cofunc_non_dp_displays(void)
+{
+ uint32_t non_dp_displays = DEFAULT_NUM_COFUNC_NON_DP_DISPLAYS;
+
+ if (true == dal_adapter_service_get_feature_value(
+ FEATURE_MAX_COFUNC_NON_DP_DISPLAYS,
+ &non_dp_displays,
+ sizeof(non_dp_displays))) {
+ /* the cached value exist */
+ /* TODO: add more logic as per-DAL2 */
+ }
+
+ return non_dp_displays;
+}
+
+uint32_t dal_adapter_service_get_single_selected_timing_signals(void)
+{
+ uint32_t signals_bitmap = 0;
+
+ if (dal_adapter_service_is_feature_supported(
+ FEATURE_REPORT_SINGLE_SELECTED_TIMING)) {
+ /* the cached value exist */
+ /* TODO: add more logic as per-DAL2 */
+ signals_bitmap = 0;
+ }
+
+ return signals_bitmap;
+}
+
+/*
+ * dal_adapter_service_get_i2c_info
+ *
+ * Get I2C information from BIOS
+ */
+bool dal_adapter_service_get_i2c_info(
+ struct adapter_service *as,
+ struct graphics_object_id id,
+ struct graphics_object_i2c_info *i2c_info)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (!i2c_info) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ return BP_RESULT_OK == dcb->funcs->get_i2c_info(dcb, id, i2c_info);
+}
+
+/*
+ * dal_adapter_service_obtain_ddc
+ *
+ * Obtain DDC
+ */
+struct ddc *dal_adapter_service_obtain_ddc(
+ struct adapter_service *as,
+ struct graphics_object_id id)
+{
+ struct graphics_object_i2c_info i2c_info;
+ struct gpio_ddc_hw_info hw_info;
+
+
+ if (!dal_adapter_service_get_i2c_info(as, id, &i2c_info))
+ return NULL;
+
+ hw_info.ddc_channel = i2c_info.i2c_line;
+ hw_info.hw_supported = i2c_info.i2c_hw_assist;
+
+ return dal_gpio_service_create_ddc(
+ as->gpio_service,
+ i2c_info.gpio_info.clk_a_register_index,
+ 1 << i2c_info.gpio_info.clk_a_shift,
+ &hw_info);
+}
+
+/*
+ * dal_adapter_service_release_ddc
+ *
+ * Release DDC
+ */
+void dal_adapter_service_release_ddc(
+ struct adapter_service *as,
+ struct ddc *ddc)
+{
+ dal_gpio_service_destroy_ddc(&ddc);
+}
+
+/*
+ * dal_adapter_service_obtain_hpd_irq
+ *
+ * Obtain HPD interrupt request
+ */
+struct irq *dal_adapter_service_obtain_hpd_irq(
+ struct adapter_service *as,
+ struct graphics_object_id id)
+{
+ enum bp_result bp_result;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+ struct graphics_object_hpd_info hpd_info;
+ struct gpio_pin_info pin_info;
+
+ if (!get_hpd_info(as, id, &hpd_info))
+ return NULL;
+
+ bp_result = dcb->funcs->get_gpio_pin_info(dcb,
+ hpd_info.hpd_int_gpio_uid, &pin_info);
+
+ if (bp_result != BP_RESULT_OK) {
+ ASSERT(bp_result == BP_RESULT_NORECORD);
+ return NULL;
+ }
+
+ return dal_gpio_service_create_irq(
+ as->gpio_service,
+ pin_info.offset,
+ pin_info.mask);
+}
+
+/*
+ * dal_adapter_service_release_irq
+ *
+ * Release interrupt request
+ */
+void dal_adapter_service_release_irq(
+ struct adapter_service *as,
+ struct irq *irq)
+{
+ dal_gpio_service_destroy_irq(&irq);
+}
+
+/*
+ * dal_adapter_service_get_ss_info_num
+ *
+ * Get number of spread spectrum entries from BIOS
+ */
+uint32_t dal_adapter_service_get_ss_info_num(
+ struct adapter_service *as,
+ enum as_signal_type signal)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ return dcb->funcs->get_ss_entry_number(dcb, signal);
+}
+
+/*
+ * dal_adapter_service_get_ss_info
+ *
+ * Get spread spectrum info from BIOS
+ */
+bool dal_adapter_service_get_ss_info(
+ struct adapter_service *as,
+ enum as_signal_type signal,
+ uint32_t idx,
+ struct spread_spectrum_info *info)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ enum bp_result bp_result = dcb->funcs->get_spread_spectrum_info(dcb,
+ signal, idx, info);
+
+ return BP_RESULT_OK == bp_result;
+}
+
+/*
+ * dal_adapter_service_get_integrated_info
+ *
+ * Get integrated information on BIOS
+ */
+bool dal_adapter_service_get_integrated_info(
+ struct adapter_service *as,
+ struct integrated_info *info)
+{
+ if (info == NULL || as->integrated_info == NULL)
+ return false;
+
+ dm_memmove(info, as->integrated_info, sizeof(struct integrated_info));
+
+ return true;
+}
+
+/*
+ * dal_adapter_service_is_dfs_bypass_enabled
+ *
+ * Check if DFS bypass is enabled
+ */
+bool dal_adapter_service_is_dfs_bypass_enabled(
+ struct adapter_service *as)
+{
+ if (as->integrated_info == NULL)
+ return false;
+ if ((as->integrated_info->gpu_cap_info & DFS_BYPASS_ENABLE) &&
+ dal_adapter_service_is_feature_supported(
+ FEATURE_ENABLE_DFS_BYPASS))
+ return true;
+ else
+ return false;
+}
+
+/*
+ * dal_adapter_service_get_sw_i2c_speed
+ *
+ * Get SW I2C speed
+ */
+uint32_t dal_adapter_service_get_sw_i2c_speed(
+ struct adapter_service *as)
+{
+ /* TODO: only from ASIC caps. Feature key is not implemented*/
+ return as->asic_cap->data[ASIC_DATA_DEFAULT_I2C_SPEED_IN_KHZ];
+}
+
+/*
+ * dal_adapter_service_get_hw_i2c_speed
+ *
+ * Get HW I2C speed
+ */
+uint32_t dal_adapter_service_get_hw_i2c_speed(
+ struct adapter_service *as)
+{
+ /* TODO: only from ASIC caps. Feature key is not implemented*/
+ return as->asic_cap->data[ASIC_DATA_DEFAULT_I2C_SPEED_IN_KHZ];
+}
+
+/*
+ * dal_adapter_service_get_mc_latency
+ *
+ * Get memory controller latency
+ */
+uint32_t dal_adapter_service_get_mc_latency(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_MC_LATENCY];
+}
+
+/*
+ * dal_adapter_service_get_asic_vram_bit_width
+ *
+ * Get the video RAM bit width set on the ASIC
+ */
+uint32_t dal_adapter_service_get_asic_vram_bit_width(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_VRAM_BITWIDTH];
+}
+
+/*
+ * dal_adapter_service_get_asic_bugs
+ *
+ * Get the bug flags set on this ASIC
+ */
+struct asic_bugs dal_adapter_service_get_asic_bugs(
+ struct adapter_service *as)
+{
+ return as->asic_cap->bugs;
+}
+
+
+struct dal_asic_runtime_flags dal_adapter_service_get_asic_runtime_flags(
+ struct adapter_service *as)
+{
+ return as->asic_cap->runtime_flags;
+}
+
+/*
+ * dal_adapter_service_get_line_buffer_size
+ *
+ * Get line buffer size
+ */
+uint32_t dal_adapter_service_get_line_buffer_size(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_LINEBUFFER_SIZE];
+}
+
+/*
+ * dal_adapter_service_get_bandwidth_tuning_params
+ *
+ * Get parameters for bandwidth tuning
+ */
+bool dal_adapter_service_get_bandwidth_tuning_params(
+ struct adapter_service *as,
+ union bandwidth_tuning_params *params)
+{
+ /* TODO: add implementation */
+ /* note: data comes from runtime parameters */
+ return false;
+}
+
+/*
+ * dal_adapter_service_get_feature_flags
+ *
+ * Get a copy of ASIC feature flags
+ */
+struct asic_feature_flags dal_adapter_service_get_feature_flags(
+ struct adapter_service *as)
+{
+ struct asic_feature_flags result = { { 0 } };
+
+ if (!as) {
+ ASSERT_CRITICAL(false);
+ return result;
+ }
+
+ result.raw = as->asic_cap->data[ASIC_DATA_FEATURE_FLAGS];
+
+ return result;
+}
+
+/*
+ * dal_adapter_service_get_dram_bandwidth_efficiency
+ *
+ * Get efficiency of DRAM
+ */
+uint32_t dal_adapter_service_get_dram_bandwidth_efficiency(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_DRAM_BANDWIDTH_EFFICIENCY];
+}
+
+/*
+ * dal_adapter_service_obtain_gpio
+ *
+ * Obtain GPIO
+ */
+struct gpio *dal_adapter_service_obtain_gpio(
+ struct adapter_service *as,
+ enum gpio_id id,
+ uint32_t en)
+{
+ return dal_gpio_service_create_gpio_ex(
+ as->gpio_service, id, en,
+ GPIO_PIN_OUTPUT_STATE_DEFAULT);
+}
+
+/*
+ * dal_adapter_service_obtain_stereo_gpio
+ *
+ * Obtain GPIO for stereo3D
+ */
+struct gpio *dal_adapter_service_obtain_stereo_gpio(
+ struct adapter_service *as)
+{
+ const bool have_param_stereo_gpio = false;
+
+ struct asic_feature_flags result;
+
+ result.raw = as->asic_cap->data[ASIC_DATA_FEATURE_FLAGS];
+
+ /* Case 1 : Workstation stereo */
+ if (result.bits.WORKSTATION_STEREO) {
+ /* "active low" <--> "default 3d right eye polarity" = false */
+ return dal_gpio_service_create_gpio_ex(as->gpio_service,
+ GPIO_ID_GENERIC, GPIO_GENERIC_A,
+ GPIO_PIN_OUTPUT_STATE_ACTIVE_LOW);
+ /* Case 2 : runtime parameter override for sideband stereo */
+ } else if (have_param_stereo_gpio) {
+ /* TODO implement */
+ return NULL;
+ /* Case 3 : VBIOS gives us GPIO for sideband stereo */
+ } else {
+ const struct graphics_object_id id =
+ dal_graphics_object_id_init(GENERIC_ID_STEREO,
+ ENUM_ID_1, OBJECT_TYPE_GENERIC);
+
+ struct bp_gpio_cntl_info cntl_info;
+ struct gpio_pin_info pin_info;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ /* Get GPIO record for this object.
+ * Stereo GPIO record should have exactly one entry
+ * where active state defines stereosync polarity */
+ if (1 != dcb->funcs->get_gpio_record(
+ dcb, id, &cntl_info,
+ 1)) {
+ return NULL;
+ } else if (BP_RESULT_OK
+ != dcb->funcs->get_gpio_pin_info(
+ dcb, cntl_info.id,
+ &pin_info)) {
+ /*ASSERT_CRITICAL(false);*/
+ return NULL;
+ } else {
+ return dal_gpio_service_create_gpio_ex(as->gpio_service,
+ pin_info.offset, pin_info.mask,
+ cntl_info.state);
+ }
+ }
+}
+
+/*
+ * dal_adapter_service_release_gpio
+ *
+ * Release GPIO
+ */
+void dal_adapter_service_release_gpio(
+ struct adapter_service *as,
+ struct gpio *gpio)
+{
+ dal_gpio_service_destroy_gpio(&gpio);
+}
+
+/*
+ * dal_adapter_service_get_firmware_info
+ *
+ * Get firmware information from BIOS
+ */
+bool dal_adapter_service_get_firmware_info(
+ struct adapter_service *as,
+ struct firmware_info *info)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ return dcb->funcs->get_firmware_info(dcb, info) == BP_RESULT_OK;
+}
+
+/*
+ * dal_adapter_service_get_audio_support
+ *
+ * Get information on audio support
+ */
+union audio_support dal_adapter_service_get_audio_support(
+ struct adapter_service *as)
+{
+ return dal_adapter_service_hw_ctx_get_audio_support(as->hw_ctx);
+}
+
+/*
+ * dal_adapter_service_get_stream_engines_num
+ *
+ * Get number of stream engines
+ */
+uint8_t dal_adapter_service_get_stream_engines_num(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_DIGFE_NUM];
+}
+
+/*
+ * dal_adapter_service_get_feature_value
+ *
+ * Get the cached value of a given feature. This value can be a boolean, int,
+ * or characters.
+ */
+bool dal_adapter_service_get_feature_value(
+ const enum adapter_feature_id feature_id,
+ void *data,
+ uint32_t size)
+{
+ uint32_t entry_idx = 0;
+ uint32_t set_idx = 0;
+ uint32_t set_internal_idx = 0;
+
+ if (feature_id >= FEATURE_MAXIMUM || feature_id <= FEATURE_UNKNOWN) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ if (data == NULL) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ entry_idx = lookup_feature_entry(feature_id);
+ set_idx = (uint32_t)((feature_id - 1)/32);
+ set_internal_idx = (uint32_t)((feature_id - 1) % 32);
+
+ if (entry_idx >= get_feature_entries_num()) {
+ /* Cannot find this entry */
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ if (feature_entry_table[entry_idx].is_boolean_type) {
+ if (size != sizeof(bool)) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ *(bool *)data = get_bool_value(adapter_feature_set[set_idx],
+ set_internal_idx);
+ } else {
+ if (size != sizeof(uint32_t)) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ *(uint32_t *)data = adapter_feature_set[set_idx];
+ }
+
+ return true;
+}
+
+/*
+ * dal_adapter_service_get_memory_type_multiplier
+ *
+ * Get multiplier for the memory type
+ */
+uint32_t dal_adapter_service_get_memory_type_multiplier(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_MEMORYTYPE_MULTIPLIER];
+}
+
+/*
+ * dal_adapter_service_get_bios_parser
+ *
+ * Get BIOS parser handler
+ */
+struct dc_bios *dal_adapter_service_get_bios_parser(
+ struct adapter_service *as)
+{
+ return as->dcb_override ? as->dcb_override : as->dcb_internal;
+}
+
+/*
+ * dal_adapter_service_get_i2caux
+ *
+ * Get i2c aux handler
+ */
+struct i2caux *dal_adapter_service_get_i2caux(
+ struct adapter_service *as)
+{
+ return as->i2caux;
+}
+
+bool dal_adapter_service_initialize_hw_data(
+ struct adapter_service *as)
+{
+ return as->hw_ctx->funcs->power_up(as->hw_ctx);
+}
+
+struct graphics_object_id dal_adapter_service_enum_fake_path_resource(
+ struct adapter_service *as,
+ uint32_t index)
+{
+ return as->hw_ctx->funcs->enum_fake_path_resource(as->hw_ctx, index);
+}
+
+struct graphics_object_id dal_adapter_service_enum_stereo_sync_object(
+ struct adapter_service *as,
+ uint32_t index)
+{
+ return as->hw_ctx->funcs->enum_stereo_sync_object(as->hw_ctx, index);
+}
+
+struct graphics_object_id dal_adapter_service_enum_sync_output_object(
+ struct adapter_service *as,
+ uint32_t index)
+{
+ return as->hw_ctx->funcs->enum_sync_output_object(as->hw_ctx, index);
+}
+
+struct graphics_object_id dal_adapter_service_enum_audio_object(
+ struct adapter_service *as,
+ uint32_t index)
+{
+ return as->hw_ctx->funcs->enum_audio_object(as->hw_ctx, index);
+}
+
+
+void dal_adapter_service_update_audio_connectivity(
+ struct adapter_service *as,
+ uint32_t number_of_audio_capable_display_path)
+{
+ as->hw_ctx->funcs->update_audio_connectivity(
+ as->hw_ctx,
+ number_of_audio_capable_display_path,
+ dal_adapter_service_get_controllers_num(as));
+}
+
+bool dal_adapter_service_has_embedded_display_connector(
+ struct adapter_service *as)
+{
+ uint8_t index;
+ uint8_t num_connectors = dal_adapter_service_get_connectors_num(as);
+
+ if (num_connectors == 0 || num_connectors > ENUM_ID_COUNT)
+ return false;
+
+ for (index = 0; index < num_connectors; index++) {
+ struct graphics_object_id obj_id =
+ dal_adapter_service_get_connector_obj_id(as, index);
+ enum connector_id connector_id =
+ dal_graphics_object_id_get_connector_id(obj_id);
+
+ if ((connector_id == CONNECTOR_ID_LVDS) ||
+ (connector_id == CONNECTOR_ID_EDP))
+ return true;
+ }
+
+ return false;
+}
+
+bool dal_adapter_service_get_embedded_panel_info(
+ struct adapter_service *as,
+ struct embedded_panel_info *info)
+{
+ enum bp_result result;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (info == NULL)
+ /*TODO: add DALASSERT_MSG here*/
+ return false;
+
+ result = dcb->funcs->get_embedded_panel_info(dcb, info);
+
+ return result == BP_RESULT_OK;
+}
+
+bool dal_adapter_service_enum_embedded_panel_patch_mode(
+ struct adapter_service *as,
+ uint32_t index,
+ struct embedded_panel_patch_mode *mode)
+{
+ enum bp_result result;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (mode == NULL)
+ /*TODO: add DALASSERT_MSG here*/
+ return false;
+
+ result = dcb->funcs->enum_embedded_panel_patch_mode(dcb, index, mode);
+
+ return result == BP_RESULT_OK;
+}
+
+bool dal_adapter_service_get_faked_edid_len(
+ struct adapter_service *as,
+ uint32_t *len)
+{
+ enum bp_result result;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ result = dcb->funcs->get_faked_edid_len(dcb, len);
+
+ return result == BP_RESULT_OK;
+}
+
+bool dal_adapter_service_get_faked_edid_buf(
+ struct adapter_service *as,
+ uint8_t *buf,
+ uint32_t len)
+{
+ enum bp_result result;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ result = dcb->funcs->get_faked_edid_buf(dcb, buf, len);
+
+ return result == BP_RESULT_OK;
+
+}
+
+/*
+ * dal_adapter_service_is_fusion
+ *
+ * Is this Fusion ASIC
+ */
+bool dal_adapter_service_is_fusion(struct adapter_service *as)
+{
+ return as->asic_cap->caps.IS_FUSION;
+}
+
+/*
+ * dal_adapter_service_is_dfsbyass_dynamic
+ *
+ *
+ **/
+bool dal_adapter_service_is_dfsbyass_dynamic(struct adapter_service *as)
+{
+ return as->asic_cap->caps.DFSBYPASS_DYNAMIC_SUPPORT;
+}
+
+/*
+ * dal_adapter_service_should_optimize
+ *
+ * @brief Reports whether driver settings allow requested optimization
+ *
+ * @param
+ * as: adapter service handler
+ * feature: for which optimization is validated
+ *
+ * @return
+ * true if requested feature can be optimized
+ */
+bool dal_adapter_service_should_optimize(
+ struct adapter_service *as, enum optimization_feature feature)
+{
+ uint32_t supported_optimization = 0;
+ struct dal_asic_runtime_flags flags;
+
+ if (!dal_adapter_service_get_feature_value(FEATURE_OPTIMIZATION,
+ &supported_optimization, sizeof(uint32_t)))
+ return false;
+
+ /* Retrieve ASIC runtime flags */
+ flags = dal_adapter_service_get_asic_runtime_flags(as);
+
+ /* Check runtime flags against different optimization features */
+ switch (feature) {
+ case OF_SKIP_HW_PROGRAMMING_ON_ENABLED_EMBEDDED_DISPLAY:
+ if (!flags.flags.bits.OPTIMIZED_DISPLAY_PROGRAMMING_ON_BOOT)
+ return false;
+ break;
+
+ case OF_SKIP_RESET_OF_ALL_HW_ON_S3RESUME:
+ if (as->integrated_info == NULL ||
+ !flags.flags.bits.SKIP_POWER_DOWN_ON_RESUME)
+ return false;
+ break;
+ case OF_SKIP_POWER_DOWN_INACTIVE_ENCODER:
+ if (!dal_adapter_service_get_asic_runtime_flags(as).flags.bits.
+ SKIP_POWER_DOWN_ON_RESUME)
+ return false;
+ break;
+ default:
+ break;
+ }
+
+ return (supported_optimization & feature) != 0;
+}
+
+/*
+ * dal_adapter_service_is_in_accelerated_mode
+ *
+ * @brief Determine if driver is in accelerated mode
+ *
+ * @param
+ * as: Adapter Service handler
+ *
+ * @out
+ * True if driver is in accelerated mode, false otherwise.
+ */
+bool dal_adapter_service_is_in_accelerated_mode(struct adapter_service *as)
+{
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ return dcb->funcs->is_accelerated_mode(dcb);
+}
+
+struct ddc *dal_adapter_service_obtain_ddc_from_i2c_info(
+ struct adapter_service *as,
+ struct graphics_object_i2c_info *info)
+{
+ struct gpio_ddc_hw_info hw_info = {
+ info->i2c_hw_assist,
+ info->i2c_line };
+ return dal_gpio_service_create_ddc(as->gpio_service,
+ info->gpio_info.clk_a_register_index,
+ (1 << info->gpio_info.clk_a_shift), &hw_info);
+}
+
+struct bdf_info dal_adapter_service_get_adapter_info(struct adapter_service *as)
+{
+ return as->bdf_info;
+}
+
+/*
+ * dal_adapter_service_should_psr_skip_wait_for_pll_lock
+ *
+ * @brief Determine if this ASIC needs to wait on PLL lock bit
+ *
+ * @param
+ * as: Adapter Service handle
+ *
+ * @out
+ * True if ASIC does not need to wait for PLL lock bit, i.e. skip the wait.
+ */
+bool dal_adapter_service_should_psr_skip_wait_for_pll_lock(
+ struct adapter_service *as)
+{
+ return as->asic_cap->caps.SKIP_PSR_WAIT_FOR_PLL_LOCK_BIT;
+}
+
+bool dal_adapter_service_is_lid_open(struct adapter_service *as)
+{
+ bool is_lid_open = false;
+ struct platform_info_params params;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ params.data = &is_lid_open;
+ params.method = PM_GET_LID_STATE;
+
+ if ((PM_GET_LID_STATE & as->platform_methods_mask) &&
+ dm_get_platform_info(as->ctx, ¶ms))
+ return is_lid_open;
+
+#if defined(CONFIG_DRM_AMD_DAL_VBIOS_PRESENT)
+ return dcb->funcs->is_lid_open(dcb);
+#else
+ return false;
+#endif
+}
+
+bool dal_adapter_service_get_panel_backlight_default_levels(
+ struct adapter_service *as,
+ struct panel_backlight_levels *levels)
+{
+ if (!as->backlight_caps_initialized)
+ return false;
+
+ levels->ac_level_percentage = as->ac_level_percentage;
+ levels->dc_level_percentage = as->dc_level_percentage;
+ return true;
+}
+
+bool dal_adapter_service_get_panel_backlight_boundaries(
+ struct adapter_service *as,
+ struct panel_backlight_boundaries *boundaries)
+{
+ if (!as->backlight_caps_initialized)
+ return false;
+ if (boundaries != NULL) {
+ boundaries->min_signal_level = as->backlight_8bit_lut[0];
+ boundaries->max_signal_level =
+ as->backlight_8bit_lut[SIZEOF_BACKLIGHT_LUT - 1];
+ return true;
+ }
+ return false;
+}
+
+
+uint32_t dal_adapter_service_get_view_port_pixel_granularity(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_VIEWPORT_PIXEL_GRANULARITY];
+}
+
+/**
+ * Get number of paths per DP 1.2 connector from the runtime parameter if it
+ * exists.
+ * A check to see if MST is supported for the generation of ASIC is done
+ *
+ * \return
+ * Number of paths per DP 1.2 connector is exists in runtime parameters
+ * or ASIC cap
+ */
+uint32_t dal_adapter_service_get_num_of_path_per_dp_mst_connector(
+ struct adapter_service *as)
+{
+ if (as->asic_cap->caps.DP_MST_SUPPORTED == 0) {
+ /* ASIC doesn't support DP MST at all */
+ return 0;
+ }
+
+ return as->asic_cap->data[ASIC_DATA_PATH_NUM_PER_DPMST_CONNECTOR];
+}
+
+uint32_t dal_adapter_service_get_num_of_underlays(
+ struct adapter_service *as)
+{
+ return as->asic_cap->data[ASIC_DATA_NUM_OF_VIDEO_PLANES];
+}
+
+bool dal_adapter_service_get_encoder_cap_info(
+ struct adapter_service *as,
+ struct graphics_object_id id,
+ struct graphics_object_encoder_cap_info *info)
+{
+ struct bp_encoder_cap_info bp_cap_info = {0};
+ enum bp_result result;
+ struct dc_bios *dcb = dal_adapter_service_get_bios_parser(as);
+
+ if (NULL == info) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ /*
+ * Retrieve Encoder Capability Information from VBIOS and store the
+ * call result (success or fail)
+ * Info from VBIOS about HBR2 has two fields:
+ *
+ * - dpHbr2Cap: indicates supported/not supported by HW Encoder
+ * - dpHbr2En : indicates DP spec compliant/not compliant
+ */
+ result = dcb->funcs->get_encoder_cap_info(dcb, id, &bp_cap_info);
+
+ /* Set dp_hbr2_validated flag (it's equal to Enable) */
+ info->dp_hbr2_validated = bp_cap_info.DP_HBR2_EN;
+
+ if (result == BP_RESULT_OK) {
+ info->dp_hbr2_cap = bp_cap_info.DP_HBR2_CAP;
+ return true;
+ }
+
+ return false;
+}
+
+bool dal_adapter_service_is_mc_tuning_req(struct adapter_service *as)
+{
+ return as->asic_cap->caps.NEED_MC_TUNING ? true : false;
+}
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.h b/drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.h
new file mode 100644
index 000000000000..60464e89cc5b
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/adapter_service.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#ifndef __DAL_ADAPTER_SERVICE_H__
+#define __DAL_ADAPTER_SERVICE_H__
+
+/* Include */
+#include "dc_bios_types.h"
+#include "include/adapter_service_interface.h"
+#include "wireless_data_source.h"
+
+/*
+ * Forward declaration
+ */
+struct gpio_service;
+struct asic_cap;
+
+
+/* Adapter service */
+struct adapter_service {
+ struct dc_context *ctx;
+ struct asic_capability *asic_cap;
+ struct dc_bios *dcb_internal;/* created by DC */
+ struct dc_bios *dcb_override;/* supplied by creator of DC */
+ enum dce_environment dce_environment;
+ struct gpio_service *gpio_service;
+ struct i2caux *i2caux;
+ struct wireless_data wireless_data;
+ struct hw_ctx_adapter_service *hw_ctx;
+ struct integrated_info *integrated_info;
+ struct bdf_info bdf_info;
+ uint32_t platform_methods_mask;
+ uint32_t ac_level_percentage;
+ uint32_t dc_level_percentage;
+ uint32_t backlight_caps_initialized;
+ uint32_t backlight_8bit_lut[SIZEOF_BACKLIGHT_LUT];
+};
+
+/* Type of feature with its runtime parameter and default value */
+struct feature_source_entry {
+ enum adapter_feature_id feature_id;
+ uint32_t default_value;
+ bool is_boolean_type;
+};
+
+/* Stores entire ASIC features by sets */
+extern uint32_t adapter_feature_set[];
+
+#endif /* __DAL_ADAPTER_SERVICE_H__ */
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.c b/drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.c
new file mode 100644
index 000000000000..f10bee6f2b83
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.c
@@ -0,0 +1,304 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#include "dm_services.h"
+
+#include "../hw_ctx_adapter_service.h"
+
+#include "hw_ctx_adapter_service_dce110.h"
+
+#include "include/logger_interface.h"
+#include "include/grph_object_id.h"
+
+#include "dce/dce_11_0_d.h"
+#include "dce/dce_11_0_sh_mask.h"
+
+#ifndef mmCC_DC_HDMI_STRAPS
+#define mmCC_DC_HDMI_STRAPS 0x4819
+#define CC_DC_HDMI_STRAPS__HDMI_DISABLE_MASK 0x40
+#define CC_DC_HDMI_STRAPS__HDMI_DISABLE__SHIFT 0x6
+#define CC_DC_HDMI_STRAPS__AUDIO_STREAM_NUMBER_MASK 0x700
+#define CC_DC_HDMI_STRAPS__AUDIO_STREAM_NUMBER__SHIFT 0x8
+#endif
+
+static const struct graphics_object_id invalid_go = {
+ 0, ENUM_ID_UNKNOWN, OBJECT_TYPE_UNKNOWN, 0
+};
+
+/* Macro */
+#define AUDIO_STRAPS_HDMI_ENABLE 0x2
+
+#define FROM_HW_CTX(ptr) \
+ container_of((ptr), struct hw_ctx_adapter_service_dce110, base)
+
+static const uint32_t audio_index_reg_offset[] = {
+ /*CZ has 3 DIGs but 4 audio endpoints*/
+ mmAZF0ENDPOINT0_AZALIA_F0_CODEC_ENDPOINT_INDEX,
+ mmAZF0ENDPOINT1_AZALIA_F0_CODEC_ENDPOINT_INDEX,
+ mmAZF0ENDPOINT2_AZALIA_F0_CODEC_ENDPOINT_INDEX,
+ mmAZF0ENDPOINT3_AZALIA_F0_CODEC_ENDPOINT_INDEX
+};
+
+static const uint32_t audio_data_reg_offset[] = {
+ mmAZF0ENDPOINT0_AZALIA_F0_CODEC_ENDPOINT_DATA,
+ mmAZF0ENDPOINT1_AZALIA_F0_CODEC_ENDPOINT_DATA,
+ mmAZF0ENDPOINT2_AZALIA_F0_CODEC_ENDPOINT_DATA,
+ mmAZF0ENDPOINT3_AZALIA_F0_CODEC_ENDPOINT_DATA,
+};
+
+enum {
+ MAX_NUMBER_OF_AUDIO_PINS = 4
+};
+
+static void destruct(
+ struct hw_ctx_adapter_service_dce110 *hw_ctx)
+{
+ /* There is nothing to destruct at the moment */
+ dal_adapter_service_destruct_hw_ctx(&hw_ctx->base);
+}
+
+static void destroy(
+ struct hw_ctx_adapter_service *ptr)
+{
+ struct hw_ctx_adapter_service_dce110 *hw_ctx =
+ FROM_HW_CTX(ptr);
+
+ destruct(hw_ctx);
+
+ dm_free(ptr->ctx, hw_ctx);
+}
+
+/*
+ * enum_audio_object
+ *
+ * @brief enumerate audio object
+ *
+ * @param
+ * const struct hw_ctx_adapter_service *hw_ctx - [in] provides num of endpoints
+ * uint32_t index - [in] audio index
+ *
+ * @return
+ * grphic object id
+ */
+static struct graphics_object_id enum_audio_object(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ uint32_t number_of_connected_audio_endpoints =
+ FROM_HW_CTX(hw_ctx)->number_of_connected_audio_endpoints;
+
+ if (index >= number_of_connected_audio_endpoints ||
+ number_of_connected_audio_endpoints == 0)
+ return invalid_go;
+ else
+ return dal_graphics_object_id_init(
+ AUDIO_ID_INTERNAL_AZALIA,
+ (enum object_enum_id)(index + 1),
+ OBJECT_TYPE_AUDIO);
+}
+
+static uint32_t get_number_of_connected_audio_endpoints_multistream(
+ struct dc_context *ctx)
+{
+ uint32_t num_connected_audio_endpoints = 0;
+ uint32_t i;
+ uint32_t default_config =
+ ixAZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_CONFIGURATION_DEFAULT;
+
+ /* find the total number of streams available via the
+ * AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_CONFIGURATION_DEFAULT
+ * registers (one for each pin) starting from pin 1
+ * up to the max number of audio pins.
+ * We stop on the first pin where
+ * PORT_CONNECTIVITY == 1 (as instructed by HW team).
+ */
+ for (i = 0; i < MAX_NUMBER_OF_AUDIO_PINS; i++) {
+ uint32_t value = 0;
+
+ set_reg_field_value(value,
+ default_config,
+ AZALIA_F0_CODEC_ENDPOINT_INDEX,
+ AZALIA_ENDPOINT_REG_INDEX);
+
+ dm_write_reg(ctx, audio_index_reg_offset[i], value);
+
+ value = 0;
+ value = dm_read_reg(ctx, audio_data_reg_offset[i]);
+
+ /* 1 means not supported*/
+ if (get_reg_field_value(value,
+ AZALIA_F0_CODEC_PIN_CONTROL_RESPONSE_CONFIGURATION_DEFAULT,
+ PORT_CONNECTIVITY) == 1)
+ break;
+
+ num_connected_audio_endpoints++;
+ }
+
+ return num_connected_audio_endpoints;
+
+}
+
+/*
+ * get_number_of_connected_audio_endpoints
+ */
+static uint32_t get_number_of_connected_audio_endpoints(
+ struct hw_ctx_adapter_service *hw_ctx)
+{
+ uint32_t addr = mmCC_DC_HDMI_STRAPS;
+ uint32_t value = 0;
+ uint32_t field = 0;
+
+ if (hw_ctx->cached_audio_straps == AUDIO_STRAPS_NOT_ALLOWED)
+ /* audio straps indicate no audio supported */
+ return 0;
+
+ value = dm_read_reg(hw_ctx->ctx, addr);
+
+ field = get_reg_field_value(
+ value, CC_DC_HDMI_STRAPS, AUDIO_STREAM_NUMBER);
+ if (field == 1)
+ /* multi streams not supported */
+ return 1;
+ else if (field == 0)
+ /* multi streams supported */
+ return get_number_of_connected_audio_endpoints_multistream(
+ hw_ctx->ctx);
+
+ /* unexpected value */
+ ASSERT_CRITICAL(false);
+ return field;
+}
+
+
+/*
+ * power_up
+ *
+ * @brief
+ * Determine and cache audio support from register.
+ *
+ * @param
+ * struct hw_ctx_adapter_service *hw_ctx - [in] adapter service hw context
+ *
+ * @return
+ * true if succeed, false otherwise
+ */
+static bool power_up(
+ struct hw_ctx_adapter_service *hw_ctx)
+{
+ struct hw_ctx_adapter_service_dce110 *hw_ctx_dce11 =
+ FROM_HW_CTX(hw_ctx);
+ /* Allow DP audio all the time
+ * without additional pinstrap check on Fusion */
+
+
+ {
+ uint32_t value = 0;
+ uint32_t field = 0;
+
+ value = dm_read_reg(hw_ctx->ctx, mmCC_DC_HDMI_STRAPS);
+ field = get_reg_field_value(
+ value, CC_DC_HDMI_STRAPS, HDMI_DISABLE);
+
+ if (field == 0) {
+ hw_ctx->cached_audio_straps = AUDIO_STRAPS_DP_HDMI_AUDIO;
+ } else {
+ value = dm_read_reg(
+ hw_ctx->ctx, mmDC_PINSTRAPS);
+ field = get_reg_field_value(
+ value,
+ DC_PINSTRAPS,
+ DC_PINSTRAPS_AUDIO);
+
+ if (field & AUDIO_STRAPS_HDMI_ENABLE)
+ hw_ctx->cached_audio_straps =
+ AUDIO_STRAPS_DP_HDMI_AUDIO_ON_DONGLE;
+ else
+ hw_ctx->cached_audio_straps =
+ AUDIO_STRAPS_DP_AUDIO_ALLOWED;
+ }
+
+ }
+
+ /* get the number of connected audio endpoints */
+ hw_ctx_dce11->number_of_connected_audio_endpoints =
+ get_number_of_connected_audio_endpoints(hw_ctx);
+
+ return true;
+}
+
+static void update_audio_connectivity(
+ struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t number_of_audio_capable_display_path,
+ uint32_t number_of_controllers)
+{
+ /* this one should be empty on DCE110 */
+}
+
+static const struct hw_ctx_adapter_service_funcs funcs = {
+ .destroy = destroy,
+ .power_up = power_up,
+ .enum_fake_path_resource = NULL,
+ .enum_stereo_sync_object = NULL,
+ .enum_sync_output_object = NULL,
+ .enum_audio_object = enum_audio_object,
+ .update_audio_connectivity = update_audio_connectivity
+};
+
+static bool construct(
+ struct hw_ctx_adapter_service_dce110 *hw_ctx,
+ struct dc_context *ctx)
+{
+ if (!dal_adapter_service_construct_hw_ctx(&hw_ctx->base, ctx)) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ hw_ctx->base.funcs = &funcs;
+ hw_ctx->number_of_connected_audio_endpoints = 0;
+
+ return true;
+}
+
+struct hw_ctx_adapter_service *
+ dal_adapter_service_create_hw_ctx_dce110(
+ struct dc_context *ctx)
+{
+ struct hw_ctx_adapter_service_dce110 *hw_ctx =
+ dm_alloc(ctx, sizeof(struct hw_ctx_adapter_service_dce110));
+
+ if (!hw_ctx) {
+ ASSERT_CRITICAL(false);
+ return NULL;
+ }
+
+ if (construct(hw_ctx, ctx))
+ return &hw_ctx->base;
+
+ ASSERT_CRITICAL(false);
+
+ dm_free(ctx, hw_ctx);
+
+ return NULL;
+}
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.h b/drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.h
new file mode 100644
index 000000000000..092b67173dc4
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/dce110/hw_ctx_adapter_service_dce110.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#ifndef __DAL_HW_CTX_ADAPTER_SERVICE_DCE110_H__
+#define __DAL_HW_CTX_ADAPTER_SERVICE_DCE110_H__
+
+struct hw_ctx_adapter_service_dce110 {
+ struct hw_ctx_adapter_service base;
+ uint32_t number_of_connected_audio_endpoints;
+};
+
+struct hw_ctx_adapter_service *
+ dal_adapter_service_create_hw_ctx_dce110(
+ struct dc_context *ctx);
+
+#endif /* __DAL_HW_CTX_ADAPTER_SERVICE_DCE110_H__ */
+
+
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.c b/drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.c
new file mode 100644
index 000000000000..4f5f0403af84
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.c
@@ -0,0 +1,133 @@
+/*
+ * Copyright 2012-16 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+/* FPGA Diagnostics version of AS HW CTX. */
+
+#include "dm_services.h"
+
+#include "../hw_ctx_adapter_service.h"
+
+#include "hw_ctx_adapter_service_diag.h"
+
+#include "include/logger_interface.h"
+#include "include/grph_object_id.h"
+
+static const struct graphics_object_id invalid_go = {
+ 0, ENUM_ID_UNKNOWN, OBJECT_TYPE_UNKNOWN
+};
+
+static void destroy(
+ struct hw_ctx_adapter_service *hw_ctx)
+{
+}
+
+static bool power_up(
+ struct hw_ctx_adapter_service *hw_ctx)
+{
+ return true;
+}
+
+static struct graphics_object_id enum_fake_path_resource(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ return invalid_go;
+}
+
+static struct graphics_object_id enum_stereo_sync_object(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ return invalid_go;
+}
+
+static struct graphics_object_id enum_sync_output_object(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ return invalid_go;
+}
+
+static struct graphics_object_id enum_audio_object(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ return invalid_go;
+}
+
+static void update_audio_connectivity(
+ struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t number_of_audio_capable_display_path,
+ uint32_t number_of_controllers)
+{
+}
+
+static const struct hw_ctx_adapter_service_funcs funcs = {
+ destroy,
+ power_up,
+ enum_fake_path_resource,
+ enum_stereo_sync_object,
+ enum_sync_output_object,
+ enum_audio_object,
+ update_audio_connectivity
+};
+
+static bool construct(
+ struct hw_ctx_adapter_service *hw_ctx,
+ struct dc_context *ctx)
+
+{
+ if (!dal_adapter_service_construct_hw_ctx(hw_ctx, ctx)) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ hw_ctx->funcs = &funcs;
+
+ return true;
+}
+
+struct hw_ctx_adapter_service *dal_adapter_service_create_hw_ctx_diag(
+ struct dc_context *ctx)
+{
+ struct hw_ctx_adapter_service *hw_ctx = dm_alloc(ctx,
+ sizeof(*hw_ctx));
+
+ if (!hw_ctx) {
+ ASSERT_CRITICAL(false);
+ return NULL;
+ }
+
+ if (construct(hw_ctx, ctx))
+ return hw_ctx;
+
+ ASSERT_CRITICAL(false);
+
+ dm_free(ctx, hw_ctx);
+
+ return NULL;
+}
+
+/*****************************************************************************/
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.h b/drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.h
new file mode 100644
index 000000000000..39ae7524506c
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/diagnostics/hw_ctx_adapter_service_diag.h
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2012-16 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#ifndef __DAL_HW_CTX_ADAPTER_SERVICE_DIAG_H__
+#define __DAL_HW_CTX_ADAPTER_SERVICE_DIAG_H__
+
+
+struct hw_ctx_adapter_service *dal_adapter_service_create_hw_ctx_diag(
+ struct dc_context *ctx);
+
+#endif /* __DAL_HW_CTX_ADAPTER_SERVICE_DIAG_H__ */
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.c b/drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.c
new file mode 100644
index 000000000000..12eabe0c3f89
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.c
@@ -0,0 +1,164 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#include "dm_services.h"
+#include "include/adapter_service_types.h"
+#include "include/grph_object_id.h"
+#include "hw_ctx_adapter_service.h"
+
+static const struct graphics_object_id invalid_go = {
+ 0, ENUM_ID_UNKNOWN, OBJECT_TYPE_UNKNOWN
+};
+
+static void destroy(
+ struct hw_ctx_adapter_service *hw_ctx)
+{
+ /* Attention!
+ * You must override impl method in derived class */
+ BREAK_TO_DEBUGGER();
+}
+
+static bool power_up(
+ struct hw_ctx_adapter_service *hw_ctx)
+{
+ /* Attention!
+ * You must override impl method in derived class */
+ BREAK_TO_DEBUGGER();
+
+ return false;
+}
+
+static struct graphics_object_id enum_fake_path_resource(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ return invalid_go;
+}
+
+static struct graphics_object_id enum_stereo_sync_object(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ return invalid_go;
+}
+
+static struct graphics_object_id enum_sync_output_object(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ return invalid_go;
+}
+
+static struct graphics_object_id enum_audio_object(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index)
+{
+ /* by default, we only allow one audio */
+
+ if (index > 0)
+ return invalid_go;
+ else if (hw_ctx->cached_audio_straps == AUDIO_STRAPS_NOT_ALLOWED)
+ return invalid_go;
+ else
+ return dal_graphics_object_id_init(
+ AUDIO_ID_INTERNAL_AZALIA,
+ ENUM_ID_1,
+ OBJECT_TYPE_AUDIO);
+}
+
+static void update_audio_connectivity(
+ struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t number_of_audio_capable_display_path,
+ uint32_t number_of_controllers)
+{
+ /* Attention!
+ * You must override impl method in derived class */
+ BREAK_TO_DEBUGGER();
+}
+
+static const struct hw_ctx_adapter_service_funcs funcs = {
+ destroy,
+ power_up,
+ enum_fake_path_resource,
+ enum_stereo_sync_object,
+ enum_sync_output_object,
+ enum_audio_object,
+ update_audio_connectivity
+};
+
+bool dal_adapter_service_construct_hw_ctx(
+ struct hw_ctx_adapter_service *hw_ctx,
+ struct dc_context *ctx)
+{
+
+ hw_ctx->ctx = ctx;
+ hw_ctx->funcs = &funcs;
+ hw_ctx->cached_audio_straps = AUDIO_STRAPS_NOT_ALLOWED;
+
+ return true;
+}
+
+union audio_support dal_adapter_service_hw_ctx_get_audio_support(
+ const struct hw_ctx_adapter_service *hw_ctx)
+{
+ union audio_support result;
+
+ result.raw = 0;
+
+ switch (hw_ctx->cached_audio_straps) {
+ case AUDIO_STRAPS_DP_HDMI_AUDIO:
+ result.bits.HDMI_AUDIO_NATIVE = true;
+ /* do not break ! */
+ case AUDIO_STRAPS_DP_HDMI_AUDIO_ON_DONGLE:
+ result.bits.HDMI_AUDIO_ON_DONGLE = true;
+ /* do not break ! */
+ case AUDIO_STRAPS_DP_AUDIO_ALLOWED:
+ result.bits.DP_AUDIO = true;
+ break;
+ default:
+ break;
+ }
+
+ return result;
+}
+
+void dal_adapter_service_destruct_hw_ctx(
+ struct hw_ctx_adapter_service *hw_ctx)
+{
+ /* There is nothing to destruct at the moment */
+}
+
+void dal_adapter_service_destroy_hw_ctx(
+ struct hw_ctx_adapter_service **ptr)
+{
+ if (!ptr || !*ptr) {
+ BREAK_TO_DEBUGGER();
+ return;
+ }
+
+ (*ptr)->funcs->destroy(*ptr);
+
+ *ptr = NULL;
+}
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.h b/drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.h
new file mode 100644
index 000000000000..f98c2d428b2a
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/hw_ctx_adapter_service.h
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#ifndef __DAL_HW_CTX_ADAPTER_SERVICE_H__
+#define __DAL_HW_CTX_ADAPTER_SERVICE_H__
+
+enum audio_straps {
+ AUDIO_STRAPS_NOT_ALLOWED = 0,
+ AUDIO_STRAPS_DP_AUDIO_ALLOWED,
+ AUDIO_STRAPS_DP_HDMI_AUDIO_ON_DONGLE,
+ AUDIO_STRAPS_DP_HDMI_AUDIO
+};
+
+struct hw_ctx_adapter_service;
+
+struct hw_ctx_adapter_service_funcs {
+ void (*destroy)(
+ struct hw_ctx_adapter_service *hw_ctx);
+ /* Initializes relevant HW registers
+ * and caches relevant data from HW registers */
+ bool (*power_up)(
+ struct hw_ctx_adapter_service *hw_ctx);
+ /* Enumerate fake path resources */
+ struct graphics_object_id (*enum_fake_path_resource)(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index);
+ /* Enumerate stereo sync objects */
+ struct graphics_object_id (*enum_stereo_sync_object)(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index);
+ /* Enumerate (H/V) sync output objects */
+ struct graphics_object_id (*enum_sync_output_object)(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index);
+ /* Enumerate audio objects */
+ struct graphics_object_id (*enum_audio_object)(
+ const struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t index);
+ void (*update_audio_connectivity)(
+ struct hw_ctx_adapter_service *hw_ctx,
+ uint32_t number_of_audio_capable_display_path,
+ uint32_t number_of_controllers);
+};
+
+struct hw_ctx_adapter_service {
+ struct dc_context *ctx;
+ const struct hw_ctx_adapter_service_funcs *funcs;
+ enum audio_straps cached_audio_straps;
+};
+
+bool dal_adapter_service_construct_hw_ctx(
+ struct hw_ctx_adapter_service *hw_ctx,
+ struct dc_context *ctx);
+
+union audio_support dal_adapter_service_hw_ctx_get_audio_support(
+ const struct hw_ctx_adapter_service *hw_ctx);
+
+void dal_adapter_service_destruct_hw_ctx(
+ struct hw_ctx_adapter_service *hw_ctx);
+
+void dal_adapter_service_destroy_hw_ctx(
+ struct hw_ctx_adapter_service **ptr);
+
+#endif /* __DAL_HW_CTX_ADAPTER_SERVICE_H__ */
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.c b/drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.c
new file mode 100644
index 000000000000..0b1151ec5a2c
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.c
@@ -0,0 +1,208 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+
+#include "dm_services.h"
+#include "adapter_service.h"
+#include "wireless_data_source.h"
+
+#include "atom.h"
+
+/*construct wireless data*/
+bool wireless_data_init(struct wireless_data *data,
+ struct dc_bios *dcb,
+ struct wireless_init_data *init_data)
+{
+ struct firmware_info info;
+
+ if (data == NULL || dcb == NULL || init_data == NULL) {
+ ASSERT_CRITICAL(false);
+ return false;
+ }
+
+ data->miracast_connector_enable = false;
+ data->wireless_disp_path_enable = false;
+ data->wireless_enable = false;
+
+ /* Wireless it not supported if VCE is not supported */
+ if (!init_data->vce_supported)
+ return true;
+
+ if (init_data->miracast_target_required)
+ data->miracast_connector_enable = true;
+
+ /*
+ * If override is in place for platform support, we will both
+ * enable wireless display as a feature (i.e. CCC aspect) and
+ * enable the wireless display path without any further checks.
+ */
+ if (init_data->platform_override) {
+ data->wireless_enable = true;
+ data->wireless_disp_path_enable = true;
+ } else {
+ /*
+ * Check if SBIOS sets remote display enable, exposed
+ * through VBIOS. This is only valid for APU, not dGPU
+ */
+ dcb->funcs->get_firmware_info(dcb, &info);
+
+ if ((REMOTE_DISPLAY_ENABLE == info.remote_display_config) &&
+ init_data->fusion) {
+ data->wireless_enable = true;
+ data->wireless_disp_path_enable = true;
+ }
+ }
+
+ /*
+ * If remote display path override is enabled, we enable just the
+ * remote display path. This is mainly used for testing purposes
+ */
+ if (init_data->remote_disp_path_override)
+ data->wireless_disp_path_enable = true;
+
+ return true;
+}
+
+uint8_t wireless_get_clocks_num(
+ struct adapter_service *as)
+{
+ if (as->wireless_data.wireless_enable ||
+ as->wireless_data.wireless_disp_path_enable)
+ return 1;
+ else
+ return 0;
+}
+
+static uint8_t wireless_get_encoders_num(
+ struct adapter_service *as)
+{
+ if (as->wireless_data.wireless_enable ||
+ as->wireless_data.wireless_disp_path_enable)
+ return 1;
+ else
+ return 0;
+}
+
+uint8_t wireless_get_connectors_num(
+ struct adapter_service *as)
+{
+ uint8_t wireless_connectors_num = 0;
+
+ if (as->wireless_data.wireless_enable &&
+ as->wireless_data.miracast_connector_enable)
+ wireless_connectors_num++;
+
+ if (as->wireless_data.wireless_disp_path_enable)
+ wireless_connectors_num++;
+
+ return wireless_connectors_num;
+}
+
+struct graphics_object_id wireless_get_connector_id(
+ struct adapter_service *as,
+ uint8_t index)
+{
+ struct graphics_object_id unknown_object_id =
+ dal_graphics_object_id_init(
+ 0,
+ ENUM_ID_UNKNOWN,
+ OBJECT_TYPE_UNKNOWN);
+
+ if (!as->wireless_data.wireless_enable &&
+ !as->wireless_data.wireless_disp_path_enable)
+ return unknown_object_id;
+
+ else if (!as->wireless_data.miracast_connector_enable)
+ return dal_graphics_object_id_init(
+ CONNECTOR_ID_WIRELESS,
+ ENUM_ID_1,
+ OBJECT_TYPE_CONNECTOR);
+
+ switch (index) {
+ case 0:
+ return dal_graphics_object_id_init(
+ CONNECTOR_ID_WIRELESS,
+ ENUM_ID_1,
+ OBJECT_TYPE_CONNECTOR);
+ break;
+ case 1:
+ return dal_graphics_object_id_init(
+ CONNECTOR_ID_MIRACAST,
+ ENUM_ID_1,
+ OBJECT_TYPE_CONNECTOR);
+ break;
+ default:
+ return unknown_object_id;
+ }
+}
+
+uint8_t wireless_get_srcs_num(
+ struct adapter_service *as,
+ struct graphics_object_id id)
+{
+ switch (id.type) {
+ case OBJECT_TYPE_CONNECTOR:
+ return wireless_get_encoders_num(as);
+ case OBJECT_TYPE_ENCODER:
+ return 1;
+
+ default:
+ ASSERT_CRITICAL(false);
+ break;
+ }
+
+ return 0;
+}
+
+struct graphics_object_id wireless_get_src_obj_id(
+ struct adapter_service *as,
+ struct graphics_object_id id,
+ uint8_t index)
+{
+ if (index < wireless_get_srcs_num(as, id)) {
+ switch (id.type) {
+ case OBJECT_TYPE_CONNECTOR:
+ return dal_graphics_object_id_init(
+ ENCODER_ID_INTERNAL_WIRELESS,
+ ENUM_ID_1,
+ OBJECT_TYPE_ENCODER);
+ break;
+ case OBJECT_TYPE_ENCODER:
+ return dal_graphics_object_id_init(
+ 0,
+ ENUM_ID_1,
+ OBJECT_TYPE_GPU);
+ break;
+ default:
+ ASSERT_CRITICAL(false);
+ break;
+ }
+ }
+
+ return dal_graphics_object_id_init(
+ 0,
+ ENUM_ID_UNKNOWN,
+ OBJECT_TYPE_UNKNOWN);
+}
diff --git a/drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.h b/drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.h
new file mode 100644
index 000000000000..b64089e3960e
--- /dev/null
+++ b/drivers/gpu/drm/amd/dal/dc/adapter/wireless_data_source.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2012-15 Advanced Micro Devices, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
+ * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Authors: AMD
+ *
+ */
+
+#ifndef __DAL_WIRELESS_DATA_SOURCE_H__
+#define __DAL_WIRELESS_DATA_SOURCE_H__
+
+/* Include */
+#include "include/grph_object_id.h"
+
+/*
+ * Forward declaration
+ */
+struct adapter_service;
+struct dc_bios;
+
+/* Wireless data init structure */
+struct wireless_init_data {
+ bool fusion; /* Fusion flag */
+ bool platform_override; /* Override for platform BIOS option */
+ bool remote_disp_path_override; /* Override enabling wireless path */
+ bool vce_supported; /* Existence of VCE block on this DCE */
+ bool miracast_target_required; /* OS requires Miracast target */
+};
+
+/* Wireless data */
+struct wireless_data {
+ bool wireless_enable;
+ bool wireless_disp_path_enable;
+ bool miracast_connector_enable;
+};
+
+
+/*construct wireless data*/
+bool wireless_data_init(
+ struct wireless_data *data,
+ struct dc_bios *dcb,
+ struct wireless_init_data *init_data);
+
+uint8_t wireless_get_clocks_num(
+ struct adapter_service *as);
+
+uint8_t wireless_get_connectors_num(
+ struct adapter_service *as);
+
+struct graphics_object_id wireless_get_connector_id(
+ struct adapter_service *as,
+ uint8_t connector_index);
+
+uint8_t wireless_get_srcs_num(
+ struct adapter_service *as,
+ struct graphics_object_id id);
+
+struct graphics_object_id wireless_get_src_obj_id(
+ struct adapter_service *as,
+ struct graphics_object_id id,
+ uint8_t index);
+
+#endif /* __DAL_WIRELESS_DATA_SOURCE_H__ */
--
2.1.4
_______________________________________________
dri-devel mailing list
dri-devel@lists.freedesktop.org
https://lists.freedesktop.org/mailman/listinfo/dri-devel
next prev parent reply other threads:[~2016-02-11 17:20 UTC|newest]
Thread overview: 87+ messages / expand[flat|nested] mbox.gz Atom feed top
2016-02-11 17:19 [PATCH 00/29] Enabling new DAL display driver for amdgpu on Carrizo and Tonga Harry Wentland
2016-02-11 17:19 ` [PATCH 01/29] drm/amd/dal: Add dal headers Harry Wentland
2016-02-11 17:19 ` [PATCH 02/29] drm/amd/dal: Add DAL Basic Types and Logger Harry Wentland
2016-02-11 17:19 ` [PATCH 03/29] drm/amd/dal: Fixed point arithmetic Harry Wentland
2016-02-11 17:19 ` [PATCH 04/29] drm/amd/dal: Asic Capabilities Harry Wentland
2016-02-11 17:19 ` [PATCH 05/29] drm/amd/dal: GPIO (General Purpose IO) Harry Wentland
2016-02-11 17:19 ` Harry Wentland [this message]
2016-02-12 0:26 ` [PATCH 06/29] drm/amd/dal: Adapter Service Dave Airlie
2016-02-12 14:30 ` Wentland, Harry
2016-02-11 17:19 ` [PATCH 07/29] drm/amd/dal: BIOS Parser Harry Wentland
2016-02-11 17:19 ` [PATCH 08/29] drm/amd/dal: I2C Aux Manager Harry Wentland
2016-02-11 20:19 ` Rob Clark
2016-02-11 20:52 ` Daniel Vetter
2016-02-17 3:23 ` Harry Wentland
2016-02-11 17:19 ` [PATCH 09/29] drm/amd/dal: IRQ Service Harry Wentland
2016-02-11 17:19 ` [PATCH 10/29] drm/amd/dal: GPU Harry Wentland
2016-02-11 17:19 ` [PATCH 11/29] drm/amd/dal: Audio Harry Wentland
2016-02-11 17:19 ` [PATCH 12/29] drm/amd/dal: Bandwidth calculations Harry Wentland
2016-02-11 17:19 ` [PATCH 13/29] drm/amd/dal: Add encoder HW programming Harry Wentland
2016-02-11 17:19 ` [PATCH 14/29] drm/amd/dal: Add clock source " Harry Wentland
2016-02-11 17:19 ` [PATCH 15/29] drm/amd/dal: Add timing generator " Harry Wentland
2016-02-11 17:19 ` [PATCH 16/29] drm/amd/dal: Add surface " Harry Wentland
2016-02-11 17:19 ` [PATCH 17/29] drm/amd/dal: Add framebuffer compression " Harry Wentland
2016-02-11 17:19 ` [PATCH 18/29] drm/amd/dal: Add input pixel processing " Harry Wentland
2016-02-11 17:19 ` [PATCH 19/29] drm/amd/dal: Add output " Harry Wentland
2016-02-11 17:20 ` [PATCH 20/29] drm/amd/dal: Add transform & scaler " Harry Wentland
2016-02-11 17:20 ` [PATCH 21/29] drm/amd/dal: Add Carrizo HW sequencer and resource Harry Wentland
2016-02-11 17:20 ` [PATCH 22/29] drm/amd/dal: Add Tonga/Fiji " Harry Wentland
2016-02-11 17:20 ` [PATCH 23/29] drm/amd/dal: Add empty encoder programming for virtual HW Harry Wentland
2016-02-11 17:20 ` [PATCH 24/29] drm/amd/dal: Add display core Harry Wentland
2016-02-11 17:20 ` [PATCH 25/29] drm/amd/dal: Adding amdgpu_dm for dal Harry Wentland
2016-02-11 17:20 ` [PATCH 26/29] drm/amdgpu: Use dal driver for Carrizo, Tonga, and Fiji Harry Wentland
2016-02-11 17:20 ` [PATCH 27/29] drm/amd/dal: Correctly interpret rotation as bit set Harry Wentland
2016-02-11 21:00 ` Oded Gabbay
2016-02-16 16:46 ` Harry Wentland
2016-02-11 17:20 ` [PATCH 28/29] drm/amd/dal: fix flip clean-up state Harry Wentland
2016-02-11 17:20 ` [PATCH 29/29] drm/amd/dal: Force bw programming for DCE 10 until we start calculate BW Harry Wentland
2016-02-11 20:02 ` [PATCH 00/29] Enabling new DAL display driver for amdgpu on Carrizo and Tonga Mike Lothian
2016-02-11 20:05 ` Wentland, Harry
2016-02-11 20:52 ` Dave Airlie
2016-02-11 21:06 ` Daniel Vetter
2016-02-12 0:57 ` Dave Airlie
2016-02-12 5:34 ` Daniel Vetter
2016-02-13 0:05 ` Wentland, Harry
2016-02-14 11:22 ` Jerome Glisse
2016-02-14 13:23 ` Daniel Vetter
2016-02-17 3:28 ` Harry Wentland
2016-02-14 13:32 ` Rob Clark
2016-02-14 13:51 ` Daniel Vetter
2016-02-17 3:26 ` Harry Wentland
2016-02-14 14:01 ` Daniel Vetter
2016-02-17 3:32 ` Harry Wentland
2016-02-14 21:44 ` Daniel Stone
2016-02-16 22:27 ` [PATCH v2 00/26] " Harry Wentland
2016-02-16 22:27 ` [PATCH v2 01/26] drm/amd/dal: Add dal headers Harry Wentland
2016-02-16 22:27 ` [PATCH v2 02/26] drm/amd/dal: Add DAL Basic Types and Logger Harry Wentland
2016-02-16 22:27 ` [PATCH v2 03/26] drm/amd/dal: Fixed point arithmetic Harry Wentland
2016-02-16 22:27 ` [PATCH v2 04/26] drm/amd/dal: Asic Capabilities Harry Wentland
2016-02-16 22:27 ` [PATCH v2 05/26] drm/amd/dal: GPIO (General Purpose IO) Harry Wentland
2016-02-16 22:27 ` [PATCH v2 06/26] drm/amd/dal: Adapter Service Harry Wentland
2016-02-16 22:27 ` [PATCH v2 07/26] drm/amd/dal: BIOS Parser Harry Wentland
2016-02-16 22:27 ` [PATCH v2 08/26] drm/amd/dal: I2C Aux Manager Harry Wentland
2016-02-16 22:27 ` [PATCH v2 09/26] drm/amd/dal: IRQ Service Harry Wentland
2016-02-16 22:27 ` [PATCH v2 10/26] drm/amd/dal: GPU Harry Wentland
2016-02-16 22:27 ` [PATCH v2 11/26] drm/amd/dal: Audio Harry Wentland
2016-02-16 22:27 ` [PATCH v2 12/26] drm/amd/dal: Bandwidth calculations Harry Wentland
2016-02-16 22:27 ` [PATCH v2 13/26] drm/amd/dal: Add encoder HW programming Harry Wentland
2016-02-16 22:27 ` [PATCH v2 14/26] drm/amd/dal: Add clock source " Harry Wentland
2016-02-16 22:27 ` [PATCH v2 15/26] drm/amd/dal: Add timing generator " Harry Wentland
2016-02-16 22:27 ` [PATCH v2 16/26] drm/amd/dal: Add surface " Harry Wentland
2016-02-16 22:27 ` [PATCH v2 17/26] drm/amd/dal: Add framebuffer compression " Harry Wentland
2016-02-16 22:27 ` [PATCH v2 18/26] drm/amd/dal: Add input pixel processing " Harry Wentland
2016-02-16 22:27 ` [PATCH v2 19/26] drm/amd/dal: Add output " Harry Wentland
2016-02-16 22:28 ` [PATCH v2 20/26] drm/amd/dal: Add transform & scaler " Harry Wentland
2016-02-16 22:28 ` [PATCH v2 21/26] drm/amd/dal: Add Carrizo HW sequencer and resource Harry Wentland
2016-02-16 22:28 ` [PATCH v2 22/26] drm/amd/dal: Add Tonga/Fiji " Harry Wentland
2016-02-16 22:28 ` [PATCH v2 23/26] drm/amd/dal: Add empty encoder programming for virtual HW Harry Wentland
2016-02-16 22:28 ` [PATCH v2 24/26] drm/amd/dal: Add display core Harry Wentland
2016-02-16 22:28 ` [PATCH v2 25/26] drm/amd/dal: Adding amdgpu_dm for dal Harry Wentland
2016-02-16 22:28 ` [PATCH v2 26/26] drm/amdgpu: Use dal driver for Carrizo, Tonga, and Fiji Harry Wentland
2016-02-29 21:56 ` [PATCH v3 00/26] Enabling new DAL display driver for amdgpu on Carrizo and Tonga Harry Wentland
2016-02-29 21:56 ` [PATCH v3 01/26] drm/amd/dal: Add dal headers Harry Wentland
2016-02-29 21:56 ` [PATCH v3 05/26] drm/amd/dal: GPIO (General Purpose IO) Harry Wentland
2016-02-29 21:56 ` [PATCH v3 07/26] drm/amd/dal: BIOS Parser Harry Wentland
2016-02-29 21:56 ` [PATCH v3 24/26] drm/amd/dal: Add display core Harry Wentland
2016-02-29 21:56 ` [PATCH v3 25/26] drm/amd/dal: Adding amdgpu_dm for dal Harry Wentland
2016-02-29 21:56 ` [PATCH v3 26/26] drm/amdgpu: Use dal driver for Carrizo, Tonga, and Fiji Harry Wentland
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=1455211209-26733-7-git-send-email-harry.wentland@amd.com \
--to=harry.wentland@amd.com \
--cc=dri-devel@lists.freedesktop.org \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.