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