Attachment 142354 Details for Bug 108464 – Patch for Linux-19.0 to revert e1cb3e4

[patch] Patch for Linux-19.0 to revert e1cb3e4

noreboot.patch (text/plain), 41.99 KB, created by Duncan Roe on 2018-11-03 09:28:06 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Duncan Roe

Created: 2018-11-03 09:28:06 UTC

Size: 41.99 KB

patch

obsolete

>diff --git a/drivers/gpu/drm/amd/display/TODO b/drivers/gpu/drm/amd/display/TODO
>index a8a6c10..357d5964 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. 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.
>+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.
> 
> 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/amdgpu_dm/amdgpu_dm_mst_types.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c
>index 8348d4d..c741057 100644
>--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c
>+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_mst_types.c
>@@ -80,72 +80,52 @@ static void log_dpcd(uint8_t type,
> static ssize_t dm_dp_aux_transfer(struct drm_dp_aux *aux,
> 				  struct drm_dp_aux_msg *msg)
> {
>-	ssize_t result = 0;
>-	enum i2caux_transaction_action action;
>-	enum aux_transaction_type type;
>+	enum i2c_mot_mode mot = (msg->request & DP_AUX_I2C_MOT) ?
>+		I2C_MOT_TRUE : I2C_MOT_FALSE;
>+	enum ddc_result res;
> 
> 	if (WARN_ON(msg->size > 16))
> 		return -E2BIG;
> 
> 	switch (msg->request & ~DP_AUX_I2C_MOT) {
> 	case DP_AUX_NATIVE_READ:
>-		type = AUX_TRANSACTION_TYPE_DP;
>-		action = I2CAUX_TRANSACTION_ACTION_DP_READ;
>-
>-		result = dc_link_aux_transfer(TO_DM_AUX(aux)->ddc_service,
>-					      msg->address,
>-					      &msg->reply,
>-					      msg->buffer,
>-					      msg->size,
>-					      type,
>-					      action);
>+		res = dal_ddc_service_read_dpcd_data(
>+				TO_DM_AUX(aux)->ddc_service,
>+				false,
>+				I2C_MOT_UNDEF,
>+				msg->address,
>+				msg->buffer,
>+				msg->size);
> 		break;
> 	case DP_AUX_NATIVE_WRITE:
>-		type = AUX_TRANSACTION_TYPE_DP;
>-		action = I2CAUX_TRANSACTION_ACTION_DP_WRITE;
>-
>-		dc_link_aux_transfer(TO_DM_AUX(aux)->ddc_service,
>-				     msg->address,
>-				     &msg->reply,
>-				     msg->buffer,
>-				     msg->size,
>-				     type,
>-				     action);
>-		result = msg->size;
>+		res = dal_ddc_service_write_dpcd_data(
>+				TO_DM_AUX(aux)->ddc_service,
>+				false,
>+				I2C_MOT_UNDEF,
>+				msg->address,
>+				msg->buffer,
>+				msg->size);
> 		break;
> 	case DP_AUX_I2C_READ:
>-		type = AUX_TRANSACTION_TYPE_I2C;
>-		if (msg->request & DP_AUX_I2C_MOT)
>-			action = I2CAUX_TRANSACTION_ACTION_I2C_READ_MOT;
>-		else
>-			action = I2CAUX_TRANSACTION_ACTION_I2C_READ;
>-
>-		result = dc_link_aux_transfer(TO_DM_AUX(aux)->ddc_service,
>-					      msg->address,
>-					      &msg->reply,
>-					      msg->buffer,
>-					      msg->size,
>-					      type,
>-					      action);
>+		res = dal_ddc_service_read_dpcd_data(
>+				TO_DM_AUX(aux)->ddc_service,
>+				true,
>+				mot,
>+				msg->address,
>+				msg->buffer,
>+				msg->size);
> 		break;
> 	case DP_AUX_I2C_WRITE:
>-		type = AUX_TRANSACTION_TYPE_I2C;
>-		if (msg->request & DP_AUX_I2C_MOT)
>-			action = I2CAUX_TRANSACTION_ACTION_I2C_WRITE_MOT;
>-		else
>-			action = I2CAUX_TRANSACTION_ACTION_I2C_WRITE;
>-
>-		dc_link_aux_transfer(TO_DM_AUX(aux)->ddc_service,
>-				     msg->address,
>-				     &msg->reply,
>-				     msg->buffer,
>-				     msg->size,
>-				     type,
>-				     action);
>-		result = msg->size;
>+		res = dal_ddc_service_write_dpcd_data(
>+				TO_DM_AUX(aux)->ddc_service,
>+				true,
>+				mot,
>+				msg->address,
>+				msg->buffer,
>+				msg->size);
> 		break;
> 	default:
>-		return -EINVAL;
>+		return 0;
> 	}
> 
> #ifdef TRACE_DPCD
>@@ -156,10 +136,7 @@ static ssize_t dm_dp_aux_transfer(struct drm_dp_aux *aux,
> 		 r == DDC_RESULT_SUCESSFULL);
> #endif
> 
>-	if (result < 0) /* DC doesn't know about kernel error codes */
>-		result = -EIO;
>-
>-	return result;
>+	return msg->size;
> }
> 
> static enum drm_connector_status
>diff --git a/drivers/gpu/drm/amd/display/dc/basics/Makefile b/drivers/gpu/drm/amd/display/dc/basics/Makefile
>index a50a764..b49ea96 100644
>--- a/drivers/gpu/drm/amd/display/dc/basics/Makefile
>+++ b/drivers/gpu/drm/amd/display/dc/basics/Makefile
>@@ -25,7 +25,7 @@
> # subcomponents.
> 
> BASICS = conversion.o fixpt31_32.o \
>-	log_helpers.o vector.o
>+	logger.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 26583f3..f6c00a5 100644
>--- a/drivers/gpu/drm/amd/display/dc/basics/log_helpers.c
>+++ b/drivers/gpu/drm/amd/display/dc/basics/log_helpers.c
>@@ -28,12 +28,77 @@
> #include "include/logger_interface.h"
> #include "dm_helpers.h"
> 
>-void dc_conn_log_hex_linux(const uint8_t *hex_data, int hex_data_count)
>+#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,
>+		...)
> {
> 	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++)
>-			DC_LOG_DEBUG("%2.2X ", hex_data[i]);
>-}
>+			dm_logger_append(&entry, "%2.2X ", hex_data[i]);
>+
>+	dm_logger_append(&entry, "^\n");
> 
>+fail:
>+	dm_logger_close(&entry);
>+
>+	va_end(args);
>+}
>diff --git a/drivers/gpu/drm/amd/display/dc/basics/logger.c b/drivers/gpu/drm/amd/display/dc/basics/logger.c
>new file mode 100644
>index 0000000..a3c56cd
>--- /dev/null
>+++ b/drivers/gpu/drm/amd/display/dc/basics/logger.c
>@@ -0,0 +1,406 @@
>+/*
>+ * 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,
>+			     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 62435bf..fc3f98f 100644
>--- a/drivers/gpu/drm/amd/display/dc/calcs/calcs_logger.h
>+++ b/drivers/gpu/drm/amd/display/dc/calcs/calcs_logger.h
>@@ -25,9 +25,10 @@
> 
> #ifndef _CALCS_CALCS_LOGGER_H_
> #define _CALCS_CALCS_LOGGER_H_
>-#define DC_LOGGER ctx->logger
>+#define DC_LOGGER \
>+	logger
> 
>-static void print_bw_calcs_dceip(struct dc_context *ctx, const struct bw_calcs_dceip *dceip)
>+static void print_bw_calcs_dceip(struct dal_logger *logger, const struct bw_calcs_dceip *dceip)
> {
> 
> 	DC_LOG_BANDWIDTH_CALCS("#####################################################################");
>@@ -121,7 +122,7 @@ static void print_bw_calcs_dceip(struct dc_context *ctx, const struct bw_calcs_d
> 
> }
> 
>-static void print_bw_calcs_vbios(struct dc_context *ctx, const struct bw_calcs_vbios *vbios)
>+static void print_bw_calcs_vbios(struct dal_logger *logger, const struct bw_calcs_vbios *vbios)
> {
> 
> 	DC_LOG_BANDWIDTH_CALCS("#####################################################################");
>@@ -180,7 +181,7 @@ static void print_bw_calcs_vbios(struct dc_context *ctx, const struct bw_calcs_v
> 
> }
> 
>-static void print_bw_calcs_data(struct dc_context *ctx, struct bw_calcs_data *data)
>+static void print_bw_calcs_data(struct dal_logger *logger, 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 160d11a..2c4e8f0 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, dceip);
>-			print_bw_calcs_vbios(ctx, vbios);
>-			print_bw_calcs_data(ctx, data);
>+			print_bw_calcs_dceip(ctx->logger, dceip);
>+			print_bw_calcs_vbios(ctx->logger, vbios);
>+			print_bw_calcs_data(ctx->logger, 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 cb0be7f..815656a 100644
>--- a/drivers/gpu/drm/amd/display/dc/core/dc.c
>+++ b/drivers/gpu/drm/amd/display/dc/core/dc.c
>@@ -478,6 +478,9 @@ 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;
> 
>@@ -500,6 +503,7 @@ 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;
>@@ -564,7 +568,14 @@ 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);
>@@ -983,7 +994,9 @@ 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(dc, stream);
>+		dc_stream_log(stream,
>+				dc->ctx->logger,
>+				LOG_DC);
> 	}
> 
> 	result = dc_commit_state_no_check(dc, context);
>diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link_ddc.c b/drivers/gpu/drm/amd/display/dc/core/dc_link_ddc.c
>index d108ccf..d5294798b 100644
>--- a/drivers/gpu/drm/amd/display/dc/core/dc_link_ddc.c
>+++ b/drivers/gpu/drm/amd/display/dc/core/dc_link_ddc.c
>@@ -33,7 +33,6 @@
> #include "include/vector.h"
> #include "core_types.h"
> #include "dc_link_ddc.h"
>-#include "aux_engine.h"
> 
> #define AUX_POWER_UP_WA_DELAY 500
> #define I2C_OVER_AUX_DEFER_WA_DELAY 70
>@@ -630,61 +629,77 @@ bool dal_ddc_service_query_ddc_data(
> 	return ret;
> }
> 
>-int dc_link_aux_transfer(struct ddc_service *ddc,
>-			     unsigned int address,
>-			     uint8_t *reply,
>-			     void *buffer,
>-			     unsigned int size,
>-			     enum aux_transaction_type type,
>-			     enum i2caux_transaction_action action)
>+enum ddc_result dal_ddc_service_read_dpcd_data(
>+	struct ddc_service *ddc,
>+	bool i2c,
>+	enum i2c_mot_mode mot,
>+	uint32_t address,
>+	uint8_t *data,
>+	uint32_t len)
> {
>-	struct ddc *ddc_pin = ddc->ddc_pin;
>-	struct aux_engine *aux_engine;
>-	enum aux_channel_operation_result operation_result;
>-	struct aux_request_transaction_data aux_req;
>-	struct aux_reply_transaction_data aux_rep;
>-	uint8_t returned_bytes = 0;
>-	int res = -1;
>-	uint32_t status;
>-
>-	memset(&aux_req, 0, sizeof(aux_req));
>-	memset(&aux_rep, 0, sizeof(aux_rep));
>-
>-	aux_engine = ddc->ctx->dc->res_pool->engines[ddc_pin->pin_data->en];
>-	aux_engine->funcs->acquire(aux_engine, ddc_pin);
>-
>-	aux_req.type = type;
>-	aux_req.action = action;
>-
>-	aux_req.address = address;
>-	aux_req.delay = 0;
>-	aux_req.length = size;
>-	aux_req.data = buffer;
>-
>-	aux_engine->funcs->submit_channel_request(aux_engine, &aux_req);
>-	operation_result = aux_engine->funcs->get_channel_status(aux_engine, &returned_bytes);
>+	struct aux_payload read_payload = {
>+		.i2c_over_aux = i2c,
>+		.write = false,
>+		.address = address,
>+		.length = len,
>+		.data = data,
>+	};
>+	struct aux_command command = {
>+		.payloads = &read_payload,
>+		.number_of_payloads = 1,
>+		.defer_delay = 0,
>+		.max_defer_write_retry = 0,
>+		.mot = mot
>+	};
>+
>+	if (len > DEFAULT_AUX_MAX_DATA_SIZE) {
>+		BREAK_TO_DEBUGGER();
>+		return DDC_RESULT_FAILED_INVALID_OPERATION;
>+	}
> 
>-	switch (operation_result) {
>-	case AUX_CHANNEL_OPERATION_SUCCEEDED:
>-		res = returned_bytes;
>+	if (dal_i2caux_submit_aux_command(
>+		ddc->ctx->i2caux,
>+		ddc->ddc_pin,
>+		&command))
>+		return DDC_RESULT_SUCESSFULL;
> 
>-		if (res <= size && res >= 0)
>-			res = aux_engine->funcs->read_channel_reply(aux_engine, size,
>-								buffer, reply,
>-								&status);
>+	return DDC_RESULT_FAILED_OPERATION;
>+}
> 
>-		break;
>-	case AUX_CHANNEL_OPERATION_FAILED_HPD_DISCON:
>-		res = 0;
>-		break;
>-	case AUX_CHANNEL_OPERATION_FAILED_REASON_UNKNOWN:
>-	case AUX_CHANNEL_OPERATION_FAILED_INVALID_REPLY:
>-	case AUX_CHANNEL_OPERATION_FAILED_TIMEOUT:
>-		res = -1;
>-		break;
>+enum ddc_result dal_ddc_service_write_dpcd_data(
>+	struct ddc_service *ddc,
>+	bool i2c,
>+	enum i2c_mot_mode mot,
>+	uint32_t address,
>+	const uint8_t *data,
>+	uint32_t len)
>+{
>+	struct aux_payload write_payload = {
>+		.i2c_over_aux = i2c,
>+		.write = true,
>+		.address = address,
>+		.length = len,
>+		.data = (uint8_t *)data,
>+	};
>+	struct aux_command command = {
>+		.payloads = &write_payload,
>+		.number_of_payloads = 1,
>+		.defer_delay = 0,
>+		.max_defer_write_retry = 0,
>+		.mot = mot
>+	};
>+
>+	if (len > DEFAULT_AUX_MAX_DATA_SIZE) {
>+		BREAK_TO_DEBUGGER();
>+		return DDC_RESULT_FAILED_INVALID_OPERATION;
> 	}
>-	aux_engine->funcs->release_engine(aux_engine);
>-	return res;
>+	if (dal_i2caux_submit_aux_command(
>+		ddc->ctx->i2caux,
>+		ddc->ddc_pin,
>+		&command))
>+		return DDC_RESULT_SUCESSFULL;
>+
>+	return DDC_RESULT_FAILED_OPERATION;
> }
> 
> /*test only function*/
>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 0223f48..3732a1d 100644
>--- a/drivers/gpu/drm/amd/display/dc/core/dc_stream.c
>+++ b/drivers/gpu/drm/amd/display/dc/core/dc_stream.c
>@@ -30,8 +30,6 @@
> #include "ipp.h"
> #include "timing_generator.h"
> 
>-#define DC_LOGGER dc->ctx->logger
>-
> /*******************************************************************************
>  * Private functions
>  ******************************************************************************/
>@@ -321,10 +319,16 @@ bool dc_stream_get_scanoutpos(const struct dc_stream_state *stream,
> 	return ret;
> }
> 
>-void dc_stream_log(const struct dc *dc, const struct dc_stream_state *stream)
>+
>+void dc_stream_log(
>+	const struct dc_stream_state *stream,
>+	struct dal_logger *dm_logger,
>+	enum dc_log_type log_type)
> {
>-	DC_LOG_DC(
>-			"core_stream 0x%p: src: %d, %d, %d, %d; dst: %d, %d, %d, %d, colorSpace:%d\n",
>+
>+	dm_logger_write(dm_logger,
>+			log_type,
>+			"core_stream 0x%x: src: %d, %d, %d, %d; dst: %d, %d, %d, %d, colorSpace:%d\n",
> 			stream,
> 			stream->src.x,
> 			stream->src.y,
>@@ -335,18 +339,21 @@ void dc_stream_log(const struct dc *dc, const struct dc_stream_state *stream)
> 			stream->dst.width,
> 			stream->dst.height,
> 			stream->output_color_space);
>-	DC_LOG_DC(
>+	dm_logger_write(dm_logger,
>+			log_type,
> 			"\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);
>-	DC_LOG_DC(
>+	dm_logger_write(dm_logger,
>+			log_type,
> 			"\tsink name: %s, serial: %d\n",
> 			stream->sink->edid_caps.display_name,
> 			stream->sink->edid_caps.serial_number);
>-	DC_LOG_DC(
>+	dm_logger_write(dm_logger,
>+			log_type,
> 			"\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 64eeb44..af503e0 100644
>--- a/drivers/gpu/drm/amd/display/dc/dc_stream.h
>+++ b/drivers/gpu/drm/amd/display/dc/dc_stream.h
>@@ -148,7 +148,10 @@ void dc_commit_updates_for_stream(struct dc *dc,
> /*
>  * Log the current stream state.
>  */
>-void dc_stream_log(const struct dc *dc, const struct dc_stream_state *stream);
>+void dc_stream_log(
>+	const struct dc_stream_state *stream,
>+	struct dal_logger *dc_logger,
>+	enum dc_log_type log_type);
> 
> 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 03bf9ee..c96e526 100644
>--- a/drivers/gpu/drm/amd/display/dc/dc_types.h
>+++ b/drivers/gpu/drm/amd/display/dc/dc_types.h
>@@ -77,6 +77,8 @@ 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 1c902e4..3edaa00 100644
>--- a/drivers/gpu/drm/amd/display/dc/dce110/dce110_resource.c
>+++ b/drivers/gpu/drm/amd/display/dc/dce110/dce110_resource.c
>@@ -831,38 +831,43 @@ static bool dce110_validate_bandwidth(
> 
> 	if (memcmp(&dc->current_state->bw.dce,
> 			&context->bw.dce, sizeof(context->bw.dce))) {
>-
>-		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"
>+		struct log_entry log_entry;
>+		dm_logger_open(
>+			dc->ctx->logger,
>+			&log_entry,
>+			LOG_BANDWIDTH_CALCS);
>+		dm_logger_append(&log_entry, "%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 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"
>-			,
>+			"stutMark_b: %d stutMark_a: %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,
>+			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.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,
>+			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.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,
>+			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.cpuc_state_change_enable,
> 			context->bw.dce.cpup_state_change_enable,
> 			context->bw.dce.nbp_state_change_enable,
>@@ -872,6 +877,7 @@ 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 30d5b32..9e1afb1 100644
>--- a/drivers/gpu/drm/amd/display/dc/dce112/dce112_resource.c
>+++ b/drivers/gpu/drm/amd/display/dc/dce112/dce112_resource.c
>@@ -781,38 +781,43 @@ bool dce112_validate_bandwidth(
> 
> 	if (memcmp(&dc->current_state->bw.dce,
> 			&context->bw.dce, sizeof(context->bw.dce))) {
>-
>-		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"
>+		struct log_entry log_entry;
>+		dm_logger_open(
>+			dc->ctx->logger,
>+			&log_entry,
>+			LOG_BANDWIDTH_CALCS);
>+		dm_logger_append(&log_entry, "%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 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"
>-			,
>+			"stutMark_b: %d stutMark_a: %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,
>+			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.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,
>+			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.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,
>+			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.cpuc_state_change_enable,
> 			context->bw.dce.cpup_state_change_enable,
> 			context->bw.dce.nbp_state_change_enable,
>@@ -822,6 +827,7 @@ 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/dc/inc/dc_link_ddc.h b/drivers/gpu/drm/amd/display/dc/inc/dc_link_ddc.h
>index 538b833..0bf73b7 100644
>--- a/drivers/gpu/drm/amd/display/dc/inc/dc_link_ddc.h
>+++ b/drivers/gpu/drm/amd/display/dc/inc/dc_link_ddc.h
>@@ -102,13 +102,21 @@ bool dal_ddc_service_query_ddc_data(
> 		uint8_t *read_buf,
> 		uint32_t read_size);
> 
>-int dc_link_aux_transfer(struct ddc_service *ddc,
>-			     unsigned int address,
>-			     uint8_t *reply,
>-			     void *buffer,
>-			     unsigned int size,
>-			     enum aux_transaction_type type,
>-			     enum i2caux_transaction_action action);
>+enum ddc_result dal_ddc_service_read_dpcd_data(
>+		struct ddc_service *ddc,
>+		bool i2c,
>+		enum i2c_mot_mode mot,
>+		uint32_t address,
>+		uint8_t *data,
>+		uint32_t len);
>+
>+enum ddc_result dal_ddc_service_write_dpcd_data(
>+		struct ddc_service *ddc,
>+		bool i2c,
>+		enum i2c_mot_mode mot,
>+		uint32_t address,
>+		const uint8_t *data,
>+		uint32_t len);
> 
> void dal_ddc_service_write_scdc_data(
> 		struct ddc_service *ddc_service,
>diff --git a/drivers/gpu/drm/amd/display/include/logger_interface.h b/drivers/gpu/drm/amd/display/include/logger_interface.h
>index e3c7961..0f10ed7 100644
>--- a/drivers/gpu/drm/amd/display/include/logger_interface.h
>+++ b/drivers/gpu/drm/amd/display/include/logger_interface.h
>@@ -40,7 +40,49 @@ struct dc_state;
>  *
>  */
> 
>-void dc_conn_log_hex_linux(const uint8_t *hex_data, int hex_data_count);
>+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 pre_surface_trace(
> 		struct dc *dc,
>@@ -66,31 +108,28 @@ 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, ...) \
>-	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)
>+{ \
>+	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__); \
>+	} \
>+}
> 
> /******************************************************************************
>  * Convenience macros to save on typing.
>  *****************************************************************************/
> 
> #define DC_ERROR(...) \
>-		do { \
>-			(void)(dc_ctx); \
>-			DC_LOG_ERROR(__VA_ARGS__); \
>-		} while (0)
>+	dm_logger_write(dc_ctx->logger, LOG_ERROR, \
>+		__VA_ARGS__)
> 
> #define DC_SYNC_INFO(...) \
>-		do { \
>-			(void)(dc_ctx); \
>-			DC_LOG_SYNC(__VA_ARGS__); \
>-		} while (0)
>+	dm_logger_write(dc_ctx->logger, LOG_SYNC, \
>+		__VA_ARGS__)
> 
> /* Connectivity log format:
>  * [time stamp]   [drm] [Major_minor] [connector name] message.....
>@@ -100,30 +139,20 @@ void context_clock_trace(
>  */
> 
> #define CONN_DATA_DETECT(link, hex_data, hex_len, ...) \
>-		do { \
>-			(void)(link); \
>-			dc_conn_log_hex_linux(hex_data, hex_len); \
>-			DC_LOG_EVENT_DETECTION(__VA_ARGS__); \
>-		} while (0)
>+		dc_conn_log(link->ctx, link, hex_data, hex_len, \
>+				LOG_EVENT_DETECTION, ##__VA_ARGS__)
> 
> #define CONN_DATA_LINK_LOSS(link, hex_data, hex_len, ...) \
>-		do { \
>-			(void)(link); \
>-			dc_conn_log_hex_linux(hex_data, hex_len); \
>-			DC_LOG_EVENT_LINK_LOSS(__VA_ARGS__); \
>-		} while (0)
>+		dc_conn_log(link->ctx, link, hex_data, hex_len, \
>+				LOG_EVENT_LINK_LOSS, ##__VA_ARGS__)
> 
> #define CONN_MSG_LT(link, ...) \
>-		do { \
>-			(void)(link); \
>-			DC_LOG_EVENT_LINK_TRAINING(__VA_ARGS__); \
>-		} while (0)
>+		dc_conn_log(link->ctx, link, NULL, 0, \
>+				LOG_EVENT_LINK_TRAINING, ##__VA_ARGS__)
> 
> #define CONN_MSG_MODE(link, ...) \
>-		do { \
>-			(void)(link); \
>-			DC_LOG_EVENT_MODE_SET(__VA_ARGS__); \
>-		} while (0)
>+		dc_conn_log(link->ctx, link, NULL, 0, \
>+				LOG_EVENT_MODE_SET, ##__VA_ARGS__)
> 
> /*
>  * Display Test Next logging
>@@ -138,21 +167,38 @@ 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)
>-
>-#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__, \
>+	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__,\
> 				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) (void)(entry)
>+#define DISPLAY_STATS_BEGIN(entry) \
>+	dm_logger_open(dc->ctx->logger, &entry, LOG_DISPLAYSTATS)
> 
>-#define DISPLAY_STATS(msg, ...) DC_LOG_PERF_TRACE(msg, __VA_ARGS__)
>+#define DISPLAY_STATS(msg, ...) \
>+	dm_logger_append(&log_entry, msg, ##__VA_ARGS__)
> 
>-#define DISPLAY_STATS_END(entry) (void)(entry)
>+#define DISPLAY_STATS_END(entry) \
>+	dm_logger_close(&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 ad3695e..0a540b9 100644
>--- a/drivers/gpu/drm/amd/display/include/logger_types.h
>+++ b/drivers/gpu/drm/amd/display/include/logger_types.h
>@@ -138,4 +138,63 @@ 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__ */

Actions: View | Splinter Review

Attachments on bug 108464: 142062 | 142063 | 142354 | 143007 | 143008 | 143011 | 143055 | 143344 | 143346

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.