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