/*
 * linux/include/video/mmp_disp.h
 * Header file for Marvell MMP Display Controller
 *
 * Copyright (C) 2012 Marvell Technology Group Ltd.
 * Authors: Zhou Zhu <zzhu3@marvell.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.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef _MMP_DISP_H_
#define _MMP_DISP_H_
#include <linux/kthread.h>

enum {
        PIXFMT_UYVY = 0,
        PIXFMT_VYUY,
        PIXFMT_YUYV,
        PIXFMT_YUV422P,
        PIXFMT_YVU422P,
        PIXFMT_YUV420P,
        PIXFMT_YVU420P,
        PIXFMT_RGB565 = 0x100,
        PIXFMT_BGR565,
        PIXFMT_RGB1555,
        PIXFMT_BGR1555,
        PIXFMT_RGB888PACK,
        PIXFMT_BGR888PACK,
        PIXFMT_RGB888UNPACK,
        PIXFMT_BGR888UNPACK,
        PIXFMT_RGBA888,
        PIXFMT_BGRA888,
        PIXFMT_RGB666, /* for output usage */
        PIXFMT_PSEUDOCOLOR = 0x200,
};

static inline int pixfmt_to_stride(int pix_fmt)
{
        switch (pix_fmt) {
        case PIXFMT_RGB565:
        case PIXFMT_BGR565:
        case PIXFMT_RGB1555:
        case PIXFMT_BGR1555:
        case PIXFMT_UYVY:
        case PIXFMT_VYUY:
        case PIXFMT_YUYV:
                return 2;
        case PIXFMT_RGB888UNPACK:
        case PIXFMT_BGR888UNPACK:
        case PIXFMT_RGBA888:
        case PIXFMT_BGRA888:
                return 4;
        case PIXFMT_RGB888PACK:
        case PIXFMT_BGR888PACK:
                return 3;
        case PIXFMT_YUV422P:
        case PIXFMT_YVU422P:
        case PIXFMT_YUV420P:
        case PIXFMT_YVU420P:
        case PIXFMT_PSEUDOCOLOR:
                return 1;
        default:
                return 0;
        }
}

/* parameters used by path/overlay */
/* overlay related para: win/addr */
struct mmp_win {
        /* position/size of window */
        u16     xsrc;
        u16     ysrc;
        u16     xdst;
        u16     ydst;
        u16     xpos;
        u16     ypos;
        u16     left_crop;
        u16     right_crop;
        u16     up_crop;
        u16     bottom_crop;
        int     pix_fmt;
        /*
         * pitch[0]: graphics/video layer line length or y pitch
         * pitch[1]/pitch[2]: video u/v pitch if non-zero
         */
        u32     pitch[3];
};

struct mmp_addr {
        /* phys address */
        u32     phys[6];
};

/* path related para: mode */
struct mmp_mode {
        const char *name;
        u32 refresh;
        u32 xres;
        u32 yres;
        u32 left_margin;
        u32 right_margin;
        u32 upper_margin;
        u32 lower_margin;
        u32 hsync_len;
        u32 vsync_len;
        u32 hsync_invert;
        u32 vsync_invert;
        u32 invert_pixclock;
        u32 pixclock_freq;
        int pix_fmt_out;
};

/* main structures */
struct mmp_path;
struct mmp_overlay;
struct mmp_panel;

/* status types */
enum {
        MMP_OFF = 0,
        MMP_ON,
};

static inline const char *stat_name(int stat)
{
        switch (stat) {
        case MMP_OFF:
                return "OFF";
        case MMP_ON:
                return "ON";
        default:
                return "UNKNOWNSTAT";
        }
}

struct mmp_overlay_ops {
        /* should be provided by driver */
        void (*set_fetch)(struct mmp_overlay *overlay, int fetch_id);
        void (*set_onoff)(struct mmp_overlay *overlay, int status);
        void (*set_win)(struct mmp_overlay *overlay, struct mmp_win *win);
        int (*set_addr)(struct mmp_overlay *overlay, struct mmp_addr *addr);
};

/* overlay describes a z-order indexed slot in each path. */
struct mmp_overlay {
        int id;
        const char *name;
        struct mmp_path *path;

        /* overlay info: private data */
        int dmafetch_id;
        struct mmp_addr addr;
        struct mmp_win win;

        /* state */
        int open_count;
        int status;
        struct mutex access_ok;

        struct mmp_overlay_ops *ops;
};

/* panel type */
enum {
        PANELTYPE_ACTIVE = 0,
        PANELTYPE_SMART,
        PANELTYPE_TV,
        PANELTYPE_DSI_CMD,
        PANELTYPE_DSI_VIDEO,
};

struct mmp_panel {
        /* use node to register to list */
        struct list_head node;
        const char *name;
        /* path name used to connect to proper path configed */
        const char *plat_path_name;
        struct device *dev;
        int panel_type;
        void *plat_data;
        int (*get_modelist)(struct mmp_panel *panel,
                        struct mmp_mode **modelist);
        void (*set_mode)(struct mmp_panel *panel,
                        struct mmp_mode *mode);
        void (*set_onoff)(struct mmp_panel *panel,
                        int status);
};

struct mmp_path_ops {
        int (*check_status)(struct mmp_path *path);
        struct mmp_overlay *(*get_overlay)(struct mmp_path *path,
                        int overlay_id);
        int (*get_modelist)(struct mmp_path *path,
                        struct mmp_mode **modelist);

        /* follow ops should be provided by driver */
        void (*set_mode)(struct mmp_path *path, struct mmp_mode *mode);
        void (*set_onoff)(struct mmp_path *path, int status);
        /* todo: add query */
};

/* path output types */
enum {
        PATH_OUT_PARALLEL,
        PATH_OUT_DSI,
        PATH_OUT_HDMI,
};

/* path is main part of mmp-disp */
struct mmp_path {
        /* use node to register to list */
        struct list_head node;

        /* init data */
        struct device *dev;

        int id;
        const char *name;
        int output_type;
        struct mmp_panel *panel;
        void *plat_data;

        /* dynamic use */
        struct mmp_mode mode;

        /* state */
        int open_count;
        int status;
        struct mutex access_ok;

        struct mmp_path_ops ops;

        /* layers */
        int overlay_num;
        struct mmp_overlay overlays[0];
};

extern struct mmp_path *mmp_get_path(const char *name);
static inline void mmp_path_set_mode(struct mmp_path *path,
                struct mmp_mode *mode)
{
        if (path)
                path->ops.set_mode(path, mode);
}
static inline void mmp_path_set_onoff(struct mmp_path *path, int status)
{
        if (path)
                path->ops.set_onoff(path, status);
}
static inline int mmp_path_get_modelist(struct mmp_path *path,
                struct mmp_mode **modelist)
{
        if (path)
                return path->ops.get_modelist(path, modelist);
        return 0;
}
static inline struct mmp_overlay *mmp_path_get_overlay(
                struct mmp_path *path, int overlay_id)
{
        if (path)
                return path->ops.get_overlay(path, overlay_id);
        return NULL;
}
static inline void mmp_overlay_set_fetch(struct mmp_overlay *overlay,
                int fetch_id)
{
        if (overlay)
                overlay->ops->set_fetch(overlay, fetch_id);
}
static inline void mmp_overlay_set_onoff(struct mmp_overlay *overlay,
                int status)
{
        if (overlay)
                overlay->ops->set_onoff(overlay, status);
}
static inline void mmp_overlay_set_win(struct mmp_overlay *overlay,
                struct mmp_win *win)
{
        if (overlay)
                overlay->ops->set_win(overlay, win);
}
static inline int mmp_overlay_set_addr(struct mmp_overlay *overlay,
                struct mmp_addr *addr)
{
        if (overlay)
                return overlay->ops->set_addr(overlay, addr);
        return 0;
}

/*
 * driver data is set from each detailed ctrl driver for path usage
 * it defined a common interface that plat driver need to implement
 */
struct mmp_path_info {
        /* driver data, set when registed*/
        const char *name;
        struct device *dev;
        int id;
        int output_type;
        int overlay_num;
        void (*set_mode)(struct mmp_path *path, struct mmp_mode *mode);
        void (*set_onoff)(struct mmp_path *path, int status);
        struct mmp_overlay_ops *overlay_ops;
        void *plat_data;
};

extern struct mmp_path *mmp_register_path(
                struct mmp_path_info *info);
extern void mmp_unregister_path(struct mmp_path *path);
extern void mmp_register_panel(struct mmp_panel *panel);
extern void mmp_unregister_panel(struct mmp_panel *panel);

/* defintions for platform data */
/* interface for buffer driver */
struct mmp_buffer_driver_mach_info {
        const char      *name;
        const char      *path_name;
        int     overlay_id;
        int     dmafetch_id;
        int     default_pixfmt;
};

/* interface for controllers driver */
struct mmp_mach_path_config {
        const char *name;
        int overlay_num;
        int output_type;
        u32 path_config;
        u32 link_config;
        u32 dsi_rbswap;
};

struct mmp_mach_plat_info {
        const char *name;
        const char *clk_name;
        int path_num;
        struct mmp_mach_path_config *paths;
};

/* interface for panel drivers */
struct mmp_mach_panel_info {
        const char *name;
        void (*plat_set_onoff)(int status);
        const char *plat_path_name;
};
#endif  /* _MMP_DISP_H_ */