video: mmp display subsystem
[~shefty/rdma-dev.git] / include / video / mmp_disp.h
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;
94 };
95
96 struct mmp_addr {
97         /* phys address */
98         u32     phys[6];
99 };
100
101 /* path related para: mode */
102 struct mmp_mode {
103         const char *name;
104         u32 refresh;
105         u32 xres;
106         u32 yres;
107         u32 left_margin;
108         u32 right_margin;
109         u32 upper_margin;
110         u32 lower_margin;
111         u32 hsync_len;
112         u32 vsync_len;
113         u32 hsync_invert;
114         u32 vsync_invert;
115         u32 invert_pixclock;
116         u32 pixclock_freq;
117         int pix_fmt_out;
118 };
119
120 /* main structures */
121 struct mmp_path;
122 struct mmp_overlay;
123 struct mmp_panel;
124
125 /* status types */
126 enum {
127         MMP_OFF = 0,
128         MMP_ON,
129 };
130
131 static inline const char *stat_name(int stat)
132 {
133         switch (stat) {
134         case MMP_OFF:
135                 return "OFF";
136         case MMP_ON:
137                 return "ON";
138         default:
139                 return "UNKNOWNSTAT";
140         }
141 }
142
143 struct mmp_overlay_ops {
144         /* should be provided by driver */
145         void (*set_fetch)(struct mmp_overlay *overlay, int fetch_id);
146         void (*set_onoff)(struct mmp_overlay *overlay, int status);
147         void (*set_win)(struct mmp_overlay *overlay, struct mmp_win *win);
148         int (*set_addr)(struct mmp_overlay *overlay, struct mmp_addr *addr);
149 };
150
151 /* overlay describes a z-order indexed slot in each path. */
152 struct mmp_overlay {
153         int id;
154         const char *name;
155         struct mmp_path *path;
156
157         /* overlay info: private data */
158         int dmafetch_id;
159         struct mmp_addr addr;
160         struct mmp_win win;
161
162         /* state */
163         int open_count;
164         int status;
165         struct mutex access_ok;
166
167         struct mmp_overlay_ops *ops;
168 };
169
170 /* panel type */
171 enum {
172         PANELTYPE_ACTIVE = 0,
173         PANELTYPE_SMART,
174         PANELTYPE_TV,
175         PANELTYPE_DSI_CMD,
176         PANELTYPE_DSI_VIDEO,
177 };
178
179 struct mmp_panel {
180         /* use node to register to list */
181         struct list_head node;
182         const char *name;
183         /* path name used to connect to proper path configed */
184         const char *plat_path_name;
185         struct device *dev;
186         int panel_type;
187         void *plat_data;
188         int (*get_modelist)(struct mmp_panel *panel,
189                         struct mmp_mode **modelist);
190         void (*set_mode)(struct mmp_panel *panel,
191                         struct mmp_mode *mode);
192         void (*set_onoff)(struct mmp_panel *panel,
193                         int status);
194 };
195
196 struct mmp_path_ops {
197         int (*check_status)(struct mmp_path *path);
198         struct mmp_overlay *(*get_overlay)(struct mmp_path *path,
199                         int overlay_id);
200         int (*get_modelist)(struct mmp_path *path,
201                         struct mmp_mode **modelist);
202
203         /* follow ops should be provided by driver */
204         void (*set_mode)(struct mmp_path *path, struct mmp_mode *mode);
205         void (*set_onoff)(struct mmp_path *path, int status);
206         /* todo: add query */
207 };
208
209 /* path output types */
210 enum {
211         PATH_OUT_PARALLEL,
212         PATH_OUT_DSI,
213         PATH_OUT_HDMI,
214 };
215
216 /* path is main part of mmp-disp */
217 struct mmp_path {
218         /* use node to register to list */
219         struct list_head node;
220
221         /* init data */
222         struct device *dev;
223
224         int id;
225         const char *name;
226         int output_type;
227         struct mmp_panel *panel;
228         void *plat_data;
229
230         /* dynamic use */
231         struct mmp_mode mode;
232
233         /* state */
234         int open_count;
235         int status;
236         struct mutex access_ok;
237
238         struct mmp_path_ops ops;
239
240         /* layers */
241         int overlay_num;
242         struct mmp_overlay overlays[0];
243 };
244
245 extern struct mmp_path *mmp_get_path(const char *name);
246 static inline void mmp_path_set_mode(struct mmp_path *path,
247                 struct mmp_mode *mode)
248 {
249         if (path)
250                 path->ops.set_mode(path, mode);
251 }
252 static inline void mmp_path_set_onoff(struct mmp_path *path, int status)
253 {
254         if (path)
255                 path->ops.set_onoff(path, status);
256 }
257 static inline int mmp_path_get_modelist(struct mmp_path *path,
258                 struct mmp_mode **modelist)
259 {
260         if (path)
261                 return path->ops.get_modelist(path, modelist);
262         return 0;
263 }
264 static inline struct mmp_overlay *mmp_path_get_overlay(
265                 struct mmp_path *path, int overlay_id)
266 {
267         if (path)
268                 return path->ops.get_overlay(path, overlay_id);
269         return NULL;
270 }
271 static inline void mmp_overlay_set_fetch(struct mmp_overlay *overlay,
272                 int fetch_id)
273 {
274         if (overlay)
275                 overlay->ops->set_fetch(overlay, fetch_id);
276 }
277 static inline void mmp_overlay_set_onoff(struct mmp_overlay *overlay,
278                 int status)
279 {
280         if (overlay)
281                 overlay->ops->set_onoff(overlay, status);
282 }
283 static inline void mmp_overlay_set_win(struct mmp_overlay *overlay,
284                 struct mmp_win *win)
285 {
286         if (overlay)
287                 overlay->ops->set_win(overlay, win);
288 }
289 static inline int mmp_overlay_set_addr(struct mmp_overlay *overlay,
290                 struct mmp_addr *addr)
291 {
292         if (overlay)
293                 return overlay->ops->set_addr(overlay, addr);
294         return 0;
295 }
296
297 /*
298  * driver data is set from each detailed ctrl driver for path usage
299  * it defined a common interface that plat driver need to implement
300  */
301 struct mmp_path_info {
302         /* driver data, set when registed*/
303         const char *name;
304         struct device *dev;
305         int id;
306         int output_type;
307         int overlay_num;
308         void (*set_mode)(struct mmp_path *path, struct mmp_mode *mode);
309         void (*set_onoff)(struct mmp_path *path, int status);
310         struct mmp_overlay_ops *overlay_ops;
311         void *plat_data;
312 };
313
314 extern struct mmp_path *mmp_register_path(
315                 struct mmp_path_info *info);
316 extern void mmp_unregister_path(struct mmp_path *path);
317 extern void mmp_register_panel(struct mmp_panel *panel);
318 extern void mmp_unregister_panel(struct mmp_panel *panel);
319
320 /* defintions for platform data */
321 /* interface for buffer driver */
322 struct mmp_buffer_driver_mach_info {
323         const char      *name;
324         const char      *path_name;
325         int     overlay_id;
326         int     dmafetch_id;
327         int     default_pixfmt;
328 };
329
330 /* interface for controllers driver */
331 struct mmp_mach_path_config {
332         const char *name;
333         int overlay_num;
334         int output_type;
335         u32 path_config;
336         u32 link_config;
337 };
338
339 struct mmp_mach_plat_info {
340         const char *name;
341         const char *clk_name;
342         int path_num;
343         struct mmp_mach_path_config *paths;
344 };
345
346 /* interface for panel drivers */
347 struct mmp_mach_panel_info {
348         const char *name;
349         void (*plat_set_onoff)(int status);
350         const char *plat_path_name;
351 };
352 #endif  /* _MMP_DISP_H_ */