1 /* 2 * V4L2 sub-device 3 * 4 * Copyright (C) 2010 Nokia Corporation 5 * 6 * Contact: Laurent Pinchart <laurent.pinchart@ideasonboard.com> 7 * Sakari Ailus <sakari.ailus@iki.fi> 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License version 2 as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 */ 18 19 #include <linux/ioctl.h> 20 #include <linux/mm.h> 21 #include <linux/slab.h> 22 #include <linux/types.h> 23 #include <linux/videodev2.h> 24 #include <linux/export.h> 25 26 #include <media/v4l2-ctrls.h> 27 #include <media/v4l2-device.h> 28 #include <media/v4l2-ioctl.h> 29 #include <media/v4l2-fh.h> 30 #include <media/v4l2-event.h> 31 32 static int subdev_fh_init(struct v4l2_subdev_fh *fh, struct v4l2_subdev *sd) 33 { 34 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 35 if (sd->entity.num_pads) { 36 fh->pad = v4l2_subdev_alloc_pad_config(sd); 37 if (fh->pad == NULL) 38 return -ENOMEM; 39 } 40 #endif 41 return 0; 42 } 43 44 static void subdev_fh_free(struct v4l2_subdev_fh *fh) 45 { 46 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 47 v4l2_subdev_free_pad_config(fh->pad); 48 fh->pad = NULL; 49 #endif 50 } 51 52 static int subdev_open(struct file *file) 53 { 54 struct video_device *vdev = video_devdata(file); 55 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 56 struct v4l2_subdev_fh *subdev_fh; 57 #if defined(CONFIG_MEDIA_CONTROLLER) 58 struct media_entity *entity = NULL; 59 #endif 60 int ret; 61 62 subdev_fh = kzalloc(sizeof(*subdev_fh), GFP_KERNEL); 63 if (subdev_fh == NULL) 64 return -ENOMEM; 65 66 ret = subdev_fh_init(subdev_fh, sd); 67 if (ret) { 68 kfree(subdev_fh); 69 return ret; 70 } 71 72 v4l2_fh_init(&subdev_fh->vfh, vdev); 73 v4l2_fh_add(&subdev_fh->vfh); 74 file->private_data = &subdev_fh->vfh; 75 #if defined(CONFIG_MEDIA_CONTROLLER) 76 if (sd->v4l2_dev->mdev) { 77 entity = media_entity_get(&sd->entity); 78 if (!entity) { 79 ret = -EBUSY; 80 goto err; 81 } 82 } 83 #endif 84 85 if (sd->internal_ops && sd->internal_ops->open) { 86 ret = sd->internal_ops->open(sd, subdev_fh); 87 if (ret < 0) 88 goto err; 89 } 90 91 return 0; 92 93 err: 94 #if defined(CONFIG_MEDIA_CONTROLLER) 95 media_entity_put(entity); 96 #endif 97 v4l2_fh_del(&subdev_fh->vfh); 98 v4l2_fh_exit(&subdev_fh->vfh); 99 subdev_fh_free(subdev_fh); 100 kfree(subdev_fh); 101 102 return ret; 103 } 104 105 static int subdev_close(struct file *file) 106 { 107 struct video_device *vdev = video_devdata(file); 108 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 109 struct v4l2_fh *vfh = file->private_data; 110 struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh); 111 112 if (sd->internal_ops && sd->internal_ops->close) 113 sd->internal_ops->close(sd, subdev_fh); 114 #if defined(CONFIG_MEDIA_CONTROLLER) 115 if (sd->v4l2_dev->mdev) 116 media_entity_put(&sd->entity); 117 #endif 118 v4l2_fh_del(vfh); 119 v4l2_fh_exit(vfh); 120 subdev_fh_free(subdev_fh); 121 kfree(subdev_fh); 122 file->private_data = NULL; 123 124 return 0; 125 } 126 127 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 128 static int check_format(struct v4l2_subdev *sd, 129 struct v4l2_subdev_format *format) 130 { 131 if (format->which != V4L2_SUBDEV_FORMAT_TRY && 132 format->which != V4L2_SUBDEV_FORMAT_ACTIVE) 133 return -EINVAL; 134 135 if (format->pad >= sd->entity.num_pads) 136 return -EINVAL; 137 138 return 0; 139 } 140 141 static int check_crop(struct v4l2_subdev *sd, struct v4l2_subdev_crop *crop) 142 { 143 if (crop->which != V4L2_SUBDEV_FORMAT_TRY && 144 crop->which != V4L2_SUBDEV_FORMAT_ACTIVE) 145 return -EINVAL; 146 147 if (crop->pad >= sd->entity.num_pads) 148 return -EINVAL; 149 150 return 0; 151 } 152 153 static int check_selection(struct v4l2_subdev *sd, 154 struct v4l2_subdev_selection *sel) 155 { 156 if (sel->which != V4L2_SUBDEV_FORMAT_TRY && 157 sel->which != V4L2_SUBDEV_FORMAT_ACTIVE) 158 return -EINVAL; 159 160 if (sel->pad >= sd->entity.num_pads) 161 return -EINVAL; 162 163 return 0; 164 } 165 166 static int check_edid(struct v4l2_subdev *sd, struct v4l2_subdev_edid *edid) 167 { 168 if (edid->pad >= sd->entity.num_pads) 169 return -EINVAL; 170 171 if (edid->blocks && edid->edid == NULL) 172 return -EINVAL; 173 174 return 0; 175 } 176 #endif 177 178 static long subdev_do_ioctl(struct file *file, unsigned int cmd, void *arg) 179 { 180 struct video_device *vdev = video_devdata(file); 181 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 182 struct v4l2_fh *vfh = file->private_data; 183 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 184 struct v4l2_subdev_fh *subdev_fh = to_v4l2_subdev_fh(vfh); 185 int rval; 186 #endif 187 188 switch (cmd) { 189 case VIDIOC_QUERYCTRL: 190 return v4l2_queryctrl(vfh->ctrl_handler, arg); 191 192 case VIDIOC_QUERY_EXT_CTRL: 193 return v4l2_query_ext_ctrl(vfh->ctrl_handler, arg); 194 195 case VIDIOC_QUERYMENU: 196 return v4l2_querymenu(vfh->ctrl_handler, arg); 197 198 case VIDIOC_G_CTRL: 199 return v4l2_g_ctrl(vfh->ctrl_handler, arg); 200 201 case VIDIOC_S_CTRL: 202 return v4l2_s_ctrl(vfh, vfh->ctrl_handler, arg); 203 204 case VIDIOC_G_EXT_CTRLS: 205 return v4l2_g_ext_ctrls(vfh->ctrl_handler, arg); 206 207 case VIDIOC_S_EXT_CTRLS: 208 return v4l2_s_ext_ctrls(vfh, vfh->ctrl_handler, arg); 209 210 case VIDIOC_TRY_EXT_CTRLS: 211 return v4l2_try_ext_ctrls(vfh->ctrl_handler, arg); 212 213 case VIDIOC_DQEVENT: 214 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS)) 215 return -ENOIOCTLCMD; 216 217 return v4l2_event_dequeue(vfh, arg, file->f_flags & O_NONBLOCK); 218 219 case VIDIOC_SUBSCRIBE_EVENT: 220 return v4l2_subdev_call(sd, core, subscribe_event, vfh, arg); 221 222 case VIDIOC_UNSUBSCRIBE_EVENT: 223 return v4l2_subdev_call(sd, core, unsubscribe_event, vfh, arg); 224 225 #ifdef CONFIG_VIDEO_ADV_DEBUG 226 case VIDIOC_DBG_G_REGISTER: 227 { 228 struct v4l2_dbg_register *p = arg; 229 230 if (!capable(CAP_SYS_ADMIN)) 231 return -EPERM; 232 return v4l2_subdev_call(sd, core, g_register, p); 233 } 234 case VIDIOC_DBG_S_REGISTER: 235 { 236 struct v4l2_dbg_register *p = arg; 237 238 if (!capable(CAP_SYS_ADMIN)) 239 return -EPERM; 240 return v4l2_subdev_call(sd, core, s_register, p); 241 } 242 #endif 243 244 case VIDIOC_LOG_STATUS: { 245 int ret; 246 247 pr_info("%s: ================= START STATUS =================\n", 248 sd->name); 249 ret = v4l2_subdev_call(sd, core, log_status); 250 pr_info("%s: ================== END STATUS ==================\n", 251 sd->name); 252 return ret; 253 } 254 255 #if defined(CONFIG_VIDEO_V4L2_SUBDEV_API) 256 case VIDIOC_SUBDEV_G_FMT: { 257 struct v4l2_subdev_format *format = arg; 258 259 rval = check_format(sd, format); 260 if (rval) 261 return rval; 262 263 return v4l2_subdev_call(sd, pad, get_fmt, subdev_fh->pad, format); 264 } 265 266 case VIDIOC_SUBDEV_S_FMT: { 267 struct v4l2_subdev_format *format = arg; 268 269 rval = check_format(sd, format); 270 if (rval) 271 return rval; 272 273 return v4l2_subdev_call(sd, pad, set_fmt, subdev_fh->pad, format); 274 } 275 276 case VIDIOC_SUBDEV_G_CROP: { 277 struct v4l2_subdev_crop *crop = arg; 278 struct v4l2_subdev_selection sel; 279 280 rval = check_crop(sd, crop); 281 if (rval) 282 return rval; 283 284 memset(&sel, 0, sizeof(sel)); 285 sel.which = crop->which; 286 sel.pad = crop->pad; 287 sel.target = V4L2_SEL_TGT_CROP; 288 289 rval = v4l2_subdev_call( 290 sd, pad, get_selection, subdev_fh->pad, &sel); 291 292 crop->rect = sel.r; 293 294 return rval; 295 } 296 297 case VIDIOC_SUBDEV_S_CROP: { 298 struct v4l2_subdev_crop *crop = arg; 299 struct v4l2_subdev_selection sel; 300 301 rval = check_crop(sd, crop); 302 if (rval) 303 return rval; 304 305 memset(&sel, 0, sizeof(sel)); 306 sel.which = crop->which; 307 sel.pad = crop->pad; 308 sel.target = V4L2_SEL_TGT_CROP; 309 sel.r = crop->rect; 310 311 rval = v4l2_subdev_call( 312 sd, pad, set_selection, subdev_fh->pad, &sel); 313 314 crop->rect = sel.r; 315 316 return rval; 317 } 318 319 case VIDIOC_SUBDEV_ENUM_MBUS_CODE: { 320 struct v4l2_subdev_mbus_code_enum *code = arg; 321 322 if (code->which != V4L2_SUBDEV_FORMAT_TRY && 323 code->which != V4L2_SUBDEV_FORMAT_ACTIVE) 324 return -EINVAL; 325 326 if (code->pad >= sd->entity.num_pads) 327 return -EINVAL; 328 329 return v4l2_subdev_call(sd, pad, enum_mbus_code, subdev_fh->pad, 330 code); 331 } 332 333 case VIDIOC_SUBDEV_ENUM_FRAME_SIZE: { 334 struct v4l2_subdev_frame_size_enum *fse = arg; 335 336 if (fse->which != V4L2_SUBDEV_FORMAT_TRY && 337 fse->which != V4L2_SUBDEV_FORMAT_ACTIVE) 338 return -EINVAL; 339 340 if (fse->pad >= sd->entity.num_pads) 341 return -EINVAL; 342 343 return v4l2_subdev_call(sd, pad, enum_frame_size, subdev_fh->pad, 344 fse); 345 } 346 347 case VIDIOC_SUBDEV_G_FRAME_INTERVAL: { 348 struct v4l2_subdev_frame_interval *fi = arg; 349 350 if (fi->pad >= sd->entity.num_pads) 351 return -EINVAL; 352 353 return v4l2_subdev_call(sd, video, g_frame_interval, arg); 354 } 355 356 case VIDIOC_SUBDEV_S_FRAME_INTERVAL: { 357 struct v4l2_subdev_frame_interval *fi = arg; 358 359 if (fi->pad >= sd->entity.num_pads) 360 return -EINVAL; 361 362 return v4l2_subdev_call(sd, video, s_frame_interval, arg); 363 } 364 365 case VIDIOC_SUBDEV_ENUM_FRAME_INTERVAL: { 366 struct v4l2_subdev_frame_interval_enum *fie = arg; 367 368 if (fie->which != V4L2_SUBDEV_FORMAT_TRY && 369 fie->which != V4L2_SUBDEV_FORMAT_ACTIVE) 370 return -EINVAL; 371 372 if (fie->pad >= sd->entity.num_pads) 373 return -EINVAL; 374 375 return v4l2_subdev_call(sd, pad, enum_frame_interval, subdev_fh->pad, 376 fie); 377 } 378 379 case VIDIOC_SUBDEV_G_SELECTION: { 380 struct v4l2_subdev_selection *sel = arg; 381 382 rval = check_selection(sd, sel); 383 if (rval) 384 return rval; 385 386 return v4l2_subdev_call( 387 sd, pad, get_selection, subdev_fh->pad, sel); 388 } 389 390 case VIDIOC_SUBDEV_S_SELECTION: { 391 struct v4l2_subdev_selection *sel = arg; 392 393 rval = check_selection(sd, sel); 394 if (rval) 395 return rval; 396 397 return v4l2_subdev_call( 398 sd, pad, set_selection, subdev_fh->pad, sel); 399 } 400 401 case VIDIOC_G_EDID: { 402 struct v4l2_subdev_edid *edid = arg; 403 404 rval = check_edid(sd, edid); 405 if (rval) 406 return rval; 407 408 return v4l2_subdev_call(sd, pad, get_edid, edid); 409 } 410 411 case VIDIOC_S_EDID: { 412 struct v4l2_subdev_edid *edid = arg; 413 414 rval = check_edid(sd, edid); 415 if (rval) 416 return rval; 417 418 return v4l2_subdev_call(sd, pad, set_edid, edid); 419 } 420 421 case VIDIOC_SUBDEV_DV_TIMINGS_CAP: { 422 struct v4l2_dv_timings_cap *cap = arg; 423 424 if (cap->pad >= sd->entity.num_pads) 425 return -EINVAL; 426 427 return v4l2_subdev_call(sd, pad, dv_timings_cap, cap); 428 } 429 430 case VIDIOC_SUBDEV_ENUM_DV_TIMINGS: { 431 struct v4l2_enum_dv_timings *dvt = arg; 432 433 if (dvt->pad >= sd->entity.num_pads) 434 return -EINVAL; 435 436 return v4l2_subdev_call(sd, pad, enum_dv_timings, dvt); 437 } 438 439 case VIDIOC_SUBDEV_QUERY_DV_TIMINGS: 440 return v4l2_subdev_call(sd, video, query_dv_timings, arg); 441 442 case VIDIOC_SUBDEV_G_DV_TIMINGS: 443 return v4l2_subdev_call(sd, video, g_dv_timings, arg); 444 445 case VIDIOC_SUBDEV_S_DV_TIMINGS: 446 return v4l2_subdev_call(sd, video, s_dv_timings, arg); 447 #endif 448 default: 449 return v4l2_subdev_call(sd, core, ioctl, cmd, arg); 450 } 451 452 return 0; 453 } 454 455 static long subdev_ioctl(struct file *file, unsigned int cmd, 456 unsigned long arg) 457 { 458 return video_usercopy(file, cmd, arg, subdev_do_ioctl); 459 } 460 461 #ifdef CONFIG_COMPAT 462 static long subdev_compat_ioctl32(struct file *file, unsigned int cmd, 463 unsigned long arg) 464 { 465 struct video_device *vdev = video_devdata(file); 466 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 467 468 return v4l2_subdev_call(sd, core, compat_ioctl32, cmd, arg); 469 } 470 #endif 471 472 static unsigned int subdev_poll(struct file *file, poll_table *wait) 473 { 474 struct video_device *vdev = video_devdata(file); 475 struct v4l2_subdev *sd = vdev_to_v4l2_subdev(vdev); 476 struct v4l2_fh *fh = file->private_data; 477 478 if (!(sd->flags & V4L2_SUBDEV_FL_HAS_EVENTS)) 479 return POLLERR; 480 481 poll_wait(file, &fh->wait, wait); 482 483 if (v4l2_event_pending(fh)) 484 return POLLPRI; 485 486 return 0; 487 } 488 489 const struct v4l2_file_operations v4l2_subdev_fops = { 490 .owner = THIS_MODULE, 491 .open = subdev_open, 492 .unlocked_ioctl = subdev_ioctl, 493 #ifdef CONFIG_COMPAT 494 .compat_ioctl32 = subdev_compat_ioctl32, 495 #endif 496 .release = subdev_close, 497 .poll = subdev_poll, 498 }; 499 500 #ifdef CONFIG_MEDIA_CONTROLLER 501 int v4l2_subdev_link_validate_default(struct v4l2_subdev *sd, 502 struct media_link *link, 503 struct v4l2_subdev_format *source_fmt, 504 struct v4l2_subdev_format *sink_fmt) 505 { 506 /* The width, height and code must match. */ 507 if (source_fmt->format.width != sink_fmt->format.width 508 || source_fmt->format.height != sink_fmt->format.height 509 || source_fmt->format.code != sink_fmt->format.code) 510 return -EPIPE; 511 512 /* The field order must match, or the sink field order must be NONE 513 * to support interlaced hardware connected to bridges that support 514 * progressive formats only. 515 */ 516 if (source_fmt->format.field != sink_fmt->format.field && 517 sink_fmt->format.field != V4L2_FIELD_NONE) 518 return -EPIPE; 519 520 return 0; 521 } 522 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate_default); 523 524 static int 525 v4l2_subdev_link_validate_get_format(struct media_pad *pad, 526 struct v4l2_subdev_format *fmt) 527 { 528 if (is_media_entity_v4l2_subdev(pad->entity)) { 529 struct v4l2_subdev *sd = 530 media_entity_to_v4l2_subdev(pad->entity); 531 532 fmt->which = V4L2_SUBDEV_FORMAT_ACTIVE; 533 fmt->pad = pad->index; 534 return v4l2_subdev_call(sd, pad, get_fmt, NULL, fmt); 535 } 536 537 WARN(pad->entity->function != MEDIA_ENT_F_IO_V4L, 538 "Driver bug! Wrong media entity type 0x%08x, entity %s\n", 539 pad->entity->function, pad->entity->name); 540 541 return -EINVAL; 542 } 543 544 int v4l2_subdev_link_validate(struct media_link *link) 545 { 546 struct v4l2_subdev *sink; 547 struct v4l2_subdev_format sink_fmt, source_fmt; 548 int rval; 549 550 rval = v4l2_subdev_link_validate_get_format( 551 link->source, &source_fmt); 552 if (rval < 0) 553 return 0; 554 555 rval = v4l2_subdev_link_validate_get_format( 556 link->sink, &sink_fmt); 557 if (rval < 0) 558 return 0; 559 560 sink = media_entity_to_v4l2_subdev(link->sink->entity); 561 562 rval = v4l2_subdev_call(sink, pad, link_validate, link, 563 &source_fmt, &sink_fmt); 564 if (rval != -ENOIOCTLCMD) 565 return rval; 566 567 return v4l2_subdev_link_validate_default( 568 sink, link, &source_fmt, &sink_fmt); 569 } 570 EXPORT_SYMBOL_GPL(v4l2_subdev_link_validate); 571 572 struct v4l2_subdev_pad_config * 573 v4l2_subdev_alloc_pad_config(struct v4l2_subdev *sd) 574 { 575 struct v4l2_subdev_pad_config *cfg; 576 int ret; 577 578 if (!sd->entity.num_pads) 579 return NULL; 580 581 cfg = kvmalloc_array(sd->entity.num_pads, sizeof(*cfg), 582 GFP_KERNEL | __GFP_ZERO); 583 if (!cfg) 584 return NULL; 585 586 ret = v4l2_subdev_call(sd, pad, init_cfg, cfg); 587 if (ret < 0 && ret != -ENOIOCTLCMD) { 588 kvfree(cfg); 589 return NULL; 590 } 591 592 return cfg; 593 } 594 EXPORT_SYMBOL_GPL(v4l2_subdev_alloc_pad_config); 595 596 void v4l2_subdev_free_pad_config(struct v4l2_subdev_pad_config *cfg) 597 { 598 kvfree(cfg); 599 } 600 EXPORT_SYMBOL_GPL(v4l2_subdev_free_pad_config); 601 #endif /* CONFIG_MEDIA_CONTROLLER */ 602 603 void v4l2_subdev_init(struct v4l2_subdev *sd, const struct v4l2_subdev_ops *ops) 604 { 605 INIT_LIST_HEAD(&sd->list); 606 BUG_ON(!ops); 607 sd->ops = ops; 608 sd->v4l2_dev = NULL; 609 sd->flags = 0; 610 sd->name[0] = '\0'; 611 sd->grp_id = 0; 612 sd->dev_priv = NULL; 613 sd->host_priv = NULL; 614 #if defined(CONFIG_MEDIA_CONTROLLER) 615 sd->entity.name = sd->name; 616 sd->entity.obj_type = MEDIA_ENTITY_TYPE_V4L2_SUBDEV; 617 sd->entity.function = MEDIA_ENT_F_V4L2_SUBDEV_UNKNOWN; 618 #endif 619 } 620 EXPORT_SYMBOL(v4l2_subdev_init); 621 622 void v4l2_subdev_notify_event(struct v4l2_subdev *sd, 623 const struct v4l2_event *ev) 624 { 625 v4l2_event_queue(sd->devnode, ev); 626 v4l2_subdev_notify(sd, V4L2_DEVICE_NOTIFY_EVENT, (void *)ev); 627 } 628 EXPORT_SYMBOL_GPL(v4l2_subdev_notify_event); 629