/*
 * Xilinx DRM encoder driver for Xilinx
 *
 *  Copyright (C) 2013 Xilinx, Inc.
 *
 *  Author: Hyun Woo Kwon <hyunk@xilinx.com>
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

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

#include <linux/err.h>
#include <linux/i2c.h>
#include <linux/of.h>
#include <linux/of_platform.h>
#include <linux/platform_device.h>

#include "xilinx_drm_drv.h"
#include "xilinx_drm_encoder.h"

struct xilinx_drm_encoder {
        struct drm_encoder_slave slave;
        struct device *dev;
        int dpms;
};

#define to_xilinx_encoder(x)    \
        container_of(x, struct xilinx_drm_encoder, slave)

/* set encoder dpms */
static void xilinx_drm_encoder_dpms(struct drm_encoder *base_encoder, int dpms)
{
        struct xilinx_drm_encoder *encoder;
        struct drm_encoder_slave *encoder_slave;
        const struct drm_encoder_slave_funcs *encoder_sfuncs;

        encoder_slave = to_encoder_slave(base_encoder);
        encoder_sfuncs = encoder_slave->slave_funcs;
        encoder = to_xilinx_encoder(encoder_slave);

        DRM_DEBUG_KMS("dpms: %d -> %d\n", encoder->dpms, dpms);

        if (encoder->dpms == dpms)
                return;

        encoder->dpms = dpms;
        if (encoder_sfuncs->dpms)
                encoder_sfuncs->dpms(base_encoder, dpms);
}

/* adjust a mode if needed */
static bool
xilinx_drm_encoder_mode_fixup(struct drm_encoder *base_encoder,
                              const struct drm_display_mode *mode,
                              struct drm_display_mode *adjusted_mode)
{
        struct drm_encoder_slave *encoder_slave;
        const struct drm_encoder_slave_funcs *encoder_sfuncs = NULL;
        bool ret = true;

        encoder_slave = to_encoder_slave(base_encoder);
        encoder_sfuncs = encoder_slave->slave_funcs;
        if (encoder_sfuncs->mode_fixup)
                ret = encoder_sfuncs->mode_fixup(base_encoder, mode,
                                                 adjusted_mode);

        return ret;
}

/* set mode to xilinx encoder */
static void xilinx_drm_encoder_mode_set(struct drm_encoder *base_encoder,
                                        struct drm_display_mode *mode,
                                        struct drm_display_mode *adjusted_mode)
{
        struct drm_encoder_slave *encoder_slave;
        const struct drm_encoder_slave_funcs *encoder_sfuncs;

        DRM_DEBUG_KMS("h: %d, v: %d\n",
                      adjusted_mode->hdisplay, adjusted_mode->vdisplay);
        DRM_DEBUG_KMS("refresh: %d, pclock: %d khz\n",
                      adjusted_mode->vrefresh, adjusted_mode->clock);

        encoder_slave = to_encoder_slave(base_encoder);
        encoder_sfuncs = encoder_slave->slave_funcs;
        if (encoder_sfuncs->mode_set)
                encoder_sfuncs->mode_set(base_encoder, mode, adjusted_mode);
}

/* apply mode to encoder pipe */
static void xilinx_drm_encoder_commit(struct drm_encoder *base_encoder)
{
        /* start encoder with new mode */
        xilinx_drm_encoder_dpms(base_encoder, DRM_MODE_DPMS_ON);
}

/* prepare encoder */
static void xilinx_drm_encoder_prepare(struct drm_encoder *base_encoder)
{
        xilinx_drm_encoder_dpms(base_encoder, DRM_MODE_DPMS_OFF);
}

/* get crtc */
static struct drm_crtc *
xilinx_drm_encoder_get_crtc(struct drm_encoder *base_encoder)
{
        return base_encoder->crtc;
}

static const struct drm_encoder_helper_funcs xilinx_drm_encoder_helper_funcs = {
        .dpms           = xilinx_drm_encoder_dpms,
        .mode_fixup     = xilinx_drm_encoder_mode_fixup,
        .mode_set       = xilinx_drm_encoder_mode_set,
        .prepare        = xilinx_drm_encoder_prepare,
        .commit         = xilinx_drm_encoder_commit,
        .get_crtc       = xilinx_drm_encoder_get_crtc,
};

/* destroy encoder */
void xilinx_drm_encoder_destroy(struct drm_encoder *base_encoder)
{
        struct xilinx_drm_encoder *encoder;
        struct drm_encoder_slave *encoder_slave;

        encoder_slave = to_encoder_slave(base_encoder);
        encoder = to_xilinx_encoder(encoder_slave);

        /* make sure encoder is off */
        xilinx_drm_encoder_dpms(base_encoder, DRM_MODE_DPMS_OFF);

        drm_encoder_cleanup(base_encoder);
        put_device(encoder->dev);
}

static const struct drm_encoder_funcs xilinx_drm_encoder_funcs = {
        .destroy        = xilinx_drm_encoder_destroy,
};

/* create encoder */
struct drm_encoder *xilinx_drm_encoder_create(struct drm_device *drm,
                                              struct device_node *node)
{
        struct xilinx_drm_encoder *encoder;
        struct i2c_client *i2c_slv;
        struct i2c_driver *i2c_driver;
        struct drm_i2c_encoder_driver *drm_i2c_driver;
        struct device_driver *device_driver;
        struct platform_device *platform_slv;
        struct platform_driver *platform_driver;
        struct drm_platform_encoder_driver *drm_platform_driver;
        int ret = 0;

        encoder = devm_kzalloc(drm->dev, sizeof(*encoder), GFP_KERNEL);
        if (!encoder)
                return ERR_PTR(-ENOMEM);

        encoder->dpms = DRM_MODE_DPMS_OFF;

        /* FIXME: Use DT to figure out crtcs / clones */
        encoder->slave.base.possible_crtcs = 1;
        encoder->slave.base.possible_clones = ~0;
        ret = drm_encoder_init(drm, &encoder->slave.base,
                               &xilinx_drm_encoder_funcs,
                               DRM_MODE_ENCODER_TMDS, NULL);
        if (ret) {
                DRM_ERROR("failed to initialize drm encoder\n");
                return ERR_PTR(ret);
        }

        drm_encoder_helper_add(&encoder->slave.base,
                               &xilinx_drm_encoder_helper_funcs);

        /* initialize slave encoder */
        i2c_slv = of_find_i2c_device_by_node(node);
        if (i2c_slv && i2c_slv->dev.driver) {
                i2c_driver = to_i2c_driver(i2c_slv->dev.driver);
                drm_i2c_driver = to_drm_i2c_encoder_driver(i2c_driver);
                if (!drm_i2c_driver || !drm_i2c_driver->encoder_init) {
                        DRM_DEBUG_KMS("failed to initialize i2c slave\n");
                        ret = -EPROBE_DEFER;
                        goto err_out;
                }

                encoder->dev = &i2c_slv->dev;
                ret = drm_i2c_driver->encoder_init(i2c_slv, drm,
                                                   &encoder->slave);
        } else {
                platform_slv = of_find_device_by_node(node);
                if (!platform_slv) {
                        DRM_DEBUG_KMS("failed to get an encoder slv\n");
                        return ERR_PTR(-EPROBE_DEFER);
                }

                device_driver = platform_slv->dev.driver;
                if (!device_driver) {
                        DRM_DEBUG_KMS("failed to get device driver\n");
                        return ERR_PTR(-EPROBE_DEFER);
                }

                platform_driver = to_platform_driver(device_driver);
                drm_platform_driver =
                        to_drm_platform_encoder_driver(platform_driver);
                if (!drm_platform_driver ||
                    !drm_platform_driver->encoder_init) {
                        DRM_DEBUG_KMS("failed to initialize platform slave\n");
                        ret = -EPROBE_DEFER;
                        goto err_out;
                }

                encoder->dev = &platform_slv->dev;
                ret = drm_platform_driver->encoder_init(platform_slv, drm,
                                                        &encoder->slave);
        }

        if (ret) {
                DRM_ERROR("failed to initialize encoder slave\n");
                goto err_out;
        }

        if (!encoder->slave.slave_funcs) {
                DRM_ERROR("there's no encoder slave function\n");
                ret = -ENODEV;
                goto err_out;
        }

        return &encoder->slave.base;

err_out:
        return ERR_PTR(ret);
}