1 // SPDX-License-Identifier: GPL-2.0+
3 * Driver for Analog Devices ADV748X 8 channel analog front end (AFE) receiver
4 * with standard definition processor (SDP)
6 * Copyright (C) 2017 Renesas Electronics Corp.
9 #include <linux/delay.h>
10 #include <linux/module.h>
11 #include <linux/mutex.h>
12 #include <linux/v4l2-dv-timings.h>
14 #include <media/v4l2-ctrls.h>
15 #include <media/v4l2-device.h>
16 #include <media/v4l2-dv-timings.h>
17 #include <media/v4l2-ioctl.h>
21 /* -----------------------------------------------------------------------------
25 #define ADV748X_AFE_STD_AD_PAL_BG_NTSC_J_SECAM 0x0
26 #define ADV748X_AFE_STD_AD_PAL_BG_NTSC_J_SECAM_PED 0x1
27 #define ADV748X_AFE_STD_AD_PAL_N_NTSC_J_SECAM 0x2
28 #define ADV748X_AFE_STD_AD_PAL_N_NTSC_M_SECAM 0x3
29 #define ADV748X_AFE_STD_NTSC_J 0x4
30 #define ADV748X_AFE_STD_NTSC_M 0x5
31 #define ADV748X_AFE_STD_PAL60 0x6
32 #define ADV748X_AFE_STD_NTSC_443 0x7
33 #define ADV748X_AFE_STD_PAL_BG 0x8
34 #define ADV748X_AFE_STD_PAL_N 0x9
35 #define ADV748X_AFE_STD_PAL_M 0xa
36 #define ADV748X_AFE_STD_PAL_M_PED 0xb
37 #define ADV748X_AFE_STD_PAL_COMB_N 0xc
38 #define ADV748X_AFE_STD_PAL_COMB_N_PED 0xd
39 #define ADV748X_AFE_STD_PAL_SECAM 0xe
40 #define ADV748X_AFE_STD_PAL_SECAM_PED 0xf
42 static int adv748x_afe_read_ro_map(struct adv748x_state
*state
, u8 reg
)
46 /* Select SDP Read-Only Main Map */
47 ret
= sdp_write(state
, ADV748X_SDP_MAP_SEL
,
48 ADV748X_SDP_MAP_SEL_RO_MAIN
);
52 return sdp_read(state
, reg
);
55 static int adv748x_afe_status(struct adv748x_afe
*afe
, u32
*signal
,
58 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
61 /* Read status from reg 0x10 of SDP RO Map */
62 info
= adv748x_afe_read_ro_map(state
, ADV748X_SDP_RO_10
);
67 *signal
= info
& ADV748X_SDP_RO_10_IN_LOCK
?
68 0 : V4L2_IN_ST_NO_SIGNAL
;
73 /* Standard not valid if there is no signal */
74 if (!(info
& ADV748X_SDP_RO_10_IN_LOCK
)) {
75 *std
= V4L2_STD_UNKNOWN
;
79 switch (info
& 0x70) {
84 *std
= V4L2_STD_NTSC_443
;
87 *std
= V4L2_STD_PAL_M
;
90 *std
= V4L2_STD_PAL_60
;
96 *std
= V4L2_STD_SECAM
;
99 *std
= V4L2_STD_PAL_Nc
| V4L2_STD_PAL_N
;
102 *std
= V4L2_STD_SECAM
;
105 *std
= V4L2_STD_UNKNOWN
;
112 static void adv748x_afe_fill_format(struct adv748x_afe
*afe
,
113 struct v4l2_mbus_framefmt
*fmt
)
115 memset(fmt
, 0, sizeof(*fmt
));
117 fmt
->code
= MEDIA_BUS_FMT_UYVY8_2X8
;
118 fmt
->colorspace
= V4L2_COLORSPACE_SMPTE170M
;
119 fmt
->field
= V4L2_FIELD_ALTERNATE
;
122 fmt
->height
= afe
->curr_norm
& V4L2_STD_525_60
? 480 : 576;
128 static int adv748x_afe_std(v4l2_std_id std
)
130 if (std
== V4L2_STD_PAL_60
)
131 return ADV748X_AFE_STD_PAL60
;
132 if (std
== V4L2_STD_NTSC_443
)
133 return ADV748X_AFE_STD_NTSC_443
;
134 if (std
== V4L2_STD_PAL_N
)
135 return ADV748X_AFE_STD_PAL_N
;
136 if (std
== V4L2_STD_PAL_M
)
137 return ADV748X_AFE_STD_PAL_M
;
138 if (std
== V4L2_STD_PAL_Nc
)
139 return ADV748X_AFE_STD_PAL_COMB_N
;
140 if (std
& V4L2_STD_NTSC
)
141 return ADV748X_AFE_STD_NTSC_M
;
142 if (std
& V4L2_STD_PAL
)
143 return ADV748X_AFE_STD_PAL_BG
;
144 if (std
& V4L2_STD_SECAM
)
145 return ADV748X_AFE_STD_PAL_SECAM
;
150 static void adv748x_afe_set_video_standard(struct adv748x_state
*state
,
153 sdp_clrset(state
, ADV748X_SDP_VID_SEL
, ADV748X_SDP_VID_SEL_MASK
,
154 (sdpstd
& 0xf) << ADV748X_SDP_VID_SEL_SHIFT
);
157 static int adv748x_afe_s_input(struct adv748x_afe
*afe
, unsigned int input
)
159 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
161 return sdp_write(state
, ADV748X_SDP_INSEL
, input
);
164 static int adv748x_afe_g_pixelaspect(struct v4l2_subdev
*sd
,
165 struct v4l2_fract
*aspect
)
167 struct adv748x_afe
*afe
= adv748x_sd_to_afe(sd
);
169 if (afe
->curr_norm
& V4L2_STD_525_60
) {
170 aspect
->numerator
= 11;
171 aspect
->denominator
= 10;
173 aspect
->numerator
= 54;
174 aspect
->denominator
= 59;
180 /* -----------------------------------------------------------------------------
181 * v4l2_subdev_video_ops
184 static int adv748x_afe_g_std(struct v4l2_subdev
*sd
, v4l2_std_id
*norm
)
186 struct adv748x_afe
*afe
= adv748x_sd_to_afe(sd
);
188 *norm
= afe
->curr_norm
;
193 static int adv748x_afe_s_std(struct v4l2_subdev
*sd
, v4l2_std_id std
)
195 struct adv748x_afe
*afe
= adv748x_sd_to_afe(sd
);
196 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
197 int afe_std
= adv748x_afe_std(std
);
202 mutex_lock(&state
->mutex
);
204 adv748x_afe_set_video_standard(state
, afe_std
);
205 afe
->curr_norm
= std
;
207 mutex_unlock(&state
->mutex
);
212 static int adv748x_afe_querystd(struct v4l2_subdev
*sd
, v4l2_std_id
*std
)
214 struct adv748x_afe
*afe
= adv748x_sd_to_afe(sd
);
215 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
219 mutex_lock(&state
->mutex
);
221 if (afe
->streaming
) {
226 /* Set auto detect mode */
227 adv748x_afe_set_video_standard(state
,
228 ADV748X_AFE_STD_AD_PAL_BG_NTSC_J_SECAM
);
232 /* Read detected standard */
233 ret
= adv748x_afe_status(afe
, NULL
, std
);
235 afe_std
= adv748x_afe_std(afe
->curr_norm
);
239 /* Restore original state */
240 adv748x_afe_set_video_standard(state
, afe_std
);
243 mutex_unlock(&state
->mutex
);
248 static int adv748x_afe_g_tvnorms(struct v4l2_subdev
*sd
, v4l2_std_id
*norm
)
250 *norm
= V4L2_STD_ALL
;
255 static int adv748x_afe_g_input_status(struct v4l2_subdev
*sd
, u32
*status
)
257 struct adv748x_afe
*afe
= adv748x_sd_to_afe(sd
);
258 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
261 mutex_lock(&state
->mutex
);
263 ret
= adv748x_afe_status(afe
, status
, NULL
);
265 mutex_unlock(&state
->mutex
);
270 static int adv748x_afe_s_stream(struct v4l2_subdev
*sd
, int enable
)
272 struct adv748x_afe
*afe
= adv748x_sd_to_afe(sd
);
273 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
274 u32 signal
= V4L2_IN_ST_NO_SIGNAL
;
277 mutex_lock(&state
->mutex
);
280 ret
= adv748x_afe_s_input(afe
, afe
->input
);
285 ret
= adv748x_tx_power(afe
->tx
, enable
);
289 afe
->streaming
= enable
;
291 adv748x_afe_status(afe
, &signal
, NULL
);
292 if (signal
!= V4L2_IN_ST_NO_SIGNAL
)
293 adv_dbg(state
, "Detected SDP signal\n");
295 adv_dbg(state
, "Couldn't detect SDP video signal\n");
298 mutex_unlock(&state
->mutex
);
303 static const struct v4l2_subdev_video_ops adv748x_afe_video_ops
= {
304 .g_std
= adv748x_afe_g_std
,
305 .s_std
= adv748x_afe_s_std
,
306 .querystd
= adv748x_afe_querystd
,
307 .g_tvnorms
= adv748x_afe_g_tvnorms
,
308 .g_input_status
= adv748x_afe_g_input_status
,
309 .s_stream
= adv748x_afe_s_stream
,
310 .g_pixelaspect
= adv748x_afe_g_pixelaspect
,
313 /* -----------------------------------------------------------------------------
314 * v4l2_subdev_pad_ops
317 static int adv748x_afe_propagate_pixelrate(struct adv748x_afe
*afe
)
319 struct v4l2_subdev
*tx
;
321 tx
= adv748x_get_remote_sd(&afe
->pads
[ADV748X_AFE_SOURCE
]);
326 * The ADV748x ADC sampling frequency is twice the externally supplied
327 * clock whose frequency is required to be 28.63636 MHz. It oversamples
328 * with a factor of 4 resulting in a pixel rate of 14.3180180 MHz.
330 return adv748x_csi2_set_pixelrate(tx
, 14318180);
333 static int adv748x_afe_enum_mbus_code(struct v4l2_subdev
*sd
,
334 struct v4l2_subdev_pad_config
*cfg
,
335 struct v4l2_subdev_mbus_code_enum
*code
)
337 if (code
->index
!= 0)
340 code
->code
= MEDIA_BUS_FMT_UYVY8_2X8
;
345 static int adv748x_afe_get_format(struct v4l2_subdev
*sd
,
346 struct v4l2_subdev_pad_config
*cfg
,
347 struct v4l2_subdev_format
*sdformat
)
349 struct adv748x_afe
*afe
= adv748x_sd_to_afe(sd
);
350 struct v4l2_mbus_framefmt
*mbusformat
;
352 /* It makes no sense to get the format of the analog sink pads */
353 if (sdformat
->pad
!= ADV748X_AFE_SOURCE
)
356 if (sdformat
->which
== V4L2_SUBDEV_FORMAT_TRY
) {
357 mbusformat
= v4l2_subdev_get_try_format(sd
, cfg
, sdformat
->pad
);
358 sdformat
->format
= *mbusformat
;
360 adv748x_afe_fill_format(afe
, &sdformat
->format
);
361 adv748x_afe_propagate_pixelrate(afe
);
367 static int adv748x_afe_set_format(struct v4l2_subdev
*sd
,
368 struct v4l2_subdev_pad_config
*cfg
,
369 struct v4l2_subdev_format
*sdformat
)
371 struct v4l2_mbus_framefmt
*mbusformat
;
373 /* It makes no sense to get the format of the analog sink pads */
374 if (sdformat
->pad
!= ADV748X_AFE_SOURCE
)
377 if (sdformat
->which
== V4L2_SUBDEV_FORMAT_ACTIVE
)
378 return adv748x_afe_get_format(sd
, cfg
, sdformat
);
380 mbusformat
= v4l2_subdev_get_try_format(sd
, cfg
, sdformat
->pad
);
381 *mbusformat
= sdformat
->format
;
386 static const struct v4l2_subdev_pad_ops adv748x_afe_pad_ops
= {
387 .enum_mbus_code
= adv748x_afe_enum_mbus_code
,
388 .set_fmt
= adv748x_afe_set_format
,
389 .get_fmt
= adv748x_afe_get_format
,
392 /* -----------------------------------------------------------------------------
396 static const struct v4l2_subdev_ops adv748x_afe_ops
= {
397 .video
= &adv748x_afe_video_ops
,
398 .pad
= &adv748x_afe_pad_ops
,
401 /* -----------------------------------------------------------------------------
405 static const char * const afe_ctrl_frp_menu
[] = {
415 static int adv748x_afe_s_ctrl(struct v4l2_ctrl
*ctrl
)
417 struct adv748x_afe
*afe
= adv748x_ctrl_to_afe(ctrl
);
418 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
422 ret
= sdp_write(state
, 0x0e, 0x00);
427 case V4L2_CID_BRIGHTNESS
:
428 ret
= sdp_write(state
, ADV748X_SDP_BRI
, ctrl
->val
);
431 /* Hue is inverted according to HSL chart */
432 ret
= sdp_write(state
, ADV748X_SDP_HUE
, -ctrl
->val
);
434 case V4L2_CID_CONTRAST
:
435 ret
= sdp_write(state
, ADV748X_SDP_CON
, ctrl
->val
);
437 case V4L2_CID_SATURATION
:
438 ret
= sdp_write(state
, ADV748X_SDP_SD_SAT_U
, ctrl
->val
);
441 ret
= sdp_write(state
, ADV748X_SDP_SD_SAT_V
, ctrl
->val
);
443 case V4L2_CID_TEST_PATTERN
:
444 enable
= !!ctrl
->val
;
446 /* Enable/Disable Color bar test patterns */
447 ret
= sdp_clrset(state
, ADV748X_SDP_DEF
, ADV748X_SDP_DEF_VAL_EN
,
451 ret
= sdp_clrset(state
, ADV748X_SDP_FRP
, ADV748X_SDP_FRP_MASK
,
452 enable
? ctrl
->val
- 1 : 0);
461 static const struct v4l2_ctrl_ops adv748x_afe_ctrl_ops
= {
462 .s_ctrl
= adv748x_afe_s_ctrl
,
465 static int adv748x_afe_init_controls(struct adv748x_afe
*afe
)
467 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
469 v4l2_ctrl_handler_init(&afe
->ctrl_hdl
, 5);
471 /* Use our mutex for the controls */
472 afe
->ctrl_hdl
.lock
= &state
->mutex
;
474 v4l2_ctrl_new_std(&afe
->ctrl_hdl
, &adv748x_afe_ctrl_ops
,
475 V4L2_CID_BRIGHTNESS
, ADV748X_SDP_BRI_MIN
,
476 ADV748X_SDP_BRI_MAX
, 1, ADV748X_SDP_BRI_DEF
);
477 v4l2_ctrl_new_std(&afe
->ctrl_hdl
, &adv748x_afe_ctrl_ops
,
478 V4L2_CID_CONTRAST
, ADV748X_SDP_CON_MIN
,
479 ADV748X_SDP_CON_MAX
, 1, ADV748X_SDP_CON_DEF
);
480 v4l2_ctrl_new_std(&afe
->ctrl_hdl
, &adv748x_afe_ctrl_ops
,
481 V4L2_CID_SATURATION
, ADV748X_SDP_SAT_MIN
,
482 ADV748X_SDP_SAT_MAX
, 1, ADV748X_SDP_SAT_DEF
);
483 v4l2_ctrl_new_std(&afe
->ctrl_hdl
, &adv748x_afe_ctrl_ops
,
484 V4L2_CID_HUE
, ADV748X_SDP_HUE_MIN
,
485 ADV748X_SDP_HUE_MAX
, 1, ADV748X_SDP_HUE_DEF
);
487 v4l2_ctrl_new_std_menu_items(&afe
->ctrl_hdl
, &adv748x_afe_ctrl_ops
,
488 V4L2_CID_TEST_PATTERN
,
489 ARRAY_SIZE(afe_ctrl_frp_menu
) - 1,
490 0, 0, afe_ctrl_frp_menu
);
492 afe
->sd
.ctrl_handler
= &afe
->ctrl_hdl
;
493 if (afe
->ctrl_hdl
.error
) {
494 v4l2_ctrl_handler_free(&afe
->ctrl_hdl
);
495 return afe
->ctrl_hdl
.error
;
498 return v4l2_ctrl_handler_setup(&afe
->ctrl_hdl
);
501 int adv748x_afe_init(struct adv748x_afe
*afe
)
503 struct adv748x_state
*state
= adv748x_afe_to_state(afe
);
508 afe
->streaming
= false;
509 afe
->curr_norm
= V4L2_STD_NTSC_M
;
511 adv748x_subdev_init(&afe
->sd
, state
, &adv748x_afe_ops
,
512 MEDIA_ENT_F_ATV_DECODER
, "afe");
514 /* Identify the first connector found as a default input if set */
515 for (i
= ADV748X_PORT_AIN0
; i
<= ADV748X_PORT_AIN7
; i
++) {
516 /* Inputs and ports are 1-indexed to match the data sheet */
517 if (state
->endpoints
[i
]) {
523 adv748x_afe_s_input(afe
, afe
->input
);
525 adv_dbg(state
, "AFE Default input set to %d\n", afe
->input
);
527 /* Entity pads and sinks are 0-indexed to match the pads */
528 for (i
= ADV748X_AFE_SINK_AIN0
; i
<= ADV748X_AFE_SINK_AIN7
; i
++)
529 afe
->pads
[i
].flags
= MEDIA_PAD_FL_SINK
;
531 afe
->pads
[ADV748X_AFE_SOURCE
].flags
= MEDIA_PAD_FL_SOURCE
;
533 ret
= media_entity_pads_init(&afe
->sd
.entity
, ADV748X_AFE_NR_PADS
,
538 ret
= adv748x_afe_init_controls(afe
);
545 media_entity_cleanup(&afe
->sd
.entity
);
550 void adv748x_afe_cleanup(struct adv748x_afe
*afe
)
552 v4l2_device_unregister_subdev(&afe
->sd
);
553 media_entity_cleanup(&afe
->sd
.entity
);
554 v4l2_ctrl_handler_free(&afe
->ctrl_hdl
);