drm/amd/display: remove unused module/stats

/*

 * Copyright 2016 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 "mod_stats.h"

#include "dm_services.h"

#include "dc.h"

#include "core_types.h"

#define DAL_STATS_ENABLE_REGKEY			"DalStatsEnable"

#define DAL_STATS_ENABLE_REGKEY_DEFAULT		0x00000000

#define DAL_STATS_ENABLE_REGKEY_ENABLED		0x00000001

#define DAL_STATS_ENTRIES_REGKEY		"DalStatsEntries"

#define DAL_STATS_ENTRIES_REGKEY_DEFAULT	0x00350000

#define DAL_STATS_ENTRIES_REGKEY_MAX		0x01000000

#define DAL_STATS_EVENT_ENTRIES_DEFAULT		0x00000100

#define MOD_STATS_NUM_VSYNCS			5

#define MOD_STATS_EVENT_STRING_MAX		512

struct stats_time_cache {

	unsigned int entry_id;

	unsigned long flip_timestamp_in_ns;

	unsigned long vupdate_timestamp_in_ns;

	unsigned int render_time_in_us;

	unsigned int avg_render_time_in_us_last_ten;

	unsigned int v_sync_time_in_us[MOD_STATS_NUM_VSYNCS];

	unsigned int num_vsync_between_flips;

	unsigned int flip_to_vsync_time_in_us;

	unsigned int vsync_to_flip_time_in_us;

	unsigned int min_window;

	unsigned int max_window;

	unsigned int v_total_min;

	unsigned int v_total_max;

	unsigned int event_triggers;

	unsigned int lfc_mid_point_in_us;

	unsigned int num_frames_inserted;

	unsigned int inserted_duration_in_us;

	unsigned int flags;

};

struct stats_event_cache {

	unsigned int entry_id;

	char event_string[MOD_STATS_EVENT_STRING_MAX];

};

struct core_stats {

	struct mod_stats public;

	struct dc *dc;

	bool enabled;

	unsigned int entries;

	unsigned int event_entries;

	unsigned int entry_id;

	struct stats_time_cache *time;

	unsigned int index;

	struct stats_event_cache *events;

	unsigned int event_index;

};

#define MOD_STATS_TO_CORE(mod_stats)\

		container_of(mod_stats, struct core_stats, public)

bool mod_stats_init(struct mod_stats *mod_stats)

{

	bool result = false;

	struct core_stats *core_stats = NULL;

	struct dc *dc = NULL;

	if (mod_stats == NULL)

		return false;

	core_stats = MOD_STATS_TO_CORE(mod_stats);

	dc = core_stats->dc;

	return result;

}

struct mod_stats *mod_stats_create(struct dc *dc)

{

	struct core_stats *core_stats = NULL;

	struct persistent_data_flag flag;

	unsigned int reg_data;

	int i = 0;

	if (dc == NULL)

		goto fail_construct;

	core_stats = kzalloc(sizeof(struct core_stats), GFP_KERNEL);

	if (core_stats == NULL)

		goto fail_construct;

	core_stats->dc = dc;

	core_stats->enabled = DAL_STATS_ENABLE_REGKEY_DEFAULT;

	if (dm_read_persistent_data(dc->ctx, NULL, NULL,

			DAL_STATS_ENABLE_REGKEY,

			&reg_data, sizeof(unsigned int), &flag))

		core_stats->enabled = reg_data;

	if (core_stats->enabled) {

		core_stats->entries = DAL_STATS_ENTRIES_REGKEY_DEFAULT;

		if (dm_read_persistent_data(dc->ctx, NULL, NULL,

				DAL_STATS_ENTRIES_REGKEY,

				&reg_data, sizeof(unsigned int), &flag)) {

			if (reg_data > DAL_STATS_ENTRIES_REGKEY_MAX)

				core_stats->entries = DAL_STATS_ENTRIES_REGKEY_MAX;

			else

				core_stats->entries = reg_data;

		}

		core_stats->time = kcalloc(core_stats->entries,

						sizeof(struct stats_time_cache),

						GFP_KERNEL);

		if (core_stats->time == NULL)

			goto fail_construct_time;

		core_stats->event_entries = DAL_STATS_EVENT_ENTRIES_DEFAULT;

		core_stats->events = kcalloc(core_stats->event_entries,

					     sizeof(struct stats_event_cache),

					     GFP_KERNEL);

		if (core_stats->events == NULL)

			goto fail_construct_events;

	} else {

		core_stats->entries = 0;

	}

	/* Purposely leave index 0 unused so we don't need special logic to

	 * handle calculation cases that depend on previous flip data.

	 */

	core_stats->index = 1;

	core_stats->event_index = 0;

	// Keeps track of ordering within the different stats structures

	core_stats->entry_id = 0;

	return &core_stats->public;

fail_construct_events:

	kfree(core_stats->time);

fail_construct_time:

	kfree(core_stats);

fail_construct:

	return NULL;

}

void mod_stats_destroy(struct mod_stats *mod_stats)

{

	if (mod_stats != NULL) {

		struct core_stats *core_stats = MOD_STATS_TO_CORE(mod_stats);

		kfree(core_stats->time);

		kfree(core_stats->events);

		kfree(core_stats);

	}

}

void mod_stats_dump(struct mod_stats *mod_stats)

{

	struct dc  *dc = NULL;

	struct dal_logger *logger = NULL;

	struct core_stats *core_stats = NULL;

	struct stats_time_cache *time = NULL;

	struct stats_event_cache *events = NULL;

	unsigned int time_index = 1;

	unsigned int event_index = 0;

	unsigned int index = 0;

	struct log_entry log_entry;

	if (mod_stats == NULL)

		return;

	core_stats = MOD_STATS_TO_CORE(mod_stats);

	dc = core_stats->dc;

	logger = dc->ctx->logger;

	time = core_stats->time;

	events = core_stats->events;

	DISPLAY_STATS_BEGIN(log_entry);

	DISPLAY_STATS("==Display Caps==\n");

	DISPLAY_STATS("==Display Stats==\n");

	DISPLAY_STATS("%10s %10s %10s %10s %10s"

			" %11s %11s %17s %10s %14s"

			" %10s %10s %10s %10s %10s"

			" %10s %10s %10s %10s\n",

		"render", "avgRender",

		"minWindow", "midPoint", "maxWindow",

		"vsyncToFlip", "flipToVsync", "vsyncsBetweenFlip",

		"numFrame", "insertDuration",

		"vTotalMin", "vTotalMax", "eventTrigs",

		"vSyncTime1", "vSyncTime2", "vSyncTime3",

		"vSyncTime4", "vSyncTime5", "flags");

	for (int i = 0; i < core_stats->entry_id; i++) {

		if (event_index < core_stats->event_index &&

				i == events[event_index].entry_id) {

			DISPLAY_STATS("==Event==%s\n", events[event_index].event_string);

			event_index++;

		} else if (time_index < core_stats->index &&

				i == time[time_index].entry_id) {

			DISPLAY_STATS("%10u %10u %10u %10u %10u"

					" %11u %11u %17u %10u %14u"

					" %10u %10u %10u %10u %10u"

					" %10u %10u %10u %10u\n",

				time[time_index].render_time_in_us,

				time[time_index].avg_render_time_in_us_last_ten,

				time[time_index].min_window,

				time[time_index].lfc_mid_point_in_us,

				time[time_index].max_window,

				time[time_index].vsync_to_flip_time_in_us,

				time[time_index].flip_to_vsync_time_in_us,

				time[time_index].num_vsync_between_flips,

				time[time_index].num_frames_inserted,

				time[time_index].inserted_duration_in_us,

				time[time_index].v_total_min,

				time[time_index].v_total_max,

				time[time_index].event_triggers,

				time[time_index].v_sync_time_in_us[0],

				time[time_index].v_sync_time_in_us[1],

				time[time_index].v_sync_time_in_us[2],

				time[time_index].v_sync_time_in_us[3],

				time[time_index].v_sync_time_in_us[4],

				time[time_index].flags);

			time_index++;

		}

	}

	DISPLAY_STATS_END(log_entry);

}

void mod_stats_reset_data(struct mod_stats *mod_stats)

{

	struct core_stats *core_stats = NULL;

	struct stats_time_cache *time = NULL;

	unsigned int index = 0;

	if (mod_stats == NULL)

		return;

	core_stats = MOD_STATS_TO_CORE(mod_stats);

	memset(core_stats->time, 0,

		sizeof(struct stats_time_cache) * core_stats->entries);

	memset(core_stats->events, 0,

		sizeof(struct stats_event_cache) * core_stats->event_entries);

	core_stats->index = 1;

	core_stats->event_index = 0;

	// Keeps track of ordering within the different stats structures

	core_stats->entry_id = 0;

}

void mod_stats_update_event(struct mod_stats *mod_stats,

		char *event_string,

		unsigned int length)

{

	struct core_stats *core_stats = NULL;

	struct stats_event_cache *events = NULL;

	unsigned int index = 0;

	unsigned int copy_length = 0;

	if (mod_stats == NULL)

		return;

	core_stats = MOD_STATS_TO_CORE(mod_stats);

	if (core_stats->event_index >= core_stats->event_entries)

		return;

	events = core_stats->events;

	index = core_stats->event_index;

	copy_length = length;

	if (length > MOD_STATS_EVENT_STRING_MAX)

		copy_length = MOD_STATS_EVENT_STRING_MAX;

	memcpy(&events[index].event_string, event_string, copy_length);

	events[index].event_string[copy_length - 1] = '\0';

	events[index].entry_id = core_stats->entry_id;

	core_stats->event_index++;

	core_stats->entry_id++;

}

void mod_stats_update_flip(struct mod_stats *mod_stats,

		unsigned long timestamp_in_ns)

{

	struct core_stats *core_stats = NULL;

	struct stats_time_cache *time = NULL;

	unsigned int index = 0;

	if (mod_stats == NULL)

		return;

	core_stats = MOD_STATS_TO_CORE(mod_stats);

	if (core_stats->index >= core_stats->entries)

		return;

	time = core_stats->time;

	index = core_stats->index;

	time[index].flip_timestamp_in_ns = timestamp_in_ns;

	time[index].render_time_in_us =

		(timestamp_in_ns - time[index - 1].flip_timestamp_in_ns) / 1000;

	if (index >= 10) {

		for (unsigned int i = 0; i < 10; i++)

			time[index].avg_render_time_in_us_last_ten +=

					time[index - i].render_time_in_us;

		time[index].avg_render_time_in_us_last_ten /= 10;

	}

	if (time[index].num_vsync_between_flips > 0)

		time[index].vsync_to_flip_time_in_us =

			(timestamp_in_ns -

				time[index].vupdate_timestamp_in_ns) / 1000;

	else

		time[index].vsync_to_flip_time_in_us =

			(timestamp_in_ns -

				time[index - 1].vupdate_timestamp_in_ns) / 1000;

	time[index].entry_id = core_stats->entry_id;

	core_stats->index++;

	core_stats->entry_id++;

}

void mod_stats_update_vupdate(struct mod_stats *mod_stats,

		unsigned long timestamp_in_ns)

{

	struct core_stats *core_stats = NULL;

	struct stats_time_cache *time = NULL;

	unsigned int index = 0;

	unsigned int num_vsyncs = 0;

	unsigned int prev_vsync_in_ns = 0;

	if (mod_stats == NULL)

		return;

	core_stats = MOD_STATS_TO_CORE(mod_stats);

	if (core_stats->index >= core_stats->entries)

		return;

	time = core_stats->time;

	index = core_stats->index;

	num_vsyncs = time[index].num_vsync_between_flips;

	if (num_vsyncs < MOD_STATS_NUM_VSYNCS) {

		if (num_vsyncs == 0) {

			prev_vsync_in_ns =

				time[index - 1].vupdate_timestamp_in_ns;

			time[index].flip_to_vsync_time_in_us =

				(timestamp_in_ns -

					time[index - 1].flip_timestamp_in_ns) /

					1000;

		} else {

			prev_vsync_in_ns =

				time[index].vupdate_timestamp_in_ns;

		}

		time[index].v_sync_time_in_us[num_vsyncs] =

			(timestamp_in_ns - prev_vsync_in_ns) / 1000;

	}

	time[index].vupdate_timestamp_in_ns = timestamp_in_ns;

	time[index].num_vsync_between_flips++;

}

void mod_stats_update_freesync(struct mod_stats *mod_stats,

		unsigned int v_total_min,

		unsigned int v_total_max,

		unsigned int event_triggers,

		unsigned int window_min,

		unsigned int window_max,

		unsigned int lfc_mid_point_in_us,

		unsigned int inserted_frames,

		unsigned int inserted_duration_in_us)

{

	struct core_stats *core_stats = NULL;

	struct stats_time_cache *time = NULL;

	unsigned int index = 0;

	if (mod_stats == NULL)

		return;

	core_stats = MOD_STATS_TO_CORE(mod_stats);

	if (core_stats->index >= core_stats->entries)

		return;

	time = core_stats->time;

	index = core_stats->index;

	time[index].v_total_min = v_total_min;

	time[index].v_total_max = v_total_max;

	time[index].event_triggers = event_triggers;

	time[index].min_window = window_min;

	time[index].max_window = window_max;

	time[index].lfc_mid_point_in_us = lfc_mid_point_in_us;

	time[index].num_frames_inserted = inserted_frames;

	time[index].inserted_duration_in_us = inserted_duration_in_us;

}