Commit | Line | Data |
---|---|---|
c942fddf | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
88f42bf0 HF |
2 | /* |
3 | * vimc-debayer.c Virtual Media Controller Driver | |
4 | * | |
5 | * Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com> | |
88f42bf0 HF |
6 | */ |
7 | ||
f13d5f36 | 8 | #include <linux/moduleparam.h> |
88f42bf0 HF |
9 | #include <linux/platform_device.h> |
10 | #include <linux/vmalloc.h> | |
11 | #include <linux/v4l2-mediabus.h> | |
76df2e6c AML |
12 | #include <media/v4l2-ctrls.h> |
13 | #include <media/v4l2-event.h> | |
88f42bf0 HF |
14 | #include <media/v4l2-subdev.h> |
15 | ||
16 | #include "vimc-common.h" | |
17 | ||
ec917d77 DO |
18 | enum vimc_debayer_rgb_colors { |
19 | VIMC_DEBAYER_RED = 0, | |
20 | VIMC_DEBAYER_GREEN = 1, | |
21 | VIMC_DEBAYER_BLUE = 2, | |
88f42bf0 HF |
22 | }; |
23 | ||
ec917d77 | 24 | struct vimc_debayer_pix_map { |
88f42bf0 | 25 | u32 code; |
ec917d77 | 26 | enum vimc_debayer_rgb_colors order[2][2]; |
88f42bf0 HF |
27 | }; |
28 | ||
ec917d77 | 29 | struct vimc_debayer_device { |
88f42bf0 HF |
30 | struct vimc_ent_device ved; |
31 | struct v4l2_subdev sd; | |
88f42bf0 HF |
32 | /* The active format */ |
33 | struct v4l2_mbus_framefmt sink_fmt; | |
34 | u32 src_code; | |
ec917d77 DO |
35 | void (*set_rgb_src)(struct vimc_debayer_device *vdebayer, |
36 | unsigned int lin, unsigned int col, | |
37 | unsigned int rgb[3]); | |
88f42bf0 HF |
38 | /* Values calculated when the stream starts */ |
39 | u8 *src_frame; | |
ec917d77 | 40 | const struct vimc_debayer_pix_map *sink_pix_map; |
88f42bf0 | 41 | unsigned int sink_bpp; |
76df2e6c AML |
42 | unsigned int mean_win_size; |
43 | struct v4l2_ctrl_handler hdl; | |
23df45d0 | 44 | struct media_pad pads[2]; |
88f42bf0 HF |
45 | }; |
46 | ||
47 | static const struct v4l2_mbus_framefmt sink_fmt_default = { | |
48 | .width = 640, | |
49 | .height = 480, | |
85ab1aa1 | 50 | .code = MEDIA_BUS_FMT_SRGGB8_1X8, |
88f42bf0 | 51 | .field = V4L2_FIELD_NONE, |
9a42a5ff | 52 | .colorspace = V4L2_COLORSPACE_SRGB, |
88f42bf0 HF |
53 | }; |
54 | ||
ec917d77 | 55 | static const u32 vimc_debayer_src_mbus_codes[] = { |
f4d12d80 NP |
56 | MEDIA_BUS_FMT_GBR888_1X24, |
57 | MEDIA_BUS_FMT_BGR888_1X24, | |
58 | MEDIA_BUS_FMT_BGR888_3X8, | |
59 | MEDIA_BUS_FMT_RGB888_1X24, | |
60 | MEDIA_BUS_FMT_RGB888_2X12_BE, | |
61 | MEDIA_BUS_FMT_RGB888_2X12_LE, | |
62 | MEDIA_BUS_FMT_RGB888_3X8, | |
63 | MEDIA_BUS_FMT_RGB888_1X7X4_SPWG, | |
64 | MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA, | |
65 | MEDIA_BUS_FMT_RGB888_1X32_PADHI, | |
66 | }; | |
67 | ||
ec917d77 | 68 | static const struct vimc_debayer_pix_map vimc_debayer_pix_map_list[] = { |
88f42bf0 HF |
69 | { |
70 | .code = MEDIA_BUS_FMT_SBGGR8_1X8, | |
ec917d77 DO |
71 | .order = { { VIMC_DEBAYER_BLUE, VIMC_DEBAYER_GREEN }, |
72 | { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_RED } } | |
88f42bf0 HF |
73 | }, |
74 | { | |
75 | .code = MEDIA_BUS_FMT_SGBRG8_1X8, | |
ec917d77 DO |
76 | .order = { { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_BLUE }, |
77 | { VIMC_DEBAYER_RED, VIMC_DEBAYER_GREEN } } | |
88f42bf0 HF |
78 | }, |
79 | { | |
80 | .code = MEDIA_BUS_FMT_SGRBG8_1X8, | |
ec917d77 DO |
81 | .order = { { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_RED }, |
82 | { VIMC_DEBAYER_BLUE, VIMC_DEBAYER_GREEN } } | |
88f42bf0 HF |
83 | }, |
84 | { | |
85 | .code = MEDIA_BUS_FMT_SRGGB8_1X8, | |
ec917d77 DO |
86 | .order = { { VIMC_DEBAYER_RED, VIMC_DEBAYER_GREEN }, |
87 | { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_BLUE } } | |
88f42bf0 HF |
88 | }, |
89 | { | |
90 | .code = MEDIA_BUS_FMT_SBGGR10_1X10, | |
ec917d77 DO |
91 | .order = { { VIMC_DEBAYER_BLUE, VIMC_DEBAYER_GREEN }, |
92 | { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_RED } } | |
88f42bf0 HF |
93 | }, |
94 | { | |
95 | .code = MEDIA_BUS_FMT_SGBRG10_1X10, | |
ec917d77 DO |
96 | .order = { { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_BLUE }, |
97 | { VIMC_DEBAYER_RED, VIMC_DEBAYER_GREEN } } | |
88f42bf0 HF |
98 | }, |
99 | { | |
100 | .code = MEDIA_BUS_FMT_SGRBG10_1X10, | |
ec917d77 DO |
101 | .order = { { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_RED }, |
102 | { VIMC_DEBAYER_BLUE, VIMC_DEBAYER_GREEN } } | |
88f42bf0 HF |
103 | }, |
104 | { | |
105 | .code = MEDIA_BUS_FMT_SRGGB10_1X10, | |
ec917d77 DO |
106 | .order = { { VIMC_DEBAYER_RED, VIMC_DEBAYER_GREEN }, |
107 | { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_BLUE } } | |
88f42bf0 HF |
108 | }, |
109 | { | |
110 | .code = MEDIA_BUS_FMT_SBGGR12_1X12, | |
ec917d77 DO |
111 | .order = { { VIMC_DEBAYER_BLUE, VIMC_DEBAYER_GREEN }, |
112 | { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_RED } } | |
88f42bf0 HF |
113 | }, |
114 | { | |
115 | .code = MEDIA_BUS_FMT_SGBRG12_1X12, | |
ec917d77 DO |
116 | .order = { { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_BLUE }, |
117 | { VIMC_DEBAYER_RED, VIMC_DEBAYER_GREEN } } | |
88f42bf0 HF |
118 | }, |
119 | { | |
120 | .code = MEDIA_BUS_FMT_SGRBG12_1X12, | |
ec917d77 DO |
121 | .order = { { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_RED }, |
122 | { VIMC_DEBAYER_BLUE, VIMC_DEBAYER_GREEN } } | |
88f42bf0 HF |
123 | }, |
124 | { | |
125 | .code = MEDIA_BUS_FMT_SRGGB12_1X12, | |
ec917d77 DO |
126 | .order = { { VIMC_DEBAYER_RED, VIMC_DEBAYER_GREEN }, |
127 | { VIMC_DEBAYER_GREEN, VIMC_DEBAYER_BLUE } } | |
88f42bf0 HF |
128 | }, |
129 | }; | |
130 | ||
ec917d77 | 131 | static const struct vimc_debayer_pix_map *vimc_debayer_pix_map_by_code(u32 code) |
88f42bf0 HF |
132 | { |
133 | unsigned int i; | |
134 | ||
ec917d77 DO |
135 | for (i = 0; i < ARRAY_SIZE(vimc_debayer_pix_map_list); i++) |
136 | if (vimc_debayer_pix_map_list[i].code == code) | |
137 | return &vimc_debayer_pix_map_list[i]; | |
88f42bf0 HF |
138 | |
139 | return NULL; | |
140 | } | |
141 | ||
ec917d77 | 142 | static bool vimc_debayer_src_code_is_valid(u32 code) |
f4d12d80 NP |
143 | { |
144 | unsigned int i; | |
145 | ||
ec917d77 DO |
146 | for (i = 0; i < ARRAY_SIZE(vimc_debayer_src_mbus_codes); i++) |
147 | if (vimc_debayer_src_mbus_codes[i] == code) | |
f4d12d80 NP |
148 | return true; |
149 | ||
150 | return false; | |
151 | } | |
152 | ||
5755be5f LP |
153 | static int vimc_debayer_init_state(struct v4l2_subdev *sd, |
154 | struct v4l2_subdev_state *sd_state) | |
88f42bf0 | 155 | { |
ec917d77 | 156 | struct vimc_debayer_device *vdebayer = v4l2_get_subdevdata(sd); |
88f42bf0 HF |
157 | struct v4l2_mbus_framefmt *mf; |
158 | unsigned int i; | |
159 | ||
bc0e8d91 | 160 | mf = v4l2_subdev_state_get_format(sd_state, 0); |
88f42bf0 HF |
161 | *mf = sink_fmt_default; |
162 | ||
163 | for (i = 1; i < sd->entity.num_pads; i++) { | |
bc0e8d91 | 164 | mf = v4l2_subdev_state_get_format(sd_state, i); |
88f42bf0 | 165 | *mf = sink_fmt_default; |
ec917d77 | 166 | mf->code = vdebayer->src_code; |
88f42bf0 HF |
167 | } |
168 | ||
169 | return 0; | |
170 | } | |
171 | ||
ec917d77 DO |
172 | static int vimc_debayer_enum_mbus_code(struct v4l2_subdev *sd, |
173 | struct v4l2_subdev_state *sd_state, | |
174 | struct v4l2_subdev_mbus_code_enum *code) | |
88f42bf0 | 175 | { |
3a9e69f1 | 176 | if (VIMC_IS_SRC(code->pad)) { |
ec917d77 | 177 | if (code->index >= ARRAY_SIZE(vimc_debayer_src_mbus_codes)) |
09c41a23 HK |
178 | return -EINVAL; |
179 | ||
ec917d77 | 180 | code->code = vimc_debayer_src_mbus_codes[code->index]; |
09c41a23 | 181 | } else { |
ec917d77 | 182 | if (code->index >= ARRAY_SIZE(vimc_debayer_pix_map_list)) |
88f42bf0 HF |
183 | return -EINVAL; |
184 | ||
ec917d77 | 185 | code->code = vimc_debayer_pix_map_list[code->index].code; |
88f42bf0 HF |
186 | } |
187 | ||
09c41a23 | 188 | return 0; |
88f42bf0 HF |
189 | } |
190 | ||
ec917d77 DO |
191 | static int vimc_debayer_enum_frame_size(struct v4l2_subdev *sd, |
192 | struct v4l2_subdev_state *sd_state, | |
193 | struct v4l2_subdev_frame_size_enum *fse) | |
88f42bf0 | 194 | { |
88f42bf0 HF |
195 | if (fse->index) |
196 | return -EINVAL; | |
197 | ||
3a9e69f1 | 198 | if (VIMC_IS_SINK(fse->pad)) { |
ec917d77 DO |
199 | const struct vimc_debayer_pix_map *vpix = |
200 | vimc_debayer_pix_map_by_code(fse->code); | |
88f42bf0 HF |
201 | |
202 | if (!vpix) | |
203 | return -EINVAL; | |
ec917d77 | 204 | } else if (!vimc_debayer_src_code_is_valid(fse->code)) { |
09c41a23 | 205 | return -EINVAL; |
88f42bf0 HF |
206 | } |
207 | ||
208 | fse->min_width = VIMC_FRAME_MIN_WIDTH; | |
209 | fse->max_width = VIMC_FRAME_MAX_WIDTH; | |
210 | fse->min_height = VIMC_FRAME_MIN_HEIGHT; | |
211 | fse->max_height = VIMC_FRAME_MAX_HEIGHT; | |
212 | ||
213 | return 0; | |
214 | } | |
215 | ||
ec917d77 DO |
216 | static int vimc_debayer_get_fmt(struct v4l2_subdev *sd, |
217 | struct v4l2_subdev_state *sd_state, | |
218 | struct v4l2_subdev_format *fmt) | |
88f42bf0 | 219 | { |
ec917d77 | 220 | struct vimc_debayer_device *vdebayer = v4l2_get_subdevdata(sd); |
88f42bf0 HF |
221 | |
222 | /* Get the current sink format */ | |
223 | fmt->format = fmt->which == V4L2_SUBDEV_FORMAT_TRY ? | |
bc0e8d91 | 224 | *v4l2_subdev_state_get_format(sd_state, 0) : |
ec917d77 | 225 | vdebayer->sink_fmt; |
88f42bf0 HF |
226 | |
227 | /* Set the right code for the source pad */ | |
3a9e69f1 | 228 | if (VIMC_IS_SRC(fmt->pad)) |
ec917d77 | 229 | fmt->format.code = vdebayer->src_code; |
88f42bf0 HF |
230 | |
231 | return 0; | |
232 | } | |
233 | ||
ec917d77 | 234 | static void vimc_debayer_adjust_sink_fmt(struct v4l2_mbus_framefmt *fmt) |
88f42bf0 | 235 | { |
ec917d77 | 236 | const struct vimc_debayer_pix_map *vpix; |
88f42bf0 HF |
237 | |
238 | /* Don't accept a code that is not on the debayer table */ | |
ec917d77 | 239 | vpix = vimc_debayer_pix_map_by_code(fmt->code); |
88f42bf0 HF |
240 | if (!vpix) |
241 | fmt->code = sink_fmt_default.code; | |
242 | ||
243 | fmt->width = clamp_t(u32, fmt->width, VIMC_FRAME_MIN_WIDTH, | |
244 | VIMC_FRAME_MAX_WIDTH) & ~1; | |
245 | fmt->height = clamp_t(u32, fmt->height, VIMC_FRAME_MIN_HEIGHT, | |
246 | VIMC_FRAME_MAX_HEIGHT) & ~1; | |
247 | ||
248 | if (fmt->field == V4L2_FIELD_ANY) | |
249 | fmt->field = sink_fmt_default.field; | |
250 | ||
251 | vimc_colorimetry_clamp(fmt); | |
252 | } | |
253 | ||
ec917d77 DO |
254 | static int vimc_debayer_set_fmt(struct v4l2_subdev *sd, |
255 | struct v4l2_subdev_state *sd_state, | |
256 | struct v4l2_subdev_format *fmt) | |
88f42bf0 | 257 | { |
ec917d77 | 258 | struct vimc_debayer_device *vdebayer = v4l2_get_subdevdata(sd); |
88f42bf0 | 259 | struct v4l2_mbus_framefmt *sink_fmt; |
f4d12d80 | 260 | u32 *src_code; |
88f42bf0 HF |
261 | |
262 | if (fmt->which == V4L2_SUBDEV_FORMAT_ACTIVE) { | |
263 | /* Do not change the format while stream is on */ | |
ec917d77 | 264 | if (vdebayer->src_frame) |
88f42bf0 HF |
265 | return -EBUSY; |
266 | ||
ec917d77 DO |
267 | sink_fmt = &vdebayer->sink_fmt; |
268 | src_code = &vdebayer->src_code; | |
88f42bf0 | 269 | } else { |
bc0e8d91 SA |
270 | sink_fmt = v4l2_subdev_state_get_format(sd_state, 0); |
271 | src_code = &v4l2_subdev_state_get_format(sd_state, 1)->code; | |
88f42bf0 HF |
272 | } |
273 | ||
274 | /* | |
275 | * Do not change the format of the source pad, | |
09c41a23 | 276 | * it is propagated from the sink |
88f42bf0 | 277 | */ |
3a9e69f1 | 278 | if (VIMC_IS_SRC(fmt->pad)) { |
f4d12d80 NP |
279 | u32 code = fmt->format.code; |
280 | ||
88f42bf0 | 281 | fmt->format = *sink_fmt; |
f4d12d80 | 282 | |
ec917d77 | 283 | if (vimc_debayer_src_code_is_valid(code)) |
f4d12d80 NP |
284 | *src_code = code; |
285 | ||
286 | fmt->format.code = *src_code; | |
88f42bf0 HF |
287 | } else { |
288 | /* Set the new format in the sink pad */ | |
ec917d77 | 289 | vimc_debayer_adjust_sink_fmt(&fmt->format); |
88f42bf0 | 290 | |
ec917d77 | 291 | dev_dbg(vdebayer->ved.dev, "%s: sink format update: " |
88f42bf0 | 292 | "old:%dx%d (0x%x, %d, %d, %d, %d) " |
ec917d77 | 293 | "new:%dx%d (0x%x, %d, %d, %d, %d)\n", vdebayer->sd.name, |
88f42bf0 HF |
294 | /* old */ |
295 | sink_fmt->width, sink_fmt->height, sink_fmt->code, | |
296 | sink_fmt->colorspace, sink_fmt->quantization, | |
297 | sink_fmt->xfer_func, sink_fmt->ycbcr_enc, | |
298 | /* new */ | |
299 | fmt->format.width, fmt->format.height, fmt->format.code, | |
300 | fmt->format.colorspace, fmt->format.quantization, | |
301 | fmt->format.xfer_func, fmt->format.ycbcr_enc); | |
302 | ||
303 | *sink_fmt = fmt->format; | |
304 | } | |
305 | ||
306 | return 0; | |
307 | } | |
308 | ||
ec917d77 | 309 | static const struct v4l2_subdev_pad_ops vimc_debayer_pad_ops = { |
ec917d77 DO |
310 | .enum_mbus_code = vimc_debayer_enum_mbus_code, |
311 | .enum_frame_size = vimc_debayer_enum_frame_size, | |
312 | .get_fmt = vimc_debayer_get_fmt, | |
313 | .set_fmt = vimc_debayer_set_fmt, | |
88f42bf0 HF |
314 | }; |
315 | ||
ec917d77 DO |
316 | static void vimc_debayer_process_rgb_frame(struct vimc_debayer_device *vdebayer, |
317 | unsigned int lin, | |
318 | unsigned int col, | |
319 | unsigned int rgb[3]) | |
88f42bf0 | 320 | { |
f4d12d80 | 321 | const struct vimc_pix_map *vpix; |
88f42bf0 HF |
322 | unsigned int i, index; |
323 | ||
ec917d77 DO |
324 | vpix = vimc_pix_map_by_code(vdebayer->src_code); |
325 | index = VIMC_FRAME_INDEX(lin, col, vdebayer->sink_fmt.width, 3); | |
f4d12d80 NP |
326 | for (i = 0; i < 3; i++) { |
327 | switch (vpix->pixelformat) { | |
328 | case V4L2_PIX_FMT_RGB24: | |
ec917d77 | 329 | vdebayer->src_frame[index + i] = rgb[i]; |
f4d12d80 NP |
330 | break; |
331 | case V4L2_PIX_FMT_BGR24: | |
ec917d77 | 332 | vdebayer->src_frame[index + i] = rgb[2 - i]; |
f4d12d80 NP |
333 | break; |
334 | } | |
335 | } | |
88f42bf0 HF |
336 | } |
337 | ||
ec917d77 | 338 | static int vimc_debayer_s_stream(struct v4l2_subdev *sd, int enable) |
88f42bf0 | 339 | { |
ec917d77 | 340 | struct vimc_debayer_device *vdebayer = v4l2_get_subdevdata(sd); |
88f42bf0 HF |
341 | |
342 | if (enable) { | |
09c41a23 | 343 | const struct vimc_pix_map *vpix; |
88f42bf0 HF |
344 | unsigned int frame_size; |
345 | ||
ec917d77 | 346 | if (vdebayer->src_frame) |
10b1aed6 HK |
347 | return 0; |
348 | ||
09c41a23 | 349 | /* Calculate the frame size of the source pad */ |
ec917d77 DO |
350 | vpix = vimc_pix_map_by_code(vdebayer->src_code); |
351 | frame_size = vdebayer->sink_fmt.width * vdebayer->sink_fmt.height * | |
09c41a23 HK |
352 | vpix->bpp; |
353 | ||
354 | /* Save the bytes per pixel of the sink */ | |
ec917d77 DO |
355 | vpix = vimc_pix_map_by_code(vdebayer->sink_fmt.code); |
356 | vdebayer->sink_bpp = vpix->bpp; | |
88f42bf0 HF |
357 | |
358 | /* Get the corresponding pixel map from the table */ | |
ec917d77 DO |
359 | vdebayer->sink_pix_map = |
360 | vimc_debayer_pix_map_by_code(vdebayer->sink_fmt.code); | |
88f42bf0 HF |
361 | |
362 | /* | |
363 | * Allocate the frame buffer. Use vmalloc to be able to | |
364 | * allocate a large amount of memory | |
365 | */ | |
ec917d77 DO |
366 | vdebayer->src_frame = vmalloc(frame_size); |
367 | if (!vdebayer->src_frame) | |
88f42bf0 HF |
368 | return -ENOMEM; |
369 | ||
88f42bf0 | 370 | } else { |
ec917d77 | 371 | if (!vdebayer->src_frame) |
88f42bf0 HF |
372 | return 0; |
373 | ||
ec917d77 DO |
374 | vfree(vdebayer->src_frame); |
375 | vdebayer->src_frame = NULL; | |
88f42bf0 HF |
376 | } |
377 | ||
378 | return 0; | |
379 | } | |
380 | ||
ec917d77 | 381 | static const struct v4l2_subdev_core_ops vimc_debayer_core_ops = { |
76df2e6c AML |
382 | .log_status = v4l2_ctrl_subdev_log_status, |
383 | .subscribe_event = v4l2_ctrl_subdev_subscribe_event, | |
384 | .unsubscribe_event = v4l2_event_subdev_unsubscribe, | |
385 | }; | |
386 | ||
ec917d77 DO |
387 | static const struct v4l2_subdev_video_ops vimc_debayer_video_ops = { |
388 | .s_stream = vimc_debayer_s_stream, | |
88f42bf0 HF |
389 | }; |
390 | ||
ec917d77 DO |
391 | static const struct v4l2_subdev_ops vimc_debayer_ops = { |
392 | .core = &vimc_debayer_core_ops, | |
393 | .pad = &vimc_debayer_pad_ops, | |
394 | .video = &vimc_debayer_video_ops, | |
88f42bf0 HF |
395 | }; |
396 | ||
5755be5f LP |
397 | static const struct v4l2_subdev_internal_ops vimc_debayer_internal_ops = { |
398 | .init_state = vimc_debayer_init_state, | |
399 | }; | |
400 | ||
ec917d77 DO |
401 | static unsigned int vimc_debayer_get_val(const u8 *bytes, |
402 | const unsigned int n_bytes) | |
88f42bf0 HF |
403 | { |
404 | unsigned int i; | |
405 | unsigned int acc = 0; | |
406 | ||
407 | for (i = 0; i < n_bytes; i++) | |
408 | acc = acc + (bytes[i] << (8 * i)); | |
409 | ||
410 | return acc; | |
411 | } | |
412 | ||
ec917d77 DO |
413 | static void vimc_debayer_calc_rgb_sink(struct vimc_debayer_device *vdebayer, |
414 | const u8 *frame, | |
415 | const unsigned int lin, | |
416 | const unsigned int col, | |
417 | unsigned int rgb[3]) | |
88f42bf0 HF |
418 | { |
419 | unsigned int i, seek, wlin, wcol; | |
420 | unsigned int n_rgb[3] = {0, 0, 0}; | |
421 | ||
422 | for (i = 0; i < 3; i++) | |
423 | rgb[i] = 0; | |
424 | ||
425 | /* | |
426 | * Calculate how many we need to subtract to get to the pixel in | |
427 | * the top left corner of the mean window (considering the current | |
428 | * pixel as the center) | |
429 | */ | |
ec917d77 | 430 | seek = vdebayer->mean_win_size / 2; |
88f42bf0 HF |
431 | |
432 | /* Sum the values of the colors in the mean window */ | |
433 | ||
ec917d77 | 434 | dev_dbg(vdebayer->ved.dev, |
88f42bf0 | 435 | "deb: %s: --- Calc pixel %dx%d, window mean %d, seek %d ---\n", |
ec917d77 | 436 | vdebayer->sd.name, lin, col, vdebayer->sink_fmt.height, seek); |
88f42bf0 HF |
437 | |
438 | /* | |
439 | * Iterate through all the lines in the mean window, start | |
440 | * with zero if the pixel is outside the frame and don't pass | |
441 | * the height when the pixel is in the bottom border of the | |
442 | * frame | |
443 | */ | |
444 | for (wlin = seek > lin ? 0 : lin - seek; | |
ec917d77 | 445 | wlin < lin + seek + 1 && wlin < vdebayer->sink_fmt.height; |
88f42bf0 HF |
446 | wlin++) { |
447 | ||
448 | /* | |
449 | * Iterate through all the columns in the mean window, start | |
450 | * with zero if the pixel is outside the frame and don't pass | |
451 | * the width when the pixel is in the right border of the | |
452 | * frame | |
453 | */ | |
454 | for (wcol = seek > col ? 0 : col - seek; | |
ec917d77 | 455 | wcol < col + seek + 1 && wcol < vdebayer->sink_fmt.width; |
88f42bf0 | 456 | wcol++) { |
ec917d77 | 457 | enum vimc_debayer_rgb_colors color; |
88f42bf0 HF |
458 | unsigned int index; |
459 | ||
460 | /* Check which color this pixel is */ | |
ec917d77 | 461 | color = vdebayer->sink_pix_map->order[wlin % 2][wcol % 2]; |
88f42bf0 HF |
462 | |
463 | index = VIMC_FRAME_INDEX(wlin, wcol, | |
ec917d77 DO |
464 | vdebayer->sink_fmt.width, |
465 | vdebayer->sink_bpp); | |
88f42bf0 | 466 | |
ec917d77 | 467 | dev_dbg(vdebayer->ved.dev, |
88f42bf0 | 468 | "deb: %s: RGB CALC: frame index %d, win pos %dx%d, color %d\n", |
ec917d77 | 469 | vdebayer->sd.name, index, wlin, wcol, color); |
88f42bf0 HF |
470 | |
471 | /* Get its value */ | |
472 | rgb[color] = rgb[color] + | |
ec917d77 DO |
473 | vimc_debayer_get_val(&frame[index], |
474 | vdebayer->sink_bpp); | |
88f42bf0 HF |
475 | |
476 | /* Save how many values we already added */ | |
477 | n_rgb[color]++; | |
478 | ||
ec917d77 DO |
479 | dev_dbg(vdebayer->ved.dev, "deb: %s: RGB CALC: val %d, n %d\n", |
480 | vdebayer->sd.name, rgb[color], n_rgb[color]); | |
88f42bf0 HF |
481 | } |
482 | } | |
483 | ||
484 | /* Calculate the mean */ | |
485 | for (i = 0; i < 3; i++) { | |
ec917d77 | 486 | dev_dbg(vdebayer->ved.dev, |
88f42bf0 | 487 | "deb: %s: PRE CALC: %dx%d Color %d, val %d, n %d\n", |
ec917d77 | 488 | vdebayer->sd.name, lin, col, i, rgb[i], n_rgb[i]); |
88f42bf0 HF |
489 | |
490 | if (n_rgb[i]) | |
491 | rgb[i] = rgb[i] / n_rgb[i]; | |
492 | ||
ec917d77 | 493 | dev_dbg(vdebayer->ved.dev, |
88f42bf0 | 494 | "deb: %s: FINAL CALC: %dx%d Color %d, val %d\n", |
ec917d77 | 495 | vdebayer->sd.name, lin, col, i, rgb[i]); |
88f42bf0 HF |
496 | } |
497 | } | |
498 | ||
ec917d77 DO |
499 | static void *vimc_debayer_process_frame(struct vimc_ent_device *ved, |
500 | const void *sink_frame) | |
88f42bf0 | 501 | { |
ec917d77 DO |
502 | struct vimc_debayer_device *vdebayer = |
503 | container_of(ved, struct vimc_debayer_device, ved); | |
504 | ||
88f42bf0 HF |
505 | unsigned int rgb[3]; |
506 | unsigned int i, j; | |
507 | ||
508 | /* If the stream in this node is not active, just return */ | |
ec917d77 | 509 | if (!vdebayer->src_frame) |
adc589d2 | 510 | return ERR_PTR(-EINVAL); |
88f42bf0 | 511 | |
ec917d77 DO |
512 | for (i = 0; i < vdebayer->sink_fmt.height; i++) |
513 | for (j = 0; j < vdebayer->sink_fmt.width; j++) { | |
514 | vimc_debayer_calc_rgb_sink(vdebayer, sink_frame, i, j, rgb); | |
515 | vdebayer->set_rgb_src(vdebayer, i, j, rgb); | |
88f42bf0 HF |
516 | } |
517 | ||
ec917d77 | 518 | return vdebayer->src_frame; |
76df2e6c AML |
519 | } |
520 | ||
ec917d77 | 521 | static int vimc_debayer_s_ctrl(struct v4l2_ctrl *ctrl) |
76df2e6c | 522 | { |
ec917d77 DO |
523 | struct vimc_debayer_device *vdebayer = |
524 | container_of(ctrl->handler, struct vimc_debayer_device, hdl); | |
88f42bf0 | 525 | |
76df2e6c AML |
526 | switch (ctrl->id) { |
527 | case VIMC_CID_MEAN_WIN_SIZE: | |
ec917d77 | 528 | vdebayer->mean_win_size = ctrl->val; |
76df2e6c AML |
529 | break; |
530 | default: | |
531 | return -EINVAL; | |
532 | } | |
533 | return 0; | |
88f42bf0 HF |
534 | } |
535 | ||
ec917d77 DO |
536 | static const struct v4l2_ctrl_ops vimc_debayer_ctrl_ops = { |
537 | .s_ctrl = vimc_debayer_s_ctrl, | |
76df2e6c AML |
538 | }; |
539 | ||
ec917d77 | 540 | static void vimc_debayer_release(struct vimc_ent_device *ved) |
2b177f28 | 541 | { |
ec917d77 DO |
542 | struct vimc_debayer_device *vdebayer = |
543 | container_of(ved, struct vimc_debayer_device, ved); | |
2b177f28 | 544 | |
ec917d77 DO |
545 | v4l2_ctrl_handler_free(&vdebayer->hdl); |
546 | media_entity_cleanup(vdebayer->ved.ent); | |
547 | kfree(vdebayer); | |
2b177f28 HV |
548 | } |
549 | ||
ec917d77 | 550 | static const struct v4l2_ctrl_config vimc_debayer_ctrl_class = { |
76df2e6c AML |
551 | .flags = V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_WRITE_ONLY, |
552 | .id = VIMC_CID_VIMC_CLASS, | |
553 | .name = "VIMC Controls", | |
554 | .type = V4L2_CTRL_TYPE_CTRL_CLASS, | |
555 | }; | |
556 | ||
ec917d77 DO |
557 | static const struct v4l2_ctrl_config vimc_debayer_ctrl_mean_win_size = { |
558 | .ops = &vimc_debayer_ctrl_ops, | |
76df2e6c AML |
559 | .id = VIMC_CID_MEAN_WIN_SIZE, |
560 | .name = "Debayer Mean Window Size", | |
561 | .type = V4L2_CTRL_TYPE_INTEGER, | |
562 | .min = 1, | |
563 | .max = 25, | |
564 | .step = 2, | |
565 | .def = 3, | |
566 | }; | |
567 | ||
ec917d77 DO |
568 | static struct vimc_ent_device *vimc_debayer_add(struct vimc_device *vimc, |
569 | const char *vcfg_name) | |
88f42bf0 | 570 | { |
f13d5f36 | 571 | struct v4l2_device *v4l2_dev = &vimc->v4l2_dev; |
ec917d77 | 572 | struct vimc_debayer_device *vdebayer; |
88f42bf0 HF |
573 | int ret; |
574 | ||
ec917d77 DO |
575 | /* Allocate the vdebayer struct */ |
576 | vdebayer = kzalloc(sizeof(*vdebayer), GFP_KERNEL); | |
577 | if (!vdebayer) | |
967534cb | 578 | return ERR_PTR(-ENOMEM); |
88f42bf0 | 579 | |
76df2e6c | 580 | /* Create controls: */ |
ec917d77 DO |
581 | v4l2_ctrl_handler_init(&vdebayer->hdl, 2); |
582 | v4l2_ctrl_new_custom(&vdebayer->hdl, &vimc_debayer_ctrl_class, NULL); | |
583 | v4l2_ctrl_new_custom(&vdebayer->hdl, &vimc_debayer_ctrl_mean_win_size, NULL); | |
584 | vdebayer->sd.ctrl_handler = &vdebayer->hdl; | |
585 | if (vdebayer->hdl.error) { | |
586 | ret = vdebayer->hdl.error; | |
587 | goto err_free_vdebayer; | |
76df2e6c AML |
588 | } |
589 | ||
88f42bf0 | 590 | /* Initialize ved and sd */ |
ec917d77 DO |
591 | vdebayer->pads[0].flags = MEDIA_PAD_FL_SINK; |
592 | vdebayer->pads[1].flags = MEDIA_PAD_FL_SOURCE; | |
23df45d0 | 593 | |
ec917d77 | 594 | ret = vimc_ent_sd_register(&vdebayer->ved, &vdebayer->sd, v4l2_dev, |
f13d5f36 | 595 | vcfg_name, |
1ceda32b | 596 | MEDIA_ENT_F_PROC_VIDEO_PIXEL_ENC_CONV, 2, |
ec917d77 | 597 | vdebayer->pads, &vimc_debayer_ops); |
76df2e6c AML |
598 | if (ret) |
599 | goto err_free_hdl; | |
88f42bf0 | 600 | |
5755be5f LP |
601 | vdebayer->sd.internal_ops = &vimc_debayer_internal_ops; |
602 | ||
ec917d77 DO |
603 | vdebayer->ved.process_frame = vimc_debayer_process_frame; |
604 | vdebayer->ved.dev = vimc->mdev.dev; | |
605 | vdebayer->mean_win_size = vimc_debayer_ctrl_mean_win_size.def; | |
88f42bf0 HF |
606 | |
607 | /* Initialize the frame format */ | |
ec917d77 | 608 | vdebayer->sink_fmt = sink_fmt_default; |
88f42bf0 HF |
609 | /* |
610 | * TODO: Add support for more output formats, we only support | |
09c41a23 | 611 | * RGB888 for now |
88f42bf0 HF |
612 | * NOTE: the src format is always the same as the sink, except |
613 | * for the code | |
614 | */ | |
ec917d77 DO |
615 | vdebayer->src_code = MEDIA_BUS_FMT_RGB888_1X24; |
616 | vdebayer->set_rgb_src = vimc_debayer_process_rgb_frame; | |
88f42bf0 | 617 | |
ec917d77 | 618 | return &vdebayer->ved; |
76df2e6c AML |
619 | |
620 | err_free_hdl: | |
ec917d77 DO |
621 | v4l2_ctrl_handler_free(&vdebayer->hdl); |
622 | err_free_vdebayer: | |
623 | kfree(vdebayer); | |
76df2e6c | 624 | |
967534cb | 625 | return ERR_PTR(ret); |
88f42bf0 | 626 | } |
e472d6a2 | 627 | |
ec917d77 DO |
628 | struct vimc_ent_type vimc_debayer_type = { |
629 | .add = vimc_debayer_add, | |
630 | .release = vimc_debayer_release | |
e472d6a2 | 631 | }; |