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

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Driver for Analog Devices ADV748X CSI-2 Transmitter
   4  *
   5  * Copyright (C) 2017 Renesas Electronics Corp.
   6  */
   7
   8 #include <linux/module.h>
   9
  10 #include <media/v4l2-ctrls.h>
  11 #include <media/v4l2-device.h>
  12 #include <media/v4l2-ioctl.h>
  13
  14 #include "adv748x.h"
  15
  16 static const unsigned int adv748x_csi2_txa_fmts[] = {
  17         MEDIA_BUS_FMT_UYVY8_1X16,
  18         MEDIA_BUS_FMT_RGB888_1X24,
  19 };
  20
  21 static const unsigned int adv748x_csi2_txb_fmts[] = {
  22         MEDIA_BUS_FMT_UYVY8_1X16,
  23 };
  24
  25 int adv748x_csi2_set_virtual_channel(struct adv748x_csi2 *tx, unsigned int vc)
  26 {
  27         return tx_write(tx, ADV748X_CSI_VC_REF, vc << ADV748X_CSI_VC_REF_SHIFT);
  28 }
  29
  30 /**
  31  * adv748x_csi2_register_link : Register and link internal entities
  32  *
  33  * @tx: CSI2 private entity
  34  * @v4l2_dev: Video registration device
  35  * @src: Source subdevice to establish link
  36  * @src_pad: Pad number of source to link to this @tx
  37  * @enable: Link enabled flag
  38  *
  39  * Ensure that the subdevice is registered against the v4l2_device, and link the
  40  * source pad to the sink pad of the CSI2 bus entity.
  41  */
  42 static int adv748x_csi2_register_link(struct adv748x_csi2 *tx,
  43                                       struct v4l2_device *v4l2_dev,
  44                                       struct v4l2_subdev *src,
  45                                       unsigned int src_pad,
  46                                       bool enable)
  47 {
  48         int ret;
  49
  50         if (!src->v4l2_dev) {
  51                 ret = v4l2_device_register_subdev(v4l2_dev, src);
  52                 if (ret)
  53                         return ret;
  54         }
  55
  56         ret = media_create_pad_link(&src->entity, src_pad,
  57                                     &tx->sd.entity, ADV748X_CSI2_SINK,
  58                                     enable ? MEDIA_LNK_FL_ENABLED : 0);
  59         if (ret)
  60                 return ret;
  61
  62         if (enable)
  63                 tx->src = src;
  64
  65         return 0;
  66 }
  67
  68 /* -----------------------------------------------------------------------------
  69  * v4l2_subdev_internal_ops
  70  */
  71
  72 static int adv748x_csi2_init_state(struct v4l2_subdev *sd,
  73                                    struct v4l2_subdev_state *state)
  74 {
  75         static const struct v4l2_mbus_framefmt adv748x_csi2_default_fmt = {
  76                 .width          = 1280,
  77                 .height         = 720,
  78                 .code           = MEDIA_BUS_FMT_UYVY8_1X16,
  79                 .colorspace     = V4L2_COLORSPACE_SRGB,
  80                 .field          = V4L2_FIELD_NONE,
  81                 .ycbcr_enc      = V4L2_YCBCR_ENC_DEFAULT,
  82                 .quantization   = V4L2_QUANTIZATION_DEFAULT,
  83                 .xfer_func      = V4L2_XFER_FUNC_DEFAULT,
  84         };
  85         struct v4l2_mbus_framefmt *fmt;
  86
  87         fmt = v4l2_subdev_state_get_format(state, ADV748X_CSI2_SINK);
  88         *fmt = adv748x_csi2_default_fmt;
  89
  90         fmt = v4l2_subdev_state_get_format(state, ADV748X_CSI2_SOURCE);
  91         *fmt = adv748x_csi2_default_fmt;
  92
  93         return 0;
  94 }
  95
  96 /*
  97  * We use the internal registered operation to be able to ensure that our
  98  * incremental subdevices (not connected in the forward path) can be registered
  99  * against the resulting video path and media device.
 100  */
 101
 102 static int adv748x_csi2_registered(struct v4l2_subdev *sd)
 103 {
 104         struct adv748x_csi2 *tx = adv748x_sd_to_csi2(sd);
 105         struct adv748x_state *state = tx->state;
 106         int ret;
 107
 108         adv_dbg(state, "Registered %s (%s)", is_txa(tx) ? "TXA":"TXB",
 109                         sd->name);
 110
 111         /*
 112          * Link TXA to AFE and HDMI, and TXB to AFE only as TXB cannot output
 113          * HDMI.
 114          *
 115          * The HDMI->TXA link is enabled by default, as is the AFE->TXB one.
 116          */
 117         if (is_afe_enabled(state)) {
 118                 ret = adv748x_csi2_register_link(tx, sd->v4l2_dev,
 119                                                  &state->afe.sd,
 120                                                  ADV748X_AFE_SOURCE,
 121                                                  is_txb(tx));
 122                 if (ret)
 123                         return ret;
 124
 125                 /* TXB can output AFE signals only. */
 126                 if (is_txb(tx))
 127                         state->afe.tx = tx;
 128         }
 129
 130         /* Register link to HDMI for TXA only. */
 131         if (is_txb(tx) || !is_hdmi_enabled(state))
 132                 return 0;
 133
 134         ret = adv748x_csi2_register_link(tx, sd->v4l2_dev, &state->hdmi.sd,
 135                                          ADV748X_HDMI_SOURCE, true);
 136         if (ret)
 137                 return ret;
 138
 139         /* The default HDMI output is TXA. */
 140         state->hdmi.tx = tx;
 141
 142         return 0;
 143 }
 144
 145 static const struct v4l2_subdev_internal_ops adv748x_csi2_internal_ops = {
 146         .init_state = adv748x_csi2_init_state,
 147         .registered = adv748x_csi2_registered,
 148 };
 149
 150 /* -----------------------------------------------------------------------------
 151  * v4l2_subdev_video_ops
 152  */
 153
 154 static int adv748x_csi2_s_stream(struct v4l2_subdev *sd, int enable)
 155 {
 156         struct adv748x_csi2 *tx = adv748x_sd_to_csi2(sd);
 157         struct v4l2_subdev *src;
 158
 159         src = adv748x_get_remote_sd(&tx->pads[ADV748X_CSI2_SINK]);
 160         if (!src)
 161                 return -EPIPE;
 162
 163         return v4l2_subdev_call(src, video, s_stream, enable);
 164 }
 165
 166 static const struct v4l2_subdev_video_ops adv748x_csi2_video_ops = {
 167         .s_stream = adv748x_csi2_s_stream,
 168 };
 169
 170 /* -----------------------------------------------------------------------------
 171  * v4l2_subdev_pad_ops
 172  *
 173  * The CSI2 bus pads are ignorant to the data sizes or formats.
 174  * But we must support setting the pad formats for format propagation.
 175  */
 176
 177 static int adv748x_csi2_enum_mbus_code(struct v4l2_subdev *sd,
 178                                        struct v4l2_subdev_state *sd_state,
 179                                        struct v4l2_subdev_mbus_code_enum *code)
 180 {
 181         struct adv748x_csi2 *tx = adv748x_sd_to_csi2(sd);
 182         const unsigned int *codes = is_txa(tx) ?
 183                                     adv748x_csi2_txa_fmts :
 184                                     adv748x_csi2_txb_fmts;
 185         size_t num_fmts = is_txa(tx) ? ARRAY_SIZE(adv748x_csi2_txa_fmts)
 186                                      : ARRAY_SIZE(adv748x_csi2_txb_fmts);
 187
 188         /*
 189          * The format available on the source pad is the one applied on the sink
 190          * pad.
 191          */
 192         if (code->pad == ADV748X_CSI2_SOURCE) {
 193                 struct v4l2_mbus_framefmt *fmt;
 194
 195                 if (code->index)
 196                         return -EINVAL;
 197
 198                 fmt = v4l2_subdev_state_get_format(sd_state, ADV748X_CSI2_SINK);
 199                 code->code = fmt->code;
 200
 201                 return 0;
 202         }
 203
 204         if (code->index >= num_fmts)
 205                 return -EINVAL;
 206
 207         code->code = codes[code->index];
 208
 209         return 0;
 210 }
 211
 212 static bool adv748x_csi2_is_fmt_supported(struct adv748x_csi2 *tx, u32 code)
 213 {
 214         const unsigned int *codes = is_txa(tx) ?
 215                                     adv748x_csi2_txa_fmts :
 216                                     adv748x_csi2_txb_fmts;
 217         size_t num_fmts = is_txa(tx) ? ARRAY_SIZE(adv748x_csi2_txa_fmts)
 218                                      : ARRAY_SIZE(adv748x_csi2_txb_fmts);
 219
 220         for (unsigned int i = 0; i < num_fmts; i++) {
 221                 if (codes[i] == code)
 222                         return true;
 223         }
 224
 225         return false;
 226 }
 227
 228 static int adv748x_csi2_set_format(struct v4l2_subdev *sd,
 229                                    struct v4l2_subdev_state *sd_state,
 230                                    struct v4l2_subdev_format *sdformat)
 231 {
 232         struct adv748x_csi2 *tx = adv748x_sd_to_csi2(sd);
 233         struct v4l2_mbus_framefmt *mbusformat;
 234
 235         if (sdformat->pad == ADV748X_CSI2_SOURCE)
 236                 return v4l2_subdev_get_fmt(sd, sd_state, sdformat);
 237
 238         /*
 239          * Make sure the format is supported, if not default it to
 240          * UYVY8 as it's supported by both TXes.
 241          */
 242         if (!adv748x_csi2_is_fmt_supported(tx, sdformat->format.code))
 243                 sdformat->format.code = MEDIA_BUS_FMT_UYVY8_1X16;
 244
 245         mbusformat = v4l2_subdev_state_get_format(sd_state, sdformat->pad);
 246         *mbusformat = sdformat->format;
 247
 248         /* Propagate format to the source pad. */
 249         mbusformat = v4l2_subdev_state_get_format(sd_state, ADV748X_CSI2_SOURCE);
 250         *mbusformat = sdformat->format;
 251
 252         return 0;
 253 }
 254
 255 static int adv748x_csi2_get_mbus_config(struct v4l2_subdev *sd, unsigned int pad,
 256                                         struct v4l2_mbus_config *config)
 257 {
 258         struct adv748x_csi2 *tx = adv748x_sd_to_csi2(sd);
 259
 260         if (pad != ADV748X_CSI2_SOURCE)
 261                 return -EINVAL;
 262
 263         config->type = V4L2_MBUS_CSI2_DPHY;
 264         config->bus.mipi_csi2.num_data_lanes = tx->active_lanes;
 265
 266         return 0;
 267 }
 268
 269 static const struct v4l2_subdev_pad_ops adv748x_csi2_pad_ops = {
 270         .enum_mbus_code = adv748x_csi2_enum_mbus_code,
 271         .get_fmt = v4l2_subdev_get_fmt,
 272         .set_fmt = adv748x_csi2_set_format,
 273         .get_mbus_config = adv748x_csi2_get_mbus_config,
 274 };
 275
 276 /* -----------------------------------------------------------------------------
 277  * v4l2_subdev_ops
 278  */
 279
 280 static const struct v4l2_subdev_ops adv748x_csi2_ops = {
 281         .video = &adv748x_csi2_video_ops,
 282         .pad = &adv748x_csi2_pad_ops,
 283 };
 284
 285 /* -----------------------------------------------------------------------------
 286  * Subdev module and controls
 287  */
 288
 289 int adv748x_csi2_set_pixelrate(struct v4l2_subdev *sd, s64 rate)
 290 {
 291         struct adv748x_csi2 *tx = adv748x_sd_to_csi2(sd);
 292
 293         if (!tx->pixel_rate)
 294                 return -EINVAL;
 295
 296         return v4l2_ctrl_s_ctrl_int64(tx->pixel_rate, rate);
 297 }
 298
 299 static int adv748x_csi2_s_ctrl(struct v4l2_ctrl *ctrl)
 300 {
 301         switch (ctrl->id) {
 302         case V4L2_CID_PIXEL_RATE:
 303                 return 0;
 304         default:
 305                 return -EINVAL;
 306         }
 307 }
 308
 309 static const struct v4l2_ctrl_ops adv748x_csi2_ctrl_ops = {
 310         .s_ctrl = adv748x_csi2_s_ctrl,
 311 };
 312
 313 static int adv748x_csi2_init_controls(struct adv748x_csi2 *tx)
 314 {
 315
 316         v4l2_ctrl_handler_init(&tx->ctrl_hdl, 1);
 317
 318         tx->pixel_rate = v4l2_ctrl_new_std(&tx->ctrl_hdl,
 319                                            &adv748x_csi2_ctrl_ops,
 320                                            V4L2_CID_PIXEL_RATE, 1, INT_MAX,
 321                                            1, 1);
 322
 323         tx->sd.ctrl_handler = &tx->ctrl_hdl;
 324         if (tx->ctrl_hdl.error) {
 325                 v4l2_ctrl_handler_free(&tx->ctrl_hdl);
 326                 return tx->ctrl_hdl.error;
 327         }
 328
 329         return v4l2_ctrl_handler_setup(&tx->ctrl_hdl);
 330 }
 331
 332 int adv748x_csi2_init(struct adv748x_state *state, struct adv748x_csi2 *tx)
 333 {
 334         int ret;
 335
 336         if (!is_tx_enabled(tx))
 337                 return 0;
 338
 339         adv748x_subdev_init(&tx->sd, state, &adv748x_csi2_ops,
 340                             MEDIA_ENT_F_VID_IF_BRIDGE,
 341                             is_txa(tx) ? "txa" : "txb");
 342
 343         /* Register internal ops for incremental subdev registration */
 344         tx->sd.internal_ops = &adv748x_csi2_internal_ops;
 345
 346         tx->pads[ADV748X_CSI2_SINK].flags = MEDIA_PAD_FL_SINK;
 347         tx->pads[ADV748X_CSI2_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
 348
 349         ret = media_entity_pads_init(&tx->sd.entity, ADV748X_CSI2_NR_PADS,
 350                                      tx->pads);
 351         if (ret)
 352                 return ret;
 353
 354         ret = v4l2_async_subdev_endpoint_add(&tx->sd,
 355                                              of_fwnode_handle(state->endpoints[tx->port]));
 356         if (ret)
 357                 goto err_free_media;
 358
 359         ret = adv748x_csi2_init_controls(tx);
 360         if (ret)
 361                 goto err_cleanup_subdev;
 362
 363         tx->sd.state_lock = &state->mutex;
 364         ret = v4l2_subdev_init_finalize(&tx->sd);
 365         if (ret)
 366                 goto err_free_ctrl;
 367
 368         ret = v4l2_async_register_subdev(&tx->sd);
 369         if (ret)
 370                 goto err_free_ctrl;
 371
 372         return 0;
 373
 374 err_free_ctrl:
 375         v4l2_ctrl_handler_free(&tx->ctrl_hdl);
 376 err_cleanup_subdev:
 377         v4l2_subdev_cleanup(&tx->sd);
 378 err_free_media:
 379         media_entity_cleanup(&tx->sd.entity);
 380
 381         return ret;
 382 }
 383
 384 void adv748x_csi2_cleanup(struct adv748x_csi2 *tx)
 385 {
 386         if (!is_tx_enabled(tx))
 387                 return;
 388
 389         v4l2_async_unregister_subdev(&tx->sd);
 390         media_entity_cleanup(&tx->sd.entity);
 391         v4l2_ctrl_handler_free(&tx->ctrl_hdl);
 392         v4l2_subdev_cleanup(&tx->sd);
 393 }