2 * camera image capture (abstract) bus driver
4 * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
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.
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.
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/device.h>
22 #include <linux/list.h>
23 #include <linux/err.h>
24 #include <linux/mutex.h>
25 #include <linux/vmalloc.h>
27 #include <media/v4l2-common.h>
28 #include <media/v4l2-ioctl.h>
29 #include <media/v4l2-dev.h>
30 #include <media/videobuf-core.h>
31 #include <media/soc_camera.h>
33 static LIST_HEAD(hosts
);
34 static LIST_HEAD(devices
);
35 static DEFINE_MUTEX(list_lock
);
37 const struct soc_camera_data_format
*soc_camera_format_by_fourcc(
38 struct soc_camera_device
*icd
, unsigned int fourcc
)
42 for (i
= 0; i
< icd
->num_formats
; i
++)
43 if (icd
->formats
[i
].fourcc
== fourcc
)
44 return icd
->formats
+ i
;
47 EXPORT_SYMBOL(soc_camera_format_by_fourcc
);
49 const struct soc_camera_format_xlate
*soc_camera_xlate_by_fourcc(
50 struct soc_camera_device
*icd
, unsigned int fourcc
)
54 for (i
= 0; i
< icd
->num_user_formats
; i
++)
55 if (icd
->user_formats
[i
].host_fmt
->fourcc
== fourcc
)
56 return icd
->user_formats
+ i
;
59 EXPORT_SYMBOL(soc_camera_xlate_by_fourcc
);
62 * soc_camera_apply_sensor_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
63 * @icl: camera platform parameters
64 * @flags: flags to be inverted according to platform configuration
65 * @return: resulting flags
67 unsigned long soc_camera_apply_sensor_flags(struct soc_camera_link
*icl
,
72 /* If only one of the two polarities is supported, switch to the opposite */
73 if (icl
->flags
& SOCAM_SENSOR_INVERT_HSYNC
) {
74 f
= flags
& (SOCAM_HSYNC_ACTIVE_HIGH
| SOCAM_HSYNC_ACTIVE_LOW
);
75 if (f
== SOCAM_HSYNC_ACTIVE_HIGH
|| f
== SOCAM_HSYNC_ACTIVE_LOW
)
76 flags
^= SOCAM_HSYNC_ACTIVE_HIGH
| SOCAM_HSYNC_ACTIVE_LOW
;
79 if (icl
->flags
& SOCAM_SENSOR_INVERT_VSYNC
) {
80 f
= flags
& (SOCAM_VSYNC_ACTIVE_HIGH
| SOCAM_VSYNC_ACTIVE_LOW
);
81 if (f
== SOCAM_VSYNC_ACTIVE_HIGH
|| f
== SOCAM_VSYNC_ACTIVE_LOW
)
82 flags
^= SOCAM_VSYNC_ACTIVE_HIGH
| SOCAM_VSYNC_ACTIVE_LOW
;
85 if (icl
->flags
& SOCAM_SENSOR_INVERT_PCLK
) {
86 f
= flags
& (SOCAM_PCLK_SAMPLE_RISING
| SOCAM_PCLK_SAMPLE_FALLING
);
87 if (f
== SOCAM_PCLK_SAMPLE_RISING
|| f
== SOCAM_PCLK_SAMPLE_FALLING
)
88 flags
^= SOCAM_PCLK_SAMPLE_RISING
| SOCAM_PCLK_SAMPLE_FALLING
;
93 EXPORT_SYMBOL(soc_camera_apply_sensor_flags
);
95 static int soc_camera_try_fmt_vid_cap(struct file
*file
, void *priv
,
96 struct v4l2_format
*f
)
98 struct soc_camera_file
*icf
= file
->private_data
;
99 struct soc_camera_device
*icd
= icf
->icd
;
100 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
102 WARN_ON(priv
!= file
->private_data
);
104 /* limit format to hardware capabilities */
105 return ici
->ops
->try_fmt(icd
, f
);
108 static int soc_camera_enum_input(struct file
*file
, void *priv
,
109 struct v4l2_input
*inp
)
111 struct soc_camera_file
*icf
= file
->private_data
;
112 struct soc_camera_device
*icd
= icf
->icd
;
118 if (icd
->ops
->enum_input
)
119 ret
= icd
->ops
->enum_input(icd
, inp
);
121 /* default is camera */
122 inp
->type
= V4L2_INPUT_TYPE_CAMERA
;
123 inp
->std
= V4L2_STD_UNKNOWN
;
124 strcpy(inp
->name
, "Camera");
130 static int soc_camera_g_input(struct file
*file
, void *priv
, unsigned int *i
)
137 static int soc_camera_s_input(struct file
*file
, void *priv
, unsigned int i
)
145 static int soc_camera_s_std(struct file
*file
, void *priv
, v4l2_std_id
*a
)
147 struct soc_camera_file
*icf
= file
->private_data
;
148 struct soc_camera_device
*icd
= icf
->icd
;
151 if (icd
->ops
->set_std
)
152 ret
= icd
->ops
->set_std(icd
, a
);
157 static int soc_camera_reqbufs(struct file
*file
, void *priv
,
158 struct v4l2_requestbuffers
*p
)
161 struct soc_camera_file
*icf
= file
->private_data
;
162 struct soc_camera_device
*icd
= icf
->icd
;
163 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
165 WARN_ON(priv
!= file
->private_data
);
167 dev_dbg(&icd
->dev
, "%s: %d\n", __func__
, p
->memory
);
169 ret
= videobuf_reqbufs(&icf
->vb_vidq
, p
);
173 return ici
->ops
->reqbufs(icf
, p
);
176 static int soc_camera_querybuf(struct file
*file
, void *priv
,
177 struct v4l2_buffer
*p
)
179 struct soc_camera_file
*icf
= file
->private_data
;
181 WARN_ON(priv
!= file
->private_data
);
183 return videobuf_querybuf(&icf
->vb_vidq
, p
);
186 static int soc_camera_qbuf(struct file
*file
, void *priv
,
187 struct v4l2_buffer
*p
)
189 struct soc_camera_file
*icf
= file
->private_data
;
191 WARN_ON(priv
!= file
->private_data
);
193 return videobuf_qbuf(&icf
->vb_vidq
, p
);
196 static int soc_camera_dqbuf(struct file
*file
, void *priv
,
197 struct v4l2_buffer
*p
)
199 struct soc_camera_file
*icf
= file
->private_data
;
201 WARN_ON(priv
!= file
->private_data
);
203 return videobuf_dqbuf(&icf
->vb_vidq
, p
, file
->f_flags
& O_NONBLOCK
);
206 static int soc_camera_init_user_formats(struct soc_camera_device
*icd
)
208 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
211 if (!ici
->ops
->get_formats
)
213 * Fallback mode - the host will have to serve all
214 * sensor-provided formats one-to-one to the user
216 fmts
= icd
->num_formats
;
219 * First pass - only count formats this host-sensor
220 * configuration can provide
222 for (i
= 0; i
< icd
->num_formats
; i
++)
223 fmts
+= ici
->ops
->get_formats(icd
, i
, NULL
);
229 vmalloc(fmts
* sizeof(struct soc_camera_format_xlate
));
230 if (!icd
->user_formats
)
233 icd
->num_user_formats
= fmts
;
236 dev_dbg(&icd
->dev
, "Found %d supported formats.\n", fmts
);
238 /* Second pass - actually fill data formats */
239 for (i
= 0; i
< icd
->num_formats
; i
++)
240 if (!ici
->ops
->get_formats
) {
241 icd
->user_formats
[i
].host_fmt
= icd
->formats
+ i
;
242 icd
->user_formats
[i
].cam_fmt
= icd
->formats
+ i
;
243 icd
->user_formats
[i
].buswidth
= icd
->formats
[i
].depth
;
245 fmts
+= ici
->ops
->get_formats(icd
, i
,
246 &icd
->user_formats
[fmts
]);
249 icd
->current_fmt
= icd
->user_formats
[0].host_fmt
;
254 static void soc_camera_free_user_formats(struct soc_camera_device
*icd
)
256 vfree(icd
->user_formats
);
259 static int soc_camera_open(struct file
*file
)
261 struct video_device
*vdev
;
262 struct soc_camera_device
*icd
;
263 struct soc_camera_host
*ici
;
264 struct soc_camera_file
*icf
;
267 icf
= vmalloc(sizeof(*icf
));
272 * It is safe to dereference these pointers now as long as a user has
273 * the video device open - we are protected by the held cdev reference.
276 vdev
= video_devdata(file
);
277 icd
= container_of(vdev
->parent
, struct soc_camera_device
, dev
);
278 ici
= to_soc_camera_host(icd
->dev
.parent
);
280 if (!try_module_get(icd
->ops
->owner
)) {
281 dev_err(&icd
->dev
, "Couldn't lock sensor driver.\n");
286 if (!try_module_get(ici
->ops
->owner
)) {
287 dev_err(&icd
->dev
, "Couldn't lock capture bus driver.\n");
292 /* Protect against icd->remove() until we module_get() both drivers. */
293 mutex_lock(&icd
->video_lock
);
298 /* Now we really have to activate the camera */
299 if (icd
->use_count
== 1) {
300 ret
= soc_camera_init_user_formats(icd
);
303 ret
= ici
->ops
->add(icd
);
305 dev_err(&icd
->dev
, "Couldn't activate the camera: %d\n", ret
);
310 mutex_unlock(&icd
->video_lock
);
312 file
->private_data
= icf
;
313 dev_dbg(&icd
->dev
, "camera device open\n");
315 ici
->ops
->init_videobuf(&icf
->vb_vidq
, icd
);
319 /* First two errors are entered with the .video_lock held */
321 soc_camera_free_user_formats(icd
);
324 mutex_unlock(&icd
->video_lock
);
325 module_put(ici
->ops
->owner
);
327 module_put(icd
->ops
->owner
);
333 static int soc_camera_close(struct file
*file
)
335 struct soc_camera_file
*icf
= file
->private_data
;
336 struct soc_camera_device
*icd
= icf
->icd
;
337 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
338 struct video_device
*vdev
= icd
->vdev
;
340 mutex_lock(&icd
->video_lock
);
342 if (!icd
->use_count
) {
343 ici
->ops
->remove(icd
);
344 soc_camera_free_user_formats(icd
);
346 mutex_unlock(&icd
->video_lock
);
348 module_put(icd
->ops
->owner
);
349 module_put(ici
->ops
->owner
);
353 dev_dbg(vdev
->parent
, "camera device close\n");
358 static ssize_t
soc_camera_read(struct file
*file
, char __user
*buf
,
359 size_t count
, loff_t
*ppos
)
361 struct soc_camera_file
*icf
= file
->private_data
;
362 struct soc_camera_device
*icd
= icf
->icd
;
363 struct video_device
*vdev
= icd
->vdev
;
366 dev_err(vdev
->parent
, "camera device read not implemented\n");
371 static int soc_camera_mmap(struct file
*file
, struct vm_area_struct
*vma
)
373 struct soc_camera_file
*icf
= file
->private_data
;
374 struct soc_camera_device
*icd
= icf
->icd
;
377 dev_dbg(&icd
->dev
, "mmap called, vma=0x%08lx\n", (unsigned long)vma
);
379 err
= videobuf_mmap_mapper(&icf
->vb_vidq
, vma
);
381 dev_dbg(&icd
->dev
, "vma start=0x%08lx, size=%ld, ret=%d\n",
382 (unsigned long)vma
->vm_start
,
383 (unsigned long)vma
->vm_end
- (unsigned long)vma
->vm_start
,
389 static unsigned int soc_camera_poll(struct file
*file
, poll_table
*pt
)
391 struct soc_camera_file
*icf
= file
->private_data
;
392 struct soc_camera_device
*icd
= icf
->icd
;
393 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
395 if (list_empty(&icf
->vb_vidq
.stream
)) {
396 dev_err(&icd
->dev
, "Trying to poll with no queued buffers!\n");
400 return ici
->ops
->poll(file
, pt
);
403 static struct v4l2_file_operations soc_camera_fops
= {
404 .owner
= THIS_MODULE
,
405 .open
= soc_camera_open
,
406 .release
= soc_camera_close
,
407 .ioctl
= video_ioctl2
,
408 .read
= soc_camera_read
,
409 .mmap
= soc_camera_mmap
,
410 .poll
= soc_camera_poll
,
413 static int soc_camera_s_fmt_vid_cap(struct file
*file
, void *priv
,
414 struct v4l2_format
*f
)
416 struct soc_camera_file
*icf
= file
->private_data
;
417 struct soc_camera_device
*icd
= icf
->icd
;
418 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
419 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
420 __u32 pixfmt
= pix
->pixelformat
;
422 struct v4l2_rect rect
;
424 WARN_ON(priv
!= file
->private_data
);
426 ret
= soc_camera_try_fmt_vid_cap(file
, priv
, f
);
430 mutex_lock(&icf
->vb_vidq
.vb_lock
);
432 if (videobuf_queue_is_busy(&icf
->vb_vidq
)) {
433 dev_err(&icd
->dev
, "S_FMT denied: queue busy\n");
438 rect
.left
= icd
->x_current
;
439 rect
.top
= icd
->y_current
;
440 rect
.width
= pix
->width
;
441 rect
.height
= pix
->height
;
442 ret
= ici
->ops
->set_fmt(icd
, pix
->pixelformat
, &rect
);
445 } else if (!icd
->current_fmt
||
446 icd
->current_fmt
->fourcc
!= pixfmt
) {
448 "Host driver hasn't set up current format correctly!\n");
453 icd
->width
= rect
.width
;
454 icd
->height
= rect
.height
;
455 icf
->vb_vidq
.field
= pix
->field
;
456 if (f
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
457 dev_warn(&icd
->dev
, "Attention! Wrong buf-type %d\n",
460 dev_dbg(&icd
->dev
, "set width: %d height: %d\n",
461 icd
->width
, icd
->height
);
463 /* set physical bus parameters */
464 ret
= ici
->ops
->set_bus_param(icd
, pixfmt
);
467 mutex_unlock(&icf
->vb_vidq
.vb_lock
);
472 static int soc_camera_enum_fmt_vid_cap(struct file
*file
, void *priv
,
473 struct v4l2_fmtdesc
*f
)
475 struct soc_camera_file
*icf
= file
->private_data
;
476 struct soc_camera_device
*icd
= icf
->icd
;
477 const struct soc_camera_data_format
*format
;
479 WARN_ON(priv
!= file
->private_data
);
481 if (f
->index
>= icd
->num_user_formats
)
484 format
= icd
->user_formats
[f
->index
].host_fmt
;
486 strlcpy(f
->description
, format
->name
, sizeof(f
->description
));
487 f
->pixelformat
= format
->fourcc
;
491 static int soc_camera_g_fmt_vid_cap(struct file
*file
, void *priv
,
492 struct v4l2_format
*f
)
494 struct soc_camera_file
*icf
= file
->private_data
;
495 struct soc_camera_device
*icd
= icf
->icd
;
496 struct v4l2_pix_format
*pix
= &f
->fmt
.pix
;
498 WARN_ON(priv
!= file
->private_data
);
500 pix
->width
= icd
->width
;
501 pix
->height
= icd
->height
;
502 pix
->field
= icf
->vb_vidq
.field
;
503 pix
->pixelformat
= icd
->current_fmt
->fourcc
;
504 pix
->bytesperline
= pix
->width
*
505 DIV_ROUND_UP(icd
->current_fmt
->depth
, 8);
506 pix
->sizeimage
= pix
->height
* pix
->bytesperline
;
507 dev_dbg(&icd
->dev
, "current_fmt->fourcc: 0x%08x\n",
508 icd
->current_fmt
->fourcc
);
512 static int soc_camera_querycap(struct file
*file
, void *priv
,
513 struct v4l2_capability
*cap
)
515 struct soc_camera_file
*icf
= file
->private_data
;
516 struct soc_camera_device
*icd
= icf
->icd
;
517 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
519 WARN_ON(priv
!= file
->private_data
);
521 strlcpy(cap
->driver
, ici
->drv_name
, sizeof(cap
->driver
));
522 return ici
->ops
->querycap(ici
, cap
);
525 static int soc_camera_streamon(struct file
*file
, void *priv
,
526 enum v4l2_buf_type i
)
528 struct soc_camera_file
*icf
= file
->private_data
;
529 struct soc_camera_device
*icd
= icf
->icd
;
532 WARN_ON(priv
!= file
->private_data
);
534 dev_dbg(&icd
->dev
, "%s\n", __func__
);
536 if (i
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
539 mutex_lock(&icd
->video_lock
);
541 icd
->ops
->start_capture(icd
);
543 /* This calls buf_queue from host driver's videobuf_queue_ops */
544 ret
= videobuf_streamon(&icf
->vb_vidq
);
546 mutex_unlock(&icd
->video_lock
);
551 static int soc_camera_streamoff(struct file
*file
, void *priv
,
552 enum v4l2_buf_type i
)
554 struct soc_camera_file
*icf
= file
->private_data
;
555 struct soc_camera_device
*icd
= icf
->icd
;
557 WARN_ON(priv
!= file
->private_data
);
559 dev_dbg(&icd
->dev
, "%s\n", __func__
);
561 if (i
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
564 mutex_lock(&icd
->video_lock
);
566 /* This calls buf_release from host driver's videobuf_queue_ops for all
567 * remaining buffers. When the last buffer is freed, stop capture */
568 videobuf_streamoff(&icf
->vb_vidq
);
570 icd
->ops
->stop_capture(icd
);
572 mutex_unlock(&icd
->video_lock
);
577 static int soc_camera_queryctrl(struct file
*file
, void *priv
,
578 struct v4l2_queryctrl
*qc
)
580 struct soc_camera_file
*icf
= file
->private_data
;
581 struct soc_camera_device
*icd
= icf
->icd
;
584 WARN_ON(priv
!= file
->private_data
);
589 for (i
= 0; i
< icd
->ops
->num_controls
; i
++)
590 if (qc
->id
== icd
->ops
->controls
[i
].id
) {
591 memcpy(qc
, &(icd
->ops
->controls
[i
]),
599 static int soc_camera_g_ctrl(struct file
*file
, void *priv
,
600 struct v4l2_control
*ctrl
)
602 struct soc_camera_file
*icf
= file
->private_data
;
603 struct soc_camera_device
*icd
= icf
->icd
;
605 WARN_ON(priv
!= file
->private_data
);
609 if (icd
->gain
== (unsigned short)~0)
611 ctrl
->value
= icd
->gain
;
613 case V4L2_CID_EXPOSURE
:
614 if (icd
->exposure
== (unsigned short)~0)
616 ctrl
->value
= icd
->exposure
;
620 if (icd
->ops
->get_control
)
621 return icd
->ops
->get_control(icd
, ctrl
);
625 static int soc_camera_s_ctrl(struct file
*file
, void *priv
,
626 struct v4l2_control
*ctrl
)
628 struct soc_camera_file
*icf
= file
->private_data
;
629 struct soc_camera_device
*icd
= icf
->icd
;
631 WARN_ON(priv
!= file
->private_data
);
633 if (icd
->ops
->set_control
)
634 return icd
->ops
->set_control(icd
, ctrl
);
638 static int soc_camera_cropcap(struct file
*file
, void *fh
,
639 struct v4l2_cropcap
*a
)
641 struct soc_camera_file
*icf
= file
->private_data
;
642 struct soc_camera_device
*icd
= icf
->icd
;
644 a
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
645 a
->bounds
.left
= icd
->x_min
;
646 a
->bounds
.top
= icd
->y_min
;
647 a
->bounds
.width
= icd
->width_max
;
648 a
->bounds
.height
= icd
->height_max
;
649 a
->defrect
.left
= icd
->x_min
;
650 a
->defrect
.top
= icd
->y_min
;
651 a
->defrect
.width
= 640;
652 a
->defrect
.height
= 480;
653 a
->pixelaspect
.numerator
= 1;
654 a
->pixelaspect
.denominator
= 1;
659 static int soc_camera_g_crop(struct file
*file
, void *fh
,
662 struct soc_camera_file
*icf
= file
->private_data
;
663 struct soc_camera_device
*icd
= icf
->icd
;
665 a
->type
= V4L2_BUF_TYPE_VIDEO_CAPTURE
;
666 a
->c
.left
= icd
->x_current
;
667 a
->c
.top
= icd
->y_current
;
668 a
->c
.width
= icd
->width
;
669 a
->c
.height
= icd
->height
;
674 static int soc_camera_s_crop(struct file
*file
, void *fh
,
677 struct soc_camera_file
*icf
= file
->private_data
;
678 struct soc_camera_device
*icd
= icf
->icd
;
679 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
682 if (a
->type
!= V4L2_BUF_TYPE_VIDEO_CAPTURE
)
685 /* Cropping is allowed during a running capture, guard consistency */
686 mutex_lock(&icf
->vb_vidq
.vb_lock
);
688 ret
= ici
->ops
->set_fmt(icd
, 0, &a
->c
);
690 icd
->width
= a
->c
.width
;
691 icd
->height
= a
->c
.height
;
692 icd
->x_current
= a
->c
.left
;
693 icd
->y_current
= a
->c
.top
;
696 mutex_unlock(&icf
->vb_vidq
.vb_lock
);
701 static int soc_camera_g_chip_ident(struct file
*file
, void *fh
,
702 struct v4l2_chip_ident
*id
)
704 struct soc_camera_file
*icf
= file
->private_data
;
705 struct soc_camera_device
*icd
= icf
->icd
;
707 if (!icd
->ops
->get_chip_id
)
710 return icd
->ops
->get_chip_id(icd
, id
);
713 #ifdef CONFIG_VIDEO_ADV_DEBUG
714 static int soc_camera_g_register(struct file
*file
, void *fh
,
715 struct v4l2_register
*reg
)
717 struct soc_camera_file
*icf
= file
->private_data
;
718 struct soc_camera_device
*icd
= icf
->icd
;
720 if (!icd
->ops
->get_register
)
723 return icd
->ops
->get_register(icd
, reg
);
726 static int soc_camera_s_register(struct file
*file
, void *fh
,
727 struct v4l2_register
*reg
)
729 struct soc_camera_file
*icf
= file
->private_data
;
730 struct soc_camera_device
*icd
= icf
->icd
;
732 if (!icd
->ops
->set_register
)
735 return icd
->ops
->set_register(icd
, reg
);
739 static int device_register_link(struct soc_camera_device
*icd
)
741 int ret
= device_register(&icd
->dev
);
744 /* Prevent calling device_unregister() */
745 icd
->dev
.parent
= NULL
;
746 dev_err(&icd
->dev
, "Cannot register device: %d\n", ret
);
747 /* Even if probe() was unsuccessful for all registered drivers,
748 * device_register() returns 0, and we add the link, just to
749 * document this camera's control device */
750 } else if (icd
->control
)
751 /* Have to sysfs_remove_link() before device_unregister()? */
752 if (sysfs_create_link(&icd
->dev
.kobj
, &icd
->control
->kobj
,
755 "Failed creating the control symlink\n");
759 /* So far this function cannot fail */
760 static void scan_add_host(struct soc_camera_host
*ici
)
762 struct soc_camera_device
*icd
;
764 mutex_lock(&list_lock
);
766 list_for_each_entry(icd
, &devices
, list
) {
767 if (icd
->iface
== ici
->nr
) {
768 icd
->dev
.parent
= &ici
->dev
;
769 device_register_link(icd
);
773 mutex_unlock(&list_lock
);
776 /* return: 0 if no match found or a match found and
777 * device_register() successful, error code otherwise */
778 static int scan_add_device(struct soc_camera_device
*icd
)
780 struct soc_camera_host
*ici
;
783 mutex_lock(&list_lock
);
785 list_add_tail(&icd
->list
, &devices
);
787 /* Watch out for class_for_each_device / class_find_device API by
788 * Dave Young <hidave.darkstar@gmail.com> */
789 list_for_each_entry(ici
, &hosts
, list
) {
790 if (icd
->iface
== ici
->nr
) {
792 icd
->dev
.parent
= &ici
->dev
;
797 mutex_unlock(&list_lock
);
800 ret
= device_register_link(icd
);
805 static int soc_camera_probe(struct device
*dev
)
807 struct soc_camera_device
*icd
= to_soc_camera_dev(dev
);
808 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
812 * Possible race scenario:
813 * modprobe <camera-host-driver> triggers __func__
814 * at this moment respective <camera-sensor-driver> gets rmmod'ed
815 * to protect take module references.
818 if (!try_module_get(icd
->ops
->owner
)) {
819 dev_err(&icd
->dev
, "Couldn't lock sensor driver.\n");
824 if (!try_module_get(ici
->ops
->owner
)) {
825 dev_err(&icd
->dev
, "Couldn't lock capture bus driver.\n");
830 mutex_lock(&icd
->video_lock
);
832 /* We only call ->add() here to activate and probe the camera.
833 * We shall ->remove() and deactivate it immediately afterwards. */
834 ret
= ici
->ops
->add(icd
);
838 ret
= icd
->ops
->probe(icd
);
840 const struct v4l2_queryctrl
*qctrl
;
842 qctrl
= soc_camera_find_qctrl(icd
->ops
, V4L2_CID_GAIN
);
843 icd
->gain
= qctrl
? qctrl
->default_value
: (unsigned short)~0;
844 qctrl
= soc_camera_find_qctrl(icd
->ops
, V4L2_CID_EXPOSURE
);
845 icd
->exposure
= qctrl
? qctrl
->default_value
:
848 ici
->ops
->remove(icd
);
851 mutex_unlock(&icd
->video_lock
);
852 module_put(ici
->ops
->owner
);
854 module_put(icd
->ops
->owner
);
859 /* This is called on device_unregister, which only means we have to disconnect
860 * from the host, but not remove ourselves from the device list */
861 static int soc_camera_remove(struct device
*dev
)
863 struct soc_camera_device
*icd
= to_soc_camera_dev(dev
);
865 if (icd
->ops
->remove
)
866 icd
->ops
->remove(icd
);
871 static int soc_camera_suspend(struct device
*dev
, pm_message_t state
)
873 struct soc_camera_device
*icd
= to_soc_camera_dev(dev
);
874 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
877 if (ici
->ops
->suspend
)
878 ret
= ici
->ops
->suspend(icd
, state
);
883 static int soc_camera_resume(struct device
*dev
)
885 struct soc_camera_device
*icd
= to_soc_camera_dev(dev
);
886 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
889 if (ici
->ops
->resume
)
890 ret
= ici
->ops
->resume(icd
);
895 static struct bus_type soc_camera_bus_type
= {
896 .name
= "soc-camera",
897 .probe
= soc_camera_probe
,
898 .remove
= soc_camera_remove
,
899 .suspend
= soc_camera_suspend
,
900 .resume
= soc_camera_resume
,
903 static struct device_driver ic_drv
= {
905 .bus
= &soc_camera_bus_type
,
906 .owner
= THIS_MODULE
,
909 static void dummy_release(struct device
*dev
)
913 int soc_camera_host_register(struct soc_camera_host
*ici
)
916 struct soc_camera_host
*ix
;
918 if (!ici
|| !ici
->ops
||
919 !ici
->ops
->try_fmt
||
920 !ici
->ops
->set_fmt
||
921 !ici
->ops
->set_bus_param
||
922 !ici
->ops
->querycap
||
923 !ici
->ops
->init_videobuf
||
924 !ici
->ops
->reqbufs
||
930 /* Number might be equal to the platform device ID */
931 dev_set_name(&ici
->dev
, "camera_host%d", ici
->nr
);
933 mutex_lock(&list_lock
);
934 list_for_each_entry(ix
, &hosts
, list
) {
935 if (ix
->nr
== ici
->nr
) {
936 mutex_unlock(&list_lock
);
941 list_add_tail(&ici
->list
, &hosts
);
942 mutex_unlock(&list_lock
);
944 ici
->dev
.release
= dummy_release
;
946 ret
= device_register(&ici
->dev
);
956 mutex_lock(&list_lock
);
957 list_del(&ici
->list
);
958 mutex_unlock(&list_lock
);
962 EXPORT_SYMBOL(soc_camera_host_register
);
964 /* Unregister all clients! */
965 void soc_camera_host_unregister(struct soc_camera_host
*ici
)
967 struct soc_camera_device
*icd
;
969 mutex_lock(&list_lock
);
971 list_del(&ici
->list
);
973 list_for_each_entry(icd
, &devices
, list
) {
974 if (icd
->dev
.parent
== &ici
->dev
) {
975 device_unregister(&icd
->dev
);
976 /* Not before device_unregister(), .remove
977 * needs parent to call ici->ops->remove() */
978 icd
->dev
.parent
= NULL
;
979 memset(&icd
->dev
.kobj
, 0, sizeof(icd
->dev
.kobj
));
983 mutex_unlock(&list_lock
);
985 device_unregister(&ici
->dev
);
987 EXPORT_SYMBOL(soc_camera_host_unregister
);
989 /* Image capture device */
990 int soc_camera_device_register(struct soc_camera_device
*icd
)
992 struct soc_camera_device
*ix
;
995 if (!icd
|| !icd
->ops
||
998 !icd
->ops
->release
||
999 !icd
->ops
->start_capture
||
1000 !icd
->ops
->stop_capture
||
1001 !icd
->ops
->set_fmt
||
1002 !icd
->ops
->try_fmt
||
1003 !icd
->ops
->query_bus_param
||
1004 !icd
->ops
->set_bus_param
)
1007 for (i
= 0; i
< 256 && num
< 0; i
++) {
1009 list_for_each_entry(ix
, &devices
, list
) {
1010 if (ix
->iface
== icd
->iface
&& ix
->devnum
== i
) {
1018 /* ok, we have 256 cameras on this host...
1019 * man, stay reasonable... */
1023 icd
->dev
.bus
= &soc_camera_bus_type
;
1024 dev_set_name(&icd
->dev
, "%u-%u", icd
->iface
, icd
->devnum
);
1026 icd
->dev
.release
= dummy_release
;
1028 icd
->host_priv
= NULL
;
1029 mutex_init(&icd
->video_lock
);
1031 return scan_add_device(icd
);
1033 EXPORT_SYMBOL(soc_camera_device_register
);
1035 void soc_camera_device_unregister(struct soc_camera_device
*icd
)
1037 mutex_lock(&list_lock
);
1038 list_del(&icd
->list
);
1040 /* The bus->remove will be eventually called */
1041 if (icd
->dev
.parent
)
1042 device_unregister(&icd
->dev
);
1043 mutex_unlock(&list_lock
);
1045 EXPORT_SYMBOL(soc_camera_device_unregister
);
1047 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops
= {
1048 .vidioc_querycap
= soc_camera_querycap
,
1049 .vidioc_g_fmt_vid_cap
= soc_camera_g_fmt_vid_cap
,
1050 .vidioc_enum_fmt_vid_cap
= soc_camera_enum_fmt_vid_cap
,
1051 .vidioc_s_fmt_vid_cap
= soc_camera_s_fmt_vid_cap
,
1052 .vidioc_enum_input
= soc_camera_enum_input
,
1053 .vidioc_g_input
= soc_camera_g_input
,
1054 .vidioc_s_input
= soc_camera_s_input
,
1055 .vidioc_s_std
= soc_camera_s_std
,
1056 .vidioc_reqbufs
= soc_camera_reqbufs
,
1057 .vidioc_try_fmt_vid_cap
= soc_camera_try_fmt_vid_cap
,
1058 .vidioc_querybuf
= soc_camera_querybuf
,
1059 .vidioc_qbuf
= soc_camera_qbuf
,
1060 .vidioc_dqbuf
= soc_camera_dqbuf
,
1061 .vidioc_streamon
= soc_camera_streamon
,
1062 .vidioc_streamoff
= soc_camera_streamoff
,
1063 .vidioc_queryctrl
= soc_camera_queryctrl
,
1064 .vidioc_g_ctrl
= soc_camera_g_ctrl
,
1065 .vidioc_s_ctrl
= soc_camera_s_ctrl
,
1066 .vidioc_cropcap
= soc_camera_cropcap
,
1067 .vidioc_g_crop
= soc_camera_g_crop
,
1068 .vidioc_s_crop
= soc_camera_s_crop
,
1069 .vidioc_g_chip_ident
= soc_camera_g_chip_ident
,
1070 #ifdef CONFIG_VIDEO_ADV_DEBUG
1071 .vidioc_g_register
= soc_camera_g_register
,
1072 .vidioc_s_register
= soc_camera_s_register
,
1077 * Usually called from the struct soc_camera_ops .probe() method, i.e., from
1078 * soc_camera_probe() above with .video_lock held
1080 int soc_camera_video_start(struct soc_camera_device
*icd
)
1082 struct soc_camera_host
*ici
= to_soc_camera_host(icd
->dev
.parent
);
1084 struct video_device
*vdev
;
1086 if (!icd
->dev
.parent
)
1089 vdev
= video_device_alloc();
1092 dev_dbg(&ici
->dev
, "Allocated video_device %p\n", vdev
);
1094 strlcpy(vdev
->name
, ici
->drv_name
, sizeof(vdev
->name
));
1096 vdev
->parent
= &icd
->dev
;
1097 vdev
->current_norm
= V4L2_STD_UNKNOWN
;
1098 vdev
->fops
= &soc_camera_fops
;
1099 vdev
->ioctl_ops
= &soc_camera_ioctl_ops
;
1100 vdev
->release
= video_device_release
;
1102 vdev
->tvnorms
= V4L2_STD_UNKNOWN
,
1104 err
= video_register_device(vdev
, VFL_TYPE_GRABBER
, vdev
->minor
);
1106 dev_err(vdev
->parent
, "video_register_device failed\n");
1114 video_device_release(vdev
);
1118 EXPORT_SYMBOL(soc_camera_video_start
);
1120 void soc_camera_video_stop(struct soc_camera_device
*icd
)
1122 struct video_device
*vdev
= icd
->vdev
;
1124 dev_dbg(&icd
->dev
, "%s\n", __func__
);
1126 if (!icd
->dev
.parent
|| !vdev
)
1129 mutex_lock(&icd
->video_lock
);
1130 video_unregister_device(vdev
);
1132 mutex_unlock(&icd
->video_lock
);
1134 EXPORT_SYMBOL(soc_camera_video_stop
);
1136 static int __init
soc_camera_init(void)
1138 int ret
= bus_register(&soc_camera_bus_type
);
1141 ret
= driver_register(&ic_drv
);
1148 bus_unregister(&soc_camera_bus_type
);
1152 static void __exit
soc_camera_exit(void)
1154 driver_unregister(&ic_drv
);
1155 bus_unregister(&soc_camera_bus_type
);
1158 module_init(soc_camera_init
);
1159 module_exit(soc_camera_exit
);
1161 MODULE_DESCRIPTION("Image capture bus driver");
1162 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
1163 MODULE_LICENSE("GPL");