drm/amd/display: Convert remaining loggers off dc_logger (e1cb3e48) · Commits · 戴 / test

drivers/gpu/drm/amd/display/TODO

+4 −4

Original line number	Diff line number	Diff line
		@@ -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

drivers/gpu/drm/amd/display/dc/basics/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -25,7 +25,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))

drivers/gpu/drm/amd/display/dc/basics/log_helpers.c

+3 −68

Original line number	Diff line number	Diff line
		@@ -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]);
		}

drivers/gpu/drm/amd/display/dc/basics/logger.c

deleted100644 → 0

+0 −406

Original line number	Diff line number	Diff line
		/*
		* 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;
		}
		}

drivers/gpu/drm/amd/display/dc/calcs/calcs_logger.h

+4 −5

Original line number	Diff line number	Diff line
		@@ -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;

Admin message