Commit | Line | Data |
---|---|---|
fef1c8d0 TS |
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 | #include "mixer.h" | |
15 | ||
16 | #include "regs-vp.h" | |
17 | ||
18 | #include <media/videobuf2-dma-contig.h> | |
19 | ||
20 | /* FORMAT DEFINITIONS */ | |
21 | static const struct mxr_format mxr_fmt_nv12 = { | |
22 | .name = "NV12", | |
23 | .fourcc = V4L2_PIX_FMT_NV12, | |
24 | .colorspace = V4L2_COLORSPACE_JPEG, | |
25 | .num_planes = 2, | |
26 | .plane = { | |
27 | { .width = 1, .height = 1, .size = 1 }, | |
28 | { .width = 2, .height = 2, .size = 2 }, | |
29 | }, | |
30 | .num_subframes = 1, | |
31 | .cookie = VP_MODE_NV12 | VP_MODE_MEM_LINEAR, | |
32 | }; | |
33 | ||
34 | static const struct mxr_format mxr_fmt_nv21 = { | |
35 | .name = "NV21", | |
36 | .fourcc = V4L2_PIX_FMT_NV21, | |
37 | .colorspace = V4L2_COLORSPACE_JPEG, | |
38 | .num_planes = 2, | |
39 | .plane = { | |
40 | { .width = 1, .height = 1, .size = 1 }, | |
41 | { .width = 2, .height = 2, .size = 2 }, | |
42 | }, | |
43 | .num_subframes = 1, | |
44 | .cookie = VP_MODE_NV21 | VP_MODE_MEM_LINEAR, | |
45 | }; | |
46 | ||
47 | static const struct mxr_format mxr_fmt_nv12m = { | |
48 | .name = "NV12 (mplane)", | |
49 | .fourcc = V4L2_PIX_FMT_NV12M, | |
50 | .colorspace = V4L2_COLORSPACE_JPEG, | |
51 | .num_planes = 2, | |
52 | .plane = { | |
53 | { .width = 1, .height = 1, .size = 1 }, | |
54 | { .width = 2, .height = 2, .size = 2 }, | |
55 | }, | |
56 | .num_subframes = 2, | |
57 | .plane2subframe = {0, 1}, | |
58 | .cookie = VP_MODE_NV12 | VP_MODE_MEM_LINEAR, | |
59 | }; | |
60 | ||
61 | static const struct mxr_format mxr_fmt_nv12mt = { | |
62 | .name = "NV12 tiled (mplane)", | |
63 | .fourcc = V4L2_PIX_FMT_NV12MT, | |
64 | .colorspace = V4L2_COLORSPACE_JPEG, | |
65 | .num_planes = 2, | |
66 | .plane = { | |
67 | { .width = 128, .height = 32, .size = 4096 }, | |
68 | { .width = 128, .height = 32, .size = 2048 }, | |
69 | }, | |
70 | .num_subframes = 2, | |
71 | .plane2subframe = {0, 1}, | |
72 | .cookie = VP_MODE_NV12 | VP_MODE_MEM_TILED, | |
73 | }; | |
74 | ||
75 | static const struct mxr_format *mxr_video_format[] = { | |
76 | &mxr_fmt_nv12, | |
77 | &mxr_fmt_nv21, | |
78 | &mxr_fmt_nv12m, | |
79 | &mxr_fmt_nv12mt, | |
80 | }; | |
81 | ||
82 | /* AUXILIARY CALLBACKS */ | |
83 | ||
84 | static void mxr_vp_layer_release(struct mxr_layer *layer) | |
85 | { | |
86 | mxr_base_layer_unregister(layer); | |
87 | mxr_base_layer_release(layer); | |
88 | } | |
89 | ||
90 | static void mxr_vp_buffer_set(struct mxr_layer *layer, | |
91 | struct mxr_buffer *buf) | |
92 | { | |
93 | dma_addr_t luma_addr[2] = {0, 0}; | |
94 | dma_addr_t chroma_addr[2] = {0, 0}; | |
95 | ||
96 | if (buf == NULL) { | |
97 | mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr); | |
98 | return; | |
99 | } | |
2d700715 | 100 | luma_addr[0] = vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 0); |
fef1c8d0 | 101 | if (layer->fmt->num_subframes == 2) { |
2d700715 JS |
102 | chroma_addr[0] = |
103 | vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 1); | |
fef1c8d0 TS |
104 | } else { |
105 | /* FIXME: mxr_get_plane_size compute integer division, | |
106 | * which is slow and should not be performed in interrupt */ | |
107 | chroma_addr[0] = luma_addr[0] + mxr_get_plane_size( | |
108 | &layer->fmt->plane[0], layer->geo.src.full_width, | |
109 | layer->geo.src.full_height); | |
110 | } | |
111 | if (layer->fmt->cookie & VP_MODE_MEM_TILED) { | |
112 | luma_addr[1] = luma_addr[0] + 0x40; | |
113 | chroma_addr[1] = chroma_addr[0] + 0x40; | |
114 | } else { | |
115 | luma_addr[1] = luma_addr[0] + layer->geo.src.full_width; | |
116 | chroma_addr[1] = chroma_addr[0]; | |
117 | } | |
118 | mxr_reg_vp_buffer(layer->mdev, luma_addr, chroma_addr); | |
119 | } | |
120 | ||
121 | static void mxr_vp_stream_set(struct mxr_layer *layer, int en) | |
122 | { | |
123 | mxr_reg_vp_layer_stream(layer->mdev, en); | |
124 | } | |
125 | ||
126 | static void mxr_vp_format_set(struct mxr_layer *layer) | |
127 | { | |
128 | mxr_reg_vp_format(layer->mdev, layer->fmt, &layer->geo); | |
129 | } | |
130 | ||
0d066d3f TS |
131 | static inline unsigned int do_center(unsigned int center, |
132 | unsigned int size, unsigned int upper, unsigned int flags) | |
fef1c8d0 | 133 | { |
0d066d3f TS |
134 | unsigned int lower; |
135 | ||
136 | if (flags & MXR_NO_OFFSET) | |
137 | return 0; | |
138 | ||
139 | lower = center - min(center, size / 2); | |
140 | return min(lower, upper - size); | |
141 | } | |
fef1c8d0 | 142 | |
0d066d3f TS |
143 | static void mxr_vp_fix_geometry(struct mxr_layer *layer, |
144 | enum mxr_geometry_stage stage, unsigned long flags) | |
145 | { | |
146 | struct mxr_geometry *geo = &layer->geo; | |
147 | struct mxr_crop *src = &geo->src; | |
148 | struct mxr_crop *dst = &geo->dst; | |
149 | unsigned long x_center, y_center; | |
150 | ||
151 | switch (stage) { | |
152 | ||
153 | case MXR_GEOMETRY_SINK: /* nothing to be fixed here */ | |
154 | case MXR_GEOMETRY_COMPOSE: | |
155 | /* remember center of the area */ | |
156 | x_center = dst->x_offset + dst->width / 2; | |
157 | y_center = dst->y_offset + dst->height / 2; | |
158 | ||
159 | /* ensure that compose is reachable using 16x scaling */ | |
160 | dst->width = clamp(dst->width, 8U, 16 * src->full_width); | |
161 | dst->height = clamp(dst->height, 1U, 16 * src->full_height); | |
162 | ||
163 | /* setup offsets */ | |
164 | dst->x_offset = do_center(x_center, dst->width, | |
165 | dst->full_width, flags); | |
166 | dst->y_offset = do_center(y_center, dst->height, | |
167 | dst->full_height, flags); | |
168 | flags = 0; /* remove possible MXR_NO_OFFSET flag */ | |
169 | /* fall through */ | |
170 | case MXR_GEOMETRY_CROP: | |
171 | /* remember center of the area */ | |
172 | x_center = src->x_offset + src->width / 2; | |
173 | y_center = src->y_offset + src->height / 2; | |
174 | ||
175 | /* ensure scaling is between 0.25x .. 16x */ | |
392d9e1d TS |
176 | src->width = clamp(src->width, round_up(dst->width / 16, 4), |
177 | dst->width * 4); | |
178 | src->height = clamp(src->height, round_up(dst->height / 16, 4), | |
179 | dst->height * 4); | |
0d066d3f TS |
180 | |
181 | /* hardware limits */ | |
182 | src->width = clamp(src->width, 32U, 2047U); | |
183 | src->height = clamp(src->height, 4U, 2047U); | |
184 | ||
185 | /* setup offsets */ | |
186 | src->x_offset = do_center(x_center, src->width, | |
187 | src->full_width, flags); | |
188 | src->y_offset = do_center(y_center, src->height, | |
189 | src->full_height, flags); | |
190 | ||
191 | /* setting scaling ratio */ | |
192 | geo->x_ratio = (src->width << 16) / dst->width; | |
193 | geo->y_ratio = (src->height << 16) / dst->height; | |
194 | /* fall through */ | |
195 | ||
196 | case MXR_GEOMETRY_SOURCE: | |
197 | src->full_width = clamp(src->full_width, | |
198 | ALIGN(src->width + src->x_offset, 8), 8192U); | |
199 | src->full_height = clamp(src->full_height, | |
200 | src->height + src->y_offset, 8192U); | |
2028c71d | 201 | } |
fef1c8d0 TS |
202 | } |
203 | ||
204 | /* PUBLIC API */ | |
205 | ||
206 | struct mxr_layer *mxr_vp_layer_create(struct mxr_device *mdev, int idx) | |
207 | { | |
208 | struct mxr_layer *layer; | |
209 | int ret; | |
adbedc29 | 210 | const struct mxr_layer_ops ops = { |
fef1c8d0 TS |
211 | .release = mxr_vp_layer_release, |
212 | .buffer_set = mxr_vp_buffer_set, | |
213 | .stream_set = mxr_vp_stream_set, | |
214 | .format_set = mxr_vp_format_set, | |
215 | .fix_geometry = mxr_vp_fix_geometry, | |
216 | }; | |
217 | char name[32]; | |
218 | ||
219 | sprintf(name, "video%d", idx); | |
220 | ||
221 | layer = mxr_base_layer_create(mdev, idx, name, &ops); | |
222 | if (layer == NULL) { | |
223 | mxr_err(mdev, "failed to initialize layer(%d) base\n", idx); | |
224 | goto fail; | |
225 | } | |
226 | ||
227 | layer->fmt_array = mxr_video_format; | |
228 | layer->fmt_array_size = ARRAY_SIZE(mxr_video_format); | |
229 | ||
230 | ret = mxr_base_layer_register(layer); | |
231 | if (ret) | |
232 | goto fail_layer; | |
233 | ||
234 | return layer; | |
235 | ||
236 | fail_layer: | |
237 | mxr_base_layer_release(layer); | |
238 | ||
239 | fail: | |
240 | return NULL; | |
241 | } | |
242 |