Merge branch 'merge' of git://git.kernel.org/pub/scm/linux/kernel/git/paulus/powerpc
[linux-2.6] / drivers / media / video / soc_camera.c
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/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>
26
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>
32
33 /* Default to VGA resolution */
34 #define DEFAULT_WIDTH   640
35 #define DEFAULT_HEIGHT  480
36
37 static LIST_HEAD(hosts);
38 static LIST_HEAD(devices);
39 static DEFINE_MUTEX(list_lock);
40
41 const struct soc_camera_data_format *soc_camera_format_by_fourcc(
42         struct soc_camera_device *icd, unsigned int fourcc)
43 {
44         unsigned int i;
45
46         for (i = 0; i < icd->num_formats; i++)
47                 if (icd->formats[i].fourcc == fourcc)
48                         return icd->formats + i;
49         return NULL;
50 }
51 EXPORT_SYMBOL(soc_camera_format_by_fourcc);
52
53 const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
54         struct soc_camera_device *icd, unsigned int fourcc)
55 {
56         unsigned int i;
57
58         for (i = 0; i < icd->num_user_formats; i++)
59                 if (icd->user_formats[i].host_fmt->fourcc == fourcc)
60                         return icd->user_formats + i;
61         return NULL;
62 }
63 EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
64
65 /**
66  * soc_camera_apply_sensor_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
67  * @icl:        camera platform parameters
68  * @flags:      flags to be inverted according to platform configuration
69  * @return:     resulting flags
70  */
71 unsigned long soc_camera_apply_sensor_flags(struct soc_camera_link *icl,
72                                             unsigned long flags)
73 {
74         unsigned long f;
75
76         /* If only one of the two polarities is supported, switch to the opposite */
77         if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) {
78                 f = flags & (SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW);
79                 if (f == SOCAM_HSYNC_ACTIVE_HIGH || f == SOCAM_HSYNC_ACTIVE_LOW)
80                         flags ^= SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW;
81         }
82
83         if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) {
84                 f = flags & (SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW);
85                 if (f == SOCAM_VSYNC_ACTIVE_HIGH || f == SOCAM_VSYNC_ACTIVE_LOW)
86                         flags ^= SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW;
87         }
88
89         if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) {
90                 f = flags & (SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING);
91                 if (f == SOCAM_PCLK_SAMPLE_RISING || f == SOCAM_PCLK_SAMPLE_FALLING)
92                         flags ^= SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING;
93         }
94
95         return flags;
96 }
97 EXPORT_SYMBOL(soc_camera_apply_sensor_flags);
98
99 static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
100                                       struct v4l2_format *f)
101 {
102         struct soc_camera_file *icf = file->private_data;
103         struct soc_camera_device *icd = icf->icd;
104         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
105
106         WARN_ON(priv != file->private_data);
107
108         /* limit format to hardware capabilities */
109         return ici->ops->try_fmt(icd, f);
110 }
111
112 static int soc_camera_enum_input(struct file *file, void *priv,
113                                  struct v4l2_input *inp)
114 {
115         struct soc_camera_file *icf = file->private_data;
116         struct soc_camera_device *icd = icf->icd;
117         int ret = 0;
118
119         if (inp->index != 0)
120                 return -EINVAL;
121
122         if (icd->ops->enum_input)
123                 ret = icd->ops->enum_input(icd, inp);
124         else {
125                 /* default is camera */
126                 inp->type = V4L2_INPUT_TYPE_CAMERA;
127                 inp->std  = V4L2_STD_UNKNOWN;
128                 strcpy(inp->name, "Camera");
129         }
130
131         return ret;
132 }
133
134 static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
135 {
136         *i = 0;
137
138         return 0;
139 }
140
141 static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
142 {
143         if (i > 0)
144                 return -EINVAL;
145
146         return 0;
147 }
148
149 static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
150 {
151         struct soc_camera_file *icf = file->private_data;
152         struct soc_camera_device *icd = icf->icd;
153         int ret = 0;
154
155         if (icd->ops->set_std)
156                 ret = icd->ops->set_std(icd, a);
157
158         return ret;
159 }
160
161 static int soc_camera_reqbufs(struct file *file, void *priv,
162                               struct v4l2_requestbuffers *p)
163 {
164         int ret;
165         struct soc_camera_file *icf = file->private_data;
166         struct soc_camera_device *icd = icf->icd;
167         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
168
169         WARN_ON(priv != file->private_data);
170
171         dev_dbg(&icd->dev, "%s: %d\n", __func__, p->memory);
172
173         ret = videobuf_reqbufs(&icf->vb_vidq, p);
174         if (ret < 0)
175                 return ret;
176
177         return ici->ops->reqbufs(icf, p);
178 }
179
180 static int soc_camera_querybuf(struct file *file, void *priv,
181                                struct v4l2_buffer *p)
182 {
183         struct soc_camera_file *icf = file->private_data;
184
185         WARN_ON(priv != file->private_data);
186
187         return videobuf_querybuf(&icf->vb_vidq, p);
188 }
189
190 static int soc_camera_qbuf(struct file *file, void *priv,
191                            struct v4l2_buffer *p)
192 {
193         struct soc_camera_file *icf = file->private_data;
194
195         WARN_ON(priv != file->private_data);
196
197         return videobuf_qbuf(&icf->vb_vidq, p);
198 }
199
200 static int soc_camera_dqbuf(struct file *file, void *priv,
201                             struct v4l2_buffer *p)
202 {
203         struct soc_camera_file *icf = file->private_data;
204
205         WARN_ON(priv != file->private_data);
206
207         return videobuf_dqbuf(&icf->vb_vidq, p, file->f_flags & O_NONBLOCK);
208 }
209
210 static int soc_camera_init_user_formats(struct soc_camera_device *icd)
211 {
212         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
213         int i, fmts = 0;
214
215         if (!ici->ops->get_formats)
216                 /*
217                  * Fallback mode - the host will have to serve all
218                  * sensor-provided formats one-to-one to the user
219                  */
220                 fmts = icd->num_formats;
221         else
222                 /*
223                  * First pass - only count formats this host-sensor
224                  * configuration can provide
225                  */
226                 for (i = 0; i < icd->num_formats; i++)
227                         fmts += ici->ops->get_formats(icd, i, NULL);
228
229         if (!fmts)
230                 return -ENXIO;
231
232         icd->user_formats =
233                 vmalloc(fmts * sizeof(struct soc_camera_format_xlate));
234         if (!icd->user_formats)
235                 return -ENOMEM;
236
237         icd->num_user_formats = fmts;
238         fmts = 0;
239
240         dev_dbg(&icd->dev, "Found %d supported formats.\n", fmts);
241
242         /* Second pass - actually fill data formats */
243         for (i = 0; i < icd->num_formats; i++)
244                 if (!ici->ops->get_formats) {
245                         icd->user_formats[i].host_fmt = icd->formats + i;
246                         icd->user_formats[i].cam_fmt = icd->formats + i;
247                         icd->user_formats[i].buswidth = icd->formats[i].depth;
248                 } else {
249                         fmts += ici->ops->get_formats(icd, i,
250                                                       &icd->user_formats[fmts]);
251                 }
252
253         icd->current_fmt = icd->user_formats[0].host_fmt;
254
255         return 0;
256 }
257
258 static void soc_camera_free_user_formats(struct soc_camera_device *icd)
259 {
260         vfree(icd->user_formats);
261 }
262
263 /* Called with .vb_lock held */
264 static int soc_camera_set_fmt(struct soc_camera_file *icf,
265                               struct v4l2_format *f)
266 {
267         struct soc_camera_device *icd = icf->icd;
268         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
269         struct v4l2_pix_format *pix = &f->fmt.pix;
270         int ret;
271
272         /* We always call try_fmt() before set_fmt() or set_crop() */
273         ret = ici->ops->try_fmt(icd, f);
274         if (ret < 0)
275                 return ret;
276
277         ret = ici->ops->set_fmt(icd, f);
278         if (ret < 0) {
279                 return ret;
280         } else if (!icd->current_fmt ||
281                    icd->current_fmt->fourcc != pix->pixelformat) {
282                 dev_err(&ici->dev,
283                         "Host driver hasn't set up current format correctly!\n");
284                 return -EINVAL;
285         }
286
287         icd->width              = pix->width;
288         icd->height             = pix->height;
289         icf->vb_vidq.field      =
290                 icd->field      = pix->field;
291
292         if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
293                 dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
294                          f->type);
295
296         dev_dbg(&icd->dev, "set width: %d height: %d\n",
297                 icd->width, icd->height);
298
299         /* set physical bus parameters */
300         return ici->ops->set_bus_param(icd, pix->pixelformat);
301 }
302
303 static int soc_camera_open(struct file *file)
304 {
305         struct video_device *vdev;
306         struct soc_camera_device *icd;
307         struct soc_camera_host *ici;
308         struct soc_camera_file *icf;
309         int ret;
310
311         icf = vmalloc(sizeof(*icf));
312         if (!icf)
313                 return -ENOMEM;
314
315         /*
316          * It is safe to dereference these pointers now as long as a user has
317          * the video device open - we are protected by the held cdev reference.
318          */
319
320         vdev = video_devdata(file);
321         icd = container_of(vdev->parent, struct soc_camera_device, dev);
322         ici = to_soc_camera_host(icd->dev.parent);
323
324         if (!try_module_get(icd->ops->owner)) {
325                 dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
326                 ret = -EINVAL;
327                 goto emgd;
328         }
329
330         if (!try_module_get(ici->ops->owner)) {
331                 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
332                 ret = -EINVAL;
333                 goto emgi;
334         }
335
336         /* Protect against icd->remove() until we module_get() both drivers. */
337         mutex_lock(&icd->video_lock);
338
339         icf->icd = icd;
340         icd->use_count++;
341
342         /* Now we really have to activate the camera */
343         if (icd->use_count == 1) {
344                 /* Restore parameters before the last close() per V4L2 API */
345                 struct v4l2_format f = {
346                         .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
347                         .fmt.pix = {
348                                 .width          = icd->width,
349                                 .height         = icd->height,
350                                 .field          = icd->field,
351                                 .pixelformat    = icd->current_fmt->fourcc,
352                                 .colorspace     = icd->current_fmt->colorspace,
353                         },
354                 };
355
356                 ret = ici->ops->add(icd);
357                 if (ret < 0) {
358                         dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
359                         goto eiciadd;
360                 }
361
362                 /* Try to configure with default parameters */
363                 ret = soc_camera_set_fmt(icf, &f);
364                 if (ret < 0)
365                         goto esfmt;
366         }
367
368         mutex_unlock(&icd->video_lock);
369
370         file->private_data = icf;
371         dev_dbg(&icd->dev, "camera device open\n");
372
373         ici->ops->init_videobuf(&icf->vb_vidq, icd);
374
375         return 0;
376
377         /*
378          * First three errors are entered with the .video_lock held
379          * and use_count == 1
380          */
381 esfmt:
382         ici->ops->remove(icd);
383 eiciadd:
384         icd->use_count--;
385         mutex_unlock(&icd->video_lock);
386         module_put(ici->ops->owner);
387 emgi:
388         module_put(icd->ops->owner);
389 emgd:
390         vfree(icf);
391         return ret;
392 }
393
394 static int soc_camera_close(struct file *file)
395 {
396         struct soc_camera_file *icf = file->private_data;
397         struct soc_camera_device *icd = icf->icd;
398         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
399         struct video_device *vdev = icd->vdev;
400
401         mutex_lock(&icd->video_lock);
402         icd->use_count--;
403         if (!icd->use_count)
404                 ici->ops->remove(icd);
405
406         mutex_unlock(&icd->video_lock);
407
408         module_put(icd->ops->owner);
409         module_put(ici->ops->owner);
410
411         vfree(icf);
412
413         dev_dbg(vdev->parent, "camera device close\n");
414
415         return 0;
416 }
417
418 static ssize_t soc_camera_read(struct file *file, char __user *buf,
419                                size_t count, loff_t *ppos)
420 {
421         struct soc_camera_file *icf = file->private_data;
422         struct soc_camera_device *icd = icf->icd;
423         struct video_device *vdev = icd->vdev;
424         int err = -EINVAL;
425
426         dev_err(vdev->parent, "camera device read not implemented\n");
427
428         return err;
429 }
430
431 static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
432 {
433         struct soc_camera_file *icf = file->private_data;
434         struct soc_camera_device *icd = icf->icd;
435         int err;
436
437         dev_dbg(&icd->dev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
438
439         err = videobuf_mmap_mapper(&icf->vb_vidq, vma);
440
441         dev_dbg(&icd->dev, "vma start=0x%08lx, size=%ld, ret=%d\n",
442                 (unsigned long)vma->vm_start,
443                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
444                 err);
445
446         return err;
447 }
448
449 static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
450 {
451         struct soc_camera_file *icf = file->private_data;
452         struct soc_camera_device *icd = icf->icd;
453         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
454
455         if (list_empty(&icf->vb_vidq.stream)) {
456                 dev_err(&icd->dev, "Trying to poll with no queued buffers!\n");
457                 return POLLERR;
458         }
459
460         return ici->ops->poll(file, pt);
461 }
462
463 static struct v4l2_file_operations soc_camera_fops = {
464         .owner          = THIS_MODULE,
465         .open           = soc_camera_open,
466         .release        = soc_camera_close,
467         .ioctl          = video_ioctl2,
468         .read           = soc_camera_read,
469         .mmap           = soc_camera_mmap,
470         .poll           = soc_camera_poll,
471 };
472
473 static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
474                                     struct v4l2_format *f)
475 {
476         struct soc_camera_file *icf = file->private_data;
477         struct soc_camera_device *icd = icf->icd;
478         int ret;
479
480         WARN_ON(priv != file->private_data);
481
482         mutex_lock(&icf->vb_vidq.vb_lock);
483
484         if (videobuf_queue_is_busy(&icf->vb_vidq)) {
485                 dev_err(&icd->dev, "S_FMT denied: queue busy\n");
486                 ret = -EBUSY;
487                 goto unlock;
488         }
489
490         ret = soc_camera_set_fmt(icf, f);
491
492 unlock:
493         mutex_unlock(&icf->vb_vidq.vb_lock);
494
495         return ret;
496 }
497
498 static int soc_camera_enum_fmt_vid_cap(struct file *file, void  *priv,
499                                        struct v4l2_fmtdesc *f)
500 {
501         struct soc_camera_file *icf = file->private_data;
502         struct soc_camera_device *icd = icf->icd;
503         const struct soc_camera_data_format *format;
504
505         WARN_ON(priv != file->private_data);
506
507         if (f->index >= icd->num_user_formats)
508                 return -EINVAL;
509
510         format = icd->user_formats[f->index].host_fmt;
511
512         strlcpy(f->description, format->name, sizeof(f->description));
513         f->pixelformat = format->fourcc;
514         return 0;
515 }
516
517 static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
518                                     struct v4l2_format *f)
519 {
520         struct soc_camera_file *icf = file->private_data;
521         struct soc_camera_device *icd = icf->icd;
522         struct v4l2_pix_format *pix = &f->fmt.pix;
523
524         WARN_ON(priv != file->private_data);
525
526         pix->width              = icd->width;
527         pix->height             = icd->height;
528         pix->field              = icf->vb_vidq.field;
529         pix->pixelformat        = icd->current_fmt->fourcc;
530         pix->bytesperline       = pix->width *
531                 DIV_ROUND_UP(icd->current_fmt->depth, 8);
532         pix->sizeimage          = pix->height * pix->bytesperline;
533         dev_dbg(&icd->dev, "current_fmt->fourcc: 0x%08x\n",
534                 icd->current_fmt->fourcc);
535         return 0;
536 }
537
538 static int soc_camera_querycap(struct file *file, void  *priv,
539                                struct v4l2_capability *cap)
540 {
541         struct soc_camera_file *icf = file->private_data;
542         struct soc_camera_device *icd = icf->icd;
543         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
544
545         WARN_ON(priv != file->private_data);
546
547         strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
548         return ici->ops->querycap(ici, cap);
549 }
550
551 static int soc_camera_streamon(struct file *file, void *priv,
552                                enum v4l2_buf_type i)
553 {
554         struct soc_camera_file *icf = file->private_data;
555         struct soc_camera_device *icd = icf->icd;
556         int ret;
557
558         WARN_ON(priv != file->private_data);
559
560         dev_dbg(&icd->dev, "%s\n", __func__);
561
562         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
563                 return -EINVAL;
564
565         mutex_lock(&icd->video_lock);
566
567         icd->ops->start_capture(icd);
568
569         /* This calls buf_queue from host driver's videobuf_queue_ops */
570         ret = videobuf_streamon(&icf->vb_vidq);
571
572         mutex_unlock(&icd->video_lock);
573
574         return ret;
575 }
576
577 static int soc_camera_streamoff(struct file *file, void *priv,
578                                 enum v4l2_buf_type i)
579 {
580         struct soc_camera_file *icf = file->private_data;
581         struct soc_camera_device *icd = icf->icd;
582
583         WARN_ON(priv != file->private_data);
584
585         dev_dbg(&icd->dev, "%s\n", __func__);
586
587         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
588                 return -EINVAL;
589
590         mutex_lock(&icd->video_lock);
591
592         /* This calls buf_release from host driver's videobuf_queue_ops for all
593          * remaining buffers. When the last buffer is freed, stop capture */
594         videobuf_streamoff(&icf->vb_vidq);
595
596         icd->ops->stop_capture(icd);
597
598         mutex_unlock(&icd->video_lock);
599
600         return 0;
601 }
602
603 static int soc_camera_queryctrl(struct file *file, void *priv,
604                                 struct v4l2_queryctrl *qc)
605 {
606         struct soc_camera_file *icf = file->private_data;
607         struct soc_camera_device *icd = icf->icd;
608         int i;
609
610         WARN_ON(priv != file->private_data);
611
612         if (!qc->id)
613                 return -EINVAL;
614
615         for (i = 0; i < icd->ops->num_controls; i++)
616                 if (qc->id == icd->ops->controls[i].id) {
617                         memcpy(qc, &(icd->ops->controls[i]),
618                                 sizeof(*qc));
619                         return 0;
620                 }
621
622         return -EINVAL;
623 }
624
625 static int soc_camera_g_ctrl(struct file *file, void *priv,
626                              struct v4l2_control *ctrl)
627 {
628         struct soc_camera_file *icf = file->private_data;
629         struct soc_camera_device *icd = icf->icd;
630
631         WARN_ON(priv != file->private_data);
632
633         switch (ctrl->id) {
634         case V4L2_CID_GAIN:
635                 if (icd->gain == (unsigned short)~0)
636                         return -EINVAL;
637                 ctrl->value = icd->gain;
638                 return 0;
639         case V4L2_CID_EXPOSURE:
640                 if (icd->exposure == (unsigned short)~0)
641                         return -EINVAL;
642                 ctrl->value = icd->exposure;
643                 return 0;
644         }
645
646         if (icd->ops->get_control)
647                 return icd->ops->get_control(icd, ctrl);
648         return -EINVAL;
649 }
650
651 static int soc_camera_s_ctrl(struct file *file, void *priv,
652                              struct v4l2_control *ctrl)
653 {
654         struct soc_camera_file *icf = file->private_data;
655         struct soc_camera_device *icd = icf->icd;
656
657         WARN_ON(priv != file->private_data);
658
659         if (icd->ops->set_control)
660                 return icd->ops->set_control(icd, ctrl);
661         return -EINVAL;
662 }
663
664 static int soc_camera_cropcap(struct file *file, void *fh,
665                               struct v4l2_cropcap *a)
666 {
667         struct soc_camera_file *icf = file->private_data;
668         struct soc_camera_device *icd = icf->icd;
669
670         a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
671         a->bounds.left                  = icd->x_min;
672         a->bounds.top                   = icd->y_min;
673         a->bounds.width                 = icd->width_max;
674         a->bounds.height                = icd->height_max;
675         a->defrect.left                 = icd->x_min;
676         a->defrect.top                  = icd->y_min;
677         a->defrect.width                = DEFAULT_WIDTH;
678         a->defrect.height               = DEFAULT_HEIGHT;
679         a->pixelaspect.numerator        = 1;
680         a->pixelaspect.denominator      = 1;
681
682         return 0;
683 }
684
685 static int soc_camera_g_crop(struct file *file, void *fh,
686                              struct v4l2_crop *a)
687 {
688         struct soc_camera_file *icf = file->private_data;
689         struct soc_camera_device *icd = icf->icd;
690
691         a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
692         a->c.left       = icd->x_current;
693         a->c.top        = icd->y_current;
694         a->c.width      = icd->width;
695         a->c.height     = icd->height;
696
697         return 0;
698 }
699
700 static int soc_camera_s_crop(struct file *file, void *fh,
701                              struct v4l2_crop *a)
702 {
703         struct soc_camera_file *icf = file->private_data;
704         struct soc_camera_device *icd = icf->icd;
705         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
706         int ret;
707
708         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
709                 return -EINVAL;
710
711         /* Cropping is allowed during a running capture, guard consistency */
712         mutex_lock(&icf->vb_vidq.vb_lock);
713
714         ret = ici->ops->set_crop(icd, &a->c);
715         if (!ret) {
716                 icd->width      = a->c.width;
717                 icd->height     = a->c.height;
718                 icd->x_current  = a->c.left;
719                 icd->y_current  = a->c.top;
720         }
721
722         mutex_unlock(&icf->vb_vidq.vb_lock);
723
724         return ret;
725 }
726
727 static int soc_camera_g_chip_ident(struct file *file, void *fh,
728                                    struct v4l2_dbg_chip_ident *id)
729 {
730         struct soc_camera_file *icf = file->private_data;
731         struct soc_camera_device *icd = icf->icd;
732
733         if (!icd->ops->get_chip_id)
734                 return -EINVAL;
735
736         return icd->ops->get_chip_id(icd, id);
737 }
738
739 #ifdef CONFIG_VIDEO_ADV_DEBUG
740 static int soc_camera_g_register(struct file *file, void *fh,
741                                  struct v4l2_dbg_register *reg)
742 {
743         struct soc_camera_file *icf = file->private_data;
744         struct soc_camera_device *icd = icf->icd;
745
746         if (!icd->ops->get_register)
747                 return -EINVAL;
748
749         return icd->ops->get_register(icd, reg);
750 }
751
752 static int soc_camera_s_register(struct file *file, void *fh,
753                                  struct v4l2_dbg_register *reg)
754 {
755         struct soc_camera_file *icf = file->private_data;
756         struct soc_camera_device *icd = icf->icd;
757
758         if (!icd->ops->set_register)
759                 return -EINVAL;
760
761         return icd->ops->set_register(icd, reg);
762 }
763 #endif
764
765 static int device_register_link(struct soc_camera_device *icd)
766 {
767         int ret = dev_set_name(&icd->dev, "%u-%u", icd->iface, icd->devnum);
768
769         if (!ret)
770                 ret = device_register(&icd->dev);
771
772         if (ret < 0) {
773                 /* Prevent calling device_unregister() */
774                 icd->dev.parent = NULL;
775                 dev_err(&icd->dev, "Cannot register device: %d\n", ret);
776         /* Even if probe() was unsuccessful for all registered drivers,
777          * device_register() returns 0, and we add the link, just to
778          * document this camera's control device */
779         } else if (icd->control)
780                 /* Have to sysfs_remove_link() before device_unregister()? */
781                 if (sysfs_create_link(&icd->dev.kobj, &icd->control->kobj,
782                                       "control"))
783                         dev_warn(&icd->dev,
784                                  "Failed creating the control symlink\n");
785         return ret;
786 }
787
788 /* So far this function cannot fail */
789 static void scan_add_host(struct soc_camera_host *ici)
790 {
791         struct soc_camera_device *icd;
792
793         mutex_lock(&list_lock);
794
795         list_for_each_entry(icd, &devices, list) {
796                 if (icd->iface == ici->nr) {
797                         icd->dev.parent = &ici->dev;
798                         device_register_link(icd);
799                 }
800         }
801
802         mutex_unlock(&list_lock);
803 }
804
805 /* return: 0 if no match found or a match found and
806  * device_register() successful, error code otherwise */
807 static int scan_add_device(struct soc_camera_device *icd)
808 {
809         struct soc_camera_host *ici;
810         int ret = 0;
811
812         mutex_lock(&list_lock);
813
814         list_add_tail(&icd->list, &devices);
815
816         /* Watch out for class_for_each_device / class_find_device API by
817          * Dave Young <hidave.darkstar@gmail.com> */
818         list_for_each_entry(ici, &hosts, list) {
819                 if (icd->iface == ici->nr) {
820                         ret = 1;
821                         icd->dev.parent = &ici->dev;
822                         break;
823                 }
824         }
825
826         mutex_unlock(&list_lock);
827
828         if (ret)
829                 ret = device_register_link(icd);
830
831         return ret;
832 }
833
834 static int soc_camera_probe(struct device *dev)
835 {
836         struct soc_camera_device *icd = to_soc_camera_dev(dev);
837         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
838         int ret;
839
840         /*
841          * Possible race scenario:
842          * modprobe <camera-host-driver> triggers __func__
843          * at this moment respective <camera-sensor-driver> gets rmmod'ed
844          * to protect take module references.
845          */
846
847         if (!try_module_get(icd->ops->owner)) {
848                 dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
849                 ret = -EINVAL;
850                 goto emgd;
851         }
852
853         if (!try_module_get(ici->ops->owner)) {
854                 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
855                 ret = -EINVAL;
856                 goto emgi;
857         }
858
859         mutex_lock(&icd->video_lock);
860
861         /* We only call ->add() here to activate and probe the camera.
862          * We shall ->remove() and deactivate it immediately afterwards. */
863         ret = ici->ops->add(icd);
864         if (ret < 0)
865                 goto eiadd;
866
867         ret = icd->ops->probe(icd);
868         if (ret >= 0) {
869                 const struct v4l2_queryctrl *qctrl;
870
871                 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
872                 icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
873                 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
874                 icd->exposure = qctrl ? qctrl->default_value :
875                         (unsigned short)~0;
876
877                 ret = soc_camera_init_user_formats(icd);
878                 if (ret < 0)
879                         goto eiufmt;
880
881                 icd->height     = DEFAULT_HEIGHT;
882                 icd->width      = DEFAULT_WIDTH;
883                 icd->field      = V4L2_FIELD_ANY;
884         }
885
886 eiufmt:
887         ici->ops->remove(icd);
888 eiadd:
889         mutex_unlock(&icd->video_lock);
890         module_put(ici->ops->owner);
891 emgi:
892         module_put(icd->ops->owner);
893 emgd:
894         return ret;
895 }
896
897 /* This is called on device_unregister, which only means we have to disconnect
898  * from the host, but not remove ourselves from the device list */
899 static int soc_camera_remove(struct device *dev)
900 {
901         struct soc_camera_device *icd = to_soc_camera_dev(dev);
902
903         if (icd->ops->remove)
904                 icd->ops->remove(icd);
905
906         soc_camera_free_user_formats(icd);
907
908         return 0;
909 }
910
911 static int soc_camera_suspend(struct device *dev, pm_message_t state)
912 {
913         struct soc_camera_device *icd = to_soc_camera_dev(dev);
914         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
915         int ret = 0;
916
917         if (ici->ops->suspend)
918                 ret = ici->ops->suspend(icd, state);
919
920         return ret;
921 }
922
923 static int soc_camera_resume(struct device *dev)
924 {
925         struct soc_camera_device *icd = to_soc_camera_dev(dev);
926         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
927         int ret = 0;
928
929         if (ici->ops->resume)
930                 ret = ici->ops->resume(icd);
931
932         return ret;
933 }
934
935 static struct bus_type soc_camera_bus_type = {
936         .name           = "soc-camera",
937         .probe          = soc_camera_probe,
938         .remove         = soc_camera_remove,
939         .suspend        = soc_camera_suspend,
940         .resume         = soc_camera_resume,
941 };
942
943 static struct device_driver ic_drv = {
944         .name   = "camera",
945         .bus    = &soc_camera_bus_type,
946         .owner  = THIS_MODULE,
947 };
948
949 static void dummy_release(struct device *dev)
950 {
951 }
952
953 int soc_camera_host_register(struct soc_camera_host *ici)
954 {
955         int ret;
956         struct soc_camera_host *ix;
957
958         if (!ici || !ici->ops ||
959             !ici->ops->try_fmt ||
960             !ici->ops->set_fmt ||
961             !ici->ops->set_crop ||
962             !ici->ops->set_bus_param ||
963             !ici->ops->querycap ||
964             !ici->ops->init_videobuf ||
965             !ici->ops->reqbufs ||
966             !ici->ops->add ||
967             !ici->ops->remove ||
968             !ici->ops->poll)
969                 return -EINVAL;
970
971         /* Number might be equal to the platform device ID */
972         dev_set_name(&ici->dev, "camera_host%d", ici->nr);
973
974         mutex_lock(&list_lock);
975         list_for_each_entry(ix, &hosts, list) {
976                 if (ix->nr == ici->nr) {
977                         mutex_unlock(&list_lock);
978                         return -EBUSY;
979                 }
980         }
981
982         list_add_tail(&ici->list, &hosts);
983         mutex_unlock(&list_lock);
984
985         ici->dev.release = dummy_release;
986
987         ret = device_register(&ici->dev);
988
989         if (ret)
990                 goto edevr;
991
992         scan_add_host(ici);
993
994         return 0;
995
996 edevr:
997         mutex_lock(&list_lock);
998         list_del(&ici->list);
999         mutex_unlock(&list_lock);
1000
1001         return ret;
1002 }
1003 EXPORT_SYMBOL(soc_camera_host_register);
1004
1005 /* Unregister all clients! */
1006 void soc_camera_host_unregister(struct soc_camera_host *ici)
1007 {
1008         struct soc_camera_device *icd;
1009
1010         mutex_lock(&list_lock);
1011
1012         list_del(&ici->list);
1013
1014         list_for_each_entry(icd, &devices, list) {
1015                 if (icd->dev.parent == &ici->dev) {
1016                         device_unregister(&icd->dev);
1017                         /* Not before device_unregister(), .remove
1018                          * needs parent to call ici->ops->remove() */
1019                         icd->dev.parent = NULL;
1020                         memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
1021                 }
1022         }
1023
1024         mutex_unlock(&list_lock);
1025
1026         device_unregister(&ici->dev);
1027 }
1028 EXPORT_SYMBOL(soc_camera_host_unregister);
1029
1030 /* Image capture device */
1031 int soc_camera_device_register(struct soc_camera_device *icd)
1032 {
1033         struct soc_camera_device *ix;
1034         int num = -1, i;
1035
1036         if (!icd || !icd->ops ||
1037             !icd->ops->probe ||
1038             !icd->ops->init ||
1039             !icd->ops->release ||
1040             !icd->ops->start_capture ||
1041             !icd->ops->stop_capture ||
1042             !icd->ops->set_crop ||
1043             !icd->ops->set_fmt ||
1044             !icd->ops->try_fmt ||
1045             !icd->ops->query_bus_param ||
1046             !icd->ops->set_bus_param)
1047                 return -EINVAL;
1048
1049         for (i = 0; i < 256 && num < 0; i++) {
1050                 num = i;
1051                 list_for_each_entry(ix, &devices, list) {
1052                         if (ix->iface == icd->iface && ix->devnum == i) {
1053                                 num = -1;
1054                                 break;
1055                         }
1056                 }
1057         }
1058
1059         if (num < 0)
1060                 /* ok, we have 256 cameras on this host...
1061                  * man, stay reasonable... */
1062                 return -ENOMEM;
1063
1064         icd->devnum = num;
1065         icd->dev.bus = &soc_camera_bus_type;
1066
1067         icd->dev.release        = dummy_release;
1068         icd->use_count          = 0;
1069         icd->host_priv          = NULL;
1070         mutex_init(&icd->video_lock);
1071
1072         return scan_add_device(icd);
1073 }
1074 EXPORT_SYMBOL(soc_camera_device_register);
1075
1076 void soc_camera_device_unregister(struct soc_camera_device *icd)
1077 {
1078         mutex_lock(&list_lock);
1079         list_del(&icd->list);
1080
1081         /* The bus->remove will be eventually called */
1082         if (icd->dev.parent)
1083                 device_unregister(&icd->dev);
1084         mutex_unlock(&list_lock);
1085 }
1086 EXPORT_SYMBOL(soc_camera_device_unregister);
1087
1088 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
1089         .vidioc_querycap         = soc_camera_querycap,
1090         .vidioc_g_fmt_vid_cap    = soc_camera_g_fmt_vid_cap,
1091         .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
1092         .vidioc_s_fmt_vid_cap    = soc_camera_s_fmt_vid_cap,
1093         .vidioc_enum_input       = soc_camera_enum_input,
1094         .vidioc_g_input          = soc_camera_g_input,
1095         .vidioc_s_input          = soc_camera_s_input,
1096         .vidioc_s_std            = soc_camera_s_std,
1097         .vidioc_reqbufs          = soc_camera_reqbufs,
1098         .vidioc_try_fmt_vid_cap  = soc_camera_try_fmt_vid_cap,
1099         .vidioc_querybuf         = soc_camera_querybuf,
1100         .vidioc_qbuf             = soc_camera_qbuf,
1101         .vidioc_dqbuf            = soc_camera_dqbuf,
1102         .vidioc_streamon         = soc_camera_streamon,
1103         .vidioc_streamoff        = soc_camera_streamoff,
1104         .vidioc_queryctrl        = soc_camera_queryctrl,
1105         .vidioc_g_ctrl           = soc_camera_g_ctrl,
1106         .vidioc_s_ctrl           = soc_camera_s_ctrl,
1107         .vidioc_cropcap          = soc_camera_cropcap,
1108         .vidioc_g_crop           = soc_camera_g_crop,
1109         .vidioc_s_crop           = soc_camera_s_crop,
1110         .vidioc_g_chip_ident     = soc_camera_g_chip_ident,
1111 #ifdef CONFIG_VIDEO_ADV_DEBUG
1112         .vidioc_g_register       = soc_camera_g_register,
1113         .vidioc_s_register       = soc_camera_s_register,
1114 #endif
1115 };
1116
1117 /*
1118  * Usually called from the struct soc_camera_ops .probe() method, i.e., from
1119  * soc_camera_probe() above with .video_lock held
1120  */
1121 int soc_camera_video_start(struct soc_camera_device *icd)
1122 {
1123         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1124         int err = -ENOMEM;
1125         struct video_device *vdev;
1126
1127         if (!icd->dev.parent)
1128                 return -ENODEV;
1129
1130         vdev = video_device_alloc();
1131         if (!vdev)
1132                 goto evidallocd;
1133         dev_dbg(&ici->dev, "Allocated video_device %p\n", vdev);
1134
1135         strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
1136
1137         vdev->parent            = &icd->dev;
1138         vdev->current_norm      = V4L2_STD_UNKNOWN;
1139         vdev->fops              = &soc_camera_fops;
1140         vdev->ioctl_ops         = &soc_camera_ioctl_ops;
1141         vdev->release           = video_device_release;
1142         vdev->minor             = -1;
1143         vdev->tvnorms           = V4L2_STD_UNKNOWN,
1144
1145         err = video_register_device(vdev, VFL_TYPE_GRABBER, vdev->minor);
1146         if (err < 0) {
1147                 dev_err(vdev->parent, "video_register_device failed\n");
1148                 goto evidregd;
1149         }
1150         icd->vdev = vdev;
1151
1152         return 0;
1153
1154 evidregd:
1155         video_device_release(vdev);
1156 evidallocd:
1157         return err;
1158 }
1159 EXPORT_SYMBOL(soc_camera_video_start);
1160
1161 void soc_camera_video_stop(struct soc_camera_device *icd)
1162 {
1163         struct video_device *vdev = icd->vdev;
1164
1165         dev_dbg(&icd->dev, "%s\n", __func__);
1166
1167         if (!icd->dev.parent || !vdev)
1168                 return;
1169
1170         mutex_lock(&icd->video_lock);
1171         video_unregister_device(vdev);
1172         icd->vdev = NULL;
1173         mutex_unlock(&icd->video_lock);
1174 }
1175 EXPORT_SYMBOL(soc_camera_video_stop);
1176
1177 static int __init soc_camera_init(void)
1178 {
1179         int ret = bus_register(&soc_camera_bus_type);
1180         if (ret)
1181                 return ret;
1182         ret = driver_register(&ic_drv);
1183         if (ret)
1184                 goto edrvr;
1185
1186         return 0;
1187
1188 edrvr:
1189         bus_unregister(&soc_camera_bus_type);
1190         return ret;
1191 }
1192
1193 static void __exit soc_camera_exit(void)
1194 {
1195         driver_unregister(&ic_drv);
1196         bus_unregister(&soc_camera_bus_type);
1197 }
1198
1199 module_init(soc_camera_init);
1200 module_exit(soc_camera_exit);
1201
1202 MODULE_DESCRIPTION("Image capture bus driver");
1203 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
1204 MODULE_LICENSE("GPL");