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 } 360