Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[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 = device_register(&icd->dev);
768
769         if (ret < 0) {
770                 /* Prevent calling device_unregister() */
771                 icd->dev.parent = NULL;
772                 dev_err(&icd->dev, "Cannot register device: %d\n", ret);
773         /* Even if probe() was unsuccessful for all registered drivers,
774          * device_register() returns 0, and we add the link, just to
775          * document this camera's control device */
776         } else if (icd->control)
777                 /* Have to sysfs_remove_link() before device_unregister()? */
778                 if (sysfs_create_link(&icd->dev.kobj, &icd->control->kobj,
779                                       "control"))
780                         dev_warn(&icd->dev,
781                                  "Failed creating the control symlink\n");
782         return ret;
783 }
784
785 /* So far this function cannot fail */
786 static void scan_add_host(struct soc_camera_host *ici)
787 {
788         struct soc_camera_device *icd;
789
790         mutex_lock(&list_lock);
791
792         list_for_each_entry(icd, &devices, list) {
793                 if (icd->iface == ici->nr) {
794                         icd->dev.parent = &ici->dev;
795                         device_register_link(icd);
796                 }
797         }
798
799         mutex_unlock(&list_lock);
800 }
801
802 /* return: 0 if no match found or a match found and
803  * device_register() successful, error code otherwise */
804 static int scan_add_device(struct soc_camera_device *icd)
805 {
806         struct soc_camera_host *ici;
807         int ret = 0;
808
809         mutex_lock(&list_lock);
810
811         list_add_tail(&icd->list, &devices);
812
813         /* Watch out for class_for_each_device / class_find_device API by
814          * Dave Young <hidave.darkstar@gmail.com> */
815         list_for_each_entry(ici, &hosts, list) {
816                 if (icd->iface == ici->nr) {
817                         ret = 1;
818                         icd->dev.parent = &ici->dev;
819                         break;
820                 }
821         }
822
823         mutex_unlock(&list_lock);
824
825         if (ret)
826                 ret = device_register_link(icd);
827
828         return ret;
829 }
830
831 static int soc_camera_probe(struct device *dev)
832 {
833         struct soc_camera_device *icd = to_soc_camera_dev(dev);
834         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
835         int ret;
836
837         /*
838          * Possible race scenario:
839          * modprobe <camera-host-driver> triggers __func__
840          * at this moment respective <camera-sensor-driver> gets rmmod'ed
841          * to protect take module references.
842          */
843
844         if (!try_module_get(icd->ops->owner)) {
845                 dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
846                 ret = -EINVAL;
847                 goto emgd;
848         }
849
850         if (!try_module_get(ici->ops->owner)) {
851                 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
852                 ret = -EINVAL;
853                 goto emgi;
854         }
855
856         mutex_lock(&icd->video_lock);
857
858         /* We only call ->add() here to activate and probe the camera.
859          * We shall ->remove() and deactivate it immediately afterwards. */
860         ret = ici->ops->add(icd);
861         if (ret < 0)
862                 goto eiadd;
863
864         ret = icd->ops->probe(icd);
865         if (ret >= 0) {
866                 const struct v4l2_queryctrl *qctrl;
867
868                 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
869                 icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
870                 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
871                 icd->exposure = qctrl ? qctrl->default_value :
872                         (unsigned short)~0;
873
874                 ret = soc_camera_init_user_formats(icd);
875                 if (ret < 0)
876                         goto eiufmt;
877
878                 icd->height     = DEFAULT_HEIGHT;
879                 icd->width      = DEFAULT_WIDTH;
880                 icd->field      = V4L2_FIELD_ANY;
881         }
882
883 eiufmt:
884         ici->ops->remove(icd);
885 eiadd:
886         mutex_unlock(&icd->video_lock);
887         module_put(ici->ops->owner);
888 emgi:
889         module_put(icd->ops->owner);
890 emgd:
891         return ret;
892 }
893
894 /* This is called on device_unregister, which only means we have to disconnect
895  * from the host, but not remove ourselves from the device list */
896 static int soc_camera_remove(struct device *dev)
897 {
898         struct soc_camera_device *icd = to_soc_camera_dev(dev);
899
900         if (icd->ops->remove)
901                 icd->ops->remove(icd);
902
903         soc_camera_free_user_formats(icd);
904
905         return 0;
906 }
907
908 static int soc_camera_suspend(struct device *dev, pm_message_t state)
909 {
910         struct soc_camera_device *icd = to_soc_camera_dev(dev);
911         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
912         int ret = 0;
913
914         if (ici->ops->suspend)
915                 ret = ici->ops->suspend(icd, state);
916
917         return ret;
918 }
919
920 static int soc_camera_resume(struct device *dev)
921 {
922         struct soc_camera_device *icd = to_soc_camera_dev(dev);
923         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
924         int ret = 0;
925
926         if (ici->ops->resume)
927                 ret = ici->ops->resume(icd);
928
929         return ret;
930 }
931
932 static struct bus_type soc_camera_bus_type = {
933         .name           = "soc-camera",
934         .probe          = soc_camera_probe,
935         .remove         = soc_camera_remove,
936         .suspend        = soc_camera_suspend,
937         .resume         = soc_camera_resume,
938 };
939
940 static struct device_driver ic_drv = {
941         .name   = "camera",
942         .bus    = &soc_camera_bus_type,
943         .owner  = THIS_MODULE,
944 };
945
946 static void dummy_release(struct device *dev)
947 {
948 }
949
950 int soc_camera_host_register(struct soc_camera_host *ici)
951 {
952         int ret;
953         struct soc_camera_host *ix;
954
955         if (!ici || !ici->ops ||
956             !ici->ops->try_fmt ||
957             !ici->ops->set_fmt ||
958             !ici->ops->set_crop ||
959             !ici->ops->set_bus_param ||
960             !ici->ops->querycap ||
961             !ici->ops->init_videobuf ||
962             !ici->ops->reqbufs ||
963             !ici->ops->add ||
964             !ici->ops->remove ||
965             !ici->ops->poll)
966                 return -EINVAL;
967
968         /* Number might be equal to the platform device ID */
969         dev_set_name(&ici->dev, "camera_host%d", ici->nr);
970
971         mutex_lock(&list_lock);
972         list_for_each_entry(ix, &hosts, list) {
973                 if (ix->nr == ici->nr) {
974                         mutex_unlock(&list_lock);
975                         return -EBUSY;
976                 }
977         }
978
979         list_add_tail(&ici->list, &hosts);
980         mutex_unlock(&list_lock);
981
982         ici->dev.release = dummy_release;
983
984         ret = device_register(&ici->dev);
985
986         if (ret)
987                 goto edevr;
988
989         scan_add_host(ici);
990
991         return 0;
992
993 edevr:
994         mutex_lock(&list_lock);
995         list_del(&ici->list);
996         mutex_unlock(&list_lock);
997
998         return ret;
999 }
1000 EXPORT_SYMBOL(soc_camera_host_register);
1001
1002 /* Unregister all clients! */
1003 void soc_camera_host_unregister(struct soc_camera_host *ici)
1004 {
1005         struct soc_camera_device *icd;
1006
1007         mutex_lock(&list_lock);
1008
1009         list_del(&ici->list);
1010
1011         list_for_each_entry(icd, &devices, list) {
1012                 if (icd->dev.parent == &ici->dev) {
1013                         device_unregister(&icd->dev);
1014                         /* Not before device_unregister(), .remove
1015                          * needs parent to call ici->ops->remove() */
1016                         icd->dev.parent = NULL;
1017                         memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
1018                 }
1019         }
1020
1021         mutex_unlock(&list_lock);
1022
1023         device_unregister(&ici->dev);
1024 }
1025 EXPORT_SYMBOL(soc_camera_host_unregister);
1026
1027 /* Image capture device */
1028 int soc_camera_device_register(struct soc_camera_device *icd)
1029 {
1030         struct soc_camera_device *ix;
1031         int num = -1, i;
1032
1033         if (!icd || !icd->ops ||
1034             !icd->ops->probe ||
1035             !icd->ops->init ||
1036             !icd->ops->release ||
1037             !icd->ops->start_capture ||
1038             !icd->ops->stop_capture ||
1039             !icd->ops->set_crop ||
1040             !icd->ops->set_fmt ||
1041             !icd->ops->try_fmt ||
1042             !icd->ops->query_bus_param ||
1043             !icd->ops->set_bus_param)
1044                 return -EINVAL;
1045
1046         for (i = 0; i < 256 && num < 0; i++) {
1047                 num = i;
1048                 list_for_each_entry(ix, &devices, list) {
1049                         if (ix->iface == icd->iface && ix->devnum == i) {
1050                                 num = -1;
1051                                 break;
1052                         }
1053                 }
1054         }
1055
1056         if (num < 0)
1057                 /* ok, we have 256 cameras on this host...
1058                  * man, stay reasonable... */
1059                 return -ENOMEM;
1060
1061         icd->devnum = num;
1062         icd->dev.bus = &soc_camera_bus_type;
1063         dev_set_name(&icd->dev, "%u-%u", icd->iface, icd->devnum);
1064
1065         icd->dev.release        = dummy_release;
1066         icd->use_count          = 0;
1067         icd->host_priv          = NULL;
1068         mutex_init(&icd->video_lock);
1069
1070         return scan_add_device(icd);
1071 }
1072 EXPORT_SYMBOL(soc_camera_device_register);
1073
1074 void soc_camera_device_unregister(struct soc_camera_device *icd)
1075 {
1076         mutex_lock(&list_lock);
1077         list_del(&icd->list);
1078
1079         /* The bus->remove will be eventually called */
1080         if (icd->dev.parent)
1081                 device_unregister(&icd->dev);
1082         mutex_unlock(&list_lock);
1083 }
1084 EXPORT_SYMBOL(soc_camera_device_unregister);
1085
1086 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
1087         .vidioc_querycap         = soc_camera_querycap,
1088         .vidioc_g_fmt_vid_cap    = soc_camera_g_fmt_vid_cap,
1089         .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
1090         .vidioc_s_fmt_vid_cap    = soc_camera_s_fmt_vid_cap,
1091         .vidioc_enum_input       = soc_camera_enum_input,
1092         .vidioc_g_input          = soc_camera_g_input,
1093         .vidioc_s_input          = soc_camera_s_input,
1094         .vidioc_s_std            = soc_camera_s_std,
1095         .vidioc_reqbufs          = soc_camera_reqbufs,
1096         .vidioc_try_fmt_vid_cap  = soc_camera_try_fmt_vid_cap,
1097         .vidioc_querybuf         = soc_camera_querybuf,
1098         .vidioc_qbuf             = soc_camera_qbuf,
1099         .vidioc_dqbuf            = soc_camera_dqbuf,
1100         .vidioc_streamon         = soc_camera_streamon,
1101         .vidioc_streamoff        = soc_camera_streamoff,
1102         .vidioc_queryctrl        = soc_camera_queryctrl,
1103         .vidioc_g_ctrl           = soc_camera_g_ctrl,
1104         .vidioc_s_ctrl           = soc_camera_s_ctrl,
1105         .vidioc_cropcap          = soc_camera_cropcap,
1106         .vidioc_g_crop           = soc_camera_g_crop,
1107         .vidioc_s_crop           = soc_camera_s_crop,
1108         .vidioc_g_chip_ident     = soc_camera_g_chip_ident,
1109 #ifdef CONFIG_VIDEO_ADV_DEBUG
1110         .vidioc_g_register       = soc_camera_g_register,
1111         .vidioc_s_register       = soc_camera_s_register,
1112 #endif
1113 };
1114
1115 /*
1116  * Usually called from the struct soc_camera_ops .probe() method, i.e., from
1117  * soc_camera_probe() above with .video_lock held
1118  */
1119 int soc_camera_video_start(struct soc_camera_device *icd)
1120 {
1121         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1122         int err = -ENOMEM;
1123         struct video_device *vdev;
1124
1125         if (!icd->dev.parent)
1126                 return -ENODEV;
1127
1128         vdev = video_device_alloc();
1129         if (!vdev)
1130                 goto evidallocd;
1131         dev_dbg(&ici->dev, "Allocated video_device %p\n", vdev);
1132
1133         strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
1134
1135         vdev->parent            = &icd->dev;
1136         vdev->current_norm      = V4L2_STD_UNKNOWN;
1137         vdev->fops              = &soc_camera_fops;
1138         vdev->ioctl_ops         = &soc_camera_ioctl_ops;
1139         vdev->release           = video_device_release;
1140         vdev->minor             = -1;
1141         vdev->tvnorms           = V4L2_STD_UNKNOWN,
1142
1143         err = video_register_device(vdev, VFL_TYPE_GRABBER, vdev->minor);
1144         if (err < 0) {
1145                 dev_err(vdev->parent, "video_register_device failed\n");
1146                 goto evidregd;
1147         }
1148         icd->vdev = vdev;
1149
1150         return 0;
1151
1152 evidregd:
1153         video_device_release(vdev);
1154 evidallocd:
1155         return err;
1156 }
1157 EXPORT_SYMBOL(soc_camera_video_start);
1158
1159 void soc_camera_video_stop(struct soc_camera_device *icd)
1160 {
1161         struct video_device *vdev = icd->vdev;
1162
1163         dev_dbg(&icd->dev, "%s\n", __func__);
1164
1165         if (!icd->dev.parent || !vdev)
1166                 return;
1167
1168         mutex_lock(&icd->video_lock);
1169         video_unregister_device(vdev);
1170         icd->vdev = NULL;
1171         mutex_unlock(&icd->video_lock);
1172 }
1173 EXPORT_SYMBOL(soc_camera_video_stop);
1174
1175 static int __init soc_camera_init(void)
1176 {
1177         int ret = bus_register(&soc_camera_bus_type);
1178         if (ret)
1179                 return ret;
1180         ret = driver_register(&ic_drv);
1181         if (ret)
1182                 goto edrvr;
1183
1184         return 0;
1185
1186 edrvr:
1187         bus_unregister(&soc_camera_bus_type);
1188         return ret;
1189 }
1190
1191 static void __exit soc_camera_exit(void)
1192 {
1193         driver_unregister(&ic_drv);
1194         bus_unregister(&soc_camera_bus_type);
1195 }
1196
1197 module_init(soc_camera_init);
1198 module_exit(soc_camera_exit);
1199
1200 MODULE_DESCRIPTION("Image capture bus driver");
1201 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
1202 MODULE_LICENSE("GPL");