diff options
Diffstat (limited to 'common/recipes-kernel/linux/linux-yocto-4.14.71/4910-drm-amd-display-Convert-remaining-loggers-off-dc_log.patch')
| -rw-r--r-- | common/recipes-kernel/linux/linux-yocto-4.14.71/4910-drm-amd-display-Convert-remaining-loggers-off-dc_log.patch | 1148 |
1 files changed, 1148 insertions, 0 deletions
diff --git a/common/recipes-kernel/linux/linux-yocto-4.14.71/4910-drm-amd-display-Convert-remaining-loggers-off-dc_log.patch b/common/recipes-kernel/linux/linux-yocto-4.14.71/4910-drm-amd-display-Convert-remaining-loggers-off-dc_log.patch new file mode 100644 index 00000000..fea0ebe9 --- /dev/null +++ b/common/recipes-kernel/linux/linux-yocto-4.14.71/4910-drm-amd-display-Convert-remaining-loggers-off-dc_log.patch @@ -0,0 +1,1148 @@ +From d61f6143e00948ad798ee4f747124addd1988d01 Mon Sep 17 00:00:00 2001 +From: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com> +Date: Tue, 19 Jun 2018 09:58:24 -0400 +Subject: [PATCH 4910/5725] drm/amd/display: Convert remaining loggers off + dc_logger + +- Removed dal/dm/dc loggers from linux, switched to kernel prints +- Modified functions that used these directly to use macros +- dc_logger support is completely dropped from Linux + +Signed-off-by: Nicholas Kazlauskas <nicholas.kazlauskas@amd.com> +Reviewed-by: Harry Wentland <Harry.Wentland@amd.com> +Signed-off-by: Alex Deucher <alexander.deucher@amd.com> +Signed-off-by: Raveendra Talabattula <raveendra.talabattula@amd.com> +--- + drivers/gpu/drm/amd/display/TODO | 8 +- + drivers/gpu/drm/amd/display/dc/basics/Makefile | 2 +- + .../gpu/drm/amd/display/dc/basics/log_helpers.c | 71 +--- + drivers/gpu/drm/amd/display/dc/basics/logger.c | 406 --------------------- + .../gpu/drm/amd/display/dc/calcs/calcs_logger.h | 9 +- + drivers/gpu/drm/amd/display/dc/calcs/dce_calcs.c | 6 +- + drivers/gpu/drm/amd/display/dc/core/dc.c | 15 +- + drivers/gpu/drm/amd/display/dc/core/dc_stream.c | 23 +- + drivers/gpu/drm/amd/display/dc/dc_stream.h | 5 +- + drivers/gpu/drm/amd/display/dc/dc_types.h | 2 - + .../drm/amd/display/dc/dce110/dce110_resource.c | 34 +- + .../drm/amd/display/dc/dce112/dce112_resource.c | 34 +- + .../gpu/drm/amd/display/include/logger_interface.h | 138 +++---- + drivers/gpu/drm/amd/display/include/logger_types.h | 59 --- + 14 files changed, 99 insertions(+), 713 deletions(-) + delete mode 100644 drivers/gpu/drm/amd/display/dc/basics/logger.c + +diff --git a/drivers/gpu/drm/amd/display/TODO b/drivers/gpu/drm/amd/display/TODO +index 357d5964..a8a6c10 100644 +--- a/drivers/gpu/drm/amd/display/TODO ++++ b/drivers/gpu/drm/amd/display/TODO +@@ -97,10 +97,10 @@ share it with drivers. But that's a very long term goal, and by far not just an + issue with DC - other drivers, especially around DP sink handling, are equally + guilty. + +-19. The DC logger is still a rather sore thing, but I know that the DRM_DEBUG +-stuff just isn't up to the challenges either. We need to figure out something +-that integrates better with DRM and linux debug printing, while not being +-useless with filtering output. dynamic debug printing might be an option. ++19. DONE - The DC logger is still a rather sore thing, but I know that the ++DRM_DEBUG stuff just isn't up to the challenges either. We need to figure out ++something that integrates better with DRM and linux debug printing, while not ++being useless with filtering output. dynamic debug printing might be an option. + + 20. Use kernel i2c device to program HDMI retimer. Some boards have an HDMI + retimer that we need to program to pass PHY compliance. Currently that's +diff --git a/drivers/gpu/drm/amd/display/dc/basics/Makefile b/drivers/gpu/drm/amd/display/dc/basics/Makefile +index fbf4dbf..ccd94a3 100644 +--- a/drivers/gpu/drm/amd/display/dc/basics/Makefile ++++ b/drivers/gpu/drm/amd/display/dc/basics/Makefile +@@ -4,7 +4,7 @@ + # subcomponents. + + BASICS = conversion.o fixpt31_32.o \ +- logger.o log_helpers.o vector.o ++ log_helpers.o vector.o + + AMD_DAL_BASICS = $(addprefix $(AMDDALPATH)/dc/basics/,$(BASICS)) + +diff --git a/drivers/gpu/drm/amd/display/dc/basics/log_helpers.c b/drivers/gpu/drm/amd/display/dc/basics/log_helpers.c +index f6c00a5..26583f3 100644 +--- a/drivers/gpu/drm/amd/display/dc/basics/log_helpers.c ++++ b/drivers/gpu/drm/amd/display/dc/basics/log_helpers.c +@@ -28,77 +28,12 @@ + #include "include/logger_interface.h" + #include "dm_helpers.h" + +-#define NUM_ELEMENTS(a) (sizeof(a) / sizeof((a)[0])) +- +-struct dc_signal_type_info { +- enum signal_type type; +- char name[MAX_NAME_LEN]; +-}; +- +-static const struct dc_signal_type_info signal_type_info_tbl[] = { +- {SIGNAL_TYPE_NONE, "NC"}, +- {SIGNAL_TYPE_DVI_SINGLE_LINK, "DVI"}, +- {SIGNAL_TYPE_DVI_DUAL_LINK, "DDVI"}, +- {SIGNAL_TYPE_HDMI_TYPE_A, "HDMIA"}, +- {SIGNAL_TYPE_LVDS, "LVDS"}, +- {SIGNAL_TYPE_RGB, "VGA"}, +- {SIGNAL_TYPE_DISPLAY_PORT, "DP"}, +- {SIGNAL_TYPE_DISPLAY_PORT_MST, "MST"}, +- {SIGNAL_TYPE_EDP, "eDP"}, +- {SIGNAL_TYPE_VIRTUAL, "Virtual"} +-}; +- +-void dc_conn_log(struct dc_context *ctx, +- const struct dc_link *link, +- uint8_t *hex_data, +- int hex_data_count, +- enum dc_log_type event, +- const char *msg, +- ...) ++void dc_conn_log_hex_linux(const uint8_t *hex_data, int hex_data_count) + { + int i; +- va_list args; +- struct log_entry entry = { 0 }; +- enum signal_type signal; +- +- if (link->local_sink) +- signal = link->local_sink->sink_signal; +- else +- signal = link->connector_signal; +- +- if (link->type == dc_connection_mst_branch) +- signal = SIGNAL_TYPE_DISPLAY_PORT_MST; +- +- dm_logger_open(ctx->logger, &entry, event); +- +- for (i = 0; i < NUM_ELEMENTS(signal_type_info_tbl); i++) +- if (signal == signal_type_info_tbl[i].type) +- break; +- +- if (i == NUM_ELEMENTS(signal_type_info_tbl)) +- goto fail; +- +- dm_logger_append_heading(&entry); +- +- dm_logger_append(&entry, "[%s][ConnIdx:%d] ", +- signal_type_info_tbl[i].name, +- link->link_index); +- +- va_start(args, msg); +- dm_logger_append_va(&entry, msg, args); +- +- if (entry.buf_offset > 0 && +- entry.buf[entry.buf_offset - 1] == '\n') +- entry.buf_offset--; + + if (hex_data) + for (i = 0; i < hex_data_count; i++) +- dm_logger_append(&entry, "%2.2X ", hex_data[i]); +- +- dm_logger_append(&entry, "^\n"); +- +-fail: +- dm_logger_close(&entry); +- +- va_end(args); ++ DC_LOG_DEBUG("%2.2X ", hex_data[i]); + } ++ +diff --git a/drivers/gpu/drm/amd/display/dc/basics/logger.c b/drivers/gpu/drm/amd/display/dc/basics/logger.c +deleted file mode 100644 +index 733bc5b..0000000 +--- a/drivers/gpu/drm/amd/display/dc/basics/logger.c ++++ /dev/null +@@ -1,406 +0,0 @@ +-/* +- * 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/logger_interface.h" +-#include "logger.h" +- +- +-#define NUM_ELEMENTS(a) (sizeof(a) / sizeof((a)[0])) +- +-static const struct dc_log_type_info log_type_info_tbl[] = { +- {LOG_ERROR, "Error"}, +- {LOG_WARNING, "Warning"}, +- {LOG_DEBUG, "Debug"}, +- {LOG_DC, "DC_Interface"}, +- {LOG_DTN, "DTN"}, +- {LOG_SURFACE, "Surface"}, +- {LOG_HW_HOTPLUG, "HW_Hotplug"}, +- {LOG_HW_LINK_TRAINING, "HW_LKTN"}, +- {LOG_HW_SET_MODE, "HW_Mode"}, +- {LOG_HW_RESUME_S3, "HW_Resume"}, +- {LOG_HW_AUDIO, "HW_Audio"}, +- {LOG_HW_HPD_IRQ, "HW_HPDIRQ"}, +- {LOG_MST, "MST"}, +- {LOG_SCALER, "Scaler"}, +- {LOG_BIOS, "BIOS"}, +- {LOG_BANDWIDTH_CALCS, "BWCalcs"}, +- {LOG_BANDWIDTH_VALIDATION, "BWValidation"}, +- {LOG_I2C_AUX, "I2C_AUX"}, +- {LOG_SYNC, "Sync"}, +- {LOG_BACKLIGHT, "Backlight"}, +- {LOG_FEATURE_OVERRIDE, "Override"}, +- {LOG_DETECTION_EDID_PARSER, "Edid"}, +- {LOG_DETECTION_DP_CAPS, "DP_Caps"}, +- {LOG_RESOURCE, "Resource"}, +- {LOG_DML, "DML"}, +- {LOG_EVENT_MODE_SET, "Mode"}, +- {LOG_EVENT_DETECTION, "Detect"}, +- {LOG_EVENT_LINK_TRAINING, "LKTN"}, +- {LOG_EVENT_LINK_LOSS, "LinkLoss"}, +- {LOG_EVENT_UNDERFLOW, "Underflow"}, +- {LOG_IF_TRACE, "InterfaceTrace"}, +- {LOG_PERF_TRACE, "PerfTrace"}, +- {LOG_DISPLAYSTATS, "DisplayStats"} +-}; +- +- +-/* ----------- Object init and destruction ----------- */ +-static bool construct(struct dc_context *ctx, struct dal_logger *logger, +- uint32_t log_mask) +-{ +- /* malloc buffer and init offsets */ +- logger->log_buffer_size = DAL_LOGGER_BUFFER_MAX_SIZE; +- logger->log_buffer = kcalloc(logger->log_buffer_size, sizeof(char), +- GFP_KERNEL); +- if (!logger->log_buffer) +- return false; +- +- /* Initialize both offsets to start of buffer (empty) */ +- logger->buffer_read_offset = 0; +- logger->buffer_write_offset = 0; +- +- logger->open_count = 0; +- +- logger->flags.bits.ENABLE_CONSOLE = 1; +- logger->flags.bits.ENABLE_BUFFER = 0; +- +- logger->ctx = ctx; +- +- logger->mask = log_mask; +- +- return true; +-} +- +-static void destruct(struct dal_logger *logger) +-{ +- if (logger->log_buffer) { +- kfree(logger->log_buffer); +- logger->log_buffer = NULL; +- } +-} +- +-struct dal_logger *dal_logger_create(struct dc_context *ctx, uint32_t log_mask) +-{ +- /* malloc struct */ +- struct dal_logger *logger = kzalloc(sizeof(struct dal_logger), +- GFP_KERNEL); +- +- if (!logger) +- return NULL; +- if (!construct(ctx, logger, log_mask)) { +- kfree(logger); +- return NULL; +- } +- +- return logger; +-} +- +-uint32_t dal_logger_destroy(struct dal_logger **logger) +-{ +- if (logger == NULL || *logger == NULL) +- return 1; +- destruct(*logger); +- kfree(*logger); +- *logger = NULL; +- +- return 0; +-} +- +-/* ------------------------------------------------------------------------ */ +-void dm_logger_append_heading(struct log_entry *entry) +-{ +- int j; +- +- for (j = 0; j < NUM_ELEMENTS(log_type_info_tbl); j++) { +- +- const struct dc_log_type_info *info = &log_type_info_tbl[j]; +- +- if (info->type == entry->type) +- dm_logger_append(entry, "[%s]\t", info->name); +- } +-} +- +- +-/* Print everything unread existing in log_buffer to debug console*/ +-void dm_logger_flush_buffer(struct dal_logger *logger, bool should_warn) +-{ +- char *string_start = &logger->log_buffer[logger->buffer_read_offset]; +- +- if (should_warn) +- dm_output_to_console( +- "---------------- FLUSHING LOG BUFFER ----------------\n"); +- while (logger->buffer_read_offset < logger->buffer_write_offset) { +- +- if (logger->log_buffer[logger->buffer_read_offset] == '\0') { +- dm_output_to_console("%s", string_start); +- string_start = logger->log_buffer + logger->buffer_read_offset + 1; +- } +- logger->buffer_read_offset++; +- } +- if (should_warn) +- dm_output_to_console( +- "-------------- END FLUSHING LOG BUFFER --------------\n\n"); +-} +-/* ------------------------------------------------------------------------ */ +- +-/* Warning: Be careful that 'msg' is null terminated and the total size is +- * less than DAL_LOGGER_BUFFER_MAX_LOG_LINE_SIZE (256) including '\0' +- */ +-static bool dal_logger_should_log( +- struct dal_logger *logger, +- enum dc_log_type log_type) +-{ +- if (logger->mask & (1 << log_type)) +- return true; +- +- return false; +-} +- +-static void log_to_debug_console(struct log_entry *entry) +-{ +- struct dal_logger *logger = entry->logger; +- +- if (logger->flags.bits.ENABLE_CONSOLE == 0) +- return; +- +- if (entry->buf_offset) { +- switch (entry->type) { +- case LOG_ERROR: +- dm_error("%s", entry->buf); +- break; +- default: +- dm_output_to_console("%s", entry->buf); +- break; +- } +- } +-} +- +- +-static void log_to_internal_buffer(struct log_entry *entry) +-{ +- +- uint32_t size = entry->buf_offset; +- struct dal_logger *logger = entry->logger; +- +- if (logger->flags.bits.ENABLE_BUFFER == 0) +- return; +- +- if (logger->log_buffer == NULL) +- return; +- +- if (size > 0 && size < logger->log_buffer_size) { +- +- int buffer_space = logger->log_buffer_size - +- logger->buffer_write_offset; +- +- if (logger->buffer_write_offset == logger->buffer_read_offset) { +- /* Buffer is empty, start writing at beginning */ +- buffer_space = logger->log_buffer_size; +- logger->buffer_write_offset = 0; +- logger->buffer_read_offset = 0; +- } +- +- if (buffer_space > size) { +- /* No wrap around, copy 'size' bytes +- * from 'entry->buf' to 'log_buffer' +- */ +- memmove(logger->log_buffer + +- logger->buffer_write_offset, +- entry->buf, size); +- logger->buffer_write_offset += size; +- +- } else { +- /* Not enough room remaining, we should flush +- * existing logs */ +- +- /* Flush existing unread logs to console */ +- dm_logger_flush_buffer(logger, true); +- +- /* Start writing to beginning of buffer */ +- memmove(logger->log_buffer, entry->buf, size); +- logger->buffer_write_offset = size; +- logger->buffer_read_offset = 0; +- } +- +- } +-} +- +-static void append_entry( +- struct log_entry *entry, +- char *buffer, +- uint32_t buf_size) +-{ +- if (!entry->buf || +- entry->buf_offset + buf_size > entry->max_buf_bytes +- ) { +- BREAK_TO_DEBUGGER(); +- return; +- } +- +- /* Todo: check if off by 1 byte due to \0 anywhere */ +- memmove(entry->buf + entry->buf_offset, buffer, buf_size); +- entry->buf_offset += buf_size; +-} +- +- +-void dm_logger_write( +- struct dal_logger *logger, +- enum dc_log_type log_type, +- const char *msg, +- ...) +-{ +- if (logger && dal_logger_should_log(logger, log_type)) { +- uint32_t size; +- va_list args; +- char buffer[LOG_MAX_LINE_SIZE]; +- struct log_entry entry; +- +- va_start(args, msg); +- +- entry.logger = logger; +- +- entry.buf = buffer; +- +- entry.buf_offset = 0; +- entry.max_buf_bytes = DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char); +- +- entry.type = log_type; +- +- dm_logger_append_heading(&entry); +- +- size = dm_log_to_buffer( +- buffer, LOG_MAX_LINE_SIZE - 1, msg, args); +- +- buffer[entry.buf_offset + size] = '\0'; +- entry.buf_offset += size + 1; +- +- /* --Flush log_entry buffer-- */ +- /* print to kernel console */ +- log_to_debug_console(&entry); +- /* log internally for dsat */ +- log_to_internal_buffer(&entry); +- +- va_end(args); +- } +-} +- +-/* Same as dm_logger_write, except without open() and close(), which must +- * be done separately. +- */ +-void dm_logger_append( +- struct log_entry *entry, +- const char *msg, +- ...) +-{ +- va_list args; +- +- va_start(args, msg); +- dm_logger_append_va(entry, msg, args); +- va_end(args); +-} +- +-void dm_logger_append_va( +- struct log_entry *entry, +- const char *msg, +- va_list args) +-{ +- struct dal_logger *logger; +- +- if (!entry) { +- BREAK_TO_DEBUGGER(); +- return; +- } +- +- logger = entry->logger; +- +- if (logger && logger->open_count > 0 && +- dal_logger_should_log(logger, entry->type)) { +- +- uint32_t size; +- char buffer[LOG_MAX_LINE_SIZE]; +- +- size = dm_log_to_buffer( +- buffer, LOG_MAX_LINE_SIZE, msg, args); +- +- if (size < LOG_MAX_LINE_SIZE - 1) { +- append_entry(entry, buffer, size); +- } else { +- append_entry(entry, "LOG_ERROR, line too long\n", 27); +- } +- } +-} +- +-void dm_logger_open( +- struct dal_logger *logger, +- struct log_entry *entry, /* out */ +- enum dc_log_type log_type) +-{ +- if (!entry) { +- BREAK_TO_DEBUGGER(); +- return; +- } +- +- entry->type = log_type; +- entry->logger = logger; +- +- entry->buf = kzalloc(DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char), +- GFP_KERNEL); +- +- entry->buf_offset = 0; +- entry->max_buf_bytes = DAL_LOGGER_BUFFER_MAX_SIZE * sizeof(char); +- +- logger->open_count++; +- +- dm_logger_append_heading(entry); +-} +- +-void dm_logger_close(struct log_entry *entry) +-{ +- struct dal_logger *logger = entry->logger; +- +- if (logger && logger->open_count > 0) { +- logger->open_count--; +- } else { +- BREAK_TO_DEBUGGER(); +- goto cleanup; +- } +- +- /* --Flush log_entry buffer-- */ +- /* print to kernel console */ +- log_to_debug_console(entry); +- /* log internally for dsat */ +- log_to_internal_buffer(entry); +- +- /* TODO: Write end heading */ +- +-cleanup: +- if (entry->buf) { +- kfree(entry->buf); +- entry->buf = NULL; +- entry->buf_offset = 0; +- entry->max_buf_bytes = 0; +- } +-} +- +diff --git a/drivers/gpu/drm/amd/display/dc/calcs/calcs_logger.h b/drivers/gpu/drm/amd/display/dc/calcs/calcs_logger.h +index fc3f98f..62435bf 100644 +--- a/drivers/gpu/drm/amd/display/dc/calcs/calcs_logger.h ++++ b/drivers/gpu/drm/amd/display/dc/calcs/calcs_logger.h +@@ -25,10 +25,9 @@ + + #ifndef _CALCS_CALCS_LOGGER_H_ + #define _CALCS_CALCS_LOGGER_H_ +-#define DC_LOGGER \ +- logger ++#define DC_LOGGER ctx->logger + +-static void print_bw_calcs_dceip(struct dal_logger *logger, const struct bw_calcs_dceip *dceip) ++static void print_bw_calcs_dceip(struct dc_context *ctx, const struct bw_calcs_dceip *dceip) + { + + DC_LOG_BANDWIDTH_CALCS("#####################################################################"); +@@ -122,7 +121,7 @@ static void print_bw_calcs_dceip(struct dal_logger *logger, const struct bw_calc + + } + +-static void print_bw_calcs_vbios(struct dal_logger *logger, const struct bw_calcs_vbios *vbios) ++static void print_bw_calcs_vbios(struct dc_context *ctx, const struct bw_calcs_vbios *vbios) + { + + DC_LOG_BANDWIDTH_CALCS("#####################################################################"); +@@ -181,7 +180,7 @@ static void print_bw_calcs_vbios(struct dal_logger *logger, const struct bw_calc + + } + +-static void print_bw_calcs_data(struct dal_logger *logger, struct bw_calcs_data *data) ++static void print_bw_calcs_data(struct dc_context *ctx, struct bw_calcs_data *data) + { + + int i, j, k; +diff --git a/drivers/gpu/drm/amd/display/dc/calcs/dce_calcs.c b/drivers/gpu/drm/amd/display/dc/calcs/dce_calcs.c +index 2c4e8f0..160d11a 100644 +--- a/drivers/gpu/drm/amd/display/dc/calcs/dce_calcs.c ++++ b/drivers/gpu/drm/amd/display/dc/calcs/dce_calcs.c +@@ -3010,9 +3010,9 @@ bool bw_calcs(struct dc_context *ctx, + struct bw_fixed low_yclk = vbios->low_yclk; + + if (ctx->dc->debug.bandwidth_calcs_trace) { +- print_bw_calcs_dceip(ctx->logger, dceip); +- print_bw_calcs_vbios(ctx->logger, vbios); +- print_bw_calcs_data(ctx->logger, data); ++ print_bw_calcs_dceip(ctx, dceip); ++ print_bw_calcs_vbios(ctx, vbios); ++ print_bw_calcs_data(ctx, data); + } + calculate_bandwidth(dceip, vbios, data); + +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc.c b/drivers/gpu/drm/amd/display/dc/core/dc.c +index b14741d..e9e7953 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc.c +@@ -465,9 +465,6 @@ static void destruct(struct dc *dc) + if (dc->ctx->created_bios) + dal_bios_parser_destroy(&dc->ctx->dc_bios); + +- if (dc->ctx->logger) +- dal_logger_destroy(&dc->ctx->logger); +- + kfree(dc->ctx); + dc->ctx = NULL; + +@@ -490,7 +487,6 @@ static void destruct(struct dc *dc) + static bool construct(struct dc *dc, + const struct dc_init_data *init_params) + { +- struct dal_logger *logger; + struct dc_context *dc_ctx; + struct bw_calcs_dceip *dc_dceip; + struct bw_calcs_vbios *dc_vbios; +@@ -555,14 +551,7 @@ static bool construct(struct dc *dc, + } + + /* Create logger */ +- logger = dal_logger_create(dc_ctx, init_params->log_mask); + +- if (!logger) { +- /* can *not* call logger. call base driver 'print error' */ +- dm_error("%s: failed to create Logger!\n", __func__); +- goto fail; +- } +- dc_ctx->logger = logger; + dc_ctx->dce_environment = init_params->dce_environment; + + dc_version = resource_parse_asic_id(init_params->asic_id); +@@ -1007,9 +996,7 @@ bool dc_commit_state(struct dc *dc, struct dc_state *context) + for (i = 0; i < context->stream_count; i++) { + struct dc_stream_state *stream = context->streams[i]; + +- dc_stream_log(stream, +- dc->ctx->logger, +- LOG_DC); ++ dc_stream_log(dc, stream); + } + + result = dc_commit_state_no_check(dc, context); +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_stream.c b/drivers/gpu/drm/amd/display/dc/core/dc_stream.c +index 3732a1d..0223f48 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc_stream.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc_stream.c +@@ -30,6 +30,8 @@ + #include "ipp.h" + #include "timing_generator.h" + ++#define DC_LOGGER dc->ctx->logger ++ + /******************************************************************************* + * Private functions + ******************************************************************************/ +@@ -317,16 +319,10 @@ bool dc_stream_get_scanoutpos(const struct dc_stream_state *stream, + return ret; + } + +- +-void dc_stream_log( +- const struct dc_stream_state *stream, +- struct dal_logger *dm_logger, +- enum dc_log_type log_type) ++void dc_stream_log(const struct dc *dc, const struct dc_stream_state *stream) + { +- +- dm_logger_write(dm_logger, +- log_type, +- "core_stream 0x%x: src: %d, %d, %d, %d; dst: %d, %d, %d, %d, colorSpace:%d\n", ++ DC_LOG_DC( ++ "core_stream 0x%p: src: %d, %d, %d, %d; dst: %d, %d, %d, %d, colorSpace:%d\n", + stream, + stream->src.x, + stream->src.y, +@@ -337,21 +333,18 @@ void dc_stream_log( + stream->dst.width, + stream->dst.height, + stream->output_color_space); +- dm_logger_write(dm_logger, +- log_type, ++ DC_LOG_DC( + "\tpix_clk_khz: %d, h_total: %d, v_total: %d, pixelencoder:%d, displaycolorDepth:%d\n", + stream->timing.pix_clk_khz, + stream->timing.h_total, + stream->timing.v_total, + stream->timing.pixel_encoding, + stream->timing.display_color_depth); +- dm_logger_write(dm_logger, +- log_type, ++ DC_LOG_DC( + "\tsink name: %s, serial: %d\n", + stream->sink->edid_caps.display_name, + stream->sink->edid_caps.serial_number); +- dm_logger_write(dm_logger, +- log_type, ++ DC_LOG_DC( + "\tlink: %d\n", + stream->sink->link->link_index); + } +diff --git a/drivers/gpu/drm/amd/display/dc/dc_stream.h b/drivers/gpu/drm/amd/display/dc/dc_stream.h +index 597c6bf..e7a05d2 100644 +--- a/drivers/gpu/drm/amd/display/dc/dc_stream.h ++++ b/drivers/gpu/drm/amd/display/dc/dc_stream.h +@@ -158,10 +158,7 @@ void dc_commit_updates_for_stream(struct dc *dc, + /* + * Log the current stream state. + */ +-void dc_stream_log( +- const struct dc_stream_state *stream, +- struct dal_logger *dc_logger, +- enum dc_log_type log_type); ++void dc_stream_log(const struct dc *dc, const struct dc_stream_state *stream); + + uint8_t dc_get_current_stream_count(struct dc *dc); + struct dc_stream_state *dc_get_stream_at_index(struct dc *dc, uint8_t i); +diff --git a/drivers/gpu/drm/amd/display/dc/dc_types.h b/drivers/gpu/drm/amd/display/dc/dc_types.h +index 9467249..59bf0d5 100644 +--- a/drivers/gpu/drm/amd/display/dc/dc_types.h ++++ b/drivers/gpu/drm/amd/display/dc/dc_types.h +@@ -77,8 +77,6 @@ struct dc_context { + struct dc *dc; + + void *driver_context; /* e.g. amdgpu_device */ +- +- struct dal_logger *logger; + void *cgs_device; + + enum dce_environment dce_environment; +diff --git a/drivers/gpu/drm/amd/display/dc/dce110/dce110_resource.c b/drivers/gpu/drm/amd/display/dc/dce110/dce110_resource.c +index 3edaa00..1c902e4 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce110/dce110_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/dce110/dce110_resource.c +@@ -794,43 +794,38 @@ static bool dce110_validate_bandwidth( + + if (memcmp(&dc->current_state->bw.dce, + &context->bw.dce, sizeof(context->bw.dce))) { +- struct log_entry log_entry; +- dm_logger_open( +- dc->ctx->logger, +- &log_entry, +- LOG_BANDWIDTH_CALCS); +- dm_logger_append(&log_entry, "%s: finish,\n" ++ ++ DC_LOG_BANDWIDTH_CALCS( ++ "%s: finish,\n" ++ "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" ++ "stutMark_b: %d stutMark_a: %d\n" + "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" +- "stutMark_b: %d stutMark_a: %d\n", ++ "stutMark_b: %d stutMark_a: %d\n" ++ "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" ++ "stutMark_b: %d stutMark_a: %d stutter_mode_enable: %d\n" ++ "cstate: %d pstate: %d nbpstate: %d sync: %d dispclk: %d\n" ++ "sclk: %d sclk_sleep: %d yclk: %d blackout_recovery_time_us: %d\n" ++ , + __func__, + context->bw.dce.nbp_state_change_wm_ns[0].b_mark, + context->bw.dce.nbp_state_change_wm_ns[0].a_mark, + context->bw.dce.urgent_wm_ns[0].b_mark, + context->bw.dce.urgent_wm_ns[0].a_mark, + context->bw.dce.stutter_exit_wm_ns[0].b_mark, +- context->bw.dce.stutter_exit_wm_ns[0].a_mark); +- dm_logger_append(&log_entry, +- "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" +- "stutMark_b: %d stutMark_a: %d\n", ++ context->bw.dce.stutter_exit_wm_ns[0].a_mark, + context->bw.dce.nbp_state_change_wm_ns[1].b_mark, + context->bw.dce.nbp_state_change_wm_ns[1].a_mark, + context->bw.dce.urgent_wm_ns[1].b_mark, + context->bw.dce.urgent_wm_ns[1].a_mark, + context->bw.dce.stutter_exit_wm_ns[1].b_mark, +- context->bw.dce.stutter_exit_wm_ns[1].a_mark); +- dm_logger_append(&log_entry, +- "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" +- "stutMark_b: %d stutMark_a: %d stutter_mode_enable: %d\n", ++ context->bw.dce.stutter_exit_wm_ns[1].a_mark, + context->bw.dce.nbp_state_change_wm_ns[2].b_mark, + context->bw.dce.nbp_state_change_wm_ns[2].a_mark, + context->bw.dce.urgent_wm_ns[2].b_mark, + context->bw.dce.urgent_wm_ns[2].a_mark, + context->bw.dce.stutter_exit_wm_ns[2].b_mark, + context->bw.dce.stutter_exit_wm_ns[2].a_mark, +- context->bw.dce.stutter_mode_enable); +- dm_logger_append(&log_entry, +- "cstate: %d pstate: %d nbpstate: %d sync: %d dispclk: %d\n" +- "sclk: %d sclk_sleep: %d yclk: %d blackout_recovery_time_us: %d\n", ++ context->bw.dce.stutter_mode_enable, + context->bw.dce.cpuc_state_change_enable, + context->bw.dce.cpup_state_change_enable, + context->bw.dce.nbp_state_change_enable, +@@ -840,7 +835,6 @@ static bool dce110_validate_bandwidth( + context->bw.dce.sclk_deep_sleep_khz, + context->bw.dce.yclk_khz, + context->bw.dce.blackout_recovery_time_us); +- dm_logger_close(&log_entry); + } + return result; + } +diff --git a/drivers/gpu/drm/amd/display/dc/dce112/dce112_resource.c b/drivers/gpu/drm/amd/display/dc/dce112/dce112_resource.c +index 9e1afb1..30d5b32 100644 +--- a/drivers/gpu/drm/amd/display/dc/dce112/dce112_resource.c ++++ b/drivers/gpu/drm/amd/display/dc/dce112/dce112_resource.c +@@ -744,43 +744,38 @@ bool dce112_validate_bandwidth( + + if (memcmp(&dc->current_state->bw.dce, + &context->bw.dce, sizeof(context->bw.dce))) { +- struct log_entry log_entry; +- dm_logger_open( +- dc->ctx->logger, +- &log_entry, +- LOG_BANDWIDTH_CALCS); +- dm_logger_append(&log_entry, "%s: finish,\n" ++ ++ DC_LOG_BANDWIDTH_CALCS( ++ "%s: finish,\n" ++ "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" ++ "stutMark_b: %d stutMark_a: %d\n" + "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" +- "stutMark_b: %d stutMark_a: %d\n", ++ "stutMark_b: %d stutMark_a: %d\n" ++ "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" ++ "stutMark_b: %d stutMark_a: %d stutter_mode_enable: %d\n" ++ "cstate: %d pstate: %d nbpstate: %d sync: %d dispclk: %d\n" ++ "sclk: %d sclk_sleep: %d yclk: %d blackout_recovery_time_us: %d\n" ++ , + __func__, + context->bw.dce.nbp_state_change_wm_ns[0].b_mark, + context->bw.dce.nbp_state_change_wm_ns[0].a_mark, + context->bw.dce.urgent_wm_ns[0].b_mark, + context->bw.dce.urgent_wm_ns[0].a_mark, + context->bw.dce.stutter_exit_wm_ns[0].b_mark, +- context->bw.dce.stutter_exit_wm_ns[0].a_mark); +- dm_logger_append(&log_entry, +- "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" +- "stutMark_b: %d stutMark_a: %d\n", ++ context->bw.dce.stutter_exit_wm_ns[0].a_mark, + context->bw.dce.nbp_state_change_wm_ns[1].b_mark, + context->bw.dce.nbp_state_change_wm_ns[1].a_mark, + context->bw.dce.urgent_wm_ns[1].b_mark, + context->bw.dce.urgent_wm_ns[1].a_mark, + context->bw.dce.stutter_exit_wm_ns[1].b_mark, +- context->bw.dce.stutter_exit_wm_ns[1].a_mark); +- dm_logger_append(&log_entry, +- "nbpMark_b: %d nbpMark_a: %d urgentMark_b: %d urgentMark_a: %d\n" +- "stutMark_b: %d stutMark_a: %d stutter_mode_enable: %d\n", ++ context->bw.dce.stutter_exit_wm_ns[1].a_mark, + context->bw.dce.nbp_state_change_wm_ns[2].b_mark, + context->bw.dce.nbp_state_change_wm_ns[2].a_mark, + context->bw.dce.urgent_wm_ns[2].b_mark, + context->bw.dce.urgent_wm_ns[2].a_mark, + context->bw.dce.stutter_exit_wm_ns[2].b_mark, + context->bw.dce.stutter_exit_wm_ns[2].a_mark, +- context->bw.dce.stutter_mode_enable); +- dm_logger_append(&log_entry, +- "cstate: %d pstate: %d nbpstate: %d sync: %d dispclk: %d\n" +- "sclk: %d sclk_sleep: %d yclk: %d blackout_recovery_time_us: %d\n", ++ context->bw.dce.stutter_mode_enable, + context->bw.dce.cpuc_state_change_enable, + context->bw.dce.cpup_state_change_enable, + context->bw.dce.nbp_state_change_enable, +@@ -790,7 +785,6 @@ bool dce112_validate_bandwidth( + context->bw.dce.sclk_deep_sleep_khz, + context->bw.dce.yclk_khz, + context->bw.dce.blackout_recovery_time_us); +- dm_logger_close(&log_entry); + } + return result; + } +diff --git a/drivers/gpu/drm/amd/display/include/logger_interface.h b/drivers/gpu/drm/amd/display/include/logger_interface.h +index 0f10ed7..e3c7961 100644 +--- a/drivers/gpu/drm/amd/display/include/logger_interface.h ++++ b/drivers/gpu/drm/amd/display/include/logger_interface.h +@@ -40,49 +40,7 @@ struct dc_state; + * + */ + +-struct dal_logger *dal_logger_create(struct dc_context *ctx, uint32_t log_mask); +- +-uint32_t dal_logger_destroy(struct dal_logger **logger); +- +-void dm_logger_flush_buffer(struct dal_logger *logger, bool should_warn); +- +-void dm_logger_write( +- struct dal_logger *logger, +- enum dc_log_type log_type, +- const char *msg, +- ...); +- +-void dm_logger_append( +- struct log_entry *entry, +- const char *msg, +- ...); +- +-void dm_logger_append_va( +- struct log_entry *entry, +- const char *msg, +- va_list args); +- +-void dm_logger_append_heading(struct log_entry *entry); +- +-void dm_logger_open( +- struct dal_logger *logger, +- struct log_entry *entry, +- enum dc_log_type log_type); +- +-void dm_logger_close(struct log_entry *entry); +- +-void dc_conn_log(struct dc_context *ctx, +- const struct dc_link *link, +- uint8_t *hex_data, +- int hex_data_count, +- enum dc_log_type event, +- const char *msg, +- ...); +- +-void logger_write(struct dal_logger *logger, +- enum dc_log_type log_type, +- const char *msg, +- void *paralist); ++void dc_conn_log_hex_linux(const uint8_t *hex_data, int hex_data_count); + + void pre_surface_trace( + struct dc *dc, +@@ -108,28 +66,31 @@ void context_clock_trace( + * marked by this macro. + * Note that the message will be printed exactly once for every function + * it is used in order to avoid repeating of the same message. */ ++ + #define DAL_LOGGER_NOT_IMPL(fmt, ...) \ +-{ \ +- static bool print_not_impl = true; \ +-\ +- if (print_not_impl == true) { \ +- print_not_impl = false; \ +- dm_logger_write(ctx->logger, LOG_WARNING, \ +- "DAL_NOT_IMPL: " fmt, ##__VA_ARGS__); \ +- } \ +-} ++ do { \ ++ static bool print_not_impl = true; \ ++ if (print_not_impl == true) { \ ++ print_not_impl = false; \ ++ DRM_WARN("DAL_NOT_IMPL: " fmt, ##__VA_ARGS__); \ ++ } \ ++ } while (0) + + /****************************************************************************** + * Convenience macros to save on typing. + *****************************************************************************/ + + #define DC_ERROR(...) \ +- dm_logger_write(dc_ctx->logger, LOG_ERROR, \ +- __VA_ARGS__) ++ do { \ ++ (void)(dc_ctx); \ ++ DC_LOG_ERROR(__VA_ARGS__); \ ++ } while (0) + + #define DC_SYNC_INFO(...) \ +- dm_logger_write(dc_ctx->logger, LOG_SYNC, \ +- __VA_ARGS__) ++ do { \ ++ (void)(dc_ctx); \ ++ DC_LOG_SYNC(__VA_ARGS__); \ ++ } while (0) + + /* Connectivity log format: + * [time stamp] [drm] [Major_minor] [connector name] message..... +@@ -139,20 +100,30 @@ void context_clock_trace( + */ + + #define CONN_DATA_DETECT(link, hex_data, hex_len, ...) \ +- dc_conn_log(link->ctx, link, hex_data, hex_len, \ +- LOG_EVENT_DETECTION, ##__VA_ARGS__) ++ do { \ ++ (void)(link); \ ++ dc_conn_log_hex_linux(hex_data, hex_len); \ ++ DC_LOG_EVENT_DETECTION(__VA_ARGS__); \ ++ } while (0) + + #define CONN_DATA_LINK_LOSS(link, hex_data, hex_len, ...) \ +- dc_conn_log(link->ctx, link, hex_data, hex_len, \ +- LOG_EVENT_LINK_LOSS, ##__VA_ARGS__) ++ do { \ ++ (void)(link); \ ++ dc_conn_log_hex_linux(hex_data, hex_len); \ ++ DC_LOG_EVENT_LINK_LOSS(__VA_ARGS__); \ ++ } while (0) + + #define CONN_MSG_LT(link, ...) \ +- dc_conn_log(link->ctx, link, NULL, 0, \ +- LOG_EVENT_LINK_TRAINING, ##__VA_ARGS__) ++ do { \ ++ (void)(link); \ ++ DC_LOG_EVENT_LINK_TRAINING(__VA_ARGS__); \ ++ } while (0) + + #define CONN_MSG_MODE(link, ...) \ +- dc_conn_log(link->ctx, link, NULL, 0, \ +- LOG_EVENT_MODE_SET, ##__VA_ARGS__) ++ do { \ ++ (void)(link); \ ++ DC_LOG_EVENT_MODE_SET(__VA_ARGS__); \ ++ } while (0) + + /* + * Display Test Next logging +@@ -167,38 +138,21 @@ void context_clock_trace( + dm_dtn_log_end(dc_ctx) + + #define PERFORMANCE_TRACE_START() \ +- unsigned long long perf_trc_start_stmp = dm_get_timestamp(dc->ctx); \ +- unsigned long long perf_trc_start_log_msk = dc->ctx->logger->mask; \ +- unsigned int perf_trc_start_log_flags = dc->ctx->logger->flags.value; \ +- if (dc->debug.performance_trace) {\ +- dm_logger_flush_buffer(dc->ctx->logger, false);\ +- dc->ctx->logger->mask = 1<<LOG_PERF_TRACE;\ +- dc->ctx->logger->flags.bits.ENABLE_CONSOLE = 0;\ +- dc->ctx->logger->flags.bits.ENABLE_BUFFER = 1;\ +- } +- +-#define PERFORMANCE_TRACE_END() do {\ +- unsigned long long perf_trc_end_stmp = dm_get_timestamp(dc->ctx);\ +- if (dc->debug.performance_trace) {\ +- dm_logger_write(dc->ctx->logger, \ +- LOG_PERF_TRACE, \ +- "%s duration: %d ticks\n", __func__,\ ++ unsigned long long perf_trc_start_stmp = dm_get_timestamp(dc->ctx) ++ ++#define PERFORMANCE_TRACE_END() \ ++ do { \ ++ unsigned long long perf_trc_end_stmp = dm_get_timestamp(dc->ctx); \ ++ if (dc->debug.performance_trace) { \ ++ DC_LOG_PERF_TRACE("%s duration: %lld ticks\n", __func__, \ + perf_trc_end_stmp - perf_trc_start_stmp); \ +- if (perf_trc_start_log_msk != 1<<LOG_PERF_TRACE) {\ +- dc->ctx->logger->mask = perf_trc_start_log_msk;\ +- dc->ctx->logger->flags.value = perf_trc_start_log_flags;\ +- dm_logger_flush_buffer(dc->ctx->logger, false);\ + } \ +- } \ +-} while (0) ++ } while (0) + +-#define DISPLAY_STATS_BEGIN(entry) \ +- dm_logger_open(dc->ctx->logger, &entry, LOG_DISPLAYSTATS) ++#define DISPLAY_STATS_BEGIN(entry) (void)(entry) + +-#define DISPLAY_STATS(msg, ...) \ +- dm_logger_append(&log_entry, msg, ##__VA_ARGS__) ++#define DISPLAY_STATS(msg, ...) DC_LOG_PERF_TRACE(msg, __VA_ARGS__) + +-#define DISPLAY_STATS_END(entry) \ +- dm_logger_close(&entry) ++#define DISPLAY_STATS_END(entry) (void)(entry) + + #endif /* __DAL_LOGGER_INTERFACE_H__ */ +diff --git a/drivers/gpu/drm/amd/display/include/logger_types.h b/drivers/gpu/drm/amd/display/include/logger_types.h +index 0a540b9..ad3695e 100644 +--- a/drivers/gpu/drm/amd/display/include/logger_types.h ++++ b/drivers/gpu/drm/amd/display/include/logger_types.h +@@ -138,63 +138,4 @@ enum dc_log_type { + (1 << LOG_HW_AUDIO)| \ + (1 << LOG_BANDWIDTH_CALCS)*/ + +-union logger_flags { +- struct { +- uint32_t ENABLE_CONSOLE:1; /* Print to console */ +- uint32_t ENABLE_BUFFER:1; /* Print to buffer */ +- uint32_t RESERVED:30; +- } bits; +- uint32_t value; +-}; +- +-struct log_entry { +- struct dal_logger *logger; +- enum dc_log_type type; +- +- char *buf; +- uint32_t buf_offset; +- uint32_t max_buf_bytes; +-}; +- +-/** +-* Structure for enumerating log types +-*/ +-struct dc_log_type_info { +- enum dc_log_type type; +- char name[MAX_NAME_LEN]; +-}; +- +-/* Structure for keeping track of offsets, buffer, etc */ +- +-#define DAL_LOGGER_BUFFER_MAX_SIZE 2048 +- +-/*Connectivity log needs to output EDID, which needs at lease 256x3 bytes, +- * change log line size to 896 to meet the request. +- */ +-#define LOG_MAX_LINE_SIZE 896 +- +-struct dal_logger { +- +- /* How far into the circular buffer has been read by dsat +- * Read offset should never cross write offset. Write \0's to +- * read data just to be sure? +- */ +- uint32_t buffer_read_offset; +- +- /* How far into the circular buffer we have written +- * Write offset should never cross read offset +- */ +- uint32_t buffer_write_offset; +- +- uint32_t open_count; +- +- char *log_buffer; /* Pointer to malloc'ed buffer */ +- uint32_t log_buffer_size; /* Size of circular buffer */ +- +- uint32_t mask; /*array of masks for major elements*/ +- +- union logger_flags flags; +- struct dc_context *ctx; +-}; +- + #endif /* __DAL_LOGGER_TYPES_H__ */ +-- +2.7.4 + |