drivers/media/i2c/adv748x/adv748x-afe.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Driver for Analog Devices ADV748X 8 channel analog front end (AFE) receiver
   4  * with standard definition processor (SDP)
   5  *
   6  * Copyright (C) 2017 Renesas Electronics Corp.
   7  */
   8
   9 #include <linux/delay.h>
  10 #include <linux/module.h>
  11 #include <linux/mutex.h>
  12 #include <linux/v4l2-dv-timings.h>
  13
  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>
  18
  19 #include "adv748x.h"
  20
  21 /* -----------------------------------------------------------------------------
  22  * SDP
  23  */
  24
  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
  41
  42 static int adv748x_afe_read_ro_map(struct adv748x_state *state, u8 reg)
  43 {
  44         int ret;
  45
  46         /* Select SDP Read-Only Main Map */
  47         ret = sdp_write(state, ADV748X_SDP_MAP_SEL,
  48                         ADV748X_SDP_MAP_SEL_RO_MAIN);
  49         if (ret < 0)
  50                 return ret;
  51
  52         return sdp_read(state, reg);
  53 }
  54
  55 static int adv748x_afe_status(struct adv748x_afe *afe, u32 *signal,
  56                               v4l2_std_id *std)
  57 {
  58         struct adv748x_state *state = adv748x_afe_to_state(afe);
  59         int info;
  60
  61         /* Read status from reg 0x10 of SDP RO Map */
  62         info = adv748x_afe_read_ro_map(state, ADV748X_SDP_RO_10);
  63         if (info < 0)
  64                 return info;
  65
  66         if (signal)
  67                 *signal = info & ADV748X_SDP_RO_10_IN_LOCK ?
  68                                 0 : V4L2_IN_ST_NO_SIGNAL;
  69
  70         if (!std)
  71                 return 0;
  72
  73         /* Standard not valid if there is no signal */
  74         if (!(info & ADV748X_SDP_RO_10_IN_LOCK)) {
  75                 *std = V4L2_STD_UNKNOWN;
  76                 return 0;
  77         }
  78
  79         switch (info & 0x70) {
  80         case 0x00:
  81                 *std = V4L2_STD_NTSC;
  82                 break;
  83         case 0x10:
  84                 *std = V4L2_STD_NTSC_443;
  85                 break;
  86         case 0x20:
  87                 *std = V4L2_STD_PAL_M;
  88                 break;
  89         case 0x30:
  90                 *std = V4L2_STD_PAL_60;
  91                 break;
  92         case 0x40:
  93                 *std = V4L2_STD_PAL;
  94                 break;
  95         case 0x50:
  96                 *std = V4L2_STD_SECAM;
  97                 break;
  98         case 0x60:
  99                 *std = V4L2_STD_PAL_Nc | V4L2_STD_PAL_N;
 100                 break;
 101         case 0x70:
 102                 *std = V4L2_STD_SECAM;
 103                 break;
 104         default:
 105                 *std = V4L2_STD_UNKNOWN;
 106                 break;
 107         }
 108
 109         return 0;
 110 }
 111
 112 static void adv748x_afe_fill_format(struct adv748x_afe *afe,
 113                                     struct v4l2_mbus_framefmt *fmt)
 114 {
 115         memset(fmt, 0, sizeof(*fmt));
 116
 117         fmt->code = MEDIA_BUS_FMT_UYVY8_1X16;
 118         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 119         fmt->field = V4L2_FIELD_ALTERNATE;
 120
 121         fmt->width = 720;
 122         fmt->height = afe->curr_norm & V4L2_STD_525_60 ? 480 : 576;
 123
 124         /* Field height */
 125         fmt->height /= 2;
 126 }
 127
 128 static int adv748x_afe_std(v4l2_std_id std)
 129 {
 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;
 146
 147         return -EINVAL;
 148 }
 149
 150 static void adv748x_afe_set_video_standard(struct adv748x_state *state,
 151                                           int sdpstd)
 152 {
 153         sdp_clrset(state, ADV748X_SDP_VID_SEL, ADV748X_SDP_VID_SEL_MASK,
 154                    (sdpstd & 0xf) << ADV748X_SDP_VID_SEL_SHIFT);
 155 }
 156
 157 int adv748x_afe_s_input(struct adv748x_afe *afe, unsigned int input)
 158 {
 159         struct adv748x_state *state = adv748x_afe_to_state(afe);
 160
 161         return sdp_write(state, ADV748X_SDP_INSEL, input);
 162 }
 163
 164 static int adv748x_afe_g_pixelaspect(struct v4l2_subdev *sd,
 165                                      struct v4l2_fract *aspect)
 166 {
 167         struct adv748x_afe *afe = adv748x_sd_to_afe(sd);
 168
 169         if (afe->curr_norm & V4L2_STD_525_60) {
 170                 aspect->numerator = 11;
 171                 aspect->denominator = 10;
 172         } else {
 173                 aspect->numerator = 54;
 174                 aspect->denominator = 59;
 175         }
 176
 177         return 0;
 178 }
 179
 180 /* -----------------------------------------------------------------------------
 181  * v4l2_subdev_video_ops
 182  */
 183
 184 static int adv748x_afe_g_std(struct v4l2_subdev *sd, v4l2_std_id *norm)
 185 {
 186         struct adv748x_afe *afe = adv748x_sd_to_afe(sd);
 187
 188         *norm = afe->curr_norm;
 189
 190         return 0;
 191 }
 192
 193 static int adv748x_afe_s_std(struct v4l2_subdev *sd, v4l2_std_id std)
 194 {
 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);
 198
 199         if (afe_std < 0)
 200                 return afe_std;
 201
 202         mutex_lock(&state->mutex);
 203
 204         adv748x_afe_set_video_standard(state, afe_std);
 205         afe->curr_norm = std;
 206
 207         mutex_unlock(&state->mutex);
 208
 209         return 0;
 210 }
 211
 212 static int adv748x_afe_querystd(struct v4l2_subdev *sd, v4l2_std_id *std)
 213 {
 214         struct adv748x_afe *afe = adv748x_sd_to_afe(sd);
 215         struct adv748x_state *state = adv748x_afe_to_state(afe);
 216         int afe_std;
 217         int ret;
 218
 219         mutex_lock(&state->mutex);
 220
 221         if (afe->streaming) {
 222                 ret = -EBUSY;
 223                 goto unlock;
 224         }
 225
 226         /* Set auto detect mode */
 227         adv748x_afe_set_video_standard(state,
 228                                        ADV748X_AFE_STD_AD_PAL_BG_NTSC_J_SECAM);
 229
 230         msleep(100);
 231
 232         /* Read detected standard */
 233         ret = adv748x_afe_status(afe, NULL, std);
 234
 235         afe_std = adv748x_afe_std(afe->curr_norm);
 236         if (afe_std < 0)
 237                 goto unlock;
 238
 239         /* Restore original state */
 240         adv748x_afe_set_video_standard(state, afe_std);
 241
 242 unlock:
 243         mutex_unlock(&state->mutex);
 244
 245         return ret;
 246 }
 247
 248 static int adv748x_afe_g_tvnorms(struct v4l2_subdev *sd, v4l2_std_id *norm)
 249 {
 250         *norm = V4L2_STD_ALL;
 251
 252         return 0;
 253 }
 254
 255 static int adv748x_afe_g_input_status(struct v4l2_subdev *sd, u32 *status)
 256 {
 257         struct adv748x_afe *afe = adv748x_sd_to_afe(sd);
 258         struct adv748x_state *state = adv748x_afe_to_state(afe);
 259         int ret;
 260
 261         mutex_lock(&state->mutex);
 262
 263         ret = adv748x_afe_status(afe, status, NULL);
 264
 265         mutex_unlock(&state->mutex);
 266
 267         return ret;
 268 }
 269
 270 static int adv748x_afe_s_stream(struct v4l2_subdev *sd, int enable)
 271 {
 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;
 275         int ret;
 276
 277         mutex_lock(&state->mutex);
 278
 279         if (enable) {
 280                 ret = adv748x_afe_s_input(afe, afe->input);
 281                 if (ret)
 282                         goto unlock;
 283         }
 284
 285         ret = adv748x_tx_power(afe->tx, enable);
 286         if (ret)
 287                 goto unlock;
 288
 289         afe->streaming = enable;
 290
 291         adv748x_afe_status(afe, &signal, NULL);
 292         if (signal != V4L2_IN_ST_NO_SIGNAL)
 293                 adv_dbg(state, "Detected SDP signal\n");
 294         else
 295                 adv_dbg(state, "Couldn't detect SDP video signal\n");
 296
 297 unlock:
 298         mutex_unlock(&state->mutex);
 299
 300         return ret;
 301 }
 302
 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,
 311 };
 312
 313 /* -----------------------------------------------------------------------------
 314  * v4l2_subdev_pad_ops
 315  */
 316
 317 static int adv748x_afe_propagate_pixelrate(struct adv748x_afe *afe)
 318 {
 319         struct v4l2_subdev *tx;
 320
 321         tx = adv748x_get_remote_sd(&afe->pads[ADV748X_AFE_SOURCE]);
 322         if (!tx)
 323                 return -ENOLINK;
 324
 325         /*
 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.
 329          */
 330         return adv748x_csi2_set_pixelrate(tx, 14318180);
 331 }
 332
 333 static int adv748x_afe_enum_mbus_code(struct v4l2_subdev *sd,
 334                                       struct v4l2_subdev_state *sd_state,
 335                                       struct v4l2_subdev_mbus_code_enum *code)
 336 {
 337         if (code->index != 0)
 338                 return -EINVAL;
 339
 340         code->code = MEDIA_BUS_FMT_UYVY8_1X16;
 341
 342         return 0;
 343 }
 344
 345 static int adv748x_afe_get_format(struct v4l2_subdev *sd,
 346                                       struct v4l2_subdev_state *sd_state,
 347                                       struct v4l2_subdev_format *sdformat)
 348 {
 349         struct adv748x_afe *afe = adv748x_sd_to_afe(sd);
 350         struct v4l2_mbus_framefmt *mbusformat;
 351
 352         /* It makes no sense to get the format of the analog sink pads */
 353         if (sdformat->pad != ADV748X_AFE_SOURCE)
 354                 return -EINVAL;
 355
 356         if (sdformat->which == V4L2_SUBDEV_FORMAT_TRY) {
 357                 mbusformat = v4l2_subdev_state_get_format(sd_state,
 358                                                           sdformat->pad);
 359                 sdformat->format = *mbusformat;
 360         } else {
 361                 adv748x_afe_fill_format(afe, &sdformat->format);
 362                 adv748x_afe_propagate_pixelrate(afe);
 363         }
 364
 365         return 0;
 366 }
 367
 368 static int adv748x_afe_set_format(struct v4l2_subdev *sd,
 369                                       struct v4l2_subdev_state *sd_state,
 370                                       struct v4l2_subdev_format *sdformat)
 371 {
 372         struct v4l2_mbus_framefmt *mbusformat;
 373
 374         /* It makes no sense to get the format of the analog sink pads */
 375         if (sdformat->pad != ADV748X_AFE_SOURCE)
 376                 return -EINVAL;
 377
 378         if (sdformat->which == V4L2_SUBDEV_FORMAT_ACTIVE)
 379                 return adv748x_afe_get_format(sd, sd_state, sdformat);
 380
 381         mbusformat = v4l2_subdev_state_get_format(sd_state, sdformat->pad);
 382         *mbusformat = sdformat->format;
 383
 384         return 0;
 385 }
 386
 387 static const struct v4l2_subdev_pad_ops adv748x_afe_pad_ops = {
 388         .enum_mbus_code = adv748x_afe_enum_mbus_code,
 389         .set_fmt = adv748x_afe_set_format,
 390         .get_fmt = adv748x_afe_get_format,
 391 };
 392
 393 /* -----------------------------------------------------------------------------
 394  * v4l2_subdev_ops
 395  */
 396
 397 static const struct v4l2_subdev_ops adv748x_afe_ops = {
 398         .video = &adv748x_afe_video_ops,
 399         .pad = &adv748x_afe_pad_ops,
 400 };
 401
 402 /* -----------------------------------------------------------------------------
 403  * Controls
 404  */
 405
 406 static const char * const afe_ctrl_frp_menu[] = {
 407         "Disabled",
 408         "Solid Blue",
 409         "Color Bars",
 410         "Grey Ramp",
 411         "Cb Ramp",
 412         "Cr Ramp",
 413         "Boundary"
 414 };
 415
 416 static int adv748x_afe_s_ctrl(struct v4l2_ctrl *ctrl)
 417 {
 418         struct adv748x_afe *afe = adv748x_ctrl_to_afe(ctrl);
 419         struct adv748x_state *state = adv748x_afe_to_state(afe);
 420         bool enable;
 421         int ret;
 422
 423         ret = sdp_write(state, 0x0e, 0x00);
 424         if (ret < 0)
 425                 return ret;
 426
 427         switch (ctrl->id) {
 428         case V4L2_CID_BRIGHTNESS:
 429                 ret = sdp_write(state, ADV748X_SDP_BRI, ctrl->val);
 430                 break;
 431         case V4L2_CID_HUE:
 432                 /* Hue is inverted according to HSL chart */
 433                 ret = sdp_write(state, ADV748X_SDP_HUE, -ctrl->val);
 434                 break;
 435         case V4L2_CID_CONTRAST:
 436                 ret = sdp_write(state, ADV748X_SDP_CON, ctrl->val);
 437                 break;
 438         case V4L2_CID_SATURATION:
 439                 ret = sdp_write(state, ADV748X_SDP_SD_SAT_U, ctrl->val);
 440                 if (ret)
 441                         break;
 442                 ret = sdp_write(state, ADV748X_SDP_SD_SAT_V, ctrl->val);
 443                 break;
 444         case V4L2_CID_TEST_PATTERN:
 445                 enable = !!ctrl->val;
 446
 447                 /* Enable/Disable Color bar test patterns */
 448                 ret = sdp_clrset(state, ADV748X_SDP_DEF, ADV748X_SDP_DEF_VAL_EN,
 449                                 enable);
 450                 if (ret)
 451                         break;
 452                 ret = sdp_clrset(state, ADV748X_SDP_FRP, ADV748X_SDP_FRP_MASK,
 453                                 enable ? ctrl->val - 1 : 0);
 454                 break;
 455         default:
 456                 return -EINVAL;
 457         }
 458
 459         return ret;
 460 }
 461
 462 static const struct v4l2_ctrl_ops adv748x_afe_ctrl_ops = {
 463         .s_ctrl = adv748x_afe_s_ctrl,
 464 };
 465
 466 static int adv748x_afe_init_controls(struct adv748x_afe *afe)
 467 {
 468         struct adv748x_state *state = adv748x_afe_to_state(afe);
 469
 470         v4l2_ctrl_handler_init(&afe->ctrl_hdl, 5);
 471
 472         /* Use our mutex for the controls */
 473         afe->ctrl_hdl.lock = &state->mutex;
 474
 475         v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,
 476                           V4L2_CID_BRIGHTNESS, ADV748X_SDP_BRI_MIN,
 477                           ADV748X_SDP_BRI_MAX, 1, ADV748X_SDP_BRI_DEF);
 478         v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,
 479                           V4L2_CID_CONTRAST, ADV748X_SDP_CON_MIN,
 480                           ADV748X_SDP_CON_MAX, 1, ADV748X_SDP_CON_DEF);
 481         v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,
 482                           V4L2_CID_SATURATION, ADV748X_SDP_SAT_MIN,
 483                           ADV748X_SDP_SAT_MAX, 1, ADV748X_SDP_SAT_DEF);
 484         v4l2_ctrl_new_std(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,
 485                           V4L2_CID_HUE, ADV748X_SDP_HUE_MIN,
 486                           ADV748X_SDP_HUE_MAX, 1, ADV748X_SDP_HUE_DEF);
 487
 488         v4l2_ctrl_new_std_menu_items(&afe->ctrl_hdl, &adv748x_afe_ctrl_ops,
 489                                      V4L2_CID_TEST_PATTERN,
 490                                      ARRAY_SIZE(afe_ctrl_frp_menu) - 1,
 491                                      0, 0, afe_ctrl_frp_menu);
 492
 493         afe->sd.ctrl_handler = &afe->ctrl_hdl;
 494         if (afe->ctrl_hdl.error) {
 495                 v4l2_ctrl_handler_free(&afe->ctrl_hdl);
 496                 return afe->ctrl_hdl.error;
 497         }
 498
 499         return v4l2_ctrl_handler_setup(&afe->ctrl_hdl);
 500 }
 501
 502 int adv748x_afe_init(struct adv748x_afe *afe)
 503 {
 504         struct adv748x_state *state = adv748x_afe_to_state(afe);
 505         int ret;
 506         unsigned int i;
 507
 508         afe->input = 0;
 509         afe->streaming = false;
 510         afe->curr_norm = V4L2_STD_NTSC_M;
 511
 512         adv748x_subdev_init(&afe->sd, state, &adv748x_afe_ops,
 513                             MEDIA_ENT_F_ATV_DECODER, "afe");
 514
 515         /* Identify the first connector found as a default input if set */
 516         for (i = ADV748X_PORT_AIN0; i <= ADV748X_PORT_AIN7; i++) {
 517                 /* Inputs and ports are 1-indexed to match the data sheet */
 518                 if (state->endpoints[i]) {
 519                         afe->input = i;
 520                         break;
 521                 }
 522         }
 523
 524         adv748x_afe_s_input(afe, afe->input);
 525
 526         adv_dbg(state, "AFE Default input set to %d\n", afe->input);
 527
 528         /* Entity pads and sinks are 0-indexed to match the pads */
 529         for (i = ADV748X_AFE_SINK_AIN0; i <= ADV748X_AFE_SINK_AIN7; i++)
 530                 afe->pads[i].flags = MEDIA_PAD_FL_SINK;
 531
 532         afe->pads[ADV748X_AFE_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
 533
 534         ret = media_entity_pads_init(&afe->sd.entity, ADV748X_AFE_NR_PADS,
 535                         afe->pads);
 536         if (ret)
 537                 return ret;
 538
 539         ret = adv748x_afe_init_controls(afe);
 540         if (ret)
 541                 goto error;
 542
 543         return 0;
 544
 545 error:
 546         media_entity_cleanup(&afe->sd.entity);
 547
 548         return ret;
 549 }
 550
 551 void adv748x_afe_cleanup(struct adv748x_afe *afe)
 552 {
 553         v4l2_device_unregister_subdev(&afe->sd);
 554         media_entity_cleanup(&afe->sd.entity);
 555         v4l2_ctrl_handler_free(&afe->ctrl_hdl);
 556 }