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