/*
 * 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
 *
 */

/*
 * Pre-requisites: headers required by header of this unit
 */

#include "dm_services.h"
#include "include/gpio_interface.h"
#include "include/gpio_service_interface.h"
#include "hw_translate.h"
#include "hw_factory.h"

/*
 * Header of this unit
 */

#include "gpio_service.h"

/*
 * Post-requisites: headers required by this unit
 */

#include "hw_gpio.h"

/*
 * @brief
 * Public API.
 */

struct gpio_service *dal_gpio_service_create(
        enum dce_version dce_version,
        enum dce_environment dce_environment,
        struct dc_context *ctx)
{
        struct gpio_service *service;
        int32_t index_of_id;

        service = kzalloc_obj(struct gpio_service);

        if (!service) {
                BREAK_TO_DEBUGGER();
                return NULL;
        }

        if (!dal_hw_translate_init(&service->translate, dce_version,
                        dce_environment)) {
                BREAK_TO_DEBUGGER();
                goto failure_1;
        }

        if (!dal_hw_factory_init(&service->factory, dce_version,
                        dce_environment)) {
                BREAK_TO_DEBUGGER();
                goto failure_1;
        }

        /* allocate and initialize busyness storage */
        {
                index_of_id = 0;
                service->ctx = ctx;

                do {
                        uint32_t number_of_bits =
                                service->factory.number_of_pins[index_of_id];
                        uint32_t i = 0;

                        if (number_of_bits)  {
                                service->busyness[index_of_id] =
                                        kcalloc(number_of_bits, sizeof(char),
                                                GFP_KERNEL);

                                if (!service->busyness[index_of_id]) {
                                        BREAK_TO_DEBUGGER();
                                        goto failure_2;
                                }

                                do {
                                        service->busyness[index_of_id][i] = 0;
                                        ++i;
                                } while (i < number_of_bits);
                        } else {
                                service->busyness[index_of_id] = NULL;
                        }

                        ++index_of_id;
                } while (index_of_id < GPIO_ID_COUNT);
        }

        return service;

failure_2:
        while (index_of_id > 0) {
                --index_of_id;
                kfree(service->busyness[index_of_id]);
        }

failure_1:
        kfree(service);

        return NULL;
}

struct gpio *dal_gpio_service_create_irq(
        struct gpio_service *service,
        uint32_t offset,
        uint32_t mask)
{
        enum gpio_id id = 0;
        uint32_t en;

        if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en)) {
                ASSERT_CRITICAL(false);
                return NULL;
        }

        return dal_gpio_create_irq(service, id, en);
}

struct gpio *dal_gpio_service_create_generic_mux(
        struct gpio_service *service,
        uint32_t offset,
        uint32_t mask)
{
        enum gpio_id id = 0;
        uint32_t en;
        struct gpio *generic;

        if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en)) {
                ASSERT_CRITICAL(false);
                return NULL;
        }

        generic = dal_gpio_create(
                service, id, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);

        return generic;
}

void dal_gpio_destroy_generic_mux(
        struct gpio **mux)
{
        if (!mux || !*mux) {
                ASSERT_CRITICAL(false);
                return;
        }

        dal_gpio_destroy(mux);
        kfree(*mux);

        *mux = NULL;
}

struct gpio_pin_info dal_gpio_get_generic_pin_info(
        struct gpio_service *service,
        enum gpio_id id,
        uint32_t en)
{
        struct gpio_pin_info pin = {0};

        if (service->translate.funcs->id_to_offset) {
                service->translate.funcs->id_to_offset(id, en, &pin);
        } else {
                pin.mask = 0xFFFFFFFF;
                pin.offset = 0xFFFFFFFF;
        }

        return pin;
}

void dal_gpio_service_destroy(
        struct gpio_service **ptr)
{
        if (!ptr || !*ptr) {
                BREAK_TO_DEBUGGER();
                return;
        }

        /* free business storage */
        {
                uint32_t index_of_id = 0;

                do {
                        kfree((*ptr)->busyness[index_of_id]);

                        ++index_of_id;
                } while (index_of_id < GPIO_ID_COUNT);
        }

        kfree(*ptr);

        *ptr = NULL;
}

enum gpio_result dal_mux_setup_config(
        struct gpio *mux,
        struct gpio_generic_mux_config *config)
{
        struct gpio_config_data config_data;

        if (!config)
                return GPIO_RESULT_INVALID_DATA;

        config_data.config.generic_mux = *config;
        config_data.type = GPIO_CONFIG_TYPE_GENERIC_MUX;

        return dal_gpio_set_config(mux, &config_data);
}

/*
 * @brief
 * Private API.
 */

static bool is_pin_busy(
        const struct gpio_service *service,
        enum gpio_id id,
        uint32_t en)
{
        if (id == GPIO_ID_UNKNOWN)
                return false;

        return service->busyness[id][en];
}

static void set_pin_busy(
        struct gpio_service *service,
        enum gpio_id id,
        uint32_t en)
{
        if (id == GPIO_ID_UNKNOWN)
                return;

        service->busyness[id][en] = true;
}

static void set_pin_free(
        struct gpio_service *service,
        enum gpio_id id,
        uint32_t en)
{
        if (id == GPIO_ID_UNKNOWN)
                return;

        service->busyness[id][en] = false;
}

enum gpio_result dal_gpio_service_lock(
        struct gpio_service *service,
        enum gpio_id id,
        uint32_t en)
{
        if (id != GPIO_ID_UNKNOWN && !service->busyness[id]) {
                ASSERT_CRITICAL(false);
                return GPIO_RESULT_OPEN_FAILED;
        }

        set_pin_busy(service, id, en);
        return GPIO_RESULT_OK;
}

enum gpio_result dal_gpio_service_unlock(
        struct gpio_service *service,
        enum gpio_id id,
        uint32_t en)
{
        if (id != GPIO_ID_UNKNOWN && !service->busyness[id]) {
                ASSERT_CRITICAL(false);
                return GPIO_RESULT_OPEN_FAILED;
        }

        set_pin_free(service, id, en);
        return GPIO_RESULT_OK;
}

enum gpio_result dal_gpio_service_open(
        struct gpio *gpio)
{
        struct gpio_service *service = gpio->service;
        enum gpio_id id = gpio->id;
        uint32_t en = gpio->en;
        enum gpio_mode mode = gpio->mode;

        struct hw_gpio_pin **pin = &gpio->pin;


        if (!service->busyness[id]) {
                ASSERT_CRITICAL(false);
                return GPIO_RESULT_OPEN_FAILED;
        }

        if (is_pin_busy(service, id, en)) {
                ASSERT_CRITICAL(false);
                return GPIO_RESULT_DEVICE_BUSY;
        }

        switch (id) {
        case GPIO_ID_DDC_DATA:
                *pin = service->factory.funcs->get_ddc_pin(gpio);
                service->factory.funcs->define_ddc_registers(*pin, en);
        break;
        case GPIO_ID_DDC_CLOCK:
                *pin = service->factory.funcs->get_ddc_pin(gpio);
                service->factory.funcs->define_ddc_registers(*pin, en);
        break;
        case GPIO_ID_GENERIC:
                *pin = service->factory.funcs->get_generic_pin(gpio);
                service->factory.funcs->define_generic_registers(*pin, en);
        break;
        case GPIO_ID_HPD:
                *pin = service->factory.funcs->get_hpd_pin(gpio);
                service->factory.funcs->define_hpd_registers(*pin, en);
        break;

        //TODO: gsl and sync support? create_sync and create_gsl are NULL
        case GPIO_ID_SYNC:
        case GPIO_ID_GSL:
        break;
        default:
                ASSERT_CRITICAL(false);
                return GPIO_RESULT_NON_SPECIFIC_ERROR;
        }

        if (!*pin) {
                ASSERT_CRITICAL(false);
                return GPIO_RESULT_NON_SPECIFIC_ERROR;
        }

        if (!(*pin)->funcs->open(*pin, mode)) {
                ASSERT_CRITICAL(false);
                dal_gpio_service_close(service, pin);
                return GPIO_RESULT_OPEN_FAILED;
        }

        set_pin_busy(service, id, en);
        return GPIO_RESULT_OK;
}

void dal_gpio_service_close(
        struct gpio_service *service,
        struct hw_gpio_pin **ptr)
{
        struct hw_gpio_pin *pin;

        if (!ptr) {
                ASSERT_CRITICAL(false);
                return;
        }

        pin = *ptr;

        if (pin) {
                set_pin_free(service, pin->id, pin->en);

                pin->funcs->close(pin);

                *ptr = NULL;
        }
}

enum dc_irq_source dal_irq_get_source(
        const struct gpio *irq)
{
        enum gpio_id id = dal_gpio_get_id(irq);

        switch (id) {
        case GPIO_ID_HPD:
                return (enum dc_irq_source)(DC_IRQ_SOURCE_HPD1 +
                        dal_gpio_get_enum(irq));
        case GPIO_ID_GPIO_PAD:
                return (enum dc_irq_source)(DC_IRQ_SOURCE_GPIOPAD0 +
                        dal_gpio_get_enum(irq));
        default:
                return DC_IRQ_SOURCE_INVALID;
        }
}

enum dc_irq_source dal_irq_get_rx_source(
        const struct gpio *irq)
{
        enum gpio_id id = dal_gpio_get_id(irq);

        switch (id) {
        case GPIO_ID_HPD:
                return (enum dc_irq_source)(DC_IRQ_SOURCE_HPD1RX +
                        dal_gpio_get_enum(irq));
        default:
                return DC_IRQ_SOURCE_INVALID;
        }
}

enum dc_irq_source dal_irq_get_read_request(
        const struct gpio *irq)
{
        enum gpio_id id = dal_gpio_get_id(irq);

        switch (id) {
        case GPIO_ID_HPD:
                return (enum dc_irq_source)(DC_IRQ_SOURCE_DCI2C_RR_DDC1 +
                        dal_gpio_get_enum(irq));
        default:
                return DC_IRQ_SOURCE_INVALID;
        }
}

enum gpio_result dal_irq_setup_hpd_filter(
        struct gpio *irq,
        struct gpio_hpd_config *config)
{
        struct gpio_config_data config_data;

        if (!config)
                return GPIO_RESULT_INVALID_DATA;

        config_data.type = GPIO_CONFIG_TYPE_HPD;
        config_data.config.hpd = *config;

        return dal_gpio_set_config(irq, &config_data);
}

/*
 * @brief
 * Creation and destruction
 */

struct gpio *dal_gpio_create_irq(
        struct gpio_service *service,
        enum gpio_id id,
        uint32_t en)
{
        struct gpio *irq;

        switch (id) {
        case GPIO_ID_HPD:
        case GPIO_ID_GPIO_PAD:
        break;
        default:
                ASSERT_CRITICAL(false);
                return NULL;
        }

        irq = dal_gpio_create(
                service, id, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);

        if (irq)
                return irq;

        ASSERT_CRITICAL(false);
        return NULL;
}

void dal_gpio_destroy_irq(
        struct gpio **irq)
{
        if (!irq || !*irq) {
                ASSERT_CRITICAL(false);
                return;
        }

        dal_gpio_destroy(irq);
        kfree(*irq);

        *irq = NULL;
}

struct ddc *dal_gpio_create_ddc(
        struct gpio_service *service,
        uint32_t offset,
        uint32_t mask,
        struct gpio_ddc_hw_info *info)
{
        enum gpio_id id;
        uint32_t en;
        struct ddc *ddc;

        if (!service->translate.funcs->offset_to_id(offset, mask, &id, &en))
                return NULL;

        ddc = kzalloc_obj(struct ddc);

        if (!ddc) {
                BREAK_TO_DEBUGGER();
                return NULL;
        }

        ddc->pin_data = dal_gpio_create(
                service, GPIO_ID_DDC_DATA, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);

        if (!ddc->pin_data) {
                BREAK_TO_DEBUGGER();
                goto failure_1;
        }

        ddc->pin_clock = dal_gpio_create(
                service, GPIO_ID_DDC_CLOCK, en, GPIO_PIN_OUTPUT_STATE_DEFAULT);

        if (!ddc->pin_clock) {
                BREAK_TO_DEBUGGER();
                goto failure_2;
        }

        ddc->hw_info = *info;

        ddc->ctx = service->ctx;

        return ddc;

failure_2:
        dal_gpio_destroy(&ddc->pin_data);

failure_1:
        kfree(ddc);

        return NULL;
}

void dal_gpio_destroy_ddc(
        struct ddc **ddc)
{
        if (!ddc || !*ddc) {
                BREAK_TO_DEBUGGER();
                return;
        }

        dal_ddc_close(*ddc);
        dal_gpio_destroy(&(*ddc)->pin_data);
        dal_gpio_destroy(&(*ddc)->pin_clock);
        kfree(*ddc);

        *ddc = NULL;
}

enum gpio_result dal_ddc_open(
        struct ddc *ddc,
        enum gpio_mode mode,
        enum gpio_ddc_config_type config_type)
{
        enum gpio_result result;

        struct gpio_config_data config_data;
        struct hw_gpio *hw_data;
        struct hw_gpio *hw_clock;

        result = dal_gpio_open_ex(ddc->pin_data, mode);

        if (result != GPIO_RESULT_OK) {
                BREAK_TO_DEBUGGER();
                return result;
        }

        result = dal_gpio_open_ex(ddc->pin_clock, mode);

        if (result != GPIO_RESULT_OK) {
                BREAK_TO_DEBUGGER();
                goto failure;
        }

        /* DDC clock and data pins should belong
         * to the same DDC block id,
         * we use the data pin to set the pad mode. */

        if (mode == GPIO_MODE_INPUT)
                /* this is from detect_sink_type,
                 * we need extra delay there */
                config_data.type = GPIO_CONFIG_TYPE_I2C_AUX_DUAL_MODE;
        else
                config_data.type = GPIO_CONFIG_TYPE_DDC;

        config_data.config.ddc.type = config_type;

        hw_data = FROM_HW_GPIO_PIN(ddc->pin_data->pin);
        hw_clock = FROM_HW_GPIO_PIN(ddc->pin_clock->pin);

        config_data.config.ddc.data_en_bit_present = hw_data->store.en != 0;
        config_data.config.ddc.clock_en_bit_present = hw_clock->store.en != 0;

        result = dal_gpio_set_config(ddc->pin_data, &config_data);

        if (result == GPIO_RESULT_OK)
                return result;

        BREAK_TO_DEBUGGER();

        dal_gpio_close(ddc->pin_clock);

failure:
        dal_gpio_close(ddc->pin_data);

        return result;
}

enum gpio_result dal_ddc_change_mode(
        struct ddc *ddc,
        enum gpio_mode mode)
{
        enum gpio_result result;

        enum gpio_mode original_mode =
                dal_gpio_get_mode(ddc->pin_data);

        result = dal_gpio_change_mode(ddc->pin_data, mode);

        /* [anaumov] DAL2 code returns GPIO_RESULT_NON_SPECIFIC_ERROR
         * in case of failures;
         * set_mode() is so that, in case of failure,
         * we must explicitly set original mode */

        if (result != GPIO_RESULT_OK)
                goto failure;

        result = dal_gpio_change_mode(ddc->pin_clock, mode);

        if (result == GPIO_RESULT_OK)
                return result;

        dal_gpio_change_mode(ddc->pin_clock, original_mode);

failure:
        dal_gpio_change_mode(ddc->pin_data, original_mode);

        return result;
}

enum gpio_ddc_line dal_ddc_get_line(
        const struct ddc *ddc)
{
        return (enum gpio_ddc_line)dal_gpio_get_enum(ddc->pin_data);
}

enum gpio_result dal_ddc_set_config(
        struct ddc *ddc,
        enum gpio_ddc_config_type config_type)
{
        struct gpio_config_data config_data;

        config_data.type = GPIO_CONFIG_TYPE_DDC;

        config_data.config.ddc.type = config_type;
        config_data.config.ddc.data_en_bit_present = false;
        config_data.config.ddc.clock_en_bit_present = false;

        return dal_gpio_set_config(ddc->pin_data, &config_data);
}

void dal_ddc_close(
        struct ddc *ddc)
{
        if (ddc != NULL) {
                dal_gpio_close(ddc->pin_clock);
                dal_gpio_close(ddc->pin_data);
        }
}