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__ */