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