/* exynos_drm_encoder.c
 *
 * Copyright (c) 2011 Samsung Electronics Co., Ltd.
 * Authors:
 *      Inki Dae <inki.dae@samsung.com>
 *      Joonyoung Shim <jy0922.shim@samsung.com>
 *      Seung-Woo Kim <sw0312.kim@samsung.com>
 *
 * This program is free software; you can redistribute  it and/or modify it
 * under  the terms of  the GNU General  Public License as published by the
 * Free Software Foundation;  either version 2 of the  License, or (at your
 * option) any later version.
 */

#include <drm/drmP.h>
#include <drm/drm_crtc_helper.h>

#include "exynos_drm_drv.h"
#include "exynos_drm_encoder.h"
#include "exynos_drm_connector.h"

#define to_exynos_encoder(x)    container_of(x, struct exynos_drm_encoder,\
                                drm_encoder)

/*
 * exynos specific encoder structure.
 *
 * @drm_encoder: encoder object.
 * @manager: specific encoder has its own manager to control a hardware
 *      appropriately and we can access a hardware drawing on this manager.
 * @dpms: store the encoder dpms value.
 * @updated: indicate whether overlay data updating is needed or not.
 */
struct exynos_drm_encoder {
        struct drm_crtc                 *old_crtc;
        struct drm_encoder              drm_encoder;
        struct exynos_drm_manager       *manager;
        int                             dpms;
        bool                            updated;
};

static void exynos_drm_connector_power(struct drm_encoder *encoder, int mode)
{
        struct drm_device *dev = encoder->dev;
        struct drm_connector *connector;

        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                if (exynos_drm_best_encoder(connector) == encoder) {
                        DRM_DEBUG_KMS("connector[%d] dpms[%d]\n",
                                        connector->base.id, mode);

                        exynos_drm_display_power(connector, mode);
                }
        }
}

static void exynos_drm_encoder_dpms(struct drm_encoder *encoder, int mode)
{
        struct drm_device *dev = encoder->dev;
        struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
        struct exynos_drm_manager_ops *manager_ops = manager->ops;
        struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);

        DRM_DEBUG_KMS("%s, encoder dpms: %d\n", __FILE__, mode);

        if (exynos_encoder->dpms == mode) {
                DRM_DEBUG_KMS("desired dpms mode is same as previous one.\n");
                return;
        }

        mutex_lock(&dev->struct_mutex);

        switch (mode) {
        case DRM_MODE_DPMS_ON:
                if (manager_ops && manager_ops->apply)
                        if (!exynos_encoder->updated)
                                manager_ops->apply(manager->dev);

                exynos_drm_connector_power(encoder, mode);
                exynos_encoder->dpms = mode;
                break;
        case DRM_MODE_DPMS_STANDBY:
        case DRM_MODE_DPMS_SUSPEND:
        case DRM_MODE_DPMS_OFF:
                exynos_drm_connector_power(encoder, mode);
                exynos_encoder->dpms = mode;
                exynos_encoder->updated = false;
                break;
        default:
                DRM_ERROR("unspecified mode %d\n", mode);
                break;
        }

        mutex_unlock(&dev->struct_mutex);
}

static bool
exynos_drm_encoder_mode_fixup(struct drm_encoder *encoder,
                               const struct drm_display_mode *mode,
                               struct drm_display_mode *adjusted_mode)
{
        struct drm_device *dev = encoder->dev;
        struct drm_connector *connector;
        struct exynos_drm_manager *manager = exynos_drm_get_manager(encoder);
        struct exynos_drm_manager_ops *manager_ops = manager->ops;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                if (connector->encoder == encoder)
                        if (manager_ops && manager_ops->mode_fixup)
                                manager_ops->mode_fixup(manager->dev, connector,
                                                        mode, adjusted_mode);
        }

        return true;
}

static void disable_plane_to_crtc(struct drm_device *dev,
                                                struct drm_crtc *old_crtc,
                                                struct drm_crtc *new_crtc)
{
        struct drm_plane *plane;

        /*
         * if old_crtc isn't same as encoder->crtc then it means that
         * user changed crtc id to another one so the plane to old_crtc
         * should be disabled and plane->crtc should be set to new_crtc
         * (encoder->crtc)
         */
        list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
                if (plane->crtc == old_crtc) {
                        /*
                         * do not change below call order.
                         *
                         * plane->funcs->disable_plane call checks
                         * if encoder->crtc is same as plane->crtc and if same
                         * then overlay_ops->disable callback will be called
                         * to diasble current hw overlay so plane->crtc should
                         * have new_crtc because new_crtc was set to
                         * encoder->crtc in advance.
                         */
                        plane->crtc = new_crtc;
                        plane->funcs->disable_plane(plane);
                }
        }
}

static void exynos_drm_encoder_mode_set(struct drm_encoder *encoder,
                                         struct drm_display_mode *mode,
                                         struct drm_display_mode *adjusted_mode)
{
        struct drm_device *dev = encoder->dev;
        struct drm_connector *connector;
        struct exynos_drm_manager *manager;
        struct exynos_drm_manager_ops *manager_ops;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
                if (connector->encoder == encoder) {
                        struct exynos_drm_encoder *exynos_encoder;

                        exynos_encoder = to_exynos_encoder(encoder);

                        if (exynos_encoder->old_crtc != encoder->crtc &&
                                        exynos_encoder->old_crtc) {

                                /*
                                 * disable a plane to old crtc and change
                                 * crtc of the plane to new one.
                                 */
                                disable_plane_to_crtc(dev,
                                                exynos_encoder->old_crtc,
                                                encoder->crtc);
                        }

                        manager = exynos_drm_get_manager(encoder);
                        manager_ops = manager->ops;

                        if (manager_ops && manager_ops->mode_set)
                                manager_ops->mode_set(manager->dev,
                                                        adjusted_mode);

                        exynos_encoder->old_crtc = encoder->crtc;
                }
        }
}

static void exynos_drm_encoder_prepare(struct drm_encoder *encoder)
{
        DRM_DEBUG_KMS("%s\n", __FILE__);

        /* drm framework doesn't check NULL. */
}

static void exynos_drm_encoder_commit(struct drm_encoder *encoder)
{
        struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
        struct exynos_drm_manager *manager = exynos_encoder->manager;
        struct exynos_drm_manager_ops *manager_ops = manager->ops;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        if (manager_ops && manager_ops->commit)
                manager_ops->commit(manager->dev);

        /*
         * this will avoid one issue that overlay data is updated to
         * real hardware two times.
         * And this variable will be used to check if the data was
         * already updated or not by exynos_drm_encoder_dpms function.
         */
        exynos_encoder->updated = true;

        /*
         * In case of setcrtc, there is no way to update encoder's dpms
         * so update it here.
         */
        exynos_encoder->dpms = DRM_MODE_DPMS_ON;
}

void exynos_drm_encoder_complete_scanout(struct drm_framebuffer *fb)
{
        struct exynos_drm_encoder *exynos_encoder;
        struct exynos_drm_manager_ops *ops;
        struct drm_device *dev = fb->dev;
        struct drm_encoder *encoder;

        /*
         * make sure that overlay data are updated to real hardware
         * for all encoders.
         */
        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                exynos_encoder = to_exynos_encoder(encoder);
                ops = exynos_encoder->manager->ops;

                /*
                 * wait for vblank interrupt
                 * - this makes sure that overlay data are updated to
                 *      real hardware.
                 */
                if (ops->wait_for_vblank)
                        ops->wait_for_vblank(exynos_encoder->manager->dev);
        }
}


static void exynos_drm_encoder_disable(struct drm_encoder *encoder)
{
        struct drm_plane *plane;
        struct drm_device *dev = encoder->dev;

        exynos_drm_encoder_dpms(encoder, DRM_MODE_DPMS_OFF);

        /* all planes connected to this encoder should be also disabled. */
        list_for_each_entry(plane, &dev->mode_config.plane_list, head) {
                if (plane->crtc == encoder->crtc)
                        plane->funcs->disable_plane(plane);
        }
}

static struct drm_encoder_helper_funcs exynos_encoder_helper_funcs = {
        .dpms           = exynos_drm_encoder_dpms,
        .mode_fixup     = exynos_drm_encoder_mode_fixup,
        .mode_set       = exynos_drm_encoder_mode_set,
        .prepare        = exynos_drm_encoder_prepare,
        .commit         = exynos_drm_encoder_commit,
        .disable        = exynos_drm_encoder_disable,
};

static void exynos_drm_encoder_destroy(struct drm_encoder *encoder)
{
        struct exynos_drm_encoder *exynos_encoder =
                to_exynos_encoder(encoder);

        DRM_DEBUG_KMS("%s\n", __FILE__);

        exynos_encoder->manager->pipe = -1;

        drm_encoder_cleanup(encoder);
        kfree(exynos_encoder);
}

static struct drm_encoder_funcs exynos_encoder_funcs = {
        .destroy = exynos_drm_encoder_destroy,
};

static unsigned int exynos_drm_encoder_clones(struct drm_encoder *encoder)
{
        struct drm_encoder *clone;
        struct drm_device *dev = encoder->dev;
        struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
        struct exynos_drm_display_ops *display_ops =
                                exynos_encoder->manager->display_ops;
        unsigned int clone_mask = 0;
        int cnt = 0;

        list_for_each_entry(clone, &dev->mode_config.encoder_list, head) {
                switch (display_ops->type) {
                case EXYNOS_DISPLAY_TYPE_LCD:
                case EXYNOS_DISPLAY_TYPE_HDMI:
                case EXYNOS_DISPLAY_TYPE_VIDI:
                        clone_mask |= (1 << (cnt++));
                        break;
                default:
                        continue;
                }
        }

        return clone_mask;
}

void exynos_drm_encoder_setup(struct drm_device *dev)
{
        struct drm_encoder *encoder;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
                encoder->possible_clones = exynos_drm_encoder_clones(encoder);
}

struct drm_encoder *
exynos_drm_encoder_create(struct drm_device *dev,
                           struct exynos_drm_manager *manager,
                           unsigned int possible_crtcs)
{
        struct drm_encoder *encoder;
        struct exynos_drm_encoder *exynos_encoder;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        if (!manager || !possible_crtcs)
                return NULL;

        if (!manager->dev)
                return NULL;

        exynos_encoder = kzalloc(sizeof(*exynos_encoder), GFP_KERNEL);
        if (!exynos_encoder) {
                DRM_ERROR("failed to allocate encoder\n");
                return NULL;
        }

        exynos_encoder->dpms = DRM_MODE_DPMS_OFF;
        exynos_encoder->manager = manager;
        encoder = &exynos_encoder->drm_encoder;
        encoder->possible_crtcs = possible_crtcs;

        DRM_DEBUG_KMS("possible_crtcs = 0x%x\n", encoder->possible_crtcs);

        drm_encoder_init(dev, encoder, &exynos_encoder_funcs,
                        DRM_MODE_ENCODER_TMDS);

        drm_encoder_helper_add(encoder, &exynos_encoder_helper_funcs);

        DRM_DEBUG_KMS("encoder has been created\n");

        return encoder;
}

struct exynos_drm_manager *exynos_drm_get_manager(struct drm_encoder *encoder)
{
        return to_exynos_encoder(encoder)->manager;
}

void exynos_drm_fn_encoder(struct drm_crtc *crtc, void *data,
                            void (*fn)(struct drm_encoder *, void *))
{
        struct drm_device *dev = crtc->dev;
        struct drm_encoder *encoder;
        struct exynos_drm_private *private = dev->dev_private;
        struct exynos_drm_manager *manager;

        list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
                /*
                 * if crtc is detached from encoder, check pipe,
                 * otherwise check crtc attached to encoder
                 */
                if (!encoder->crtc) {
                        manager = to_exynos_encoder(encoder)->manager;
                        if (manager->pipe < 0 ||
                                        private->crtc[manager->pipe] != crtc)
                                continue;
                } else {
                        if (encoder->crtc != crtc)
                                continue;
                }

                fn(encoder, data);
        }
}

void exynos_drm_enable_vblank(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_manager *manager =
                to_exynos_encoder(encoder)->manager;
        struct exynos_drm_manager_ops *manager_ops = manager->ops;
        int crtc = *(int *)data;

        if (manager->pipe != crtc)
                return;

        if (manager_ops->enable_vblank)
                manager_ops->enable_vblank(manager->dev);
}

void exynos_drm_disable_vblank(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_manager *manager =
                to_exynos_encoder(encoder)->manager;
        struct exynos_drm_manager_ops *manager_ops = manager->ops;
        int crtc = *(int *)data;

        if (manager->pipe != crtc)
                return;

        if (manager_ops->disable_vblank)
                manager_ops->disable_vblank(manager->dev);
}

void exynos_drm_encoder_crtc_dpms(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_encoder *exynos_encoder = to_exynos_encoder(encoder);
        struct exynos_drm_manager *manager = exynos_encoder->manager;
        struct exynos_drm_manager_ops *manager_ops = manager->ops;
        int mode = *(int *)data;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        if (manager_ops && manager_ops->dpms)
                manager_ops->dpms(manager->dev, mode);

        /*
         * if this condition is ok then it means that the crtc is already
         * detached from encoder and last function for detaching is properly
         * done, so clear pipe from manager to prevent repeated call.
         */
        if (mode > DRM_MODE_DPMS_ON) {
                if (!encoder->crtc)
                        manager->pipe = -1;
        }
}

void exynos_drm_encoder_crtc_pipe(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_manager *manager =
                to_exynos_encoder(encoder)->manager;
        int pipe = *(int *)data;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        /*
         * when crtc is detached from encoder, this pipe is used
         * to select manager operation
         */
        manager->pipe = pipe;
}

void exynos_drm_encoder_plane_mode_set(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_manager *manager =
                to_exynos_encoder(encoder)->manager;
        struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
        struct exynos_drm_overlay *overlay = data;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        if (overlay_ops && overlay_ops->mode_set)
                overlay_ops->mode_set(manager->dev, overlay);
}

void exynos_drm_encoder_plane_commit(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_manager *manager =
                to_exynos_encoder(encoder)->manager;
        struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
        int zpos = DEFAULT_ZPOS;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        if (data)
                zpos = *(int *)data;

        if (overlay_ops && overlay_ops->commit)
                overlay_ops->commit(manager->dev, zpos);
}

void exynos_drm_encoder_plane_enable(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_manager *manager =
                to_exynos_encoder(encoder)->manager;
        struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
        int zpos = DEFAULT_ZPOS;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        if (data)
                zpos = *(int *)data;

        if (overlay_ops && overlay_ops->enable)
                overlay_ops->enable(manager->dev, zpos);
}

void exynos_drm_encoder_plane_disable(struct drm_encoder *encoder, void *data)
{
        struct exynos_drm_manager *manager =
                to_exynos_encoder(encoder)->manager;
        struct exynos_drm_overlay_ops *overlay_ops = manager->overlay_ops;
        int zpos = DEFAULT_ZPOS;

        DRM_DEBUG_KMS("%s\n", __FILE__);

        if (data)
                zpos = *(int *)data;

        if (overlay_ops && overlay_ops->disable)
                overlay_ops->disable(manager->dev, zpos);
}