?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
V4L/DVB (12530): soc-camera: switch to using v4l2_subdev_call()
[linux-2.6/mini2440.git] / drivers / media / video / soc_camera.c
blobdd023bdb189e0a22398d122fe6d23b2f90e5325f
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/vmalloc.h>
28
29 #include <media/soc_camera.h>
30 #include <media/v4l2-common.h>
31 #include <media/v4l2-ioctl.h>
32 #include <media/v4l2-dev.h>
33 #include <media/videobuf-core.h>
34
35 /* Default to VGA resolution */
36 #define DEFAULT_WIDTH 640
37 #define DEFAULT_HEIGHT 480
38
39 static LIST_HEAD(hosts);
40 static LIST_HEAD(devices);
41 static DEFINE_MUTEX(list_lock); /* Protects the list of hosts */
42
43 const struct soc_camera_data_format *soc_camera_format_by_fourcc(
44 struct soc_camera_device *icd, unsigned int fourcc)
45 {
46 unsigned int i;
47
48 for (i = 0; i < icd->num_formats; i++)
49 if (icd->formats[i].fourcc == fourcc)
50 return icd->formats + i;
51 return NULL;
52 }
53 EXPORT_SYMBOL(soc_camera_format_by_fourcc);
54
55 const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
56 struct soc_camera_device *icd, unsigned int fourcc)
57 {
58 unsigned int i;
59
60 for (i = 0; i < icd->num_user_formats; i++)
61 if (icd->user_formats[i].host_fmt->fourcc == fourcc)
62 return icd->user_formats + i;
63 return NULL;
64 }
65 EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
66
67 /**
68 * soc_camera_apply_sensor_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
69 * @icl: camera platform parameters
70 * @flags: flags to be inverted according to platform configuration
71 * @return: resulting flags
72 */
73 unsigned long soc_camera_apply_sensor_flags(struct soc_camera_link *icl,
74 unsigned long flags)
75 {
76 unsigned long f;
77
78 /* If only one of the two polarities is supported, switch to the opposite */
79 if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) {
80 f = flags & (SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW);
81 if (f == SOCAM_HSYNC_ACTIVE_HIGH || f == SOCAM_HSYNC_ACTIVE_LOW)
82 flags ^= SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW;
83 }
84
85 if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) {
86 f = flags & (SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW);
87 if (f == SOCAM_VSYNC_ACTIVE_HIGH || f == SOCAM_VSYNC_ACTIVE_LOW)
88 flags ^= SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW;
89 }
90
91 if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) {
92 f = flags & (SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING);
93 if (f == SOCAM_PCLK_SAMPLE_RISING || f == SOCAM_PCLK_SAMPLE_FALLING)
94 flags ^= SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING;
95 }
96
97 return flags;
98 }
99 EXPORT_SYMBOL(soc_camera_apply_sensor_flags);
100
101 static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
102 struct v4l2_format *f)
103 {
104 struct soc_camera_file *icf = file->private_data;
105 struct soc_camera_device *icd = icf->icd;
106 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
107
108 WARN_ON(priv != file->private_data);
109
110 /* limit format to hardware capabilities */
111 return ici->ops->try_fmt(icd, f);
112 }
113
114 static int soc_camera_enum_input(struct file *file, void *priv,
115 struct v4l2_input *inp)
116 {
117 struct soc_camera_file *icf = file->private_data;
118 struct soc_camera_device *icd = icf->icd;
119 int ret = 0;
120
121 if (inp->index != 0)
122 return -EINVAL;
123
124 if (icd->ops->enum_input)
125 ret = icd->ops->enum_input(icd, inp);
126 else {
127 /* default is camera */
128 inp->type = V4L2_INPUT_TYPE_CAMERA;
129 inp->std = V4L2_STD_UNKNOWN;
130 strcpy(inp->name, "Camera");
131 }
132
133 return ret;
134 }
135
136 static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
137 {
138 *i = 0;
139
140 return 0;
141 }
142
143 static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
144 {
145 if (i > 0)
146 return -EINVAL;
147
148 return 0;
149 }
150
151 static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
152 {
153 struct soc_camera_file *icf = file->private_data;
154 struct soc_camera_device *icd = icf->icd;
155 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
156
157 return v4l2_subdev_call(sd, core, s_std, *a);
158 }
159
160 static int soc_camera_reqbufs(struct file *file, void *priv,
161 struct v4l2_requestbuffers *p)
162 {
163 int ret;
164 struct soc_camera_file *icf = file->private_data;
165 struct soc_camera_device *icd = icf->icd;
166 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
167
168 WARN_ON(priv != file->private_data);
169
170 ret = videobuf_reqbufs(&icf->vb_vidq, p);
171 if (ret < 0)
172 return ret;
173
174 return ici->ops->reqbufs(icf, p);
175 }
176
177 static int soc_camera_querybuf(struct file *file, void *priv,
178 struct v4l2_buffer *p)
179 {
180 struct soc_camera_file *icf = file->private_data;
181
182 WARN_ON(priv != file->private_data);
183
184 return videobuf_querybuf(&icf->vb_vidq, p);
185 }
186
187 static int soc_camera_qbuf(struct file *file, void *priv,
188 struct v4l2_buffer *p)
189 {
190 struct soc_camera_file *icf = file->private_data;
191
192 WARN_ON(priv != file->private_data);
193
194 return videobuf_qbuf(&icf->vb_vidq, p);
195 }
196
197 static int soc_camera_dqbuf(struct file *file, void *priv,
198 struct v4l2_buffer *p)
199 {
200 struct soc_camera_file *icf = file->private_data;
201
202 WARN_ON(priv != file->private_data);
203
204 return videobuf_dqbuf(&icf->vb_vidq, p, file->f_flags & O_NONBLOCK);
205 }
206
207 /* Always entered with .video_lock held */
208 static int soc_camera_init_user_formats(struct soc_camera_device *icd)
209 {
210 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
211 int i, fmts = 0, ret;
212
213 if (!ici->ops->get_formats)
214 /*
215 * Fallback mode - the host will have to serve all
216 * sensor-provided formats one-to-one to the user
217 */
218 fmts = icd->num_formats;
219 else
220 /*
221 * First pass - only count formats this host-sensor
222 * configuration can provide
223 */
224 for (i = 0; i < icd->num_formats; i++) {
225 ret = ici->ops->get_formats(icd, i, NULL);
226 if (ret < 0)
227 return ret;
228 fmts += ret;
229 }
230
231 if (!fmts)
232 return -ENXIO;
233
234 icd->user_formats =
235 vmalloc(fmts * sizeof(struct soc_camera_format_xlate));
236 if (!icd->user_formats)
237 return -ENOMEM;
238
239 icd->num_user_formats = fmts;
240
241 dev_dbg(&icd->dev, "Found %d supported formats.\n", fmts);
242
243 /* Second pass - actually fill data formats */
244 fmts = 0;
245 for (i = 0; i < icd->num_formats; i++)
246 if (!ici->ops->get_formats) {
247 icd->user_formats[i].host_fmt = icd->formats + i;
248 icd->user_formats[i].cam_fmt = icd->formats + i;
249 icd->user_formats[i].buswidth = icd->formats[i].depth;
250 } else {
251 ret = ici->ops->get_formats(icd, i,
252 &icd->user_formats[fmts]);
253 if (ret < 0)
254 goto egfmt;
255 fmts += ret;
256 }
257
258 icd->current_fmt = icd->user_formats[0].host_fmt;
259
260 return 0;
261
262 egfmt:
263 icd->num_user_formats = 0;
264 vfree(icd->user_formats);
265 return ret;
266 }
267
268 /* Always entered with .video_lock held */
269 static void soc_camera_free_user_formats(struct soc_camera_device *icd)
270 {
271 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
272
273 if (ici->ops->put_formats)
274 ici->ops->put_formats(icd);
275 icd->current_fmt = NULL;
276 icd->num_user_formats = 0;
277 vfree(icd->user_formats);
278 icd->user_formats = NULL;
279 }
280
281 /* Called with .vb_lock held */
282 static int soc_camera_set_fmt(struct soc_camera_file *icf,
283 struct v4l2_format *f)
284 {
285 struct soc_camera_device *icd = icf->icd;
286 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
287 struct v4l2_pix_format *pix = &f->fmt.pix;
288 int ret;
289
290 /* We always call try_fmt() before set_fmt() or set_crop() */
291 ret = ici->ops->try_fmt(icd, f);
292 if (ret < 0)
293 return ret;
294
295 ret = ici->ops->set_fmt(icd, f);
296 if (ret < 0) {
297 return ret;
298 } else if (!icd->current_fmt ||
299 icd->current_fmt->fourcc != pix->pixelformat) {
300 dev_err(ici->v4l2_dev.dev,
301 "Host driver hasn't set up current format correctly!\n");
302 return -EINVAL;
303 }
304
305 icd->rect_current.width = pix->width;
306 icd->rect_current.height = pix->height;
307 icf->vb_vidq.field =
308 icd->field = pix->field;
309
310 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
311 dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
312 f->type);
313
314 dev_dbg(&icd->dev, "set width: %d height: %d\n",
315 icd->rect_current.width, icd->rect_current.height);
316
317 /* set physical bus parameters */
318 return ici->ops->set_bus_param(icd, pix->pixelformat);
319 }
320
321 static int soc_camera_open(struct file *file)
322 {
323 struct video_device *vdev = video_devdata(file);
324 struct soc_camera_device *icd = container_of(vdev->parent, struct soc_camera_device, dev);
325 struct soc_camera_link *icl = to_soc_camera_link(icd);
326 struct soc_camera_host *ici;
327 struct soc_camera_file *icf;
328 int ret;
329
330 if (!icd->ops)
331 /* No device driver attached */
332 return -ENODEV;
333
334 ici = to_soc_camera_host(icd->dev.parent);
335
336 icf = vmalloc(sizeof(*icf));
337 if (!icf)
338 return -ENOMEM;
339
340 if (!try_module_get(ici->ops->owner)) {
341 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
342 ret = -EINVAL;
343 goto emgi;
344 }
345
346 /* Protect against icd->ops->remove() until we module_get() both drivers. */
347 mutex_lock(&icd->video_lock);
348
349 icf->icd = icd;
350 icd->use_count++;
351
352 /* Now we really have to activate the camera */
353 if (icd->use_count == 1) {
354 /* Restore parameters before the last close() per V4L2 API */
355 struct v4l2_format f = {
356 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
357 .fmt.pix = {
358 .width = icd->rect_current.width,
359 .height = icd->rect_current.height,
360 .field = icd->field,
361 .pixelformat = icd->current_fmt->fourcc,
362 .colorspace = icd->current_fmt->colorspace,
363 },
364 };
365
366 if (icl->power) {
367 ret = icl->power(icd->pdev, 1);
368 if (ret < 0)
369 goto epower;
370 }
371
372 /* The camera could have been already on, try to reset */
373 if (icl->reset)
374 icl->reset(icd->pdev);
375
376 ret = ici->ops->add(icd);
377 if (ret < 0) {
378 dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
379 goto eiciadd;
380 }
381
382 if (icd->ops->init) {
383 ret = icd->ops->init(icd);
384 if (ret < 0)
385 goto einit;
386 }
387
388 /* Try to configure with default parameters */
389 ret = soc_camera_set_fmt(icf, &f);
390 if (ret < 0)
391 goto esfmt;
392 }
393
394 file->private_data = icf;
395 dev_dbg(&icd->dev, "camera device open\n");
396
397 ici->ops->init_videobuf(&icf->vb_vidq, icd);
398
399 mutex_unlock(&icd->video_lock);
400
401 return 0;
402
403 /*
404 * First five errors are entered with the .video_lock held
405 * and use_count == 1
406 */
407 esfmt:
408 if (icd->ops->release)
409 icd->ops->release(icd);
410 einit:
411 ici->ops->remove(icd);
412 eiciadd:
413 if (icl->power)
414 icl->power(icd->pdev, 0);
415 epower:
416 icd->use_count--;
417 mutex_unlock(&icd->video_lock);
418 module_put(ici->ops->owner);
419 emgi:
420 vfree(icf);
421 return ret;
422 }
423
424 static int soc_camera_close(struct file *file)
425 {
426 struct soc_camera_file *icf = file->private_data;
427 struct soc_camera_device *icd = icf->icd;
428 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
429 struct video_device *vdev = icd->vdev;
430
431 mutex_lock(&icd->video_lock);
432 icd->use_count--;
433 if (!icd->use_count) {
434 struct soc_camera_link *icl = to_soc_camera_link(icd);
435
436 if (icd->ops->release)
437 icd->ops->release(icd);
438 ici->ops->remove(icd);
439 if (icl->power)
440 icl->power(icd->pdev, 0);
441 }
442
443 mutex_unlock(&icd->video_lock);
444
445 module_put(ici->ops->owner);
446
447 vfree(icf);
448
449 dev_dbg(vdev->parent, "camera device close\n");
450
451 return 0;
452 }
453
454 static ssize_t soc_camera_read(struct file *file, char __user *buf,
455 size_t count, loff_t *ppos)
456 {
457 struct soc_camera_file *icf = file->private_data;
458 struct soc_camera_device *icd = icf->icd;
459 struct video_device *vdev = icd->vdev;
460 int err = -EINVAL;
461
462 dev_err(vdev->parent, "camera device read not implemented\n");
463
464 return err;
465 }
466
467 static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
468 {
469 struct soc_camera_file *icf = file->private_data;
470 struct soc_camera_device *icd = icf->icd;
471 int err;
472
473 dev_dbg(&icd->dev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
474
475 err = videobuf_mmap_mapper(&icf->vb_vidq, vma);
476
477 dev_dbg(&icd->dev, "vma start=0x%08lx, size=%ld, ret=%d\n",
478 (unsigned long)vma->vm_start,
479 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
480 err);
481
482 return err;
483 }
484
485 static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
486 {
487 struct soc_camera_file *icf = file->private_data;
488 struct soc_camera_device *icd = icf->icd;
489 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
490
491 if (list_empty(&icf->vb_vidq.stream)) {
492 dev_err(&icd->dev, "Trying to poll with no queued buffers!\n");
493 return POLLERR;
494 }
495
496 return ici->ops->poll(file, pt);
497 }
498
499 static struct v4l2_file_operations soc_camera_fops = {
500 .owner = THIS_MODULE,
501 .open = soc_camera_open,
502 .release = soc_camera_close,
503 .ioctl = video_ioctl2,
504 .read = soc_camera_read,
505 .mmap = soc_camera_mmap,
506 .poll = soc_camera_poll,
507 };
508
509 static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
510 struct v4l2_format *f)
511 {
512 struct soc_camera_file *icf = file->private_data;
513 struct soc_camera_device *icd = icf->icd;
514 int ret;
515
516 WARN_ON(priv != file->private_data);
517
518 mutex_lock(&icf->vb_vidq.vb_lock);
519
520 if (icf->vb_vidq.bufs[0]) {
521 dev_err(&icd->dev, "S_FMT denied: queue initialised\n");
522 ret = -EBUSY;
523 goto unlock;
524 }
525
526 ret = soc_camera_set_fmt(icf, f);
527
528 unlock:
529 mutex_unlock(&icf->vb_vidq.vb_lock);
530
531 return ret;
532 }
533
534 static int soc_camera_enum_fmt_vid_cap(struct file *file, void *priv,
535 struct v4l2_fmtdesc *f)
536 {
537 struct soc_camera_file *icf = file->private_data;
538 struct soc_camera_device *icd = icf->icd;
539 const struct soc_camera_data_format *format;
540
541 WARN_ON(priv != file->private_data);
542
543 if (f->index >= icd->num_user_formats)
544 return -EINVAL;
545
546 format = icd->user_formats[f->index].host_fmt;
547
548 strlcpy(f->description, format->name, sizeof(f->description));
549 f->pixelformat = format->fourcc;
550 return 0;
551 }
552
553 static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
554 struct v4l2_format *f)
555 {
556 struct soc_camera_file *icf = file->private_data;
557 struct soc_camera_device *icd = icf->icd;
558 struct v4l2_pix_format *pix = &f->fmt.pix;
559
560 WARN_ON(priv != file->private_data);
561
562 pix->width = icd->rect_current.width;
563 pix->height = icd->rect_current.height;
564 pix->field = icf->vb_vidq.field;
565 pix->pixelformat = icd->current_fmt->fourcc;
566 pix->bytesperline = pix->width *
567 DIV_ROUND_UP(icd->current_fmt->depth, 8);
568 pix->sizeimage = pix->height * pix->bytesperline;
569 dev_dbg(&icd->dev, "current_fmt->fourcc: 0x%08x\n",
570 icd->current_fmt->fourcc);
571 return 0;
572 }
573
574 static int soc_camera_querycap(struct file *file, void *priv,
575 struct v4l2_capability *cap)
576 {
577 struct soc_camera_file *icf = file->private_data;
578 struct soc_camera_device *icd = icf->icd;
579 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
580
581 WARN_ON(priv != file->private_data);
582
583 strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
584 return ici->ops->querycap(ici, cap);
585 }
586
587 static int soc_camera_streamon(struct file *file, void *priv,
588 enum v4l2_buf_type i)
589 {
590 struct soc_camera_file *icf = file->private_data;
591 struct soc_camera_device *icd = icf->icd;
592 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
593 int ret;
594
595 WARN_ON(priv != file->private_data);
596
597 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
598 return -EINVAL;
599
600 mutex_lock(&icd->video_lock);
601
602 v4l2_subdev_call(sd, video, s_stream, 1);
603
604 /* This calls buf_queue from host driver's videobuf_queue_ops */
605 ret = videobuf_streamon(&icf->vb_vidq);
606
607 mutex_unlock(&icd->video_lock);
608
609 return ret;
610 }
611
612 static int soc_camera_streamoff(struct file *file, void *priv,
613 enum v4l2_buf_type i)
614 {
615 struct soc_camera_file *icf = file->private_data;
616 struct soc_camera_device *icd = icf->icd;
617 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
618
619 WARN_ON(priv != file->private_data);
620
621 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
622 return -EINVAL;
623
624 mutex_lock(&icd->video_lock);
625
626 /* This calls buf_release from host driver's videobuf_queue_ops for all
627 * remaining buffers. When the last buffer is freed, stop capture */
628 videobuf_streamoff(&icf->vb_vidq);
629
630 v4l2_subdev_call(sd, video, s_stream, 0);
631
632 mutex_unlock(&icd->video_lock);
633
634 return 0;
635 }
636
637 static int soc_camera_queryctrl(struct file *file, void *priv,
638 struct v4l2_queryctrl *qc)
639 {
640 struct soc_camera_file *icf = file->private_data;
641 struct soc_camera_device *icd = icf->icd;
642 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
643 int i;
644
645 WARN_ON(priv != file->private_data);
646
647 if (!qc->id)
648 return -EINVAL;
649
650 /* First check host controls */
651 for (i = 0; i < ici->ops->num_controls; i++)
652 if (qc->id == ici->ops->controls[i].id) {
653 memcpy(qc, &(ici->ops->controls[i]),
654 sizeof(*qc));
655 return 0;
656 }
657
658 /* Then device controls */
659 for (i = 0; i < icd->ops->num_controls; i++)
660 if (qc->id == icd->ops->controls[i].id) {
661 memcpy(qc, &(icd->ops->controls[i]),
662 sizeof(*qc));
663 return 0;
664 }
665
666 return -EINVAL;
667 }
668
669 static int soc_camera_g_ctrl(struct file *file, void *priv,
670 struct v4l2_control *ctrl)
671 {
672 struct soc_camera_file *icf = file->private_data;
673 struct soc_camera_device *icd = icf->icd;
674 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
675 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
676 int ret;
677
678 WARN_ON(priv != file->private_data);
679
680 switch (ctrl->id) {
681 case V4L2_CID_GAIN:
682 if (icd->gain == (unsigned short)~0)
683 return -EINVAL;
684 ctrl->value = icd->gain;
685 return 0;
686 case V4L2_CID_EXPOSURE:
687 if (icd->exposure == (unsigned short)~0)
688 return -EINVAL;
689 ctrl->value = icd->exposure;
690 return 0;
691 }
692
693 if (ici->ops->get_ctrl) {
694 ret = ici->ops->get_ctrl(icd, ctrl);
695 if (ret != -ENOIOCTLCMD)
696 return ret;
697 }
698
699 return v4l2_subdev_call(sd, core, g_ctrl, ctrl);
700 }
701
702 static int soc_camera_s_ctrl(struct file *file, void *priv,
703 struct v4l2_control *ctrl)
704 {
705 struct soc_camera_file *icf = file->private_data;
706 struct soc_camera_device *icd = icf->icd;
707 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
708 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
709 int ret;
710
711 WARN_ON(priv != file->private_data);
712
713 if (ici->ops->set_ctrl) {
714 ret = ici->ops->set_ctrl(icd, ctrl);
715 if (ret != -ENOIOCTLCMD)
716 return ret;
717 }
718
719 return v4l2_subdev_call(sd, core, s_ctrl, ctrl);
720 }
721
722 static int soc_camera_cropcap(struct file *file, void *fh,
723 struct v4l2_cropcap *a)
724 {
725 struct soc_camera_file *icf = file->private_data;
726 struct soc_camera_device *icd = icf->icd;
727
728 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
729 a->bounds = icd->rect_max;
730 a->defrect.left = icd->rect_max.left;
731 a->defrect.top = icd->rect_max.top;
732 a->defrect.width = DEFAULT_WIDTH;
733 a->defrect.height = DEFAULT_HEIGHT;
734 a->pixelaspect.numerator = 1;
735 a->pixelaspect.denominator = 1;
736
737 return 0;
738 }
739
740 static int soc_camera_g_crop(struct file *file, void *fh,
741 struct v4l2_crop *a)
742 {
743 struct soc_camera_file *icf = file->private_data;
744 struct soc_camera_device *icd = icf->icd;
745
746 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
747 a->c = icd->rect_current;
748
749 return 0;
750 }
751
752 /*
753 * According to the V4L2 API, drivers shall not update the struct v4l2_crop
754 * argument with the actual geometry, instead, the user shall use G_CROP to
755 * retrieve it. However, we expect camera host and client drivers to update
756 * the argument, which we then use internally, but do not return to the user.
757 */
758 static int soc_camera_s_crop(struct file *file, void *fh,
759 struct v4l2_crop *a)
760 {
761 struct soc_camera_file *icf = file->private_data;
762 struct soc_camera_device *icd = icf->icd;
763 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
764 struct v4l2_rect rect = a->c;
765 int ret;
766
767 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
768 return -EINVAL;
769
770 /* Cropping is allowed during a running capture, guard consistency */
771 mutex_lock(&icf->vb_vidq.vb_lock);
772
773 /* Prohibit window size change with initialised buffers */
774 if (icf->vb_vidq.bufs[0] && (rect.width != icd->rect_current.width ||
775 rect.height != icd->rect_current.height)) {
776 dev_err(&icd->dev,
777 "S_CROP denied: queue initialised and sizes differ\n");
778 ret = -EBUSY;
779 goto unlock;
780 }
781
782 if (rect.width > icd->rect_max.width)
783 rect.width = icd->rect_max.width;
784
785 if (rect.width < icd->width_min)
786 rect.width = icd->width_min;
787
788 if (rect.height > icd->rect_max.height)
789 rect.height = icd->rect_max.height;
790
791 if (rect.height < icd->height_min)
792 rect.height = icd->height_min;
793
794 if (rect.width + rect.left > icd->rect_max.width + icd->rect_max.left)
795 rect.left = icd->rect_max.width + icd->rect_max.left -
796 rect.width;
797
798 if (rect.height + rect.top > icd->rect_max.height + icd->rect_max.top)
799 rect.top = icd->rect_max.height + icd->rect_max.top -
800 rect.height;
801
802 ret = ici->ops->set_crop(icd, a);
803 if (!ret)
804 icd->rect_current = rect;
805
806 unlock:
807 mutex_unlock(&icf->vb_vidq.vb_lock);
808
809 return ret;
810 }
811
812 static int soc_camera_g_chip_ident(struct file *file, void *fh,
813 struct v4l2_dbg_chip_ident *id)
814 {
815 struct soc_camera_file *icf = file->private_data;
816 struct soc_camera_device *icd = icf->icd;
817 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
818
819 return v4l2_subdev_call(sd, core, g_chip_ident, id);
820 }
821
822 #ifdef CONFIG_VIDEO_ADV_DEBUG
823 static int soc_camera_g_register(struct file *file, void *fh,
824 struct v4l2_dbg_register *reg)
825 {
826 struct soc_camera_file *icf = file->private_data;
827 struct soc_camera_device *icd = icf->icd;
828 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
829
830 return v4l2_subdev_call(sd, core, g_register, reg);
831 }
832
833 static int soc_camera_s_register(struct file *file, void *fh,
834 struct v4l2_dbg_register *reg)
835 {
836 struct soc_camera_file *icf = file->private_data;
837 struct soc_camera_device *icd = icf->icd;
838 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
839
840 return v4l2_subdev_call(sd, core, s_register, reg);
841 }
842 #endif
843
844 /* So far this function cannot fail */
845 static void scan_add_host(struct soc_camera_host *ici)
846 {
847 struct soc_camera_device *icd;
848
849 mutex_lock(&list_lock);
850
851 list_for_each_entry(icd, &devices, list) {
852 if (icd->iface == ici->nr) {
853 int ret;
854 icd->dev.parent = ici->v4l2_dev.dev;
855 dev_set_name(&icd->dev, "%u-%u", icd->iface,
856 icd->devnum);
857 ret = device_register(&icd->dev);
858 if (ret < 0) {
859 icd->dev.parent = NULL;
860 dev_err(&icd->dev,
861 "Cannot register device: %d\n", ret);
862 }
863 }
864 }
865
866 mutex_unlock(&list_lock);
867 }
868
869 #ifdef CONFIG_I2C_BOARDINFO
870 static int soc_camera_init_i2c(struct soc_camera_device *icd,
871 struct soc_camera_link *icl)
872 {
873 struct i2c_client *client;
874 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
875 struct i2c_adapter *adap = i2c_get_adapter(icl->i2c_adapter_id);
876 struct v4l2_subdev *subdev;
877 int ret;
878
879 if (!adap) {
880 ret = -ENODEV;
881 dev_err(&icd->dev, "Cannot get I2C adapter #%d. No driver?\n",
882 icl->i2c_adapter_id);
883 goto ei2cga;
884 }
885
886 icl->board_info->platform_data = icd;
887
888 subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
889 icl->module_name, icl->board_info, NULL);
890 if (!subdev) {
891 ret = -ENOMEM;
892 goto ei2cnd;
893 }
894
895 subdev->grp_id = (__u32)icd;
896 client = subdev->priv;
897
898 /* Use to_i2c_client(dev) to recover the i2c client */
899 dev_set_drvdata(&icd->dev, &client->dev);
900
901 return 0;
902 ei2cnd:
903 i2c_put_adapter(adap);
904 ei2cga:
905 return ret;
906 }
907
908 static void soc_camera_free_i2c(struct soc_camera_device *icd)
909 {
910 struct i2c_client *client =
911 to_i2c_client(to_soc_camera_control(icd));
912 dev_set_drvdata(&icd->dev, NULL);
913 v4l2_device_unregister_subdev(i2c_get_clientdata(client));
914 i2c_unregister_device(client);
915 i2c_put_adapter(client->adapter);
916 }
917 #else
918 #define soc_camera_init_i2c(icd, icl) (-ENODEV)
919 #define soc_camera_free_i2c(icd) do {} while (0)
920 #endif
921
922 static int soc_camera_video_start(struct soc_camera_device *icd);
923 static int video_dev_create(struct soc_camera_device *icd);
924 /* Called during host-driver probe */
925 static int soc_camera_probe(struct device *dev)
926 {
927 struct soc_camera_device *icd = to_soc_camera_dev(dev);
928 struct soc_camera_host *ici = to_soc_camera_host(dev->parent);
929 struct soc_camera_link *icl = to_soc_camera_link(icd);
930 struct device *control = NULL;
931 int ret;
932
933 dev_info(dev, "Probing %s\n", dev_name(dev));
934
935 if (icl->power) {
936 ret = icl->power(icd->pdev, 1);
937 if (ret < 0) {
938 dev_err(dev,
939 "Platform failed to power-on the camera.\n");
940 goto epower;
941 }
942 }
943
944 /* The camera could have been already on, try to reset */
945 if (icl->reset)
946 icl->reset(icd->pdev);
947
948 ret = ici->ops->add(icd);
949 if (ret < 0)
950 goto eadd;
951
952 /* Must have icd->vdev before registering the device */
953 ret = video_dev_create(icd);
954 if (ret < 0)
955 goto evdc;
956
957 /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */
958 if (icl->board_info) {
959 ret = soc_camera_init_i2c(icd, icl);
960 if (ret < 0)
961 goto eadddev;
962 } else if (!icl->add_device || !icl->del_device) {
963 ret = -EINVAL;
964 goto eadddev;
965 } else {
966 if (icl->module_name)
967 ret = request_module(icl->module_name);
968
969 ret = icl->add_device(icl, &icd->dev);
970 if (ret < 0)
971 goto eadddev;
972
973 /* FIXME: this is racy, have to use driver-binding notification */
974 control = to_soc_camera_control(icd);
975 if (!control || !control->driver || !dev_get_drvdata(control) ||
976 !try_module_get(control->driver->owner)) {
977 icl->del_device(icl);
978 goto enodrv;
979 }
980 }
981
982 /* At this point client .probe() should have run already */
983 ret = soc_camera_init_user_formats(icd);
984 if (ret < 0)
985 goto eiufmt;
986
987 icd->rect_current = icd->rect_max;
988 icd->field = V4L2_FIELD_ANY;
989
990 /* ..._video_start() will create a device node, so we have to protect */
991 mutex_lock(&icd->video_lock);
992
993 ret = soc_camera_video_start(icd);
994 if (ret < 0)
995 goto evidstart;
996
997 /* Do we have to sysfs_remove_link() before device_unregister()? */
998 if (to_soc_camera_control(icd) &&
999 sysfs_create_link(&icd->dev.kobj, &to_soc_camera_control(icd)->kobj,
1000 "control"))
1001 dev_warn(&icd->dev, "Failed creating the control symlink\n");
1002
1003 ici->ops->remove(icd);
1004
1005 if (icl->power)
1006 icl->power(icd->pdev, 0);
1007
1008 mutex_unlock(&icd->video_lock);
1009
1010 return 0;
1011
1012 evidstart:
1013 mutex_unlock(&icd->video_lock);
1014 soc_camera_free_user_formats(icd);
1015 eiufmt:
1016 if (icl->board_info) {
1017 soc_camera_free_i2c(icd);
1018 } else {
1019 icl->del_device(icl);
1020 module_put(control->driver->owner);
1021 }
1022 enodrv:
1023 eadddev:
1024 video_device_release(icd->vdev);
1025 evdc:
1026 ici->ops->remove(icd);
1027 eadd:
1028 if (icl->power)
1029 icl->power(icd->pdev, 0);
1030 epower:
1031 return ret;
1032 }
1033
1034 /* This is called on device_unregister, which only means we have to disconnect
1035 * from the host, but not remove ourselves from the device list */
1036 static int soc_camera_remove(struct device *dev)
1037 {
1038 struct soc_camera_device *icd = to_soc_camera_dev(dev);
1039 struct soc_camera_link *icl = to_soc_camera_link(icd);
1040 struct video_device *vdev = icd->vdev;
1041
1042 BUG_ON(!dev->parent);
1043
1044 if (vdev) {
1045 mutex_lock(&icd->video_lock);
1046 video_unregister_device(vdev);
1047 icd->vdev = NULL;
1048 mutex_unlock(&icd->video_lock);
1049 }
1050
1051 if (icl->board_info) {
1052 soc_camera_free_i2c(icd);
1053 } else {
1054 struct device_driver *drv = to_soc_camera_control(icd) ?
1055 to_soc_camera_control(icd)->driver : NULL;
1056 if (drv) {
1057 icl->del_device(icl);
1058 module_put(drv->owner);
1059 }
1060 }
1061 soc_camera_free_user_formats(icd);
1062
1063 return 0;
1064 }
1065
1066 static int soc_camera_suspend(struct device *dev, pm_message_t state)
1067 {
1068 struct soc_camera_device *icd = to_soc_camera_dev(dev);
1069 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1070 int ret = 0;
1071
1072 if (ici->ops->suspend)
1073 ret = ici->ops->suspend(icd, state);
1074
1075 return ret;
1076 }
1077
1078 static int soc_camera_resume(struct device *dev)
1079 {
1080 struct soc_camera_device *icd = to_soc_camera_dev(dev);
1081 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1082 int ret = 0;
1083
1084 if (ici->ops->resume)
1085 ret = ici->ops->resume(icd);
1086
1087 return ret;
1088 }
1089
1090 static struct bus_type soc_camera_bus_type = {
1091 .name = "soc-camera",
1092 .probe = soc_camera_probe,
1093 .remove = soc_camera_remove,
1094 .suspend = soc_camera_suspend,
1095 .resume = soc_camera_resume,
1096 };
1097
1098 static struct device_driver ic_drv = {
1099 .name = "camera",
1100 .bus = &soc_camera_bus_type,
1101 .owner = THIS_MODULE,
1102 };
1103
1104 static void dummy_release(struct device *dev)
1105 {
1106 }
1107
1108 int soc_camera_host_register(struct soc_camera_host *ici)
1109 {
1110 struct soc_camera_host *ix;
1111 int ret;
1112
1113 if (!ici || !ici->ops ||
1114 !ici->ops->try_fmt ||
1115 !ici->ops->set_fmt ||
1116 !ici->ops->set_crop ||
1117 !ici->ops->set_bus_param ||
1118 !ici->ops->querycap ||
1119 !ici->ops->init_videobuf ||
1120 !ici->ops->reqbufs ||
1121 !ici->ops->add ||
1122 !ici->ops->remove ||
1123 !ici->ops->poll ||
1124 !ici->v4l2_dev.dev)
1125 return -EINVAL;
1126
1127 mutex_lock(&list_lock);
1128 list_for_each_entry(ix, &hosts, list) {
1129 if (ix->nr == ici->nr) {
1130 ret = -EBUSY;
1131 goto edevreg;
1132 }
1133 }
1134
1135 ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);
1136 if (ret < 0)
1137 goto edevreg;
1138
1139 list_add_tail(&ici->list, &hosts);
1140 mutex_unlock(&list_lock);
1141
1142 scan_add_host(ici);
1143
1144 return 0;
1145
1146 edevreg:
1147 mutex_unlock(&list_lock);
1148 return ret;
1149 }
1150 EXPORT_SYMBOL(soc_camera_host_register);
1151
1152 /* Unregister all clients! */
1153 void soc_camera_host_unregister(struct soc_camera_host *ici)
1154 {
1155 struct soc_camera_device *icd;
1156
1157 mutex_lock(&list_lock);
1158
1159 list_del(&ici->list);
1160
1161 list_for_each_entry(icd, &devices, list) {
1162 if (icd->iface == ici->nr) {
1163 /* The bus->remove will be called */
1164 device_unregister(&icd->dev);
1165 /* Not before device_unregister(), .remove
1166 * needs parent to call ici->ops->remove() */
1167 icd->dev.parent = NULL;
1168
1169 /* If the host module is loaded again, device_register()
1170 * would complain "already initialised" */
1171 memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
1172 }
1173 }
1174
1175 mutex_unlock(&list_lock);
1176
1177 v4l2_device_unregister(&ici->v4l2_dev);
1178 }
1179 EXPORT_SYMBOL(soc_camera_host_unregister);
1180
1181 /* Image capture device */
1182 static int soc_camera_device_register(struct soc_camera_device *icd)
1183 {
1184 struct soc_camera_device *ix;
1185 int num = -1, i;
1186
1187 for (i = 0; i < 256 && num < 0; i++) {
1188 num = i;
1189 /* Check if this index is available on this interface */
1190 list_for_each_entry(ix, &devices, list) {
1191 if (ix->iface == icd->iface && ix->devnum == i) {
1192 num = -1;
1193 break;
1194 }
1195 }
1196 }
1197
1198 if (num < 0)
1199 /* ok, we have 256 cameras on this host...
1200 * man, stay reasonable... */
1201 return -ENOMEM;
1202
1203 icd->devnum = num;
1204 icd->dev.bus = &soc_camera_bus_type;
1205
1206 icd->dev.release = dummy_release;
1207 icd->use_count = 0;
1208 icd->host_priv = NULL;
1209 mutex_init(&icd->video_lock);
1210
1211 list_add_tail(&icd->list, &devices);
1212
1213 return 0;
1214 }
1215
1216 static void soc_camera_device_unregister(struct soc_camera_device *icd)
1217 {
1218 list_del(&icd->list);
1219 }
1220
1221 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
1222 .vidioc_querycap = soc_camera_querycap,
1223 .vidioc_g_fmt_vid_cap = soc_camera_g_fmt_vid_cap,
1224 .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
1225 .vidioc_s_fmt_vid_cap = soc_camera_s_fmt_vid_cap,
1226 .vidioc_enum_input = soc_camera_enum_input,
1227 .vidioc_g_input = soc_camera_g_input,
1228 .vidioc_s_input = soc_camera_s_input,
1229 .vidioc_s_std = soc_camera_s_std,
1230 .vidioc_reqbufs = soc_camera_reqbufs,
1231 .vidioc_try_fmt_vid_cap = soc_camera_try_fmt_vid_cap,
1232 .vidioc_querybuf = soc_camera_querybuf,
1233 .vidioc_qbuf = soc_camera_qbuf,
1234 .vidioc_dqbuf = soc_camera_dqbuf,
1235 .vidioc_streamon = soc_camera_streamon,
1236 .vidioc_streamoff = soc_camera_streamoff,
1237 .vidioc_queryctrl = soc_camera_queryctrl,
1238 .vidioc_g_ctrl = soc_camera_g_ctrl,
1239 .vidioc_s_ctrl = soc_camera_s_ctrl,
1240 .vidioc_cropcap = soc_camera_cropcap,
1241 .vidioc_g_crop = soc_camera_g_crop,
1242 .vidioc_s_crop = soc_camera_s_crop,
1243 .vidioc_g_chip_ident = soc_camera_g_chip_ident,
1244 #ifdef CONFIG_VIDEO_ADV_DEBUG
1245 .vidioc_g_register = soc_camera_g_register,
1246 .vidioc_s_register = soc_camera_s_register,
1247 #endif
1248 };
1249
1250 static int video_dev_create(struct soc_camera_device *icd)
1251 {
1252 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1253 struct video_device *vdev = video_device_alloc();
1254
1255 if (!vdev)
1256 return -ENOMEM;
1257
1258 strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
1259
1260 vdev->parent = &icd->dev;
1261 vdev->current_norm = V4L2_STD_UNKNOWN;
1262 vdev->fops = &soc_camera_fops;
1263 vdev->ioctl_ops = &soc_camera_ioctl_ops;
1264 vdev->release = video_device_release;
1265 vdev->minor = -1;
1266 vdev->tvnorms = V4L2_STD_UNKNOWN;
1267
1268 icd->vdev = vdev;
1269
1270 return 0;
1271 }
1272
1273 /*
1274 * Called from soc_camera_probe() above (with .video_lock held???)
1275 */
1276 static int soc_camera_video_start(struct soc_camera_device *icd)
1277 {
1278 const struct v4l2_queryctrl *qctrl;
1279 int ret;
1280
1281 if (!icd->dev.parent)
1282 return -ENODEV;
1283
1284 if (!icd->ops ||
1285 !icd->ops->query_bus_param ||
1286 !icd->ops->set_bus_param)
1287 return -EINVAL;
1288
1289 ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER,
1290 icd->vdev->minor);
1291 if (ret < 0) {
1292 dev_err(&icd->dev, "video_register_device failed: %d\n", ret);
1293 return ret;
1294 }
1295
1296 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
1297 icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
1298 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
1299 icd->exposure = qctrl ? qctrl->default_value : (unsigned short)~0;
1300
1301 return 0;
1302 }
1303
1304 static int __devinit soc_camera_pdrv_probe(struct platform_device *pdev)
1305 {
1306 struct soc_camera_link *icl = pdev->dev.platform_data;
1307 struct soc_camera_device *icd;
1308 int ret;
1309
1310 if (!icl)
1311 return -EINVAL;
1312
1313 icd = kzalloc(sizeof(*icd), GFP_KERNEL);
1314 if (!icd)
1315 return -ENOMEM;
1316
1317 icd->iface = icl->bus_id;
1318 icd->pdev = &pdev->dev;
1319 platform_set_drvdata(pdev, icd);
1320 icd->dev.platform_data = icl;
1321
1322 ret = soc_camera_device_register(icd);
1323 if (ret < 0)
1324 goto escdevreg;
1325
1326 return 0;
1327
1328 escdevreg:
1329 kfree(icd);
1330
1331 return ret;
1332 }
1333
1334 /* Only called on rmmod for each platform device, since they are not
1335 * hot-pluggable. Now we know, that all our users - hosts and devices have
1336 * been unloaded already */
1337 static int __devexit soc_camera_pdrv_remove(struct platform_device *pdev)
1338 {
1339 struct soc_camera_device *icd = platform_get_drvdata(pdev);
1340
1341 if (!icd)
1342 return -EINVAL;
1343
1344 soc_camera_device_unregister(icd);
1345
1346 kfree(icd);
1347
1348 return 0;
1349 }
1350
1351 static struct platform_driver __refdata soc_camera_pdrv = {
1352 .remove = __devexit_p(soc_camera_pdrv_remove),
1353 .driver = {
1354 .name = "soc-camera-pdrv",
1355 .owner = THIS_MODULE,
1356 },
1357 };
1358
1359 static int __init soc_camera_init(void)
1360 {
1361 int ret = bus_register(&soc_camera_bus_type);
1362 if (ret)
1363 return ret;
1364 ret = driver_register(&ic_drv);
1365 if (ret)
1366 goto edrvr;
1367
1368 ret = platform_driver_probe(&soc_camera_pdrv, soc_camera_pdrv_probe);
1369 if (ret)
1370 goto epdr;
1371
1372 return 0;
1373
1374 epdr:
1375 driver_unregister(&ic_drv);
1376 edrvr:
1377 bus_unregister(&soc_camera_bus_type);
1378 return ret;
1379 }
1380
1381 static void __exit soc_camera_exit(void)
1382 {
1383 platform_driver_unregister(&soc_camera_pdrv);
1384 driver_unregister(&ic_drv);
1385 bus_unregister(&soc_camera_bus_type);
1386 }
1387
1388 module_init(soc_camera_init);
1389 module_exit(soc_camera_exit);
1390
1391 MODULE_DESCRIPTION("Image capture bus driver");
1392 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
1393 MODULE_LICENSE("GPL");
1394 MODULE_ALIAS("platform:soc-camera-pdrv");
Support for the Chinese Samsung S3C2440 based development boards