/*
 * Copyright 2021 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 "link_enc_cfg.h"
#include "resource.h"
#include "dc_link_dp.h"

/* Check whether stream is supported by DIG link encoders. */
static bool is_dig_link_enc_stream(struct dc_stream_state *stream)
{
        bool is_dig_stream = false;
        struct link_encoder *link_enc = NULL;
        int i;

        /* Loop over created link encoder objects. */
        for (i = 0; i < stream->ctx->dc->res_pool->res_cap->num_dig_link_enc; i++) {
                link_enc = stream->ctx->dc->res_pool->link_encoders[i];

                if (link_enc &&
                                ((uint32_t)stream->signal & link_enc->output_signals)) {
                        if (dc_is_dp_signal(stream->signal)) {
                                /* DIGs do not support DP2.0 streams with 128b/132b encoding. */
                                struct dc_link_settings link_settings = {0};

                                decide_link_settings(stream, &link_settings);
                                if ((link_settings.link_rate >= LINK_RATE_LOW) &&
                                                link_settings.link_rate <= LINK_RATE_HIGH3) {
                                        is_dig_stream = true;
                                        break;
                                }
                        } else {
                                is_dig_stream = true;
                                break;
                        }
                }
        }

        return is_dig_stream;
}

/* Update DIG link encoder resource tracking variables in dc_state. */
static void update_link_enc_assignment(
                struct dc_state *state,
                struct dc_stream_state *stream,
                enum engine_id eng_id,
                bool add_enc)
{
        int eng_idx;
        int stream_idx;
        int i;

        if (eng_id != ENGINE_ID_UNKNOWN) {
                eng_idx = eng_id - ENGINE_ID_DIGA;
                stream_idx = -1;

                /* Index of stream in dc_state used to update correct entry in
                 * link_enc_assignments table.
                 */
                for (i = 0; i < state->stream_count; i++) {
                        if (stream == state->streams[i]) {
                                stream_idx = i;
                                break;
                        }
                }

                /* Update link encoder assignments table, link encoder availability
                 * pool and link encoder assigned to stream in state.
                 * Add/remove encoder resource to/from stream.
                 */
                if (stream_idx != -1) {
                        if (add_enc) {
                                state->res_ctx.link_enc_assignments[stream_idx] = (struct link_enc_assignment){
                                        .valid = true,
                                        .ep_id = (struct display_endpoint_id) {
                                                .link_id = stream->link->link_id,
                                                .ep_type = stream->link->ep_type},
                                        .eng_id = eng_id};
                                state->res_ctx.link_enc_avail[eng_idx] = ENGINE_ID_UNKNOWN;
                                stream->link_enc = stream->ctx->dc->res_pool->link_encoders[eng_idx];
                        } else {
                                state->res_ctx.link_enc_assignments[stream_idx].valid = false;
                                state->res_ctx.link_enc_avail[eng_idx] = eng_id;
                                stream->link_enc = NULL;
                        }
                } else {
                        dm_output_to_console("%s: Stream not found in dc_state.\n", __func__);
                }
        }
}

/* Return first available DIG link encoder. */
static enum engine_id find_first_avail_link_enc(
                const struct dc_context *ctx,
                const struct dc_state *state)
{
        enum engine_id eng_id = ENGINE_ID_UNKNOWN;
        int i;

        for (i = 0; i < ctx->dc->res_pool->res_cap->num_dig_link_enc; i++) {
                eng_id = state->res_ctx.link_enc_avail[i];
                if (eng_id != ENGINE_ID_UNKNOWN)
                        break;
        }

        return eng_id;
}

/* Return stream using DIG link encoder resource. NULL if unused. */
static struct dc_stream_state *get_stream_using_link_enc(
                struct dc_state *state,
                enum engine_id eng_id)
{
        struct dc_stream_state *stream = NULL;
        int stream_idx = -1;
        int i;

        for (i = 0; i < state->stream_count; i++) {
                struct link_enc_assignment assignment = state->res_ctx.link_enc_assignments[i];

                if (assignment.valid && (assignment.eng_id == eng_id)) {
                        stream_idx = i;
                        break;
                }
        }

        if (stream_idx != -1)
                stream = state->streams[stream_idx];
        else
                dm_output_to_console("%s: No stream using DIG(%d).\n", __func__, eng_id);

        return stream;
}

void link_enc_cfg_init(
                struct dc *dc,
                struct dc_state *state)
{
        int i;

        for (i = 0; i < dc->res_pool->res_cap->num_dig_link_enc; i++) {
                if (dc->res_pool->link_encoders[i])
                        state->res_ctx.link_enc_avail[i] = (enum engine_id) i;
                else
                        state->res_ctx.link_enc_avail[i] = ENGINE_ID_UNKNOWN;
        }
}

void link_enc_cfg_link_encs_assign(
                struct dc *dc,
                struct dc_state *state,
                struct dc_stream_state *streams[],
                uint8_t stream_count)
{
        enum engine_id eng_id = ENGINE_ID_UNKNOWN;
        int i;

        /* Release DIG link encoder resources before running assignment algorithm. */
        for (i = 0; i < stream_count; i++)
                dc->res_pool->funcs->link_enc_unassign(state, streams[i]);

        /* (a) Assign DIG link encoders to physical (unmappable) endpoints first. */
        for (i = 0; i < stream_count; i++) {
                struct dc_stream_state *stream = streams[i];

                /* Skip stream if not supported by DIG link encoder. */
                if (!is_dig_link_enc_stream(stream))
                        continue;

                /* Physical endpoints have a fixed mapping to DIG link encoders. */
                if (!stream->link->is_dig_mapping_flexible) {
                        eng_id = stream->link->eng_id;
                        update_link_enc_assignment(state, stream, eng_id, true);
                }
        }

        /* (b) Then assign encoders to mappable endpoints. */
        eng_id = ENGINE_ID_UNKNOWN;

        for (i = 0; i < stream_count; i++) {
                struct dc_stream_state *stream = streams[i];

                /* Skip stream if not supported by DIG link encoder. */
                if (!is_dig_link_enc_stream(stream))
                        continue;

                /* Mappable endpoints have a flexible mapping to DIG link encoders. */
                if (stream->link->is_dig_mapping_flexible) {
                        eng_id = find_first_avail_link_enc(stream->ctx, state);
                        update_link_enc_assignment(state, stream, eng_id, true);
                }
        }
}

void link_enc_cfg_link_enc_unassign(
                struct dc_state *state,
                struct dc_stream_state *stream)
{
        enum engine_id eng_id = ENGINE_ID_UNKNOWN;

        /* Only DIG link encoders. */
        if (!is_dig_link_enc_stream(stream))
                return;

        if (stream->link_enc)
                eng_id = stream->link_enc->preferred_engine;

        update_link_enc_assignment(state, stream, eng_id, false);
}

bool link_enc_cfg_is_transmitter_mappable(
                struct dc_state *state,
                struct link_encoder *link_enc)
{
        bool is_mappable = false;
        enum engine_id eng_id = link_enc->preferred_engine;
        struct dc_stream_state *stream = get_stream_using_link_enc(state, eng_id);

        if (stream)
                is_mappable = stream->link->is_dig_mapping_flexible;

        return is_mappable;
}

struct dc_link *link_enc_cfg_get_link_using_link_enc(
                struct dc_state *state,
                enum engine_id eng_id)
{
        struct dc_link *link = NULL;
        int stream_idx = -1;
        int i;

        for (i = 0; i < state->stream_count; i++) {
                struct link_enc_assignment assignment = state->res_ctx.link_enc_assignments[i];

                if (assignment.valid && (assignment.eng_id == eng_id)) {
                        stream_idx = i;
                        break;
                }
        }

        if (stream_idx != -1)
                link = state->streams[stream_idx]->link;
        else
                dm_output_to_console("%s: No link using DIG(%d).\n", __func__, eng_id);

        return link;
}

struct link_encoder *link_enc_cfg_get_link_enc_used_by_link(
                struct dc_state *state,
                const struct dc_link *link)
{
        struct link_encoder *link_enc = NULL;
        struct display_endpoint_id ep_id;
        int stream_idx = -1;
        int i;

        ep_id = (struct display_endpoint_id) {
                .link_id = link->link_id,
                .ep_type = link->ep_type};

        for (i = 0; i < state->stream_count; i++) {
                struct link_enc_assignment assignment = state->res_ctx.link_enc_assignments[i];

                if (assignment.valid &&
                                assignment.ep_id.link_id.id == ep_id.link_id.id &&
                                assignment.ep_id.link_id.enum_id == ep_id.link_id.enum_id &&
                                assignment.ep_id.link_id.type == ep_id.link_id.type &&
                                assignment.ep_id.ep_type == ep_id.ep_type) {
                        stream_idx = i;
                        break;
                }
        }

        if (stream_idx != -1)
                link_enc = state->streams[stream_idx]->link_enc;

        return link_enc;
}

struct link_encoder *link_enc_cfg_get_next_avail_link_enc(
        const struct dc *dc,
        const struct dc_state *state)
{
        struct link_encoder *link_enc = NULL;
        enum engine_id eng_id;

        eng_id = find_first_avail_link_enc(dc->ctx, state);
        if (eng_id != ENGINE_ID_UNKNOWN)
                link_enc = dc->res_pool->link_encoders[eng_id - ENGINE_ID_DIGA];

        return link_enc;
}