1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * vimc-scaler.c Virtual Media Controller Driver
4  *
5  * Copyright (C) 2015-2017 Helen Koike <helen.fornazier@gmail.com>
6  */
7 
8 #include <linux/moduleparam.h>
9 #include <linux/string.h>
10 #include <linux/vmalloc.h>
11 #include <linux/v4l2-mediabus.h>
12 #include <media/v4l2-rect.h>
13 #include <media/v4l2-subdev.h>
14 
15 #include "vimc-common.h"
16 
17 /* Pad identifier */
18 enum vic_sca_pad {
19 	VIMC_SCA_SINK = 0,
20 	VIMC_SCA_SRC = 1,
21 };
22 
23 #define VIMC_SCA_FMT_WIDTH_DEFAULT  640
24 #define VIMC_SCA_FMT_HEIGHT_DEFAULT 480
25 
26 struct vimc_sca_device {
27 	struct vimc_ent_device ved;
28 	struct v4l2_subdev sd;
29 	struct v4l2_rect crop_rect;
30 	/* Frame format for both sink and src pad */
31 	struct v4l2_mbus_framefmt fmt[2];
32 	/* Values calculated when the stream starts */
33 	u8 *src_frame;
34 	unsigned int bpp;
35 	struct media_pad pads[2];
36 };
37 
38 static const struct v4l2_mbus_framefmt fmt_default = {
39 	.width = VIMC_SCA_FMT_WIDTH_DEFAULT,
40 	.height = VIMC_SCA_FMT_HEIGHT_DEFAULT,
41 	.code = MEDIA_BUS_FMT_RGB888_1X24,
42 	.field = V4L2_FIELD_NONE,
43 	.colorspace = V4L2_COLORSPACE_SRGB,
44 };
45 
46 static const struct v4l2_rect crop_rect_default = {
47 	.width = VIMC_SCA_FMT_WIDTH_DEFAULT,
48 	.height = VIMC_SCA_FMT_HEIGHT_DEFAULT,
49 	.top = 0,
50 	.left = 0,
51 };
52 
53 static const struct v4l2_rect crop_rect_min = {
54 	.width = VIMC_FRAME_MIN_WIDTH,
55 	.height = VIMC_FRAME_MIN_HEIGHT,
56 	.top = 0,
57 	.left = 0,
58 };
59 
60 static struct v4l2_rect
61 vimc_sca_get_crop_bound_sink(const struct v4l2_mbus_framefmt *sink_fmt)
62 {
63 	/* Get the crop bounds to clamp the crop rectangle correctly */
64 	struct v4l2_rect r = {
65 		.left = 0,
66 		.top = 0,
67 		.width = sink_fmt->width,
68 		.height = sink_fmt->height,
69 	};
70 	return r;
71 }
72 
73 static int vimc_sca_init_cfg(struct v4l2_subdev *sd,
74 			     struct v4l2_subdev_state *sd_state)
75 {
76 	struct v4l2_mbus_framefmt *mf;
77 	struct v4l2_rect *r;
78 	unsigned int i;
79 
80 	for (i = 0; i < sd->entity.num_pads; i++) {
81 		mf = v4l2_subdev_get_try_format(sd, sd_state, i);
82 		*mf = fmt_default;
83 	}
84 
85 	r = v4l2_subdev_get_try_crop(sd, sd_state, VIMC_SCA_SINK);
86 	*r = crop_rect_default;
87 
88 	return 0;
89 }
90 
91 static int vimc_sca_enum_mbus_code(struct v4l2_subdev *sd,
92 				   struct v4l2_subdev_state *sd_state,
93 				   struct v4l2_subdev_mbus_code_enum *code)
94 {
95 	u32 mbus_code = vimc_mbus_code_by_index(code->index);
96 	const struct vimc_pix_map *vpix;
97 
98 	if (!mbus_code)
99 		return -EINVAL;
100 
101 	vpix = vimc_pix_map_by_code(mbus_code);
102 
103 	/* We don't support bayer format */
104 	if (!vpix || vpix->bayer)
105 		return -EINVAL;
106 
107 	code->code = mbus_code;
108 
109 	return 0;
110 }
111 
112 static int vimc_sca_enum_frame_size(struct v4l2_subdev *sd,
113 				    struct v4l2_subdev_state *sd_state,
114 				    struct v4l2_subdev_frame_size_enum *fse)
115 {
116 	const struct vimc_pix_map *vpix;
117 
118 	if (fse->index)
119 		return -EINVAL;
120 
121 	/* Only accept code in the pix map table in non bayer format */
122 	vpix = vimc_pix_map_by_code(fse->code);
123 	if (!vpix || vpix->bayer)
124 		return -EINVAL;
125 
126 	fse->min_width = VIMC_FRAME_MIN_WIDTH;
127 	fse->min_height = VIMC_FRAME_MIN_HEIGHT;
128 
129 	fse->max_width = VIMC_FRAME_MAX_WIDTH;
130 	fse->max_height = VIMC_FRAME_MAX_HEIGHT;
131 
132 	return 0;
133 }
134 
135 static struct v4l2_mbus_framefmt *
136 vimc_sca_pad_format(struct vimc_sca_device *vsca,
137 		    struct v4l2_subdev_state *sd_state, u32 pad,
138 		    enum v4l2_subdev_format_whence which)
139 {
140 	if (which == V4L2_SUBDEV_FORMAT_TRY)
141 		return v4l2_subdev_get_try_format(&vsca->sd, sd_state, pad);
142 	else
143 		return &vsca->fmt[pad];
144 }
145 
146 static struct v4l2_rect *
147 vimc_sca_pad_crop(struct vimc_sca_device *vsca,
148 		  struct v4l2_subdev_state *sd_state,
149 		  enum v4l2_subdev_format_whence which)
150 {
151 	if (which == V4L2_SUBDEV_FORMAT_TRY)
152 		return v4l2_subdev_get_try_crop(&vsca->sd, sd_state,
153 						VIMC_SCA_SINK);
154 	else
155 		return &vsca->crop_rect;
156 }
157 
158 static int vimc_sca_get_fmt(struct v4l2_subdev *sd,
159 			    struct v4l2_subdev_state *sd_state,
160 			    struct v4l2_subdev_format *format)
161 {
162 	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
163 
164 	format->format = *vimc_sca_pad_format(vsca, sd_state, format->pad,
165 					      format->which);
166 	return 0;
167 }
168 
169 static int vimc_sca_set_fmt(struct v4l2_subdev *sd,
170 			    struct v4l2_subdev_state *sd_state,
171 			    struct v4l2_subdev_format *format)
172 {
173 	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
174 	struct v4l2_mbus_framefmt *fmt;
175 
176 	/* Do not change the active format while stream is on */
177 	if (format->which == V4L2_SUBDEV_FORMAT_ACTIVE && vsca->src_frame)
178 		return -EBUSY;
179 
180 	fmt = vimc_sca_pad_format(vsca, sd_state, format->pad, format->which);
181 
182 	/*
183 	 * The media bus code and colorspace can only be changed on the sink
184 	 * pad, the source pad only follows.
185 	 */
186 	if (format->pad == VIMC_SCA_SINK) {
187 		const struct vimc_pix_map *vpix;
188 
189 		/* Only accept code in the pix map table in non bayer format. */
190 		vpix = vimc_pix_map_by_code(format->format.code);
191 		if (vpix && !vpix->bayer)
192 			fmt->code = format->format.code;
193 		else
194 			fmt->code = fmt_default.code;
195 
196 		/* Clamp the colorspace to valid values. */
197 		fmt->colorspace = format->format.colorspace;
198 		fmt->ycbcr_enc = format->format.ycbcr_enc;
199 		fmt->quantization = format->format.quantization;
200 		fmt->xfer_func = format->format.xfer_func;
201 		vimc_colorimetry_clamp(fmt);
202 	}
203 
204 	/* Clamp and align the width and height */
205 	fmt->width = clamp_t(u32, format->format.width, VIMC_FRAME_MIN_WIDTH,
206 			     VIMC_FRAME_MAX_WIDTH) & ~1;
207 	fmt->height = clamp_t(u32, format->format.height, VIMC_FRAME_MIN_HEIGHT,
208 			      VIMC_FRAME_MAX_HEIGHT) & ~1;
209 
210 	/*
211 	 * Propagate the sink pad format to the crop rectangle and the source
212 	 * pad.
213 	 */
214 	if (format->pad == VIMC_SCA_SINK) {
215 		struct v4l2_mbus_framefmt *src_fmt;
216 		struct v4l2_rect *crop;
217 
218 		crop = vimc_sca_pad_crop(vsca, sd_state, format->which);
219 		crop->width = fmt->width;
220 		crop->height = fmt->height;
221 		crop->top = 0;
222 		crop->left = 0;
223 
224 		src_fmt = vimc_sca_pad_format(vsca, sd_state, VIMC_SCA_SRC,
225 					      format->which);
226 		*src_fmt = *fmt;
227 	}
228 
229 	format->format = *fmt;
230 
231 	return 0;
232 }
233 
234 static int vimc_sca_get_selection(struct v4l2_subdev *sd,
235 				  struct v4l2_subdev_state *sd_state,
236 				  struct v4l2_subdev_selection *sel)
237 {
238 	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
239 	struct v4l2_mbus_framefmt *sink_fmt;
240 
241 	if (VIMC_IS_SRC(sel->pad))
242 		return -EINVAL;
243 
244 	switch (sel->target) {
245 	case V4L2_SEL_TGT_CROP:
246 		sel->r = *vimc_sca_pad_crop(vsca, sd_state, sel->which);
247 		break;
248 	case V4L2_SEL_TGT_CROP_BOUNDS:
249 		sink_fmt = vimc_sca_pad_format(vsca, sd_state, VIMC_SCA_SINK,
250 					       sel->which);
251 		sel->r = vimc_sca_get_crop_bound_sink(sink_fmt);
252 		break;
253 	default:
254 		return -EINVAL;
255 	}
256 
257 	return 0;
258 }
259 
260 static void vimc_sca_adjust_sink_crop(struct v4l2_rect *r,
261 				      const struct v4l2_mbus_framefmt *sink_fmt)
262 {
263 	const struct v4l2_rect sink_rect =
264 		vimc_sca_get_crop_bound_sink(sink_fmt);
265 
266 	/* Disallow rectangles smaller than the minimal one. */
267 	v4l2_rect_set_min_size(r, &crop_rect_min);
268 	v4l2_rect_map_inside(r, &sink_rect);
269 }
270 
271 static int vimc_sca_set_selection(struct v4l2_subdev *sd,
272 				  struct v4l2_subdev_state *sd_state,
273 				  struct v4l2_subdev_selection *sel)
274 {
275 	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
276 	struct v4l2_mbus_framefmt *sink_fmt;
277 	struct v4l2_rect *crop_rect;
278 
279 	/* Only support setting the crop of the sink pad */
280 	if (VIMC_IS_SRC(sel->pad) || sel->target != V4L2_SEL_TGT_CROP)
281 		return -EINVAL;
282 
283 	if (sel->which == V4L2_SUBDEV_FORMAT_ACTIVE && vsca->src_frame)
284 		return -EBUSY;
285 
286 	crop_rect = vimc_sca_pad_crop(vsca, sd_state, sel->which);
287 	sink_fmt = vimc_sca_pad_format(vsca, sd_state, VIMC_SCA_SINK,
288 				       sel->which);
289 	vimc_sca_adjust_sink_crop(&sel->r, sink_fmt);
290 	*crop_rect = sel->r;
291 
292 	return 0;
293 }
294 
295 static const struct v4l2_subdev_pad_ops vimc_sca_pad_ops = {
296 	.init_cfg		= vimc_sca_init_cfg,
297 	.enum_mbus_code		= vimc_sca_enum_mbus_code,
298 	.enum_frame_size	= vimc_sca_enum_frame_size,
299 	.get_fmt		= vimc_sca_get_fmt,
300 	.set_fmt		= vimc_sca_set_fmt,
301 	.get_selection		= vimc_sca_get_selection,
302 	.set_selection		= vimc_sca_set_selection,
303 };
304 
305 static int vimc_sca_s_stream(struct v4l2_subdev *sd, int enable)
306 {
307 	struct vimc_sca_device *vsca = v4l2_get_subdevdata(sd);
308 
309 	if (enable) {
310 		const struct vimc_pix_map *vpix;
311 		unsigned int frame_size;
312 
313 		if (vsca->src_frame)
314 			return 0;
315 
316 		/* Save the bytes per pixel of the sink */
317 		vpix = vimc_pix_map_by_code(vsca->fmt[VIMC_SCA_SINK].code);
318 		vsca->bpp = vpix->bpp;
319 
320 		/* Calculate the frame size of the source pad */
321 		frame_size = vsca->fmt[VIMC_SCA_SRC].width
322 			   * vsca->fmt[VIMC_SCA_SRC].height * vsca->bpp;
323 
324 		/* Allocate the frame buffer. Use vmalloc to be able to
325 		 * allocate a large amount of memory
326 		 */
327 		vsca->src_frame = vmalloc(frame_size);
328 		if (!vsca->src_frame)
329 			return -ENOMEM;
330 
331 	} else {
332 		if (!vsca->src_frame)
333 			return 0;
334 
335 		vfree(vsca->src_frame);
336 		vsca->src_frame = NULL;
337 	}
338 
339 	return 0;
340 }
341 
342 static const struct v4l2_subdev_video_ops vimc_sca_video_ops = {
343 	.s_stream = vimc_sca_s_stream,
344 };
345 
346 static const struct v4l2_subdev_ops vimc_sca_ops = {
347 	.pad = &vimc_sca_pad_ops,
348 	.video = &vimc_sca_video_ops,
349 };
350 
351 static void vimc_sca_fill_src_frame(const struct vimc_sca_device *const vsca,
352 				    const u8 *const sink_frame)
353 {
354 	const struct v4l2_mbus_framefmt *src_fmt = &vsca->fmt[VIMC_SCA_SRC];
355 	const struct v4l2_rect *r = &vsca->crop_rect;
356 	unsigned int snk_width = vsca->fmt[VIMC_SCA_SINK].width;
357 	unsigned int src_x, src_y;
358 	u8 *walker = vsca->src_frame;
359 
360 	/* Set each pixel at the src_frame to its sink_frame equivalent */
361 	for (src_y = 0; src_y < src_fmt->height; src_y++) {
362 		unsigned int snk_y, y_offset;
363 
364 		snk_y = (src_y * r->height) / src_fmt->height + r->top;
365 		y_offset = snk_y * snk_width * vsca->bpp;
366 
367 		for (src_x = 0; src_x < src_fmt->width; src_x++) {
368 			unsigned int snk_x, x_offset, index;
369 
370 			snk_x = (src_x * r->width) / src_fmt->width + r->left;
371 			x_offset = snk_x * vsca->bpp;
372 			index = y_offset + x_offset;
373 			memcpy(walker, &sink_frame[index], vsca->bpp);
374 			walker += vsca->bpp;
375 		}
376 	}
377 }
378 
379 static void *vimc_sca_process_frame(struct vimc_ent_device *ved,
380 				    const void *sink_frame)
381 {
382 	struct vimc_sca_device *vsca = container_of(ved, struct vimc_sca_device,
383 						    ved);
384 
385 	/* If the stream in this node is not active, just return */
386 	if (!vsca->src_frame)
387 		return ERR_PTR(-EINVAL);
388 
389 	vimc_sca_fill_src_frame(vsca, sink_frame);
390 
391 	return vsca->src_frame;
392 };
393 
394 static void vimc_sca_release(struct vimc_ent_device *ved)
395 {
396 	struct vimc_sca_device *vsca =
397 		container_of(ved, struct vimc_sca_device, ved);
398 
399 	media_entity_cleanup(vsca->ved.ent);
400 	kfree(vsca);
401 }
402 
403 static struct vimc_ent_device *vimc_sca_add(struct vimc_device *vimc,
404 					    const char *vcfg_name)
405 {
406 	struct v4l2_device *v4l2_dev = &vimc->v4l2_dev;
407 	struct vimc_sca_device *vsca;
408 	int ret;
409 
410 	/* Allocate the vsca struct */
411 	vsca = kzalloc(sizeof(*vsca), GFP_KERNEL);
412 	if (!vsca)
413 		return ERR_PTR(-ENOMEM);
414 
415 	/* Initialize ved and sd */
416 	vsca->pads[VIMC_SCA_SINK].flags = MEDIA_PAD_FL_SINK;
417 	vsca->pads[VIMC_SCA_SRC].flags = MEDIA_PAD_FL_SOURCE;
418 
419 	ret = vimc_ent_sd_register(&vsca->ved, &vsca->sd, v4l2_dev,
420 				   vcfg_name,
421 				   MEDIA_ENT_F_PROC_VIDEO_SCALER, 2,
422 				   vsca->pads, &vimc_sca_ops);
423 	if (ret) {
424 		kfree(vsca);
425 		return ERR_PTR(ret);
426 	}
427 
428 	vsca->ved.process_frame = vimc_sca_process_frame;
429 	vsca->ved.dev = vimc->mdev.dev;
430 
431 	/* Initialize the frame format */
432 	vsca->fmt[VIMC_SCA_SINK] = fmt_default;
433 	vsca->fmt[VIMC_SCA_SRC] = fmt_default;
434 
435 	/* Initialize the crop selection */
436 	vsca->crop_rect = crop_rect_default;
437 
438 	return &vsca->ved;
439 }
440 
441 struct vimc_ent_type vimc_sca_type = {
442 	.add = vimc_sca_add,
443 	.release = vimc_sca_release
444 };
445