[mirror_ubuntu-bionic-kernel.git] / include / video / mmp_disp.h

/*
 * 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_ */
Commit	Line	Data
59393bb9 ZZ	1	/*
	2	* linux/include/video/mmp_disp.h
	3	* Header file for Marvell MMP Display Controller
	4	*
	5	* Copyright (C) 2012 Marvell Technology Group Ltd.
	6	* Authors: Zhou Zhu <zzhu3@marvell.com>
	7	*
	8	* This program is free software; you can redistribute it and/or modify it
	9	* under the terms of the GNU General Public License as published by the
	10	* Free Software Foundation; either version 2 of the License, or (at your
	11	* option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful, but WITHOUT
	14	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	15	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	16	* more details.
	17	*
	18	* You should have received a copy of the GNU General Public License along with
	19	* this program. If not, see <http://www.gnu.org/licenses/>.
	20	*
	21	*/
	22
	23	#ifndef _MMP_DISP_H_
	24	#define _MMP_DISP_H_
	25	#include <linux/kthread.h>
	26
	27	enum {
	28	PIXFMT_UYVY = 0,
	29	PIXFMT_VYUY,
	30	PIXFMT_YUYV,
	31	PIXFMT_YUV422P,
	32	PIXFMT_YVU422P,
	33	PIXFMT_YUV420P,
	34	PIXFMT_YVU420P,
	35	PIXFMT_RGB565 = 0x100,
	36	PIXFMT_BGR565,
	37	PIXFMT_RGB1555,
	38	PIXFMT_BGR1555,
	39	PIXFMT_RGB888PACK,
	40	PIXFMT_BGR888PACK,
	41	PIXFMT_RGB888UNPACK,
	42	PIXFMT_BGR888UNPACK,
	43	PIXFMT_RGBA888,
	44	PIXFMT_BGRA888,
	45	PIXFMT_RGB666, /* for output usage */
	46	PIXFMT_PSEUDOCOLOR = 0x200,
	47	};
	48
	49	static inline int pixfmt_to_stride(int pix_fmt)
	50	{
	51	switch (pix_fmt) {
	52	case PIXFMT_RGB565:
	53	case PIXFMT_BGR565:
	54	case PIXFMT_RGB1555:
	55	case PIXFMT_BGR1555:
	56	case PIXFMT_UYVY:
	57	case PIXFMT_VYUY:
	58	case PIXFMT_YUYV:
	59	return 2;
	60	case PIXFMT_RGB888UNPACK:
	61	case PIXFMT_BGR888UNPACK:
	62	case PIXFMT_RGBA888:
	63	case PIXFMT_BGRA888:
	64	return 4;
65	case PIXFMT_RGB888PACK:
66	case PIXFMT_BGR888PACK:
67	return 3;
68	case PIXFMT_YUV422P:
69	case PIXFMT_YVU422P:
70	case PIXFMT_YUV420P:
71	case PIXFMT_YVU420P:
72	case PIXFMT_PSEUDOCOLOR:
73	return 1;
74	default:
75	return 0;
76	}
77	}
78
79	/* parameters used by path/overlay */
80	/* overlay related para: win/addr */
81	struct mmp_win {
82	/* position/size of window */
83	u16 xsrc;
84	u16 ysrc;
85	u16 xdst;
86	u16 ydst;
87	u16 xpos;
88	u16 ypos;
89	u16 left_crop;
90	u16 right_crop;
91	u16 up_crop;
92	u16 bottom_crop;
93	int pix_fmt;
24586d83 JX	94	/*
	95	* pitch[0]: graphics/video layer line length or y pitch
	96	* pitch[1]/pitch[2]: video u/v pitch if non-zero
	97	*/
	98	u32 pitch[3];
59393bb9 ZZ	99	};
	100
	101	struct mmp_addr {
	102	/* phys address */
	103	u32 phys[6];
	104	};
	105
	106	/* path related para: mode */
	107	struct mmp_mode {
	108	const char *name;
	109	u32 refresh;
	110	u32 xres;
	111	u32 yres;
	112	u32 left_margin;
	113	u32 right_margin;
	114	u32 upper_margin;
	115	u32 lower_margin;
	116	u32 hsync_len;
	117	u32 vsync_len;
	118	u32 hsync_invert;
	119	u32 vsync_invert;
	120	u32 invert_pixclock;
	121	u32 pixclock_freq;
	122	int pix_fmt_out;
	123	};
	124
	125	/* main structures */
	126	struct mmp_path;
	127	struct mmp_overlay;
	128	struct mmp_panel;
	129
	130	/* status types */
	131	enum {
	132	MMP_OFF = 0,
	133	MMP_ON,
	134	};
	135
	136	static inline const char *stat_name(int stat)
	137	{
	138	switch (stat) {
	139	case MMP_OFF:
	140	return "OFF";
	141	case MMP_ON:
	142	return "ON";
	143	default:
	144	return "UNKNOWNSTAT";
	145	}
	146	}
	147
	148	struct mmp_overlay_ops {
	149	/* should be provided by driver */
	150	void (set_fetch)(struct mmp_overlay overlay, int fetch_id);
	151	void (set_onoff)(struct mmp_overlay overlay, int status);
	152	void (set_win)(struct mmp_overlay overlay, struct mmp_win *win);
	153	int (set_addr)(struct mmp_overlay overlay, struct mmp_addr *addr);
	154	};
	155
	156	/* overlay describes a z-order indexed slot in each path. */
	157	struct mmp_overlay {
	158	int id;
	159	const char *name;
	160	struct mmp_path *path;
	161
	162	/* overlay info: private data */
163	int dmafetch_id;
164	struct mmp_addr addr;
165	struct mmp_win win;
166
167	/* state */
168	int open_count;
169	int status;
170	struct mutex access_ok;
171
172	struct mmp_overlay_ops *ops;
173	};
174
175	/* panel type */
176	enum {
177	PANELTYPE_ACTIVE = 0,
178	PANELTYPE_SMART,
179	PANELTYPE_TV,
180	PANELTYPE_DSI_CMD,
181	PANELTYPE_DSI_VIDEO,
182	};
183
184	struct mmp_panel {
185	/* use node to register to list */
186	struct list_head node;
187	const char *name;
188	/* path name used to connect to proper path configed */
189	const char *plat_path_name;
190	struct device *dev;
191	int panel_type;
192	void *plat_data;
193	int (get_modelist)(struct mmp_panel panel,
194	struct mmp_mode **modelist);
195	void (set_mode)(struct mmp_panel panel,
196	struct mmp_mode *mode);
197	void (set_onoff)(struct mmp_panel panel,
198	int status);
199	};
200
201	struct mmp_path_ops {
202	int (check_status)(struct mmp_path path);
203	struct mmp_overlay (get_overlay)(struct mmp_path *path,
204	int overlay_id);
205	int (get_modelist)(struct mmp_path path,
206	struct mmp_mode **modelist);
207
208	/* follow ops should be provided by driver */
209	void (set_mode)(struct mmp_path path, struct mmp_mode *mode);
210	void (set_onoff)(struct mmp_path path, int status);
211	/* todo: add query */
212	};
213
214	/* path output types */
215	enum {
216	PATH_OUT_PARALLEL,
217	PATH_OUT_DSI,
218	PATH_OUT_HDMI,
219	};
220
221	/* path is main part of mmp-disp */
222	struct mmp_path {
223	/* use node to register to list */
224	struct list_head node;
225
226	/* init data */
227	struct device *dev;
228
229	int id;
230	const char *name;
231	int output_type;
232	struct mmp_panel *panel;
233	void *plat_data;
234
235	/* dynamic use */
236	struct mmp_mode mode;
237
238	/* state */
239	int open_count;
240	int status;
241	struct mutex access_ok;
242
243	struct mmp_path_ops ops;
244
245	/* layers */
246	int overlay_num;
247	struct mmp_overlay overlays[0];
248	};
249
250	extern struct mmp_path mmp_get_path(const char name);
251	static inline void mmp_path_set_mode(struct mmp_path *path,
252	struct mmp_mode *mode)
253	{
254	if (path)
255	path->ops.set_mode(path, mode);
256	}
257	static inline void mmp_path_set_onoff(struct mmp_path *path, int status)
258	{
259	if (path)
260	path->ops.set_onoff(path, status);
261	}
262	static inline int mmp_path_get_modelist(struct mmp_path *path,
263	struct mmp_mode **modelist)
264	{
265	if (path)
266	return path->ops.get_modelist(path, modelist);
267	return 0;
268	}
269	static inline struct mmp_overlay *mmp_path_get_overlay(
270	struct mmp_path *path, int overlay_id)
271	{
272	if (path)
273	return path->ops.get_overlay(path, overlay_id);
274	return NULL;
275	}
276	static inline void mmp_overlay_set_fetch(struct mmp_overlay *overlay,
277	int fetch_id)
278	{
279	if (overlay)
280	overlay->ops->set_fetch(overlay, fetch_id);
281	}
282	static inline void mmp_overlay_set_onoff(struct mmp_overlay *overlay,
283	int status)
284	{
285	if (overlay)
286	overlay->ops->set_onoff(overlay, status);
287	}
288	static inline void mmp_overlay_set_win(struct mmp_overlay *overlay,
289	struct mmp_win *win)
290	{
291	if (overlay)
292	overlay->ops->set_win(overlay, win);
293	}
294	static inline int mmp_overlay_set_addr(struct mmp_overlay *overlay,
295	struct mmp_addr *addr)
296	{
297	if (overlay)
298	return overlay->ops->set_addr(overlay, addr);
299	return 0;
300	}
301
302	/*
303	* driver data is set from each detailed ctrl driver for path usage
304	* it defined a common interface that plat driver need to implement
305	*/
306	struct mmp_path_info {
307	/* driver data, set when registed*/
308	const char *name;
309	struct device *dev;
310	int id;
311	int output_type;
312	int overlay_num;
313	void (set_mode)(struct mmp_path path, struct mmp_mode *mode);
314	void (set_onoff)(struct mmp_path path, int status);
315	struct mmp_overlay_ops *overlay_ops;
316	void *plat_data;
317	};
318
319	extern struct mmp_path *mmp_register_path(
320	struct mmp_path_info *info);
321	extern void mmp_unregister_path(struct mmp_path *path);
322	extern void mmp_register_panel(struct mmp_panel *panel);
323	extern void mmp_unregister_panel(struct mmp_panel *panel);
324
325	/* defintions for platform data */
326	/* interface for buffer driver */
327	struct mmp_buffer_driver_mach_info {
328	const char *name;
329	const char *path_name;
330	int overlay_id;
331	int dmafetch_id;
332	int default_pixfmt;
333	};
334
335	/* interface for controllers driver */
336	struct mmp_mach_path_config {
337	const char *name;
338	int overlay_num;
339	int output_type;
340	u32 path_config;
341	u32 link_config;
9a27d591	342	u32 dsi_rbswap;
59393bb9 ZZ	343	};
	344
	345	struct mmp_mach_plat_info {
	346	const char *name;
	347	const char *clk_name;
	348	int path_num;
	349	struct mmp_mach_path_config *paths;
	350	};
	351
	352	/* interface for panel drivers */
	353	struct mmp_mach_panel_info {
	354	const char *name;
	355	void (*plat_set_onoff)(int status);
	356	const char *plat_path_name;
	357	};
	358	#endif /* _MMP_DISP_H_ */