1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * V4L2 Capture IC Preprocess Subdev for Freescale i.MX5/6 SOC 4 * 5 * This subdevice handles capture of video frames from the CSI or VDIC, 6 * which are routed directly to the Image Converter preprocess tasks, 7 * for resizing, colorspace conversion, and rotation. 8 * 9 * Copyright (c) 2012-2017 Mentor Graphics Inc. 10 */ 11 #include <linux/delay.h> 12 #include <linux/interrupt.h> 13 #include <linux/module.h> 14 #include <linux/sched.h> 15 #include <linux/slab.h> 16 #include <linux/spinlock.h> 17 #include <linux/timer.h> 18 #include <media/v4l2-ctrls.h> 19 #include <media/v4l2-device.h> 20 #include <media/v4l2-ioctl.h> 21 #include <media/v4l2-subdev.h> 22 #include <media/imx.h> 23 #include "imx-media.h" 24 #include "imx-ic.h" 25 26 /* 27 * Min/Max supported width and heights. 28 */ 29 #define MIN_W 176 30 #define MIN_H 144 31 #define MAX_W 4096 32 #define MAX_H 4096 33 #define W_ALIGN 4 /* multiple of 16 pixels */ 34 #define H_ALIGN 1 /* multiple of 2 lines */ 35 #define S_ALIGN 1 /* multiple of 2 */ 36 37 struct prp_priv { 38 struct imx_ic_priv *ic_priv; 39 struct media_pad pad[PRP_NUM_PADS]; 40 41 /* lock to protect all members below */ 42 struct mutex lock; 43 44 struct v4l2_subdev *src_sd; 45 struct v4l2_subdev *sink_sd_prpenc; 46 struct v4l2_subdev *sink_sd_prpvf; 47 48 /* the CSI id at link validate */ 49 int csi_id; 50 51 struct v4l2_mbus_framefmt format_mbus; 52 struct v4l2_fract frame_interval; 53 54 int stream_count; 55 }; 56 57 static inline struct prp_priv *sd_to_priv(struct v4l2_subdev *sd) 58 { 59 struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd); 60 61 return ic_priv->task_priv; 62 } 63 64 static int prp_start(struct prp_priv *priv) 65 { 66 struct imx_ic_priv *ic_priv = priv->ic_priv; 67 bool src_is_vdic; 68 69 /* set IC to receive from CSI or VDI depending on source */ 70 src_is_vdic = !!(priv->src_sd->grp_id & IMX_MEDIA_GRP_ID_IPU_VDIC); 71 72 ipu_set_ic_src_mux(ic_priv->ipu, priv->csi_id, src_is_vdic); 73 74 return 0; 75 } 76 77 static void prp_stop(struct prp_priv *priv) 78 { 79 } 80 81 static struct v4l2_mbus_framefmt * 82 __prp_get_fmt(struct prp_priv *priv, struct v4l2_subdev_pad_config *cfg, 83 unsigned int pad, enum v4l2_subdev_format_whence which) 84 { 85 struct imx_ic_priv *ic_priv = priv->ic_priv; 86 87 if (which == V4L2_SUBDEV_FORMAT_TRY) 88 return v4l2_subdev_get_try_format(&ic_priv->sd, cfg, pad); 89 else 90 return &priv->format_mbus; 91 } 92 93 /* 94 * V4L2 subdev operations. 95 */ 96 97 static int prp_enum_mbus_code(struct v4l2_subdev *sd, 98 struct v4l2_subdev_pad_config *cfg, 99 struct v4l2_subdev_mbus_code_enum *code) 100 { 101 struct prp_priv *priv = sd_to_priv(sd); 102 struct v4l2_mbus_framefmt *infmt; 103 int ret = 0; 104 105 mutex_lock(&priv->lock); 106 107 switch (code->pad) { 108 case PRP_SINK_PAD: 109 ret = imx_media_enum_ipu_format(&code->code, code->index, 110 CS_SEL_ANY); 111 break; 112 case PRP_SRC_PAD_PRPENC: 113 case PRP_SRC_PAD_PRPVF: 114 if (code->index != 0) { 115 ret = -EINVAL; 116 goto out; 117 } 118 infmt = __prp_get_fmt(priv, cfg, PRP_SINK_PAD, code->which); 119 code->code = infmt->code; 120 break; 121 default: 122 ret = -EINVAL; 123 } 124 out: 125 mutex_unlock(&priv->lock); 126 return ret; 127 } 128 129 static int prp_get_fmt(struct v4l2_subdev *sd, 130 struct v4l2_subdev_pad_config *cfg, 131 struct v4l2_subdev_format *sdformat) 132 { 133 struct prp_priv *priv = sd_to_priv(sd); 134 struct v4l2_mbus_framefmt *fmt; 135 int ret = 0; 136 137 if (sdformat->pad >= PRP_NUM_PADS) 138 return -EINVAL; 139 140 mutex_lock(&priv->lock); 141 142 fmt = __prp_get_fmt(priv, cfg, sdformat->pad, sdformat->which); 143 if (!fmt) { 144 ret = -EINVAL; 145 goto out; 146 } 147 148 sdformat->format = *fmt; 149 out: 150 mutex_unlock(&priv->lock); 151 return ret; 152 } 153 154 static int prp_set_fmt(struct v4l2_subdev *sd, 155 struct v4l2_subdev_pad_config *cfg, 156 struct v4l2_subdev_format *sdformat) 157 { 158 struct prp_priv *priv = sd_to_priv(sd); 159 struct v4l2_mbus_framefmt *fmt, *infmt; 160 const struct imx_media_pixfmt *cc; 161 int ret = 0; 162 u32 code; 163 164 if (sdformat->pad >= PRP_NUM_PADS) 165 return -EINVAL; 166 167 mutex_lock(&priv->lock); 168 169 if (priv->stream_count > 0) { 170 ret = -EBUSY; 171 goto out; 172 } 173 174 infmt = __prp_get_fmt(priv, cfg, PRP_SINK_PAD, sdformat->which); 175 176 switch (sdformat->pad) { 177 case PRP_SINK_PAD: 178 v4l_bound_align_image(&sdformat->format.width, MIN_W, MAX_W, 179 W_ALIGN, &sdformat->format.height, 180 MIN_H, MAX_H, H_ALIGN, S_ALIGN); 181 182 cc = imx_media_find_ipu_format(sdformat->format.code, 183 CS_SEL_ANY); 184 if (!cc) { 185 imx_media_enum_ipu_format(&code, 0, CS_SEL_ANY); 186 cc = imx_media_find_ipu_format(code, CS_SEL_ANY); 187 sdformat->format.code = cc->codes[0]; 188 } 189 190 if (sdformat->format.field == V4L2_FIELD_ANY) 191 sdformat->format.field = V4L2_FIELD_NONE; 192 break; 193 case PRP_SRC_PAD_PRPENC: 194 case PRP_SRC_PAD_PRPVF: 195 /* Output pads mirror input pad */ 196 sdformat->format = *infmt; 197 break; 198 } 199 200 imx_media_try_colorimetry(&sdformat->format, true); 201 202 fmt = __prp_get_fmt(priv, cfg, sdformat->pad, sdformat->which); 203 *fmt = sdformat->format; 204 out: 205 mutex_unlock(&priv->lock); 206 return ret; 207 } 208 209 static int prp_link_setup(struct media_entity *entity, 210 const struct media_pad *local, 211 const struct media_pad *remote, u32 flags) 212 { 213 struct v4l2_subdev *sd = media_entity_to_v4l2_subdev(entity); 214 struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd); 215 struct prp_priv *priv = ic_priv->task_priv; 216 struct v4l2_subdev *remote_sd; 217 int ret = 0; 218 219 dev_dbg(ic_priv->ipu_dev, "%s: link setup %s -> %s", 220 ic_priv->sd.name, remote->entity->name, local->entity->name); 221 222 remote_sd = media_entity_to_v4l2_subdev(remote->entity); 223 224 mutex_lock(&priv->lock); 225 226 if (local->flags & MEDIA_PAD_FL_SINK) { 227 if (flags & MEDIA_LNK_FL_ENABLED) { 228 if (priv->src_sd) { 229 ret = -EBUSY; 230 goto out; 231 } 232 if (priv->sink_sd_prpenc && 233 (remote_sd->grp_id & IMX_MEDIA_GRP_ID_IPU_VDIC)) { 234 ret = -EINVAL; 235 goto out; 236 } 237 priv->src_sd = remote_sd; 238 } else { 239 priv->src_sd = NULL; 240 } 241 242 goto out; 243 } 244 245 /* this is a source pad */ 246 if (flags & MEDIA_LNK_FL_ENABLED) { 247 switch (local->index) { 248 case PRP_SRC_PAD_PRPENC: 249 if (priv->sink_sd_prpenc) { 250 ret = -EBUSY; 251 goto out; 252 } 253 if (priv->src_sd && (priv->src_sd->grp_id & 254 IMX_MEDIA_GRP_ID_IPU_VDIC)) { 255 ret = -EINVAL; 256 goto out; 257 } 258 priv->sink_sd_prpenc = remote_sd; 259 break; 260 case PRP_SRC_PAD_PRPVF: 261 if (priv->sink_sd_prpvf) { 262 ret = -EBUSY; 263 goto out; 264 } 265 priv->sink_sd_prpvf = remote_sd; 266 break; 267 default: 268 ret = -EINVAL; 269 } 270 } else { 271 switch (local->index) { 272 case PRP_SRC_PAD_PRPENC: 273 priv->sink_sd_prpenc = NULL; 274 break; 275 case PRP_SRC_PAD_PRPVF: 276 priv->sink_sd_prpvf = NULL; 277 break; 278 default: 279 ret = -EINVAL; 280 } 281 } 282 283 out: 284 mutex_unlock(&priv->lock); 285 return ret; 286 } 287 288 static int prp_link_validate(struct v4l2_subdev *sd, 289 struct media_link *link, 290 struct v4l2_subdev_format *source_fmt, 291 struct v4l2_subdev_format *sink_fmt) 292 { 293 struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd); 294 struct prp_priv *priv = ic_priv->task_priv; 295 struct v4l2_subdev *csi; 296 int ret; 297 298 ret = v4l2_subdev_link_validate_default(sd, link, 299 source_fmt, sink_fmt); 300 if (ret) 301 return ret; 302 303 csi = imx_media_pipeline_subdev(&ic_priv->sd.entity, 304 IMX_MEDIA_GRP_ID_IPU_CSI, true); 305 if (IS_ERR(csi)) 306 csi = NULL; 307 308 mutex_lock(&priv->lock); 309 310 if (priv->src_sd->grp_id & IMX_MEDIA_GRP_ID_IPU_VDIC) { 311 /* 312 * the ->PRPENC link cannot be enabled if the source 313 * is the VDIC 314 */ 315 if (priv->sink_sd_prpenc) { 316 ret = -EINVAL; 317 goto out; 318 } 319 } else { 320 /* the source is a CSI */ 321 if (!csi) { 322 ret = -EINVAL; 323 goto out; 324 } 325 } 326 327 if (csi) { 328 switch (csi->grp_id) { 329 case IMX_MEDIA_GRP_ID_IPU_CSI0: 330 priv->csi_id = 0; 331 break; 332 case IMX_MEDIA_GRP_ID_IPU_CSI1: 333 priv->csi_id = 1; 334 break; 335 default: 336 ret = -EINVAL; 337 } 338 } else { 339 priv->csi_id = 0; 340 } 341 342 out: 343 mutex_unlock(&priv->lock); 344 return ret; 345 } 346 347 static int prp_s_stream(struct v4l2_subdev *sd, int enable) 348 { 349 struct imx_ic_priv *ic_priv = v4l2_get_subdevdata(sd); 350 struct prp_priv *priv = ic_priv->task_priv; 351 int ret = 0; 352 353 mutex_lock(&priv->lock); 354 355 if (!priv->src_sd || (!priv->sink_sd_prpenc && !priv->sink_sd_prpvf)) { 356 ret = -EPIPE; 357 goto out; 358 } 359 360 /* 361 * enable/disable streaming only if stream_count is 362 * going from 0 to 1 / 1 to 0. 363 */ 364 if (priv->stream_count != !enable) 365 goto update_count; 366 367 dev_dbg(ic_priv->ipu_dev, "%s: stream %s\n", sd->name, 368 enable ? "ON" : "OFF"); 369 370 if (enable) 371 ret = prp_start(priv); 372 else 373 prp_stop(priv); 374 if (ret) 375 goto out; 376 377 /* start/stop upstream */ 378 ret = v4l2_subdev_call(priv->src_sd, video, s_stream, enable); 379 ret = (ret && ret != -ENOIOCTLCMD) ? ret : 0; 380 if (ret) { 381 if (enable) 382 prp_stop(priv); 383 goto out; 384 } 385 386 update_count: 387 priv->stream_count += enable ? 1 : -1; 388 if (priv->stream_count < 0) 389 priv->stream_count = 0; 390 out: 391 mutex_unlock(&priv->lock); 392 return ret; 393 } 394 395 static int prp_g_frame_interval(struct v4l2_subdev *sd, 396 struct v4l2_subdev_frame_interval *fi) 397 { 398 struct prp_priv *priv = sd_to_priv(sd); 399 400 if (fi->pad >= PRP_NUM_PADS) 401 return -EINVAL; 402 403 mutex_lock(&priv->lock); 404 fi->interval = priv->frame_interval; 405 mutex_unlock(&priv->lock); 406 407 return 0; 408 } 409 410 static int prp_s_frame_interval(struct v4l2_subdev *sd, 411 struct v4l2_subdev_frame_interval *fi) 412 { 413 struct prp_priv *priv = sd_to_priv(sd); 414 415 if (fi->pad >= PRP_NUM_PADS) 416 return -EINVAL; 417 418 mutex_lock(&priv->lock); 419 420 /* No limits on valid frame intervals */ 421 if (fi->interval.numerator == 0 || fi->interval.denominator == 0) 422 fi->interval = priv->frame_interval; 423 else 424 priv->frame_interval = fi->interval; 425 426 mutex_unlock(&priv->lock); 427 428 return 0; 429 } 430 431 /* 432 * retrieve our pads parsed from the OF graph by the media device 433 */ 434 static int prp_registered(struct v4l2_subdev *sd) 435 { 436 struct prp_priv *priv = sd_to_priv(sd); 437 int i, ret; 438 u32 code; 439 440 for (i = 0; i < PRP_NUM_PADS; i++) { 441 priv->pad[i].flags = (i == PRP_SINK_PAD) ? 442 MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE; 443 } 444 445 /* init default frame interval */ 446 priv->frame_interval.numerator = 1; 447 priv->frame_interval.denominator = 30; 448 449 /* set a default mbus format */ 450 imx_media_enum_ipu_format(&code, 0, CS_SEL_YUV); 451 ret = imx_media_init_mbus_fmt(&priv->format_mbus, 640, 480, code, 452 V4L2_FIELD_NONE, NULL); 453 if (ret) 454 return ret; 455 456 return media_entity_pads_init(&sd->entity, PRP_NUM_PADS, priv->pad); 457 } 458 459 static const struct v4l2_subdev_pad_ops prp_pad_ops = { 460 .init_cfg = imx_media_init_cfg, 461 .enum_mbus_code = prp_enum_mbus_code, 462 .get_fmt = prp_get_fmt, 463 .set_fmt = prp_set_fmt, 464 .link_validate = prp_link_validate, 465 }; 466 467 static const struct v4l2_subdev_video_ops prp_video_ops = { 468 .g_frame_interval = prp_g_frame_interval, 469 .s_frame_interval = prp_s_frame_interval, 470 .s_stream = prp_s_stream, 471 }; 472 473 static const struct media_entity_operations prp_entity_ops = { 474 .link_setup = prp_link_setup, 475 .link_validate = v4l2_subdev_link_validate, 476 }; 477 478 static const struct v4l2_subdev_ops prp_subdev_ops = { 479 .video = &prp_video_ops, 480 .pad = &prp_pad_ops, 481 }; 482 483 static const struct v4l2_subdev_internal_ops prp_internal_ops = { 484 .registered = prp_registered, 485 }; 486 487 static int prp_init(struct imx_ic_priv *ic_priv) 488 { 489 struct prp_priv *priv; 490 491 priv = devm_kzalloc(ic_priv->ipu_dev, sizeof(*priv), GFP_KERNEL); 492 if (!priv) 493 return -ENOMEM; 494 495 mutex_init(&priv->lock); 496 ic_priv->task_priv = priv; 497 priv->ic_priv = ic_priv; 498 499 return 0; 500 } 501 502 static void prp_remove(struct imx_ic_priv *ic_priv) 503 { 504 struct prp_priv *priv = ic_priv->task_priv; 505 506 mutex_destroy(&priv->lock); 507 } 508 509 struct imx_ic_ops imx_ic_prp_ops = { 510 .subdev_ops = &prp_subdev_ops, 511 .internal_ops = &prp_internal_ops, 512 .entity_ops = &prp_entity_ops, 513 .init = prp_init, 514 .remove = prp_remove, 515 }; 516