?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
WIP FPC-III support
[linux/fpc-iii.git] / drivers / media / platform / xilinx / xilinx-tpg.c
blobed01bedb5db69962a67fb149c76363b92e10f7f7
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Xilinx Test Pattern Generator
4 *
5 * Copyright (C) 2013-2015 Ideas on Board
6 * Copyright (C) 2013-2015 Xilinx, Inc.
7 *
8 * Contacts: Hyun Kwon <hyun.kwon@xilinx.com>
9 * Laurent Pinchart <laurent.pinchart@ideasonboard.com>
10 */
11
12 #include <linux/device.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/module.h>
15 #include <linux/of.h>
16 #include <linux/platform_device.h>
17 #include <linux/xilinx-v4l2-controls.h>
18
19 #include <media/v4l2-async.h>
20 #include <media/v4l2-ctrls.h>
21 #include <media/v4l2-subdev.h>
22
23 #include "xilinx-vip.h"
24 #include "xilinx-vtc.h"
25
26 #define XTPG_CTRL_STATUS_SLAVE_ERROR (1 << 16)
27 #define XTPG_CTRL_IRQ_SLAVE_ERROR (1 << 16)
28
29 #define XTPG_PATTERN_CONTROL 0x0100
30 #define XTPG_PATTERN_MASK (0xf << 0)
31 #define XTPG_PATTERN_CONTROL_CROSS_HAIRS (1 << 4)
32 #define XTPG_PATTERN_CONTROL_MOVING_BOX (1 << 5)
33 #define XTPG_PATTERN_CONTROL_COLOR_MASK_SHIFT 6
34 #define XTPG_PATTERN_CONTROL_COLOR_MASK_MASK (0xf << 6)
35 #define XTPG_PATTERN_CONTROL_STUCK_PIXEL (1 << 9)
36 #define XTPG_PATTERN_CONTROL_NOISE (1 << 10)
37 #define XTPG_PATTERN_CONTROL_MOTION (1 << 12)
38 #define XTPG_MOTION_SPEED 0x0104
39 #define XTPG_CROSS_HAIRS 0x0108
40 #define XTPG_CROSS_HAIRS_ROW_SHIFT 0
41 #define XTPG_CROSS_HAIRS_ROW_MASK (0xfff << 0)
42 #define XTPG_CROSS_HAIRS_COLUMN_SHIFT 16
43 #define XTPG_CROSS_HAIRS_COLUMN_MASK (0xfff << 16)
44 #define XTPG_ZPLATE_HOR_CONTROL 0x010c
45 #define XTPG_ZPLATE_VER_CONTROL 0x0110
46 #define XTPG_ZPLATE_START_SHIFT 0
47 #define XTPG_ZPLATE_START_MASK (0xffff << 0)
48 #define XTPG_ZPLATE_SPEED_SHIFT 16
49 #define XTPG_ZPLATE_SPEED_MASK (0xffff << 16)
50 #define XTPG_BOX_SIZE 0x0114
51 #define XTPG_BOX_COLOR 0x0118
52 #define XTPG_STUCK_PIXEL_THRESH 0x011c
53 #define XTPG_NOISE_GAIN 0x0120
54 #define XTPG_BAYER_PHASE 0x0124
55 #define XTPG_BAYER_PHASE_RGGB 0
56 #define XTPG_BAYER_PHASE_GRBG 1
57 #define XTPG_BAYER_PHASE_GBRG 2
58 #define XTPG_BAYER_PHASE_BGGR 3
59 #define XTPG_BAYER_PHASE_OFF 4
60
61 /*
62 * The minimum blanking value is one clock cycle for the front porch, one clock
63 * cycle for the sync pulse and one clock cycle for the back porch.
64 */
65 #define XTPG_MIN_HBLANK 3
66 #define XTPG_MAX_HBLANK (XVTC_MAX_HSIZE - XVIP_MIN_WIDTH)
67 #define XTPG_MIN_VBLANK 3
68 #define XTPG_MAX_VBLANK (XVTC_MAX_VSIZE - XVIP_MIN_HEIGHT)
69
70 /**
71 * struct xtpg_device - Xilinx Test Pattern Generator device structure
72 * @xvip: Xilinx Video IP device
73 * @pads: media pads
74 * @npads: number of pads (1 or 2)
75 * @has_input: whether an input is connected to the sink pad
76 * @formats: active V4L2 media bus format for each pad
77 * @default_format: default V4L2 media bus format
78 * @vip_format: format information corresponding to the active format
79 * @bayer: boolean flag if TPG is set to any bayer format
80 * @ctrl_handler: control handler
81 * @hblank: horizontal blanking control
82 * @vblank: vertical blanking control
83 * @pattern: test pattern control
84 * @streaming: is the video stream active
85 * @vtc: video timing controller
86 * @vtmux_gpio: video timing mux GPIO
87 */
88 struct xtpg_device {
89 struct xvip_device xvip;
90
91 struct media_pad pads[2];
92 unsigned int npads;
93 bool has_input;
94
95 struct v4l2_mbus_framefmt formats[2];
96 struct v4l2_mbus_framefmt default_format;
97 const struct xvip_video_format *vip_format;
98 bool bayer;
99
100 struct v4l2_ctrl_handler ctrl_handler;
101 struct v4l2_ctrl *hblank;
102 struct v4l2_ctrl *vblank;
103 struct v4l2_ctrl *pattern;
104 bool streaming;
105
106 struct xvtc_device *vtc;
107 struct gpio_desc *vtmux_gpio;
108 };
109
110 static inline struct xtpg_device *to_tpg(struct v4l2_subdev *subdev)
111 {
112 return container_of(subdev, struct xtpg_device, xvip.subdev);
113 }
114
115 static u32 xtpg_get_bayer_phase(unsigned int code)
116 {
117 switch (code) {
118 case MEDIA_BUS_FMT_SRGGB8_1X8:
119 return XTPG_BAYER_PHASE_RGGB;
120 case MEDIA_BUS_FMT_SGRBG8_1X8:
121 return XTPG_BAYER_PHASE_GRBG;
122 case MEDIA_BUS_FMT_SGBRG8_1X8:
123 return XTPG_BAYER_PHASE_GBRG;
124 case MEDIA_BUS_FMT_SBGGR8_1X8:
125 return XTPG_BAYER_PHASE_BGGR;
126 default:
127 return XTPG_BAYER_PHASE_OFF;
128 }
129 }
130
131 static void __xtpg_update_pattern_control(struct xtpg_device *xtpg,
132 bool passthrough, bool pattern)
133 {
134 u32 pattern_mask = (1 << (xtpg->pattern->maximum + 1)) - 1;
135
136 /*
137 * If the TPG has no sink pad or no input connected to its sink pad
138 * passthrough mode can't be enabled.
139 */
140 if (xtpg->npads == 1 || !xtpg->has_input)
141 passthrough = false;
142
143 /* If passthrough mode is allowed unmask bit 0. */
144 if (passthrough)
145 pattern_mask &= ~1;
146
147 /* If test pattern mode is allowed unmask all other bits. */
148 if (pattern)
149 pattern_mask &= 1;
150
151 __v4l2_ctrl_modify_range(xtpg->pattern, 0, xtpg->pattern->maximum,
152 pattern_mask, pattern ? 9 : 0);
153 }
154
155 static void xtpg_update_pattern_control(struct xtpg_device *xtpg,
156 bool passthrough, bool pattern)
157 {
158 mutex_lock(xtpg->ctrl_handler.lock);
159 __xtpg_update_pattern_control(xtpg, passthrough, pattern);
160 mutex_unlock(xtpg->ctrl_handler.lock);
161 }
162
163 /* -----------------------------------------------------------------------------
164 * V4L2 Subdevice Video Operations
165 */
166
167 static int xtpg_s_stream(struct v4l2_subdev *subdev, int enable)
168 {
169 struct xtpg_device *xtpg = to_tpg(subdev);
170 unsigned int width = xtpg->formats[0].width;
171 unsigned int height = xtpg->formats[0].height;
172 bool passthrough;
173 u32 bayer_phase;
174
175 if (!enable) {
176 xvip_stop(&xtpg->xvip);
177 if (xtpg->vtc)
178 xvtc_generator_stop(xtpg->vtc);
179
180 xtpg_update_pattern_control(xtpg, true, true);
181 xtpg->streaming = false;
182 return 0;
183 }
184
185 xvip_set_frame_size(&xtpg->xvip, &xtpg->formats[0]);
186
187 if (xtpg->vtc) {
188 struct xvtc_config config = {
189 .hblank_start = width,
190 .hsync_start = width + 1,
191 .vblank_start = height,
192 .vsync_start = height + 1,
193 };
194 unsigned int htotal;
195 unsigned int vtotal;
196
197 htotal = min_t(unsigned int, XVTC_MAX_HSIZE,
198 v4l2_ctrl_g_ctrl(xtpg->hblank) + width);
199 vtotal = min_t(unsigned int, XVTC_MAX_VSIZE,
200 v4l2_ctrl_g_ctrl(xtpg->vblank) + height);
201
202 config.hsync_end = htotal - 1;
203 config.hsize = htotal;
204 config.vsync_end = vtotal - 1;
205 config.vsize = vtotal;
206
207 xvtc_generator_start(xtpg->vtc, &config);
208 }
209
210 /*
211 * Configure the bayer phase and video timing mux based on the
212 * operation mode (passthrough or test pattern generation). The test
213 * pattern can be modified by the control set handler, we thus need to
214 * take the control lock here to avoid races.
215 */
216 mutex_lock(xtpg->ctrl_handler.lock);
217
218 xvip_clr_and_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
219 XTPG_PATTERN_MASK, xtpg->pattern->cur.val);
220
221 /*
222 * Switching between passthrough and test pattern generation modes isn't
223 * allowed during streaming, update the control range accordingly.
224 */
225 passthrough = xtpg->pattern->cur.val == 0;
226 __xtpg_update_pattern_control(xtpg, passthrough, !passthrough);
227
228 xtpg->streaming = true;
229
230 mutex_unlock(xtpg->ctrl_handler.lock);
231
232 /*
233 * For TPG v5.0, the bayer phase needs to be off for the pass through
234 * mode, otherwise the external input would be subsampled.
235 */
236 bayer_phase = passthrough ? XTPG_BAYER_PHASE_OFF
237 : xtpg_get_bayer_phase(xtpg->formats[0].code);
238 xvip_write(&xtpg->xvip, XTPG_BAYER_PHASE, bayer_phase);
239
240 if (xtpg->vtmux_gpio)
241 gpiod_set_value_cansleep(xtpg->vtmux_gpio, !passthrough);
242
243 xvip_start(&xtpg->xvip);
244
245 return 0;
246 }
247
248 /* -----------------------------------------------------------------------------
249 * V4L2 Subdevice Pad Operations
250 */
251
252 static struct v4l2_mbus_framefmt *
253 __xtpg_get_pad_format(struct xtpg_device *xtpg,
254 struct v4l2_subdev_pad_config *cfg,
255 unsigned int pad, u32 which)
256 {
257 switch (which) {
258 case V4L2_SUBDEV_FORMAT_TRY:
259 return v4l2_subdev_get_try_format(&xtpg->xvip.subdev, cfg, pad);
260 case V4L2_SUBDEV_FORMAT_ACTIVE:
261 return &xtpg->formats[pad];
262 default:
263 return NULL;
264 }
265 }
266
267 static int xtpg_get_format(struct v4l2_subdev *subdev,
268 struct v4l2_subdev_pad_config *cfg,
269 struct v4l2_subdev_format *fmt)
270 {
271 struct xtpg_device *xtpg = to_tpg(subdev);
272
273 fmt->format = *__xtpg_get_pad_format(xtpg, cfg, fmt->pad, fmt->which);
274
275 return 0;
276 }
277
278 static int xtpg_set_format(struct v4l2_subdev *subdev,
279 struct v4l2_subdev_pad_config *cfg,
280 struct v4l2_subdev_format *fmt)
281 {
282 struct xtpg_device *xtpg = to_tpg(subdev);
283 struct v4l2_mbus_framefmt *__format;
284 u32 bayer_phase;
285
286 __format = __xtpg_get_pad_format(xtpg, cfg, fmt->pad, fmt->which);
287
288 /* In two pads mode the source pad format is always identical to the
289 * sink pad format.
290 */
291 if (xtpg->npads == 2 && fmt->pad == 1) {
292 fmt->format = *__format;
293 return 0;
294 }
295
296 /* Bayer phase is configurable at runtime */
297 if (xtpg->bayer) {
298 bayer_phase = xtpg_get_bayer_phase(fmt->format.code);
299 if (bayer_phase != XTPG_BAYER_PHASE_OFF)
300 __format->code = fmt->format.code;
301 }
302
303 xvip_set_format_size(__format, fmt);
304
305 fmt->format = *__format;
306
307 /* Propagate the format to the source pad. */
308 if (xtpg->npads == 2) {
309 __format = __xtpg_get_pad_format(xtpg, cfg, 1, fmt->which);
310 *__format = fmt->format;
311 }
312
313 return 0;
314 }
315
316 /* -----------------------------------------------------------------------------
317 * V4L2 Subdevice Operations
318 */
319
320 static int xtpg_enum_frame_size(struct v4l2_subdev *subdev,
321 struct v4l2_subdev_pad_config *cfg,
322 struct v4l2_subdev_frame_size_enum *fse)
323 {
324 struct v4l2_mbus_framefmt *format;
325
326 format = v4l2_subdev_get_try_format(subdev, cfg, fse->pad);
327
328 if (fse->index || fse->code != format->code)
329 return -EINVAL;
330
331 /* Min / max values for pad 0 is always fixed in both one and two pads
332 * modes. In two pads mode, the source pad(= 1) size is identical to
333 * the sink pad size */
334 if (fse->pad == 0) {
335 fse->min_width = XVIP_MIN_WIDTH;
336 fse->max_width = XVIP_MAX_WIDTH;
337 fse->min_height = XVIP_MIN_HEIGHT;
338 fse->max_height = XVIP_MAX_HEIGHT;
339 } else {
340 fse->min_width = format->width;
341 fse->max_width = format->width;
342 fse->min_height = format->height;
343 fse->max_height = format->height;
344 }
345
346 return 0;
347 }
348
349 static int xtpg_open(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh)
350 {
351 struct xtpg_device *xtpg = to_tpg(subdev);
352 struct v4l2_mbus_framefmt *format;
353
354 format = v4l2_subdev_get_try_format(subdev, fh->pad, 0);
355 *format = xtpg->default_format;
356
357 if (xtpg->npads == 2) {
358 format = v4l2_subdev_get_try_format(subdev, fh->pad, 1);
359 *format = xtpg->default_format;
360 }
361
362 return 0;
363 }
364
365 static int xtpg_close(struct v4l2_subdev *subdev, struct v4l2_subdev_fh *fh)
366 {
367 return 0;
368 }
369
370 static int xtpg_s_ctrl(struct v4l2_ctrl *ctrl)
371 {
372 struct xtpg_device *xtpg = container_of(ctrl->handler,
373 struct xtpg_device,
374 ctrl_handler);
375 switch (ctrl->id) {
376 case V4L2_CID_TEST_PATTERN:
377 xvip_clr_and_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
378 XTPG_PATTERN_MASK, ctrl->val);
379 return 0;
380 case V4L2_CID_XILINX_TPG_CROSS_HAIRS:
381 xvip_clr_or_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
382 XTPG_PATTERN_CONTROL_CROSS_HAIRS, ctrl->val);
383 return 0;
384 case V4L2_CID_XILINX_TPG_MOVING_BOX:
385 xvip_clr_or_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
386 XTPG_PATTERN_CONTROL_MOVING_BOX, ctrl->val);
387 return 0;
388 case V4L2_CID_XILINX_TPG_COLOR_MASK:
389 xvip_clr_and_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
390 XTPG_PATTERN_CONTROL_COLOR_MASK_MASK,
391 ctrl->val <<
392 XTPG_PATTERN_CONTROL_COLOR_MASK_SHIFT);
393 return 0;
394 case V4L2_CID_XILINX_TPG_STUCK_PIXEL:
395 xvip_clr_or_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
396 XTPG_PATTERN_CONTROL_STUCK_PIXEL, ctrl->val);
397 return 0;
398 case V4L2_CID_XILINX_TPG_NOISE:
399 xvip_clr_or_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
400 XTPG_PATTERN_CONTROL_NOISE, ctrl->val);
401 return 0;
402 case V4L2_CID_XILINX_TPG_MOTION:
403 xvip_clr_or_set(&xtpg->xvip, XTPG_PATTERN_CONTROL,
404 XTPG_PATTERN_CONTROL_MOTION, ctrl->val);
405 return 0;
406 case V4L2_CID_XILINX_TPG_MOTION_SPEED:
407 xvip_write(&xtpg->xvip, XTPG_MOTION_SPEED, ctrl->val);
408 return 0;
409 case V4L2_CID_XILINX_TPG_CROSS_HAIR_ROW:
410 xvip_clr_and_set(&xtpg->xvip, XTPG_CROSS_HAIRS,
411 XTPG_CROSS_HAIRS_ROW_MASK,
412 ctrl->val << XTPG_CROSS_HAIRS_ROW_SHIFT);
413 return 0;
414 case V4L2_CID_XILINX_TPG_CROSS_HAIR_COLUMN:
415 xvip_clr_and_set(&xtpg->xvip, XTPG_CROSS_HAIRS,
416 XTPG_CROSS_HAIRS_COLUMN_MASK,
417 ctrl->val << XTPG_CROSS_HAIRS_COLUMN_SHIFT);
418 return 0;
419 case V4L2_CID_XILINX_TPG_ZPLATE_HOR_START:
420 xvip_clr_and_set(&xtpg->xvip, XTPG_ZPLATE_HOR_CONTROL,
421 XTPG_ZPLATE_START_MASK,
422 ctrl->val << XTPG_ZPLATE_START_SHIFT);
423 return 0;
424 case V4L2_CID_XILINX_TPG_ZPLATE_HOR_SPEED:
425 xvip_clr_and_set(&xtpg->xvip, XTPG_ZPLATE_HOR_CONTROL,
426 XTPG_ZPLATE_SPEED_MASK,
427 ctrl->val << XTPG_ZPLATE_SPEED_SHIFT);
428 return 0;
429 case V4L2_CID_XILINX_TPG_ZPLATE_VER_START:
430 xvip_clr_and_set(&xtpg->xvip, XTPG_ZPLATE_VER_CONTROL,
431 XTPG_ZPLATE_START_MASK,
432 ctrl->val << XTPG_ZPLATE_START_SHIFT);
433 return 0;
434 case V4L2_CID_XILINX_TPG_ZPLATE_VER_SPEED:
435 xvip_clr_and_set(&xtpg->xvip, XTPG_ZPLATE_VER_CONTROL,
436 XTPG_ZPLATE_SPEED_MASK,
437 ctrl->val << XTPG_ZPLATE_SPEED_SHIFT);
438 return 0;
439 case V4L2_CID_XILINX_TPG_BOX_SIZE:
440 xvip_write(&xtpg->xvip, XTPG_BOX_SIZE, ctrl->val);
441 return 0;
442 case V4L2_CID_XILINX_TPG_BOX_COLOR:
443 xvip_write(&xtpg->xvip, XTPG_BOX_COLOR, ctrl->val);
444 return 0;
445 case V4L2_CID_XILINX_TPG_STUCK_PIXEL_THRESH:
446 xvip_write(&xtpg->xvip, XTPG_STUCK_PIXEL_THRESH, ctrl->val);
447 return 0;
448 case V4L2_CID_XILINX_TPG_NOISE_GAIN:
449 xvip_write(&xtpg->xvip, XTPG_NOISE_GAIN, ctrl->val);
450 return 0;
451 }
452
453 return 0;
454 }
455
456 static const struct v4l2_ctrl_ops xtpg_ctrl_ops = {
457 .s_ctrl = xtpg_s_ctrl,
458 };
459
460 static const struct v4l2_subdev_core_ops xtpg_core_ops = {
461 };
462
463 static const struct v4l2_subdev_video_ops xtpg_video_ops = {
464 .s_stream = xtpg_s_stream,
465 };
466
467 static const struct v4l2_subdev_pad_ops xtpg_pad_ops = {
468 .enum_mbus_code = xvip_enum_mbus_code,
469 .enum_frame_size = xtpg_enum_frame_size,
470 .get_fmt = xtpg_get_format,
471 .set_fmt = xtpg_set_format,
472 };
473
474 static const struct v4l2_subdev_ops xtpg_ops = {
475 .core = &xtpg_core_ops,
476 .video = &xtpg_video_ops,
477 .pad = &xtpg_pad_ops,
478 };
479
480 static const struct v4l2_subdev_internal_ops xtpg_internal_ops = {
481 .open = xtpg_open,
482 .close = xtpg_close,
483 };
484
485 /*
486 * Control Config
487 */
488
489 static const char *const xtpg_pattern_strings[] = {
490 "Passthrough",
491 "Horizontal Ramp",
492 "Vertical Ramp",
493 "Temporal Ramp",
494 "Solid Red",
495 "Solid Green",
496 "Solid Blue",
497 "Solid Black",
498 "Solid White",
499 "Color Bars",
500 "Zone Plate",
501 "Tartan Color Bars",
502 "Cross Hatch",
503 "None",
504 "Vertical/Horizontal Ramps",
505 "Black/White Checker Board",
506 };
507
508 static struct v4l2_ctrl_config xtpg_ctrls[] = {
509 {
510 .ops = &xtpg_ctrl_ops,
511 .id = V4L2_CID_XILINX_TPG_CROSS_HAIRS,
512 .name = "Test Pattern: Cross Hairs",
513 .type = V4L2_CTRL_TYPE_BOOLEAN,
514 .min = false,
515 .max = true,
516 .step = 1,
517 .def = 0,
518 }, {
519 .ops = &xtpg_ctrl_ops,
520 .id = V4L2_CID_XILINX_TPG_MOVING_BOX,
521 .name = "Test Pattern: Moving Box",
522 .type = V4L2_CTRL_TYPE_BOOLEAN,
523 .min = false,
524 .max = true,
525 .step = 1,
526 .def = 0,
527 }, {
528 .ops = &xtpg_ctrl_ops,
529 .id = V4L2_CID_XILINX_TPG_COLOR_MASK,
530 .name = "Test Pattern: Color Mask",
531 .type = V4L2_CTRL_TYPE_BITMASK,
532 .min = 0,
533 .max = 0xf,
534 .def = 0,
535 }, {
536 .ops = &xtpg_ctrl_ops,
537 .id = V4L2_CID_XILINX_TPG_STUCK_PIXEL,
538 .name = "Test Pattern: Stuck Pixel",
539 .type = V4L2_CTRL_TYPE_BOOLEAN,
540 .min = false,
541 .max = true,
542 .step = 1,
543 .def = 0,
544 }, {
545 .ops = &xtpg_ctrl_ops,
546 .id = V4L2_CID_XILINX_TPG_NOISE,
547 .name = "Test Pattern: Noise",
548 .type = V4L2_CTRL_TYPE_BOOLEAN,
549 .min = false,
550 .max = true,
551 .step = 1,
552 .def = 0,
553 }, {
554 .ops = &xtpg_ctrl_ops,
555 .id = V4L2_CID_XILINX_TPG_MOTION,
556 .name = "Test Pattern: Motion",
557 .type = V4L2_CTRL_TYPE_BOOLEAN,
558 .min = false,
559 .max = true,
560 .step = 1,
561 .def = 0,
562 }, {
563 .ops = &xtpg_ctrl_ops,
564 .id = V4L2_CID_XILINX_TPG_MOTION_SPEED,
565 .name = "Test Pattern: Motion Speed",
566 .type = V4L2_CTRL_TYPE_INTEGER,
567 .min = 0,
568 .max = (1 << 8) - 1,
569 .step = 1,
570 .def = 4,
571 .flags = V4L2_CTRL_FLAG_SLIDER,
572 }, {
573 .ops = &xtpg_ctrl_ops,
574 .id = V4L2_CID_XILINX_TPG_CROSS_HAIR_ROW,
575 .name = "Test Pattern: Cross Hairs Row",
576 .type = V4L2_CTRL_TYPE_INTEGER,
577 .min = 0,
578 .max = (1 << 12) - 1,
579 .step = 1,
580 .def = 0x64,
581 .flags = V4L2_CTRL_FLAG_SLIDER,
582 }, {
583 .ops = &xtpg_ctrl_ops,
584 .id = V4L2_CID_XILINX_TPG_CROSS_HAIR_COLUMN,
585 .name = "Test Pattern: Cross Hairs Column",
586 .type = V4L2_CTRL_TYPE_INTEGER,
587 .min = 0,
588 .max = (1 << 12) - 1,
589 .step = 1,
590 .def = 0x64,
591 .flags = V4L2_CTRL_FLAG_SLIDER,
592 }, {
593 .ops = &xtpg_ctrl_ops,
594 .id = V4L2_CID_XILINX_TPG_ZPLATE_HOR_START,
595 .name = "Test Pattern: Zplate Horizontal Start Pos",
596 .type = V4L2_CTRL_TYPE_INTEGER,
597 .min = 0,
598 .max = (1 << 16) - 1,
599 .step = 1,
600 .def = 0x1e,
601 .flags = V4L2_CTRL_FLAG_SLIDER,
602 }, {
603 .ops = &xtpg_ctrl_ops,
604 .id = V4L2_CID_XILINX_TPG_ZPLATE_HOR_SPEED,
605 .name = "Test Pattern: Zplate Horizontal Speed",
606 .type = V4L2_CTRL_TYPE_INTEGER,
607 .min = 0,
608 .max = (1 << 16) - 1,
609 .step = 1,
610 .def = 0,
611 .flags = V4L2_CTRL_FLAG_SLIDER,
612 }, {
613 .ops = &xtpg_ctrl_ops,
614 .id = V4L2_CID_XILINX_TPG_ZPLATE_VER_START,
615 .name = "Test Pattern: Zplate Vertical Start Pos",
616 .type = V4L2_CTRL_TYPE_INTEGER,
617 .min = 0,
618 .max = (1 << 16) - 1,
619 .step = 1,
620 .def = 1,
621 .flags = V4L2_CTRL_FLAG_SLIDER,
622 }, {
623 .ops = &xtpg_ctrl_ops,
624 .id = V4L2_CID_XILINX_TPG_ZPLATE_VER_SPEED,
625 .name = "Test Pattern: Zplate Vertical Speed",
626 .type = V4L2_CTRL_TYPE_INTEGER,
627 .min = 0,
628 .max = (1 << 16) - 1,
629 .step = 1,
630 .def = 0,
631 .flags = V4L2_CTRL_FLAG_SLIDER,
632 }, {
633 .ops = &xtpg_ctrl_ops,
634 .id = V4L2_CID_XILINX_TPG_BOX_SIZE,
635 .name = "Test Pattern: Box Size",
636 .type = V4L2_CTRL_TYPE_INTEGER,
637 .min = 0,
638 .max = (1 << 12) - 1,
639 .step = 1,
640 .def = 0x32,
641 .flags = V4L2_CTRL_FLAG_SLIDER,
642 }, {
643 .ops = &xtpg_ctrl_ops,
644 .id = V4L2_CID_XILINX_TPG_BOX_COLOR,
645 .name = "Test Pattern: Box Color(RGB)",
646 .type = V4L2_CTRL_TYPE_INTEGER,
647 .min = 0,
648 .max = (1 << 24) - 1,
649 .step = 1,
650 .def = 0,
651 }, {
652 .ops = &xtpg_ctrl_ops,
653 .id = V4L2_CID_XILINX_TPG_STUCK_PIXEL_THRESH,
654 .name = "Test Pattern: Stuck Pixel threshold",
655 .type = V4L2_CTRL_TYPE_INTEGER,
656 .min = 0,
657 .max = (1 << 16) - 1,
658 .step = 1,
659 .def = 0,
660 .flags = V4L2_CTRL_FLAG_SLIDER,
661 }, {
662 .ops = &xtpg_ctrl_ops,
663 .id = V4L2_CID_XILINX_TPG_NOISE_GAIN,
664 .name = "Test Pattern: Noise Gain",
665 .type = V4L2_CTRL_TYPE_INTEGER,
666 .min = 0,
667 .max = (1 << 8) - 1,
668 .step = 1,
669 .def = 0,
670 .flags = V4L2_CTRL_FLAG_SLIDER,
671 },
672 };
673
674 /* -----------------------------------------------------------------------------
675 * Media Operations
676 */
677
678 static const struct media_entity_operations xtpg_media_ops = {
679 .link_validate = v4l2_subdev_link_validate,
680 };
681
682 /* -----------------------------------------------------------------------------
683 * Power Management
684 */
685
686 static int __maybe_unused xtpg_pm_suspend(struct device *dev)
687 {
688 struct xtpg_device *xtpg = dev_get_drvdata(dev);
689
690 xvip_suspend(&xtpg->xvip);
691
692 return 0;
693 }
694
695 static int __maybe_unused xtpg_pm_resume(struct device *dev)
696 {
697 struct xtpg_device *xtpg = dev_get_drvdata(dev);
698
699 xvip_resume(&xtpg->xvip);
700
701 return 0;
702 }
703
704 /* -----------------------------------------------------------------------------
705 * Platform Device Driver
706 */
707
708 static int xtpg_parse_of(struct xtpg_device *xtpg)
709 {
710 struct device *dev = xtpg->xvip.dev;
711 struct device_node *node = xtpg->xvip.dev->of_node;
712 struct device_node *ports;
713 struct device_node *port;
714 unsigned int nports = 0;
715 bool has_endpoint = false;
716
717 ports = of_get_child_by_name(node, "ports");
718 if (ports == NULL)
719 ports = node;
720
721 for_each_child_of_node(ports, port) {
722 const struct xvip_video_format *format;
723 struct device_node *endpoint;
724
725 if (!of_node_name_eq(port, "port"))
726 continue;
727
728 format = xvip_of_get_format(port);
729 if (IS_ERR(format)) {
730 dev_err(dev, "invalid format in DT");
731 of_node_put(port);
732 return PTR_ERR(format);
733 }
734
735 /* Get and check the format description */
736 if (!xtpg->vip_format) {
737 xtpg->vip_format = format;
738 } else if (xtpg->vip_format != format) {
739 dev_err(dev, "in/out format mismatch in DT");
740 of_node_put(port);
741 return -EINVAL;
742 }
743
744 if (nports == 0) {
745 endpoint = of_get_next_child(port, NULL);
746 if (endpoint)
747 has_endpoint = true;
748 of_node_put(endpoint);
749 }
750
751 /* Count the number of ports. */
752 nports++;
753 }
754
755 if (nports != 1 && nports != 2) {
756 dev_err(dev, "invalid number of ports %u\n", nports);
757 return -EINVAL;
758 }
759
760 xtpg->npads = nports;
761 if (nports == 2 && has_endpoint)
762 xtpg->has_input = true;
763
764 return 0;
765 }
766
767 static int xtpg_probe(struct platform_device *pdev)
768 {
769 struct v4l2_subdev *subdev;
770 struct xtpg_device *xtpg;
771 u32 i, bayer_phase;
772 int ret;
773
774 xtpg = devm_kzalloc(&pdev->dev, sizeof(*xtpg), GFP_KERNEL);
775 if (!xtpg)
776 return -ENOMEM;
777
778 xtpg->xvip.dev = &pdev->dev;
779
780 ret = xtpg_parse_of(xtpg);
781 if (ret < 0)
782 return ret;
783
784 ret = xvip_init_resources(&xtpg->xvip);
785 if (ret < 0)
786 return ret;
787
788 xtpg->vtmux_gpio = devm_gpiod_get_optional(&pdev->dev, "timing",
789 GPIOD_OUT_HIGH);
790 if (IS_ERR(xtpg->vtmux_gpio)) {
791 ret = PTR_ERR(xtpg->vtmux_gpio);
792 goto error_resource;
793 }
794
795 xtpg->vtc = xvtc_of_get(pdev->dev.of_node);
796 if (IS_ERR(xtpg->vtc)) {
797 ret = PTR_ERR(xtpg->vtc);
798 goto error_resource;
799 }
800
801 /* Reset and initialize the core */
802 xvip_reset(&xtpg->xvip);
803
804 /* Initialize V4L2 subdevice and media entity. Pad numbers depend on the
805 * number of pads.
806 */
807 if (xtpg->npads == 2) {
808 xtpg->pads[0].flags = MEDIA_PAD_FL_SINK;
809 xtpg->pads[1].flags = MEDIA_PAD_FL_SOURCE;
810 } else {
811 xtpg->pads[0].flags = MEDIA_PAD_FL_SOURCE;
812 }
813
814 /* Initialize the default format */
815 xtpg->default_format.code = xtpg->vip_format->code;
816 xtpg->default_format.field = V4L2_FIELD_NONE;
817 xtpg->default_format.colorspace = V4L2_COLORSPACE_SRGB;
818 xvip_get_frame_size(&xtpg->xvip, &xtpg->default_format);
819
820 bayer_phase = xtpg_get_bayer_phase(xtpg->vip_format->code);
821 if (bayer_phase != XTPG_BAYER_PHASE_OFF)
822 xtpg->bayer = true;
823
824 xtpg->formats[0] = xtpg->default_format;
825 if (xtpg->npads == 2)
826 xtpg->formats[1] = xtpg->default_format;
827
828 /* Initialize V4L2 subdevice and media entity */
829 subdev = &xtpg->xvip.subdev;
830 v4l2_subdev_init(subdev, &xtpg_ops);
831 subdev->dev = &pdev->dev;
832 subdev->internal_ops = &xtpg_internal_ops;
833 strscpy(subdev->name, dev_name(&pdev->dev), sizeof(subdev->name));
834 v4l2_set_subdevdata(subdev, xtpg);
835 subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
836 subdev->entity.ops = &xtpg_media_ops;
837
838 ret = media_entity_pads_init(&subdev->entity, xtpg->npads, xtpg->pads);
839 if (ret < 0)
840 goto error;
841
842 v4l2_ctrl_handler_init(&xtpg->ctrl_handler, 3 + ARRAY_SIZE(xtpg_ctrls));
843
844 xtpg->vblank = v4l2_ctrl_new_std(&xtpg->ctrl_handler, &xtpg_ctrl_ops,
845 V4L2_CID_VBLANK, XTPG_MIN_VBLANK,
846 XTPG_MAX_VBLANK, 1, 100);
847 xtpg->hblank = v4l2_ctrl_new_std(&xtpg->ctrl_handler, &xtpg_ctrl_ops,
848 V4L2_CID_HBLANK, XTPG_MIN_HBLANK,
849 XTPG_MAX_HBLANK, 1, 100);
850 xtpg->pattern = v4l2_ctrl_new_std_menu_items(&xtpg->ctrl_handler,
851 &xtpg_ctrl_ops, V4L2_CID_TEST_PATTERN,
852 ARRAY_SIZE(xtpg_pattern_strings) - 1,
853 1, 9, xtpg_pattern_strings);
854
855 for (i = 0; i < ARRAY_SIZE(xtpg_ctrls); i++)
856 v4l2_ctrl_new_custom(&xtpg->ctrl_handler, &xtpg_ctrls[i], NULL);
857
858 if (xtpg->ctrl_handler.error) {
859 dev_err(&pdev->dev, "failed to add controls\n");
860 ret = xtpg->ctrl_handler.error;
861 goto error;
862 }
863 subdev->ctrl_handler = &xtpg->ctrl_handler;
864
865 xtpg_update_pattern_control(xtpg, true, true);
866
867 ret = v4l2_ctrl_handler_setup(&xtpg->ctrl_handler);
868 if (ret < 0) {
869 dev_err(&pdev->dev, "failed to set controls\n");
870 goto error;
871 }
872
873 platform_set_drvdata(pdev, xtpg);
874
875 xvip_print_version(&xtpg->xvip);
876
877 ret = v4l2_async_register_subdev(subdev);
878 if (ret < 0) {
879 dev_err(&pdev->dev, "failed to register subdev\n");
880 goto error;
881 }
882
883 return 0;
884
885 error:
886 v4l2_ctrl_handler_free(&xtpg->ctrl_handler);
887 media_entity_cleanup(&subdev->entity);
888 xvtc_put(xtpg->vtc);
889 error_resource:
890 xvip_cleanup_resources(&xtpg->xvip);
891 return ret;
892 }
893
894 static int xtpg_remove(struct platform_device *pdev)
895 {
896 struct xtpg_device *xtpg = platform_get_drvdata(pdev);
897 struct v4l2_subdev *subdev = &xtpg->xvip.subdev;
898
899 v4l2_async_unregister_subdev(subdev);
900 v4l2_ctrl_handler_free(&xtpg->ctrl_handler);
901 media_entity_cleanup(&subdev->entity);
902
903 xvip_cleanup_resources(&xtpg->xvip);
904
905 return 0;
906 }
907
908 static SIMPLE_DEV_PM_OPS(xtpg_pm_ops, xtpg_pm_suspend, xtpg_pm_resume);
909
910 static const struct of_device_id xtpg_of_id_table[] = {
911 { .compatible = "xlnx,v-tpg-5.0" },
912 { }
913 };
914 MODULE_DEVICE_TABLE(of, xtpg_of_id_table);
915
916 static struct platform_driver xtpg_driver = {
917 .driver = {
918 .name = "xilinx-tpg",
919 .pm = &xtpg_pm_ops,
920 .of_match_table = xtpg_of_id_table,
921 },
922 .probe = xtpg_probe,
923 .remove = xtpg_remove,
924 };
925
926 module_platform_driver(xtpg_driver);
927
928 MODULE_AUTHOR("Laurent Pinchart <laurent.pinchart@ideasonboard.com>");
929 MODULE_DESCRIPTION("Xilinx Test Pattern Generator Driver");
930 MODULE_LICENSE("GPL v2");
Linux with added FPC-III support