1/* 2 * camera image capture (abstract) bus driver 3 * 4 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de> 5 * 6 * This driver provides an interface between platform-specific camera 7 * busses and camera devices. It should be used if the camera is 8 * connected not over a "proper" bus like PCI or USB, but over a 9 * special bus, like, for example, the Quick Capture interface on PXA270 10 * SoCs. Later it should also be used for i.MX31 SoCs from Freescale. 11 * It can handle multiple cameras and / or multiple busses, which can 12 * be used, e.g., in stereo-vision applications. 13 * 14 * This program is free software; you can redistribute it and/or modify 15 * it under the terms of the GNU General Public License version 2 as 16 * published by the Free Software Foundation. 17 */ 18 19#include <linux/device.h> 20#include <linux/err.h> 21#include <linux/i2c.h> 22#include <linux/init.h> 23#include <linux/list.h> 24#include <linux/mutex.h> 25#include <linux/module.h> 26#include <linux/platform_device.h> 27#include <linux/regulator/consumer.h> 28#include <linux/slab.h> 29#include <linux/pm_runtime.h> 30#include <linux/vmalloc.h> 31 32#include <media/soc_camera.h> 33#include <media/v4l2-common.h> 34#include <media/v4l2-ioctl.h> 35#include <media/v4l2-dev.h> 36#include <media/videobuf-core.h> 37#include <media/videobuf2-core.h> 38#include <media/soc_mediabus.h> 39 40/* Default to VGA resolution */ 41#define DEFAULT_WIDTH 640 42#define DEFAULT_HEIGHT 480 43 44#define is_streaming(ici, icd) \ 45 (((ici)->ops->init_videobuf) ? \ 46 (icd)->vb_vidq.streaming : \ 47 vb2_is_streaming(&(icd)->vb2_vidq)) 48 49static LIST_HEAD(hosts); 50static LIST_HEAD(devices); 51static DEFINE_MUTEX(list_lock); /* Protects the list of hosts */ 52 53static int soc_camera_power_on(struct soc_camera_device *icd, 54 struct soc_camera_link *icl) 55{ 56 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 57 int ret = regulator_bulk_enable(icl->num_regulators, 58 icl->regulators); 59 if (ret < 0) { 60 dev_err(icd->pdev, "Cannot enable regulators\n"); 61 return ret; 62 } 63 64 if (icl->power) { 65 ret = icl->power(icd->pdev, 1); 66 if (ret < 0) { 67 dev_err(icd->pdev, 68 "Platform failed to power-on the camera.\n"); 69 goto elinkpwr; 70 } 71 } 72 73 ret = v4l2_subdev_call(sd, core, s_power, 1); 74 if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV) 75 goto esdpwr; 76 77 return 0; 78 79esdpwr: 80 if (icl->power) 81 icl->power(icd->pdev, 0); 82elinkpwr: 83 regulator_bulk_disable(icl->num_regulators, 84 icl->regulators); 85 return ret; 86} 87 88static int soc_camera_power_off(struct soc_camera_device *icd, 89 struct soc_camera_link *icl) 90{ 91 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 92 int ret = v4l2_subdev_call(sd, core, s_power, 0); 93 94 if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV) 95 return ret; 96 97 if (icl->power) { 98 ret = icl->power(icd->pdev, 0); 99 if (ret < 0) { 100 dev_err(icd->pdev, 101 "Platform failed to power-off the camera.\n"); 102 return ret; 103 } 104 } 105 106 ret = regulator_bulk_disable(icl->num_regulators, 107 icl->regulators); 108 if (ret < 0) 109 dev_err(icd->pdev, "Cannot disable regulators\n"); 110 111 return ret; 112} 113 114const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc( 115 struct soc_camera_device *icd, unsigned int fourcc) 116{ 117 unsigned int i; 118 119 for (i = 0; i < icd->num_user_formats; i++) 120 if (icd->user_formats[i].host_fmt->fourcc == fourcc) 121 return icd->user_formats + i; 122 return NULL; 123} 124EXPORT_SYMBOL(soc_camera_xlate_by_fourcc); 125 126/** 127 * soc_camera_apply_board_flags() - apply platform SOCAM_SENSOR_INVERT_* flags 128 * @icl: camera platform parameters 129 * @cfg: media bus configuration 130 * @return: resulting flags 131 */ 132unsigned long soc_camera_apply_board_flags(struct soc_camera_link *icl, 133 const struct v4l2_mbus_config *cfg) 134{ 135 unsigned long f, flags = cfg->flags; 136 137 /* If only one of the two polarities is supported, switch to the opposite */ 138 if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) { 139 f = flags & (V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW); 140 if (f == V4L2_MBUS_HSYNC_ACTIVE_HIGH || f == V4L2_MBUS_HSYNC_ACTIVE_LOW) 141 flags ^= V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW; 142 } 143 144 if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) { 145 f = flags & (V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW); 146 if (f == V4L2_MBUS_VSYNC_ACTIVE_HIGH || f == V4L2_MBUS_VSYNC_ACTIVE_LOW) 147 flags ^= V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW; 148 } 149 150 if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) { 151 f = flags & (V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING); 152 if (f == V4L2_MBUS_PCLK_SAMPLE_RISING || f == V4L2_MBUS_PCLK_SAMPLE_FALLING) 153 flags ^= V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING; 154 } 155 156 return flags; 157} 158EXPORT_SYMBOL(soc_camera_apply_board_flags); 159 160#define pixfmtstr(x) (x) & 0xff, ((x) >> 8) & 0xff, ((x) >> 16) & 0xff, \ 161 ((x) >> 24) & 0xff 162 163static int soc_camera_try_fmt(struct soc_camera_device *icd, 164 struct v4l2_format *f) 165{ 166 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 167 struct v4l2_pix_format *pix = &f->fmt.pix; 168 int ret; 169 170 dev_dbg(icd->pdev, "TRY_FMT(%c%c%c%c, %ux%u)\n", 171 pixfmtstr(pix->pixelformat), pix->width, pix->height); 172 173 pix->bytesperline = 0; 174 pix->sizeimage = 0; 175 176 ret = ici->ops->try_fmt(icd, f); 177 if (ret < 0) 178 return ret; 179 180 if (!pix->sizeimage) { 181 if (!pix->bytesperline) { 182 const struct soc_camera_format_xlate *xlate; 183 184 xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat); 185 if (!xlate) 186 return -EINVAL; 187 188 ret = soc_mbus_bytes_per_line(pix->width, 189 xlate->host_fmt); 190 if (ret > 0) 191 pix->bytesperline = ret; 192 } 193 if (pix->bytesperline) 194 pix->sizeimage = pix->bytesperline * pix->height; 195 } 196 197 return 0; 198} 199 200static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv, 201 struct v4l2_format *f) 202{ 203 struct soc_camera_device *icd = file->private_data; 204 205 WARN_ON(priv != file->private_data); 206 207 /* Only single-plane capture is supported so far */ 208 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 209 return -EINVAL; 210 211 /* limit format to hardware capabilities */ 212 return soc_camera_try_fmt(icd, f); 213} 214 215static int soc_camera_enum_input(struct file *file, void *priv, 216 struct v4l2_input *inp) 217{ 218 if (inp->index != 0) 219 return -EINVAL; 220 221 /* default is camera */ 222 inp->type = V4L2_INPUT_TYPE_CAMERA; 223 inp->std = V4L2_STD_UNKNOWN; 224 strcpy(inp->name, "Camera"); 225 226 return 0; 227} 228 229static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i) 230{ 231 *i = 0; 232 233 return 0; 234} 235 236static int soc_camera_s_input(struct file *file, void *priv, unsigned int i) 237{ 238 if (i > 0) 239 return -EINVAL; 240 241 return 0; 242} 243 244static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a) 245{ 246 struct soc_camera_device *icd = file->private_data; 247 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 248 249 return v4l2_subdev_call(sd, core, s_std, *a); 250} 251 252static int soc_camera_g_std(struct file *file, void *priv, v4l2_std_id *a) 253{ 254 struct soc_camera_device *icd = file->private_data; 255 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 256 257 return v4l2_subdev_call(sd, core, g_std, a); 258} 259 260static int soc_camera_enum_fsizes(struct file *file, void *fh, 261 struct v4l2_frmsizeenum *fsize) 262{ 263 struct soc_camera_device *icd = file->private_data; 264 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 265 266 return ici->ops->enum_fsizes(icd, fsize); 267} 268 269static int soc_camera_reqbufs(struct file *file, void *priv, 270 struct v4l2_requestbuffers *p) 271{ 272 int ret; 273 struct soc_camera_device *icd = file->private_data; 274 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 275 276 WARN_ON(priv != file->private_data); 277 278 if (icd->streamer && icd->streamer != file) 279 return -EBUSY; 280 281 if (ici->ops->init_videobuf) { 282 ret = videobuf_reqbufs(&icd->vb_vidq, p); 283 if (ret < 0) 284 return ret; 285 286 ret = ici->ops->reqbufs(icd, p); 287 } else { 288 ret = vb2_reqbufs(&icd->vb2_vidq, p); 289 } 290 291 if (!ret && !icd->streamer) 292 icd->streamer = file; 293 294 return ret; 295} 296 297static int soc_camera_querybuf(struct file *file, void *priv, 298 struct v4l2_buffer *p) 299{ 300 struct soc_camera_device *icd = file->private_data; 301 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 302 303 WARN_ON(priv != file->private_data); 304 305 if (ici->ops->init_videobuf) 306 return videobuf_querybuf(&icd->vb_vidq, p); 307 else 308 return vb2_querybuf(&icd->vb2_vidq, p); 309} 310 311static int soc_camera_qbuf(struct file *file, void *priv, 312 struct v4l2_buffer *p) 313{ 314 struct soc_camera_device *icd = file->private_data; 315 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 316 317 WARN_ON(priv != file->private_data); 318 319 if (icd->streamer != file) 320 return -EBUSY; 321 322 if (ici->ops->init_videobuf) 323 return videobuf_qbuf(&icd->vb_vidq, p); 324 else 325 return vb2_qbuf(&icd->vb2_vidq, p); 326} 327 328static int soc_camera_dqbuf(struct file *file, void *priv, 329 struct v4l2_buffer *p) 330{ 331 struct soc_camera_device *icd = file->private_data; 332 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 333 334 WARN_ON(priv != file->private_data); 335 336 if (icd->streamer != file) 337 return -EBUSY; 338 339 if (ici->ops->init_videobuf) 340 return videobuf_dqbuf(&icd->vb_vidq, p, file->f_flags & O_NONBLOCK); 341 else 342 return vb2_dqbuf(&icd->vb2_vidq, p, file->f_flags & O_NONBLOCK); 343} 344 345static int soc_camera_create_bufs(struct file *file, void *priv, 346 struct v4l2_create_buffers *create) 347{ 348 struct soc_camera_device *icd = file->private_data; 349 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 350 351 /* videobuf2 only */ 352 if (ici->ops->init_videobuf) 353 return -EINVAL; 354 else 355 return vb2_create_bufs(&icd->vb2_vidq, create); 356} 357 358static int soc_camera_prepare_buf(struct file *file, void *priv, 359 struct v4l2_buffer *b) 360{ 361 struct soc_camera_device *icd = file->private_data; 362 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 363 364 /* videobuf2 only */ 365 if (ici->ops->init_videobuf) 366 return -EINVAL; 367 else 368 return vb2_prepare_buf(&icd->vb2_vidq, b); 369} 370 371/* Always entered with .video_lock held */ 372static int soc_camera_init_user_formats(struct soc_camera_device *icd) 373{ 374 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 375 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 376 unsigned int i, fmts = 0, raw_fmts = 0; 377 int ret; 378 enum v4l2_mbus_pixelcode code; 379 380 while (!v4l2_subdev_call(sd, video, enum_mbus_fmt, raw_fmts, &code)) 381 raw_fmts++; 382 383 if (!ici->ops->get_formats) 384 /* 385 * Fallback mode - the host will have to serve all 386 * sensor-provided formats one-to-one to the user 387 */ 388 fmts = raw_fmts; 389 else 390 /* 391 * First pass - only count formats this host-sensor 392 * configuration can provide 393 */ 394 for (i = 0; i < raw_fmts; i++) { 395 ret = ici->ops->get_formats(icd, i, NULL); 396 if (ret < 0) 397 return ret; 398 fmts += ret; 399 } 400 401 if (!fmts) 402 return -ENXIO; 403 404 icd->user_formats = 405 vmalloc(fmts * sizeof(struct soc_camera_format_xlate)); 406 if (!icd->user_formats) 407 return -ENOMEM; 408 409 dev_dbg(icd->pdev, "Found %d supported formats.\n", fmts); 410 411 /* Second pass - actually fill data formats */ 412 fmts = 0; 413 for (i = 0; i < raw_fmts; i++) 414 if (!ici->ops->get_formats) { 415 v4l2_subdev_call(sd, video, enum_mbus_fmt, i, &code); 416 icd->user_formats[fmts].host_fmt = 417 soc_mbus_get_fmtdesc(code); 418 if (icd->user_formats[fmts].host_fmt) 419 icd->user_formats[fmts++].code = code; 420 } else { 421 ret = ici->ops->get_formats(icd, i, 422 &icd->user_formats[fmts]); 423 if (ret < 0) 424 goto egfmt; 425 fmts += ret; 426 } 427 428 icd->num_user_formats = fmts; 429 icd->current_fmt = &icd->user_formats[0]; 430 431 return 0; 432 433egfmt: 434 vfree(icd->user_formats); 435 return ret; 436} 437 438/* Always entered with .video_lock held */ 439static void soc_camera_free_user_formats(struct soc_camera_device *icd) 440{ 441 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 442 443 if (ici->ops->put_formats) 444 ici->ops->put_formats(icd); 445 icd->current_fmt = NULL; 446 icd->num_user_formats = 0; 447 vfree(icd->user_formats); 448 icd->user_formats = NULL; 449} 450 451/* Called with .vb_lock held, or from the first open(2), see comment there */ 452static int soc_camera_set_fmt(struct soc_camera_device *icd, 453 struct v4l2_format *f) 454{ 455 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 456 struct v4l2_pix_format *pix = &f->fmt.pix; 457 int ret; 458 459 dev_dbg(icd->pdev, "S_FMT(%c%c%c%c, %ux%u)\n", 460 pixfmtstr(pix->pixelformat), pix->width, pix->height); 461 462 /* We always call try_fmt() before set_fmt() or set_crop() */ 463 ret = soc_camera_try_fmt(icd, f); 464 if (ret < 0) 465 return ret; 466 467 ret = ici->ops->set_fmt(icd, f); 468 if (ret < 0) { 469 return ret; 470 } else if (!icd->current_fmt || 471 icd->current_fmt->host_fmt->fourcc != pix->pixelformat) { 472 dev_err(icd->pdev, 473 "Host driver hasn't set up current format correctly!\n"); 474 return -EINVAL; 475 } 476 477 icd->user_width = pix->width; 478 icd->user_height = pix->height; 479 icd->bytesperline = pix->bytesperline; 480 icd->sizeimage = pix->sizeimage; 481 icd->colorspace = pix->colorspace; 482 icd->field = pix->field; 483 if (ici->ops->init_videobuf) 484 icd->vb_vidq.field = pix->field; 485 486 dev_dbg(icd->pdev, "set width: %d height: %d\n", 487 icd->user_width, icd->user_height); 488 489 /* set physical bus parameters */ 490 return ici->ops->set_bus_param(icd); 491} 492 493static int soc_camera_open(struct file *file) 494{ 495 struct video_device *vdev = video_devdata(file); 496 struct soc_camera_device *icd = dev_get_drvdata(vdev->parent); 497 struct soc_camera_link *icl = to_soc_camera_link(icd); 498 struct soc_camera_host *ici; 499 int ret; 500 501 if (!to_soc_camera_control(icd)) 502 /* No device driver attached */ 503 return -ENODEV; 504 505 ici = to_soc_camera_host(icd->parent); 506 507 if (!try_module_get(ici->ops->owner)) { 508 dev_err(icd->pdev, "Couldn't lock capture bus driver.\n"); 509 return -EINVAL; 510 } 511 512 icd->use_count++; 513 514 /* Now we really have to activate the camera */ 515 if (icd->use_count == 1) { 516 /* Restore parameters before the last close() per V4L2 API */ 517 struct v4l2_format f = { 518 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE, 519 .fmt.pix = { 520 .width = icd->user_width, 521 .height = icd->user_height, 522 .field = icd->field, 523 .colorspace = icd->colorspace, 524 .pixelformat = 525 icd->current_fmt->host_fmt->fourcc, 526 }, 527 }; 528 529 /* The camera could have been already on, try to reset */ 530 if (icl->reset) 531 icl->reset(icd->pdev); 532 533 /* Don't mess with the host during probe */ 534 mutex_lock(&ici->host_lock); 535 ret = ici->ops->add(icd); 536 mutex_unlock(&ici->host_lock); 537 if (ret < 0) { 538 dev_err(icd->pdev, "Couldn't activate the camera: %d\n", ret); 539 goto eiciadd; 540 } 541 542 ret = soc_camera_power_on(icd, icl); 543 if (ret < 0) 544 goto epower; 545 546 pm_runtime_enable(&icd->vdev->dev); 547 ret = pm_runtime_resume(&icd->vdev->dev); 548 if (ret < 0 && ret != -ENOSYS) 549 goto eresume; 550 551 /* 552 * Try to configure with default parameters. Notice: this is the 553 * very first open, so, we cannot race against other calls, 554 * apart from someone else calling open() simultaneously, but 555 * .video_lock is protecting us against it. 556 */ 557 ret = soc_camera_set_fmt(icd, &f); 558 if (ret < 0) 559 goto esfmt; 560 561 if (ici->ops->init_videobuf) { 562 ici->ops->init_videobuf(&icd->vb_vidq, icd); 563 } else { 564 ret = ici->ops->init_videobuf2(&icd->vb2_vidq, icd); 565 if (ret < 0) 566 goto einitvb; 567 } 568 v4l2_ctrl_handler_setup(&icd->ctrl_handler); 569 } 570 571 file->private_data = icd; 572 dev_dbg(icd->pdev, "camera device open\n"); 573 574 return 0; 575 576 /* 577 * First four errors are entered with the .video_lock held 578 * and use_count == 1 579 */ 580einitvb: 581esfmt: 582 pm_runtime_disable(&icd->vdev->dev); 583eresume: 584 soc_camera_power_off(icd, icl); 585epower: 586 ici->ops->remove(icd); 587eiciadd: 588 icd->use_count--; 589 module_put(ici->ops->owner); 590 591 return ret; 592} 593 594static int soc_camera_close(struct file *file) 595{ 596 struct soc_camera_device *icd = file->private_data; 597 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 598 599 icd->use_count--; 600 if (!icd->use_count) { 601 struct soc_camera_link *icl = to_soc_camera_link(icd); 602 603 pm_runtime_suspend(&icd->vdev->dev); 604 pm_runtime_disable(&icd->vdev->dev); 605 606 if (ici->ops->init_videobuf2) 607 vb2_queue_release(&icd->vb2_vidq); 608 ici->ops->remove(icd); 609 610 soc_camera_power_off(icd, icl); 611 } 612 613 if (icd->streamer == file) 614 icd->streamer = NULL; 615 616 module_put(ici->ops->owner); 617 618 dev_dbg(icd->pdev, "camera device close\n"); 619 620 return 0; 621} 622 623static ssize_t soc_camera_read(struct file *file, char __user *buf, 624 size_t count, loff_t *ppos) 625{ 626 struct soc_camera_device *icd = file->private_data; 627 int err = -EINVAL; 628 629 dev_err(icd->pdev, "camera device read not implemented\n"); 630 631 return err; 632} 633 634static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma) 635{ 636 struct soc_camera_device *icd = file->private_data; 637 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 638 int err; 639 640 dev_dbg(icd->pdev, "mmap called, vma=0x%08lx\n", (unsigned long)vma); 641 642 if (icd->streamer != file) 643 return -EBUSY; 644 645 if (ici->ops->init_videobuf) 646 err = videobuf_mmap_mapper(&icd->vb_vidq, vma); 647 else 648 err = vb2_mmap(&icd->vb2_vidq, vma); 649 650 dev_dbg(icd->pdev, "vma start=0x%08lx, size=%ld, ret=%d\n", 651 (unsigned long)vma->vm_start, 652 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start, 653 err); 654 655 return err; 656} 657 658static unsigned int soc_camera_poll(struct file *file, poll_table *pt) 659{ 660 struct soc_camera_device *icd = file->private_data; 661 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 662 663 if (icd->streamer != file) 664 return -EBUSY; 665 666 if (ici->ops->init_videobuf && list_empty(&icd->vb_vidq.stream)) { 667 dev_err(icd->pdev, "Trying to poll with no queued buffers!\n"); 668 return POLLERR; 669 } 670 671 return ici->ops->poll(file, pt); 672} 673 674void soc_camera_lock(struct vb2_queue *vq) 675{ 676 struct soc_camera_device *icd = vb2_get_drv_priv(vq); 677 mutex_lock(&icd->video_lock); 678} 679EXPORT_SYMBOL(soc_camera_lock); 680 681void soc_camera_unlock(struct vb2_queue *vq) 682{ 683 struct soc_camera_device *icd = vb2_get_drv_priv(vq); 684 mutex_unlock(&icd->video_lock); 685} 686EXPORT_SYMBOL(soc_camera_unlock); 687 688static struct v4l2_file_operations soc_camera_fops = { 689 .owner = THIS_MODULE, 690 .open = soc_camera_open, 691 .release = soc_camera_close, 692 .unlocked_ioctl = video_ioctl2, 693 .read = soc_camera_read, 694 .mmap = soc_camera_mmap, 695 .poll = soc_camera_poll, 696}; 697 698static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv, 699 struct v4l2_format *f) 700{ 701 struct soc_camera_device *icd = file->private_data; 702 int ret; 703 704 WARN_ON(priv != file->private_data); 705 706 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 707 dev_warn(icd->pdev, "Wrong buf-type %d\n", f->type); 708 return -EINVAL; 709 } 710 711 if (icd->streamer && icd->streamer != file) 712 return -EBUSY; 713 714 if (is_streaming(to_soc_camera_host(icd->parent), icd)) { 715 dev_err(icd->pdev, "S_FMT denied: queue initialised\n"); 716 return -EBUSY; 717 } 718 719 ret = soc_camera_set_fmt(icd, f); 720 721 if (!ret && !icd->streamer) 722 icd->streamer = file; 723 724 return ret; 725} 726 727static int soc_camera_enum_fmt_vid_cap(struct file *file, void *priv, 728 struct v4l2_fmtdesc *f) 729{ 730 struct soc_camera_device *icd = file->private_data; 731 const struct soc_mbus_pixelfmt *format; 732 733 WARN_ON(priv != file->private_data); 734 735 if (f->index >= icd->num_user_formats) 736 return -EINVAL; 737 738 format = icd->user_formats[f->index].host_fmt; 739 740 if (format->name) 741 strlcpy(f->description, format->name, sizeof(f->description)); 742 f->pixelformat = format->fourcc; 743 return 0; 744} 745 746static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv, 747 struct v4l2_format *f) 748{ 749 struct soc_camera_device *icd = file->private_data; 750 struct v4l2_pix_format *pix = &f->fmt.pix; 751 752 WARN_ON(priv != file->private_data); 753 754 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 755 return -EINVAL; 756 757 pix->width = icd->user_width; 758 pix->height = icd->user_height; 759 pix->bytesperline = icd->bytesperline; 760 pix->sizeimage = icd->sizeimage; 761 pix->field = icd->field; 762 pix->pixelformat = icd->current_fmt->host_fmt->fourcc; 763 pix->colorspace = icd->colorspace; 764 dev_dbg(icd->pdev, "current_fmt->fourcc: 0x%08x\n", 765 icd->current_fmt->host_fmt->fourcc); 766 return 0; 767} 768 769static int soc_camera_querycap(struct file *file, void *priv, 770 struct v4l2_capability *cap) 771{ 772 struct soc_camera_device *icd = file->private_data; 773 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 774 775 WARN_ON(priv != file->private_data); 776 777 strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver)); 778 return ici->ops->querycap(ici, cap); 779} 780 781static int soc_camera_streamon(struct file *file, void *priv, 782 enum v4l2_buf_type i) 783{ 784 struct soc_camera_device *icd = file->private_data; 785 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 786 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 787 int ret; 788 789 WARN_ON(priv != file->private_data); 790 791 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE) 792 return -EINVAL; 793 794 if (icd->streamer != file) 795 return -EBUSY; 796 797 /* This calls buf_queue from host driver's videobuf_queue_ops */ 798 if (ici->ops->init_videobuf) 799 ret = videobuf_streamon(&icd->vb_vidq); 800 else 801 ret = vb2_streamon(&icd->vb2_vidq, i); 802 803 if (!ret) 804 v4l2_subdev_call(sd, video, s_stream, 1); 805 806 return ret; 807} 808 809static int soc_camera_streamoff(struct file *file, void *priv, 810 enum v4l2_buf_type i) 811{ 812 struct soc_camera_device *icd = file->private_data; 813 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 814 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 815 816 WARN_ON(priv != file->private_data); 817 818 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE) 819 return -EINVAL; 820 821 if (icd->streamer != file) 822 return -EBUSY; 823 824 /* 825 * This calls buf_release from host driver's videobuf_queue_ops for all 826 * remaining buffers. When the last buffer is freed, stop capture 827 */ 828 if (ici->ops->init_videobuf) 829 videobuf_streamoff(&icd->vb_vidq); 830 else 831 vb2_streamoff(&icd->vb2_vidq, i); 832 833 v4l2_subdev_call(sd, video, s_stream, 0); 834 835 return 0; 836} 837 838static int soc_camera_cropcap(struct file *file, void *fh, 839 struct v4l2_cropcap *a) 840{ 841 struct soc_camera_device *icd = file->private_data; 842 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 843 844 return ici->ops->cropcap(icd, a); 845} 846 847static int soc_camera_g_crop(struct file *file, void *fh, 848 struct v4l2_crop *a) 849{ 850 struct soc_camera_device *icd = file->private_data; 851 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 852 int ret; 853 854 ret = ici->ops->get_crop(icd, a); 855 856 return ret; 857} 858 859/* 860 * According to the V4L2 API, drivers shall not update the struct v4l2_crop 861 * argument with the actual geometry, instead, the user shall use G_CROP to 862 * retrieve it. 863 */ 864static int soc_camera_s_crop(struct file *file, void *fh, 865 struct v4l2_crop *a) 866{ 867 struct soc_camera_device *icd = file->private_data; 868 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 869 struct v4l2_rect *rect = &a->c; 870 struct v4l2_crop current_crop; 871 int ret; 872 873 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) 874 return -EINVAL; 875 876 dev_dbg(icd->pdev, "S_CROP(%ux%u@%u:%u)\n", 877 rect->width, rect->height, rect->left, rect->top); 878 879 /* If get_crop fails, we'll let host and / or client drivers decide */ 880 ret = ici->ops->get_crop(icd, ¤t_crop); 881 882 /* Prohibit window size change with initialised buffers */ 883 if (ret < 0) { 884 dev_err(icd->pdev, 885 "S_CROP denied: getting current crop failed\n"); 886 } else if ((a->c.width == current_crop.c.width && 887 a->c.height == current_crop.c.height) || 888 !is_streaming(ici, icd)) { 889 /* same size or not streaming - use .set_crop() */ 890 ret = ici->ops->set_crop(icd, a); 891 } else if (ici->ops->set_livecrop) { 892 ret = ici->ops->set_livecrop(icd, a); 893 } else { 894 dev_err(icd->pdev, 895 "S_CROP denied: queue initialised and sizes differ\n"); 896 ret = -EBUSY; 897 } 898 899 return ret; 900} 901 902static int soc_camera_g_parm(struct file *file, void *fh, 903 struct v4l2_streamparm *a) 904{ 905 struct soc_camera_device *icd = file->private_data; 906 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 907 908 if (ici->ops->get_parm) 909 return ici->ops->get_parm(icd, a); 910 911 return -ENOIOCTLCMD; 912} 913 914static int soc_camera_s_parm(struct file *file, void *fh, 915 struct v4l2_streamparm *a) 916{ 917 struct soc_camera_device *icd = file->private_data; 918 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 919 920 if (ici->ops->set_parm) 921 return ici->ops->set_parm(icd, a); 922 923 return -ENOIOCTLCMD; 924} 925 926static int soc_camera_g_chip_ident(struct file *file, void *fh, 927 struct v4l2_dbg_chip_ident *id) 928{ 929 struct soc_camera_device *icd = file->private_data; 930 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 931 932 return v4l2_subdev_call(sd, core, g_chip_ident, id); 933} 934 935#ifdef CONFIG_VIDEO_ADV_DEBUG 936static int soc_camera_g_register(struct file *file, void *fh, 937 struct v4l2_dbg_register *reg) 938{ 939 struct soc_camera_device *icd = file->private_data; 940 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 941 942 return v4l2_subdev_call(sd, core, g_register, reg); 943} 944 945static int soc_camera_s_register(struct file *file, void *fh, 946 struct v4l2_dbg_register *reg) 947{ 948 struct soc_camera_device *icd = file->private_data; 949 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 950 951 return v4l2_subdev_call(sd, core, s_register, reg); 952} 953#endif 954 955static int soc_camera_probe(struct soc_camera_device *icd); 956 957/* So far this function cannot fail */ 958static void scan_add_host(struct soc_camera_host *ici) 959{ 960 struct soc_camera_device *icd; 961 962 mutex_lock(&ici->host_lock); 963 964 list_for_each_entry(icd, &devices, list) { 965 if (icd->iface == ici->nr) { 966 int ret; 967 968 icd->parent = ici->v4l2_dev.dev; 969 ret = soc_camera_probe(icd); 970 } 971 } 972 973 mutex_unlock(&ici->host_lock); 974} 975 976#ifdef CONFIG_I2C_BOARDINFO 977static int soc_camera_init_i2c(struct soc_camera_device *icd, 978 struct soc_camera_link *icl) 979{ 980 struct i2c_client *client; 981 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 982 struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id); 983 struct v4l2_subdev *subdev; 984 985 if (!adap) { 986 dev_err(icd->pdev, "Cannot get I2C adapter #%d. No driver?\n", 987 icl->i2c_adapter_id); 988 goto ei2cga; 989 } 990 991 icl->board_info->platform_data = icl; 992 993 subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap, 994 icl->board_info, NULL); 995 if (!subdev) 996 goto ei2cnd; 997 998 client = v4l2_get_subdevdata(subdev); 999 1000 /* Use to_i2c_client(dev) to recover the i2c client */ 1001 icd->control = &client->dev; 1002 1003 return 0; 1004ei2cnd: 1005 i2c_put_adapter(adap); 1006ei2cga: 1007 return -ENODEV; 1008} 1009 1010static void soc_camera_free_i2c(struct soc_camera_device *icd) 1011{ 1012 struct i2c_client *client = 1013 to_i2c_client(to_soc_camera_control(icd)); 1014 struct i2c_adapter *adap = client->adapter; 1015 1016 icd->control = NULL; 1017 v4l2_device_unregister_subdev(i2c_get_clientdata(client)); 1018 i2c_unregister_device(client); 1019 i2c_put_adapter(adap); 1020} 1021#else 1022#define soc_camera_init_i2c(icd, icl) (-ENODEV) 1023#define soc_camera_free_i2c(icd) do {} while (0) 1024#endif 1025 1026static int soc_camera_video_start(struct soc_camera_device *icd); 1027static int video_dev_create(struct soc_camera_device *icd); 1028/* Called during host-driver probe */ 1029static int soc_camera_probe(struct soc_camera_device *icd) 1030{ 1031 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 1032 struct soc_camera_link *icl = to_soc_camera_link(icd); 1033 struct device *control = NULL; 1034 struct v4l2_subdev *sd; 1035 struct v4l2_mbus_framefmt mf; 1036 int ret; 1037 1038 dev_info(icd->pdev, "Probing %s\n", dev_name(icd->pdev)); 1039 1040 /* 1041 * Currently the subdev with the largest number of controls (13) is 1042 * ov6550. So let's pick 16 as a hint for the control handler. Note 1043 * that this is a hint only: too large and you waste some memory, too 1044 * small and there is a (very) small performance hit when looking up 1045 * controls in the internal hash. 1046 */ 1047 ret = v4l2_ctrl_handler_init(&icd->ctrl_handler, 16); 1048 if (ret < 0) 1049 return ret; 1050 1051 ret = regulator_bulk_get(icd->pdev, icl->num_regulators, 1052 icl->regulators); 1053 if (ret < 0) 1054 goto ereg; 1055 1056 /* The camera could have been already on, try to reset */ 1057 if (icl->reset) 1058 icl->reset(icd->pdev); 1059 1060 ret = ici->ops->add(icd); 1061 if (ret < 0) 1062 goto eadd; 1063 1064 /* 1065 * This will not yet call v4l2_subdev_core_ops::s_power(1), because the 1066 * subdevice has not been initialised yet. We'll have to call it once 1067 * again after initialisation, even though it shouldn't be needed, we 1068 * don't do any IO here. 1069 */ 1070 ret = soc_camera_power_on(icd, icl); 1071 if (ret < 0) 1072 goto epower; 1073 1074 /* Must have icd->vdev before registering the device */ 1075 ret = video_dev_create(icd); 1076 if (ret < 0) 1077 goto evdc; 1078 1079 /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */ 1080 if (icl->board_info) { 1081 ret = soc_camera_init_i2c(icd, icl); 1082 if (ret < 0) 1083 goto eadddev; 1084 } else if (!icl->add_device || !icl->del_device) { 1085 ret = -EINVAL; 1086 goto eadddev; 1087 } else { 1088 if (icl->module_name) 1089 ret = request_module(icl->module_name); 1090 1091 ret = icl->add_device(icd); 1092 if (ret < 0) 1093 goto eadddev; 1094 1095 /* 1096 * FIXME: this is racy, have to use driver-binding notification, 1097 * when it is available 1098 */ 1099 control = to_soc_camera_control(icd); 1100 if (!control || !control->driver || !dev_get_drvdata(control) || 1101 !try_module_get(control->driver->owner)) { 1102 icl->del_device(icd); 1103 ret = -ENODEV; 1104 goto enodrv; 1105 } 1106 } 1107 1108 sd = soc_camera_to_subdev(icd); 1109 sd->grp_id = soc_camera_grp_id(icd); 1110 v4l2_set_subdev_hostdata(sd, icd); 1111 1112 if (v4l2_ctrl_add_handler(&icd->ctrl_handler, sd->ctrl_handler)) 1113 goto ectrl; 1114 1115 /* At this point client .probe() should have run already */ 1116 ret = soc_camera_init_user_formats(icd); 1117 if (ret < 0) 1118 goto eiufmt; 1119 1120 icd->field = V4L2_FIELD_ANY; 1121 1122 /* 1123 * ..._video_start() will create a device node, video_register_device() 1124 * itself is protected against concurrent open() calls, but we also have 1125 * to protect our data. 1126 */ 1127 mutex_lock(&icd->video_lock); 1128 1129 ret = soc_camera_video_start(icd); 1130 if (ret < 0) 1131 goto evidstart; 1132 1133 ret = v4l2_subdev_call(sd, core, s_power, 1); 1134 if (ret < 0 && ret != -ENOIOCTLCMD) 1135 goto esdpwr; 1136 1137 /* Try to improve our guess of a reasonable window format */ 1138 if (!v4l2_subdev_call(sd, video, g_mbus_fmt, &mf)) { 1139 icd->user_width = mf.width; 1140 icd->user_height = mf.height; 1141 icd->colorspace = mf.colorspace; 1142 icd->field = mf.field; 1143 } 1144 1145 ici->ops->remove(icd); 1146 1147 soc_camera_power_off(icd, icl); 1148 1149 mutex_unlock(&icd->video_lock); 1150 1151 return 0; 1152 1153esdpwr: 1154 video_unregister_device(icd->vdev); 1155evidstart: 1156 mutex_unlock(&icd->video_lock); 1157 soc_camera_free_user_formats(icd); 1158eiufmt: 1159ectrl: 1160 if (icl->board_info) { 1161 soc_camera_free_i2c(icd); 1162 } else { 1163 icl->del_device(icd); 1164 module_put(control->driver->owner); 1165 } 1166enodrv: 1167eadddev: 1168 video_device_release(icd->vdev); 1169 icd->vdev = NULL; 1170evdc: 1171 soc_camera_power_off(icd, icl); 1172epower: 1173 ici->ops->remove(icd); 1174eadd: 1175 regulator_bulk_free(icl->num_regulators, icl->regulators); 1176ereg: 1177 v4l2_ctrl_handler_free(&icd->ctrl_handler); 1178 return ret; 1179} 1180 1181/* 1182 * This is called on device_unregister, which only means we have to disconnect 1183 * from the host, but not remove ourselves from the device list 1184 */ 1185static int soc_camera_remove(struct soc_camera_device *icd) 1186{ 1187 struct soc_camera_link *icl = to_soc_camera_link(icd); 1188 struct video_device *vdev = icd->vdev; 1189 1190 BUG_ON(!icd->parent); 1191 1192 v4l2_ctrl_handler_free(&icd->ctrl_handler); 1193 if (vdev) { 1194 video_unregister_device(vdev); 1195 icd->vdev = NULL; 1196 } 1197 1198 if (icl->board_info) { 1199 soc_camera_free_i2c(icd); 1200 } else { 1201 struct device_driver *drv = to_soc_camera_control(icd)->driver; 1202 if (drv) { 1203 icl->del_device(icd); 1204 module_put(drv->owner); 1205 } 1206 } 1207 soc_camera_free_user_formats(icd); 1208 1209 regulator_bulk_free(icl->num_regulators, icl->regulators); 1210 1211 return 0; 1212} 1213 1214static int default_cropcap(struct soc_camera_device *icd, 1215 struct v4l2_cropcap *a) 1216{ 1217 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 1218 return v4l2_subdev_call(sd, video, cropcap, a); 1219} 1220 1221static int default_g_crop(struct soc_camera_device *icd, struct v4l2_crop *a) 1222{ 1223 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 1224 return v4l2_subdev_call(sd, video, g_crop, a); 1225} 1226 1227static int default_s_crop(struct soc_camera_device *icd, struct v4l2_crop *a) 1228{ 1229 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 1230 return v4l2_subdev_call(sd, video, s_crop, a); 1231} 1232 1233static int default_g_parm(struct soc_camera_device *icd, 1234 struct v4l2_streamparm *parm) 1235{ 1236 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 1237 return v4l2_subdev_call(sd, video, g_parm, parm); 1238} 1239 1240static int default_s_parm(struct soc_camera_device *icd, 1241 struct v4l2_streamparm *parm) 1242{ 1243 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 1244 return v4l2_subdev_call(sd, video, s_parm, parm); 1245} 1246 1247static int default_enum_fsizes(struct soc_camera_device *icd, 1248 struct v4l2_frmsizeenum *fsize) 1249{ 1250 int ret; 1251 struct v4l2_subdev *sd = soc_camera_to_subdev(icd); 1252 const struct soc_camera_format_xlate *xlate; 1253 __u32 pixfmt = fsize->pixel_format; 1254 struct v4l2_frmsizeenum fsize_mbus = *fsize; 1255 1256 xlate = soc_camera_xlate_by_fourcc(icd, pixfmt); 1257 if (!xlate) 1258 return -EINVAL; 1259 /* map xlate-code to pixel_format, sensor only handle xlate-code*/ 1260 fsize_mbus.pixel_format = xlate->code; 1261 1262 ret = v4l2_subdev_call(sd, video, enum_mbus_fsizes, &fsize_mbus); 1263 if (ret < 0) 1264 return ret; 1265 1266 *fsize = fsize_mbus; 1267 fsize->pixel_format = pixfmt; 1268 1269 return 0; 1270} 1271 1272int soc_camera_host_register(struct soc_camera_host *ici) 1273{ 1274 struct soc_camera_host *ix; 1275 int ret; 1276 1277 if (!ici || !ici->ops || 1278 !ici->ops->try_fmt || 1279 !ici->ops->set_fmt || 1280 !ici->ops->set_bus_param || 1281 !ici->ops->querycap || 1282 ((!ici->ops->init_videobuf || 1283 !ici->ops->reqbufs) && 1284 !ici->ops->init_videobuf2) || 1285 !ici->ops->add || 1286 !ici->ops->remove || 1287 !ici->ops->poll || 1288 !ici->v4l2_dev.dev) 1289 return -EINVAL; 1290 1291 if (!ici->ops->set_crop) 1292 ici->ops->set_crop = default_s_crop; 1293 if (!ici->ops->get_crop) 1294 ici->ops->get_crop = default_g_crop; 1295 if (!ici->ops->cropcap) 1296 ici->ops->cropcap = default_cropcap; 1297 if (!ici->ops->set_parm) 1298 ici->ops->set_parm = default_s_parm; 1299 if (!ici->ops->get_parm) 1300 ici->ops->get_parm = default_g_parm; 1301 if (!ici->ops->enum_fsizes) 1302 ici->ops->enum_fsizes = default_enum_fsizes; 1303 1304 mutex_lock(&list_lock); 1305 list_for_each_entry(ix, &hosts, list) { 1306 if (ix->nr == ici->nr) { 1307 ret = -EBUSY; 1308 goto edevreg; 1309 } 1310 } 1311 1312 ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev); 1313 if (ret < 0) 1314 goto edevreg; 1315 1316 list_add_tail(&ici->list, &hosts); 1317 mutex_unlock(&list_lock); 1318 1319 mutex_init(&ici->host_lock); 1320 scan_add_host(ici); 1321 1322 return 0; 1323 1324edevreg: 1325 mutex_unlock(&list_lock); 1326 return ret; 1327} 1328EXPORT_SYMBOL(soc_camera_host_register); 1329 1330/* Unregister all clients! */ 1331void soc_camera_host_unregister(struct soc_camera_host *ici) 1332{ 1333 struct soc_camera_device *icd; 1334 1335 mutex_lock(&list_lock); 1336 1337 list_del(&ici->list); 1338 list_for_each_entry(icd, &devices, list) 1339 if (icd->iface == ici->nr && to_soc_camera_control(icd)) 1340 soc_camera_remove(icd); 1341 1342 mutex_unlock(&list_lock); 1343 1344 v4l2_device_unregister(&ici->v4l2_dev); 1345} 1346EXPORT_SYMBOL(soc_camera_host_unregister); 1347 1348/* Image capture device */ 1349static int soc_camera_device_register(struct soc_camera_device *icd) 1350{ 1351 struct soc_camera_device *ix; 1352 int num = -1, i; 1353 1354 for (i = 0; i < 256 && num < 0; i++) { 1355 num = i; 1356 /* Check if this index is available on this interface */ 1357 list_for_each_entry(ix, &devices, list) { 1358 if (ix->iface == icd->iface && ix->devnum == i) { 1359 num = -1; 1360 break; 1361 } 1362 } 1363 } 1364 1365 if (num < 0) 1366 /* 1367 * ok, we have 256 cameras on this host... 1368 * man, stay reasonable... 1369 */ 1370 return -ENOMEM; 1371 1372 icd->devnum = num; 1373 icd->use_count = 0; 1374 icd->host_priv = NULL; 1375 mutex_init(&icd->video_lock); 1376 1377 list_add_tail(&icd->list, &devices); 1378 1379 return 0; 1380} 1381 1382static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = { 1383 .vidioc_querycap = soc_camera_querycap, 1384 .vidioc_try_fmt_vid_cap = soc_camera_try_fmt_vid_cap, 1385 .vidioc_g_fmt_vid_cap = soc_camera_g_fmt_vid_cap, 1386 .vidioc_s_fmt_vid_cap = soc_camera_s_fmt_vid_cap, 1387 .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap, 1388 .vidioc_enum_input = soc_camera_enum_input, 1389 .vidioc_g_input = soc_camera_g_input, 1390 .vidioc_s_input = soc_camera_s_input, 1391 .vidioc_s_std = soc_camera_s_std, 1392 .vidioc_g_std = soc_camera_g_std, 1393 .vidioc_enum_framesizes = soc_camera_enum_fsizes, 1394 .vidioc_reqbufs = soc_camera_reqbufs, 1395 .vidioc_querybuf = soc_camera_querybuf, 1396 .vidioc_qbuf = soc_camera_qbuf, 1397 .vidioc_dqbuf = soc_camera_dqbuf, 1398 .vidioc_create_bufs = soc_camera_create_bufs, 1399 .vidioc_prepare_buf = soc_camera_prepare_buf, 1400 .vidioc_streamon = soc_camera_streamon, 1401 .vidioc_streamoff = soc_camera_streamoff, 1402 .vidioc_cropcap = soc_camera_cropcap, 1403 .vidioc_g_crop = soc_camera_g_crop, 1404 .vidioc_s_crop = soc_camera_s_crop, 1405 .vidioc_g_parm = soc_camera_g_parm, 1406 .vidioc_s_parm = soc_camera_s_parm, 1407 .vidioc_g_chip_ident = soc_camera_g_chip_ident, 1408#ifdef CONFIG_VIDEO_ADV_DEBUG 1409 .vidioc_g_register = soc_camera_g_register, 1410 .vidioc_s_register = soc_camera_s_register, 1411#endif 1412}; 1413 1414static int video_dev_create(struct soc_camera_device *icd) 1415{ 1416 struct soc_camera_host *ici = to_soc_camera_host(icd->parent); 1417 struct video_device *vdev = video_device_alloc(); 1418 1419 if (!vdev) 1420 return -ENOMEM; 1421 1422 strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name)); 1423 1424 vdev->parent = icd->pdev; 1425 vdev->current_norm = V4L2_STD_UNKNOWN; 1426 vdev->fops = &soc_camera_fops; 1427 vdev->ioctl_ops = &soc_camera_ioctl_ops; 1428 vdev->release = video_device_release; 1429 vdev->tvnorms = V4L2_STD_UNKNOWN; 1430 vdev->ctrl_handler = &icd->ctrl_handler; 1431 vdev->lock = &icd->video_lock; 1432 1433 icd->vdev = vdev; 1434 1435 return 0; 1436} 1437 1438/* 1439 * Called from soc_camera_probe() above (with .video_lock held???) 1440 */ 1441static int soc_camera_video_start(struct soc_camera_device *icd) 1442{ 1443 const struct device_type *type = icd->vdev->dev.type; 1444 int ret; 1445 1446 if (!icd->parent) 1447 return -ENODEV; 1448 1449 ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER, -1); 1450 if (ret < 0) { 1451 dev_err(icd->pdev, "video_register_device failed: %d\n", ret); 1452 return ret; 1453 } 1454 1455 /* Restore device type, possibly set by the subdevice driver */ 1456 icd->vdev->dev.type = type; 1457 1458 return 0; 1459} 1460 1461static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev) 1462{ 1463 struct soc_camera_link *icl = pdev->dev.platform_data; 1464 struct soc_camera_device *icd; 1465 int ret; 1466 1467 if (!icl) 1468 return -EINVAL; 1469 1470 icd = kzalloc(sizeof(*icd), GFP_KERNEL); 1471 if (!icd) 1472 return -ENOMEM; 1473 1474 icd->iface = icl->bus_id; 1475 icd->link = icl; 1476 icd->pdev = &pdev->dev; 1477 platform_set_drvdata(pdev, icd); 1478 1479 ret = soc_camera_device_register(icd); 1480 if (ret < 0) 1481 goto escdevreg; 1482 1483 icd->user_width = DEFAULT_WIDTH; 1484 icd->user_height = DEFAULT_HEIGHT; 1485 1486 return 0; 1487 1488escdevreg: 1489 kfree(icd); 1490 1491 return ret; 1492} 1493 1494/* 1495 * Only called on rmmod for each platform device, since they are not 1496 * hot-pluggable. Now we know, that all our users - hosts and devices have 1497 * been unloaded already 1498 */ 1499static int __devexit soc_camera_pdrv_remove(struct platform_device *pdev) 1500{ 1501 struct soc_camera_device *icd = platform_get_drvdata(pdev); 1502 1503 if (!icd) 1504 return -EINVAL; 1505 1506 list_del(&icd->list); 1507 1508 kfree(icd); 1509 1510 return 0; 1511} 1512 1513static struct platform_driver __refdata soc_camera_pdrv = { 1514 .remove = __devexit_p(soc_camera_pdrv_remove), 1515 .driver = { 1516 .name = "soc-camera-pdrv", 1517 .owner = THIS_MODULE, 1518 }, 1519}; 1520 1521static int __init soc_camera_init(void) 1522{ 1523 return platform_driver_probe(&soc_camera_pdrv, soc_camera_pdrv_probe); 1524} 1525 1526static void __exit soc_camera_exit(void) 1527{ 1528 platform_driver_unregister(&soc_camera_pdrv); 1529} 1530 1531module_init(soc_camera_init); 1532module_exit(soc_camera_exit); 1533 1534MODULE_DESCRIPTION("Image capture bus driver"); 1535MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>"); 1536MODULE_LICENSE("GPL"); 1537MODULE_ALIAS("platform:soc-camera-pdrv"); 1538