855b7238adaa7e400484740cca5806372e0ef564
[sfrench/cifs-2.6.git] / drivers / media / platform / s5p-tv / mixer.h
1 /*
2  * Samsung TV Mixer driver
3  *
4  * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd.
5  *
6  * Tomasz Stanislawski, <t.stanislaws@samsung.com>
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published
10  * by the Free Software Foundiation. either version 2 of the License,
11  * or (at your option) any later version
12  */
13
14 #ifndef SAMSUNG_MIXER_H
15 #define SAMSUNG_MIXER_H
16
17 #ifdef CONFIG_VIDEO_SAMSUNG_S5P_MIXER_DEBUG
18         #define DEBUG
19 #endif
20
21 #include <linux/fb.h>
22 #include <linux/irqreturn.h>
23 #include <linux/kernel.h>
24 #include <linux/spinlock.h>
25 #include <linux/wait.h>
26 #include <media/v4l2-device.h>
27 #include <media/videobuf2-v4l2.h>
28
29 #include "regs-mixer.h"
30
31 /** maximum number of output interfaces */
32 #define MXR_MAX_OUTPUTS 2
33 /** maximum number of input interfaces (layers) */
34 #define MXR_MAX_LAYERS 3
35 #define MXR_DRIVER_NAME "s5p-mixer"
36 /** maximal number of planes for every layer */
37 #define MXR_MAX_PLANES  2
38
39 #define MXR_ENABLE 1
40 #define MXR_DISABLE 0
41
42 /** description of a macroblock for packed formats */
43 struct mxr_block {
44         /** vertical number of pixels in macroblock */
45         unsigned int width;
46         /** horizontal number of pixels in macroblock */
47         unsigned int height;
48         /** size of block in bytes */
49         unsigned int size;
50 };
51
52 /** description of supported format */
53 struct mxr_format {
54         /** format name/mnemonic */
55         const char *name;
56         /** fourcc identifier */
57         u32 fourcc;
58         /** colorspace identifier */
59         enum v4l2_colorspace colorspace;
60         /** number of planes in image data */
61         int num_planes;
62         /** description of block for each plane */
63         struct mxr_block plane[MXR_MAX_PLANES];
64         /** number of subframes in image data */
65         int num_subframes;
66         /** specifies to which subframe belong given plane */
67         int plane2subframe[MXR_MAX_PLANES];
68         /** internal code, driver dependent */
69         unsigned long cookie;
70 };
71
72 /** description of crop configuration for image */
73 struct mxr_crop {
74         /** width of layer in pixels */
75         unsigned int full_width;
76         /** height of layer in pixels */
77         unsigned int full_height;
78         /** horizontal offset of first pixel to be displayed */
79         unsigned int x_offset;
80         /** vertical offset of first pixel to be displayed */
81         unsigned int y_offset;
82         /** width of displayed data in pixels */
83         unsigned int width;
84         /** height of displayed data in pixels */
85         unsigned int height;
86         /** indicate which fields are present in buffer */
87         unsigned int field;
88 };
89
90 /** stages of geometry operations */
91 enum mxr_geometry_stage {
92         MXR_GEOMETRY_SINK,
93         MXR_GEOMETRY_COMPOSE,
94         MXR_GEOMETRY_CROP,
95         MXR_GEOMETRY_SOURCE,
96 };
97
98 /* flag indicating that offset should be 0 */
99 #define MXR_NO_OFFSET   0x80000000
100
101 /** description of transformation from source to destination image */
102 struct mxr_geometry {
103         /** cropping for source image */
104         struct mxr_crop src;
105         /** cropping for destination image */
106         struct mxr_crop dst;
107         /** layer-dependant description of horizontal scaling */
108         unsigned int x_ratio;
109         /** layer-dependant description of vertical scaling */
110         unsigned int y_ratio;
111 };
112
113 /** instance of a buffer */
114 struct mxr_buffer {
115         /** common v4l buffer stuff -- must be first */
116         struct vb2_buffer       vb;
117         /** node for layer's lists */
118         struct list_head        list;
119 };
120
121
122 /** internal states of layer */
123 enum mxr_layer_state {
124         /** layers is not shown */
125         MXR_LAYER_IDLE = 0,
126         /** layer is shown */
127         MXR_LAYER_STREAMING,
128         /** state before STREAMOFF is finished */
129         MXR_LAYER_STREAMING_FINISH,
130 };
131
132 /** forward declarations */
133 struct mxr_device;
134 struct mxr_layer;
135
136 /** callback for layers operation */
137 struct mxr_layer_ops {
138         /* TODO: try to port it to subdev API */
139         /** handler for resource release function */
140         void (*release)(struct mxr_layer *);
141         /** setting buffer to HW */
142         void (*buffer_set)(struct mxr_layer *, struct mxr_buffer *);
143         /** setting format and geometry in HW */
144         void (*format_set)(struct mxr_layer *);
145         /** streaming stop/start */
146         void (*stream_set)(struct mxr_layer *, int);
147         /** adjusting geometry */
148         void (*fix_geometry)(struct mxr_layer *,
149                 enum mxr_geometry_stage, unsigned long);
150 };
151
152 /** layer instance, a single window and content displayed on output */
153 struct mxr_layer {
154         /** parent mixer device */
155         struct mxr_device *mdev;
156         /** layer index (unique identifier) */
157         int idx;
158         /** callbacks for layer methods */
159         struct mxr_layer_ops ops;
160         /** format array */
161         const struct mxr_format **fmt_array;
162         /** size of format array */
163         unsigned long fmt_array_size;
164
165         /** lock for protection of list and state fields */
166         spinlock_t enq_slock;
167         /** list for enqueued buffers */
168         struct list_head enq_list;
169         /** buffer currently owned by hardware in temporary registers */
170         struct mxr_buffer *update_buf;
171         /** buffer currently owned by hardware in shadow registers */
172         struct mxr_buffer *shadow_buf;
173         /** state of layer IDLE/STREAMING */
174         enum mxr_layer_state state;
175
176         /** mutex for protection of fields below */
177         struct mutex mutex;
178         /** handler for video node */
179         struct video_device vfd;
180         /** queue for output buffers */
181         struct vb2_queue vb_queue;
182         /** current image format */
183         const struct mxr_format *fmt;
184         /** current geometry of image */
185         struct mxr_geometry geo;
186 };
187
188 /** description of mixers output interface */
189 struct mxr_output {
190         /** name of output */
191         char name[32];
192         /** output subdev */
193         struct v4l2_subdev *sd;
194         /** cookie used for configuration of registers */
195         int cookie;
196 };
197
198 /** specify source of output subdevs */
199 struct mxr_output_conf {
200         /** name of output (connector) */
201         char *output_name;
202         /** name of module that generates output subdev */
203         char *module_name;
204         /** cookie need for mixer HW */
205         int cookie;
206 };
207
208 struct clk;
209 struct regulator;
210
211 /** auxiliary resources used my mixer */
212 struct mxr_resources {
213         /** interrupt index */
214         int irq;
215         /** pointer to Mixer registers */
216         void __iomem *mxr_regs;
217         /** pointer to Video Processor registers */
218         void __iomem *vp_regs;
219         /** other resources, should used under mxr_device.mutex */
220         struct clk *mixer;
221         struct clk *vp;
222         struct clk *sclk_mixer;
223         struct clk *sclk_hdmi;
224         struct clk *sclk_dac;
225 };
226
227 /* event flags used  */
228 enum mxr_devide_flags {
229         MXR_EVENT_VSYNC = 0,
230         MXR_EVENT_TOP = 1,
231 };
232
233 /** drivers instance */
234 struct mxr_device {
235         /** master device */
236         struct device *dev;
237         /** state of each layer */
238         struct mxr_layer *layer[MXR_MAX_LAYERS];
239         /** state of each output */
240         struct mxr_output *output[MXR_MAX_OUTPUTS];
241         /** number of registered outputs */
242         int output_cnt;
243
244         /* video resources */
245
246         /** V4L2 device */
247         struct v4l2_device v4l2_dev;
248         /** context of allocator */
249         void *alloc_ctx;
250         /** event wait queue */
251         wait_queue_head_t event_queue;
252         /** state flags */
253         unsigned long event_flags;
254
255         /** spinlock for protection of registers */
256         spinlock_t reg_slock;
257
258         /** mutex for protection of fields below */
259         struct mutex mutex;
260         /** number of entities depndant on output configuration */
261         int n_output;
262         /** number of users that do streaming */
263         int n_streamer;
264         /** index of current output */
265         int current_output;
266         /** auxiliary resources used my mixer */
267         struct mxr_resources res;
268 };
269
270 /** transform device structure into mixer device */
271 static inline struct mxr_device *to_mdev(struct device *dev)
272 {
273         struct v4l2_device *vdev = dev_get_drvdata(dev);
274         return container_of(vdev, struct mxr_device, v4l2_dev);
275 }
276
277 /** get current output data, should be called under mdev's mutex */
278 static inline struct mxr_output *to_output(struct mxr_device *mdev)
279 {
280         return mdev->output[mdev->current_output];
281 }
282
283 /** get current output subdev, should be called under mdev's mutex */
284 static inline struct v4l2_subdev *to_outsd(struct mxr_device *mdev)
285 {
286         struct mxr_output *out = to_output(mdev);
287         return out ? out->sd : NULL;
288 }
289
290 /** forward declaration for mixer platform data */
291 struct mxr_platform_data;
292
293 /** acquiring common video resources */
294 int mxr_acquire_video(struct mxr_device *mdev,
295         struct mxr_output_conf *output_cont, int output_count);
296
297 /** releasing common video resources */
298 void mxr_release_video(struct mxr_device *mdev);
299
300 struct mxr_layer *mxr_graph_layer_create(struct mxr_device *mdev, int idx);
301 struct mxr_layer *mxr_vp_layer_create(struct mxr_device *mdev, int idx);
302 struct mxr_layer *mxr_base_layer_create(struct mxr_device *mdev,
303         int idx, char *name, struct mxr_layer_ops *ops);
304
305 void mxr_base_layer_release(struct mxr_layer *layer);
306 void mxr_layer_release(struct mxr_layer *layer);
307
308 int mxr_base_layer_register(struct mxr_layer *layer);
309 void mxr_base_layer_unregister(struct mxr_layer *layer);
310
311 unsigned long mxr_get_plane_size(const struct mxr_block *blk,
312         unsigned int width, unsigned int height);
313
314 /** adds new consumer for mixer's power */
315 int __must_check mxr_power_get(struct mxr_device *mdev);
316 /** removes consumer for mixer's power */
317 void mxr_power_put(struct mxr_device *mdev);
318 /** add new client for output configuration */
319 void mxr_output_get(struct mxr_device *mdev);
320 /** removes new client for output configuration */
321 void mxr_output_put(struct mxr_device *mdev);
322 /** add new client for streaming */
323 void mxr_streamer_get(struct mxr_device *mdev);
324 /** removes new client for streaming */
325 void mxr_streamer_put(struct mxr_device *mdev);
326 /** returns format of data delivared to current output */
327 void mxr_get_mbus_fmt(struct mxr_device *mdev,
328         struct v4l2_mbus_framefmt *mbus_fmt);
329
330 /* Debug */
331
332 #define mxr_err(mdev, fmt, ...)  dev_err(mdev->dev, fmt, ##__VA_ARGS__)
333 #define mxr_warn(mdev, fmt, ...) dev_warn(mdev->dev, fmt, ##__VA_ARGS__)
334 #define mxr_info(mdev, fmt, ...) dev_info(mdev->dev, fmt, ##__VA_ARGS__)
335
336 #ifdef CONFIG_VIDEO_SAMSUNG_S5P_MIXER_DEBUG
337         #define mxr_dbg(mdev, fmt, ...)  dev_dbg(mdev->dev, fmt, ##__VA_ARGS__)
338 #else
339         #define mxr_dbg(mdev, fmt, ...)  do { (void) mdev; } while (0)
340 #endif
341
342 /* accessing Mixer's and Video Processor's registers */
343
344 void mxr_vsync_set_update(struct mxr_device *mdev, int en);
345 void mxr_reg_reset(struct mxr_device *mdev);
346 irqreturn_t mxr_irq_handler(int irq, void *dev_data);
347 void mxr_reg_s_output(struct mxr_device *mdev, int cookie);
348 void mxr_reg_streamon(struct mxr_device *mdev);
349 void mxr_reg_streamoff(struct mxr_device *mdev);
350 int mxr_reg_wait4vsync(struct mxr_device *mdev);
351 void mxr_reg_set_mbus_fmt(struct mxr_device *mdev,
352         struct v4l2_mbus_framefmt *fmt);
353 void mxr_reg_graph_layer_stream(struct mxr_device *mdev, int idx, int en);
354 void mxr_reg_graph_buffer(struct mxr_device *mdev, int idx, dma_addr_t addr);
355 void mxr_reg_graph_format(struct mxr_device *mdev, int idx,
356         const struct mxr_format *fmt, const struct mxr_geometry *geo);
357
358 void mxr_reg_vp_layer_stream(struct mxr_device *mdev, int en);
359 void mxr_reg_vp_buffer(struct mxr_device *mdev,
360         dma_addr_t luma_addr[2], dma_addr_t chroma_addr[2]);
361 void mxr_reg_vp_format(struct mxr_device *mdev,
362         const struct mxr_format *fmt, const struct mxr_geometry *geo);
363 void mxr_reg_dump(struct mxr_device *mdev);
364
365 #endif /* SAMSUNG_MIXER_H */
366