V4L/DVB (8337): soc_camera: make videobuf independent
[linux-2.6] / drivers / media / video / soc_camera.c
1 /*
2  * camera image capture (abstract) bus driver
3  *
4  * Copyright (C) 2008, Guennadi Liakhovetski <kernel@pengutronix.de>
5  *
6  * This driver provides an interface between platform-specific camera
7  * busses and camera devices. It should be used if the camera is
8  * connected not over a "proper" bus like PCI or USB, but over a
9  * special bus, like, for example, the Quick Capture interface on PXA270
10  * SoCs. Later it should also be used for i.MX31 SoCs from Freescale.
11  * It can handle multiple cameras and / or multiple busses, which can
12  * be used, e.g., in stereo-vision applications.
13  *
14  * This program is free software; you can redistribute it and/or modify
15  * it under the terms of the GNU General Public License version 2 as
16  * published by the Free Software Foundation.
17  */
18
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include <linux/device.h>
22 #include <linux/list.h>
23 #include <linux/err.h>
24 #include <linux/mutex.h>
25 #include <linux/vmalloc.h>
26
27 #include <media/v4l2-common.h>
28 #include <media/v4l2-dev.h>
29 #include <media/videobuf-core.h>
30 #include <media/soc_camera.h>
31
32 static LIST_HEAD(hosts);
33 static LIST_HEAD(devices);
34 static DEFINE_MUTEX(list_lock);
35 static DEFINE_MUTEX(video_lock);
36
37 const static struct soc_camera_data_format*
38 format_by_fourcc(struct soc_camera_device *icd, unsigned int fourcc)
39 {
40         unsigned int i;
41
42         for (i = 0; i < icd->num_formats; i++)
43                 if (icd->formats[i].fourcc == fourcc)
44                         return icd->formats + i;
45         return NULL;
46 }
47
48 static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
49                                   struct v4l2_format *f)
50 {
51         struct soc_camera_file *icf = file->private_data;
52         struct soc_camera_device *icd = icf->icd;
53         struct soc_camera_host *ici =
54                 to_soc_camera_host(icd->dev.parent);
55         enum v4l2_field field;
56         const struct soc_camera_data_format *fmt;
57         int ret;
58
59         WARN_ON(priv != file->private_data);
60
61         fmt = format_by_fourcc(icd, f->fmt.pix.pixelformat);
62         if (!fmt) {
63                 dev_dbg(&icd->dev, "invalid format 0x%08x\n",
64                         f->fmt.pix.pixelformat);
65                 return -EINVAL;
66         }
67
68         dev_dbg(&icd->dev, "fmt: 0x%08x\n", fmt->fourcc);
69
70         field = f->fmt.pix.field;
71
72         if (field == V4L2_FIELD_ANY) {
73                 field = V4L2_FIELD_NONE;
74         } else if (V4L2_FIELD_NONE != field) {
75                 dev_err(&icd->dev, "Field type invalid.\n");
76                 return -EINVAL;
77         }
78
79         /* test physical bus parameters */
80         ret = ici->ops->try_bus_param(icd, f->fmt.pix.pixelformat);
81         if (ret)
82                 return ret;
83
84         /* limit format to hardware capabilities */
85         ret = ici->ops->try_fmt_cap(icd, f);
86
87         /* calculate missing fields */
88         f->fmt.pix.field = field;
89         f->fmt.pix.bytesperline =
90                 (f->fmt.pix.width * fmt->depth) >> 3;
91         f->fmt.pix.sizeimage =
92                 f->fmt.pix.height * f->fmt.pix.bytesperline;
93
94         return ret;
95 }
96
97 static int soc_camera_enum_input(struct file *file, void *priv,
98                                  struct v4l2_input *inp)
99 {
100         if (inp->index != 0)
101                 return -EINVAL;
102
103         inp->type = V4L2_INPUT_TYPE_CAMERA;
104         inp->std = V4L2_STD_UNKNOWN;
105         strcpy(inp->name, "Camera");
106
107         return 0;
108 }
109
110 static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
111 {
112         *i = 0;
113
114         return 0;
115 }
116
117 static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
118 {
119         if (i > 0)
120                 return -EINVAL;
121
122         return 0;
123 }
124
125 static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
126 {
127         return 0;
128 }
129
130 static int soc_camera_reqbufs(struct file *file, void *priv,
131                               struct v4l2_requestbuffers *p)
132 {
133         int ret;
134         struct soc_camera_file *icf = file->private_data;
135         struct soc_camera_device *icd = icf->icd;
136         struct soc_camera_host *ici =
137                 to_soc_camera_host(icd->dev.parent);
138
139         WARN_ON(priv != file->private_data);
140
141         dev_dbg(&icd->dev, "%s: %d\n", __func__, p->memory);
142
143         ret = videobuf_reqbufs(&icf->vb_vidq, p);
144         if (ret < 0)
145                 return ret;
146
147         return ici->ops->reqbufs(icf, p);
148 }
149
150 static int soc_camera_querybuf(struct file *file, void *priv,
151                                struct v4l2_buffer *p)
152 {
153         struct soc_camera_file *icf = file->private_data;
154
155         WARN_ON(priv != file->private_data);
156
157         return videobuf_querybuf(&icf->vb_vidq, p);
158 }
159
160 static int soc_camera_qbuf(struct file *file, void *priv,
161                            struct v4l2_buffer *p)
162 {
163         struct soc_camera_file *icf = file->private_data;
164
165         WARN_ON(priv != file->private_data);
166
167         return videobuf_qbuf(&icf->vb_vidq, p);
168 }
169
170 static int soc_camera_dqbuf(struct file *file, void *priv,
171                             struct v4l2_buffer *p)
172 {
173         struct soc_camera_file *icf = file->private_data;
174
175         WARN_ON(priv != file->private_data);
176
177         return videobuf_dqbuf(&icf->vb_vidq, p, file->f_flags & O_NONBLOCK);
178 }
179
180 static int soc_camera_open(struct inode *inode, struct file *file)
181 {
182         struct video_device *vdev;
183         struct soc_camera_device *icd;
184         struct soc_camera_host *ici;
185         struct soc_camera_file *icf;
186         spinlock_t *lock;
187         int ret;
188
189         icf = vmalloc(sizeof(*icf));
190         if (!icf)
191                 return -ENOMEM;
192
193         /* Protect against icd->remove() until we module_get() both drivers. */
194         mutex_lock(&video_lock);
195
196         vdev = video_devdata(file);
197         icd = container_of(vdev->dev, struct soc_camera_device, dev);
198         ici = to_soc_camera_host(icd->dev.parent);
199
200         if (!try_module_get(icd->ops->owner)) {
201                 dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
202                 ret = -EINVAL;
203                 goto emgd;
204         }
205
206         if (!try_module_get(ici->ops->owner)) {
207                 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
208                 ret = -EINVAL;
209                 goto emgi;
210         }
211
212         icf->icd = icd;
213
214         icf->lock = ici->ops->spinlock_alloc(icf);
215         if (!icf->lock) {
216                 ret = -ENOMEM;
217                 goto esla;
218         }
219
220         icd->use_count++;
221
222         /* Now we really have to activate the camera */
223         if (icd->use_count == 1) {
224                 ret = ici->ops->add(icd);
225                 if (ret < 0) {
226                         dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
227                         icd->use_count--;
228                         goto eiciadd;
229                 }
230         }
231
232         mutex_unlock(&video_lock);
233
234         file->private_data = icf;
235         dev_dbg(&icd->dev, "camera device open\n");
236
237         ici->ops->init_videobuf(&icf->vb_vidq, icf->lock, icd);
238
239         return 0;
240
241         /* All errors are entered with the video_lock held */
242 eiciadd:
243         lock = icf->lock;
244         icf->lock = NULL;
245         if (ici->ops->spinlock_free)
246                 ici->ops->spinlock_free(lock);
247 esla:
248         module_put(ici->ops->owner);
249 emgi:
250         module_put(icd->ops->owner);
251 emgd:
252         mutex_unlock(&video_lock);
253         vfree(icf);
254         return ret;
255 }
256
257 static int soc_camera_close(struct inode *inode, struct file *file)
258 {
259         struct soc_camera_file *icf = file->private_data;
260         struct soc_camera_device *icd = icf->icd;
261         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
262         struct video_device *vdev = icd->vdev;
263         spinlock_t *lock = icf->lock;
264
265         mutex_lock(&video_lock);
266         icd->use_count--;
267         if (!icd->use_count)
268                 ici->ops->remove(icd);
269         icf->lock = NULL;
270         if (ici->ops->spinlock_free)
271                 ici->ops->spinlock_free(lock);
272         module_put(icd->ops->owner);
273         module_put(ici->ops->owner);
274         mutex_unlock(&video_lock);
275
276         vfree(icf);
277
278         dev_dbg(vdev->dev, "camera device close\n");
279
280         return 0;
281 }
282
283 static ssize_t soc_camera_read(struct file *file, char __user *buf,
284                            size_t count, loff_t *ppos)
285 {
286         struct soc_camera_file *icf = file->private_data;
287         struct soc_camera_device *icd = icf->icd;
288         struct video_device *vdev = icd->vdev;
289         int err = -EINVAL;
290
291         dev_err(vdev->dev, "camera device read not implemented\n");
292
293         return err;
294 }
295
296 static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
297 {
298         struct soc_camera_file *icf = file->private_data;
299         struct soc_camera_device *icd = icf->icd;
300         int err;
301
302         dev_dbg(&icd->dev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
303
304         err = videobuf_mmap_mapper(&icf->vb_vidq, vma);
305
306         dev_dbg(&icd->dev, "vma start=0x%08lx, size=%ld, ret=%d\n",
307                 (unsigned long)vma->vm_start,
308                 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
309                 err);
310
311         return err;
312 }
313
314 static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
315 {
316         struct soc_camera_file *icf = file->private_data;
317         struct soc_camera_device *icd = icf->icd;
318         struct soc_camera_host *ici =
319                 to_soc_camera_host(icd->dev.parent);
320
321         if (list_empty(&icf->vb_vidq.stream)) {
322                 dev_err(&icd->dev, "Trying to poll with no queued buffers!\n");
323                 return POLLERR;
324         }
325
326         return ici->ops->poll(file, pt);
327 }
328
329
330 static struct file_operations soc_camera_fops = {
331         .owner          = THIS_MODULE,
332         .open           = soc_camera_open,
333         .release        = soc_camera_close,
334         .ioctl          = video_ioctl2,
335         .read           = soc_camera_read,
336         .mmap           = soc_camera_mmap,
337         .poll           = soc_camera_poll,
338         .llseek         = no_llseek,
339 };
340
341
342 static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
343                                 struct v4l2_format *f)
344 {
345         struct soc_camera_file *icf = file->private_data;
346         struct soc_camera_device *icd = icf->icd;
347         struct soc_camera_host *ici =
348                 to_soc_camera_host(icd->dev.parent);
349         int ret;
350         struct v4l2_rect rect;
351         const static struct soc_camera_data_format *data_fmt;
352
353         WARN_ON(priv != file->private_data);
354
355         data_fmt = format_by_fourcc(icd, f->fmt.pix.pixelformat);
356         if (!data_fmt)
357                 return -EINVAL;
358
359         /* buswidth may be further adjusted by the ici */
360         icd->buswidth = data_fmt->depth;
361
362         ret = soc_camera_try_fmt_vid_cap(file, icf, f);
363         if (ret < 0)
364                 return ret;
365
366         rect.left       = icd->x_current;
367         rect.top        = icd->y_current;
368         rect.width      = f->fmt.pix.width;
369         rect.height     = f->fmt.pix.height;
370         ret = ici->ops->set_fmt_cap(icd, f->fmt.pix.pixelformat, &rect);
371         if (ret < 0)
372                 return ret;
373
374         icd->current_fmt        = data_fmt;
375         icd->width              = rect.width;
376         icd->height             = rect.height;
377         icf->vb_vidq.field      = f->fmt.pix.field;
378         if (V4L2_BUF_TYPE_VIDEO_CAPTURE != f->type)
379                 dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
380                          f->type);
381
382         dev_dbg(&icd->dev, "set width: %d height: %d\n",
383                 icd->width, icd->height);
384
385         /* set physical bus parameters */
386         return ici->ops->set_bus_param(icd, f->fmt.pix.pixelformat);
387 }
388
389 static int soc_camera_enum_fmt_vid_cap(struct file *file, void  *priv,
390                                    struct v4l2_fmtdesc *f)
391 {
392         struct soc_camera_file *icf = file->private_data;
393         struct soc_camera_device *icd = icf->icd;
394         const struct soc_camera_data_format *format;
395
396         WARN_ON(priv != file->private_data);
397
398         if (f->index >= icd->num_formats)
399                 return -EINVAL;
400
401         format = &icd->formats[f->index];
402
403         strlcpy(f->description, format->name, sizeof(f->description));
404         f->pixelformat = format->fourcc;
405         return 0;
406 }
407
408 static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
409                                 struct v4l2_format *f)
410 {
411         struct soc_camera_file *icf = file->private_data;
412         struct soc_camera_device *icd = icf->icd;
413
414         WARN_ON(priv != file->private_data);
415
416         f->fmt.pix.width        = icd->width;
417         f->fmt.pix.height       = icd->height;
418         f->fmt.pix.field        = icf->vb_vidq.field;
419         f->fmt.pix.pixelformat  = icd->current_fmt->fourcc;
420         f->fmt.pix.bytesperline =
421                 (f->fmt.pix.width * icd->current_fmt->depth) >> 3;
422         f->fmt.pix.sizeimage    =
423                 f->fmt.pix.height * f->fmt.pix.bytesperline;
424         dev_dbg(&icd->dev, "current_fmt->fourcc: 0x%08x\n",
425                 icd->current_fmt->fourcc);
426         return 0;
427 }
428
429 static int soc_camera_querycap(struct file *file, void  *priv,
430                                struct v4l2_capability *cap)
431 {
432         struct soc_camera_file *icf = file->private_data;
433         struct soc_camera_device *icd = icf->icd;
434         struct soc_camera_host *ici =
435                 to_soc_camera_host(icd->dev.parent);
436
437         WARN_ON(priv != file->private_data);
438
439         strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
440         return ici->ops->querycap(ici, cap);
441 }
442
443 static int soc_camera_streamon(struct file *file, void *priv,
444                                enum v4l2_buf_type i)
445 {
446         struct soc_camera_file *icf = file->private_data;
447         struct soc_camera_device *icd = icf->icd;
448
449         WARN_ON(priv != file->private_data);
450
451         dev_dbg(&icd->dev, "%s\n", __func__);
452
453         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
454                 return -EINVAL;
455
456         icd->ops->start_capture(icd);
457
458         /* This calls buf_queue from host driver's videobuf_queue_ops */
459         return videobuf_streamon(&icf->vb_vidq);
460 }
461
462 static int soc_camera_streamoff(struct file *file, void *priv,
463                                 enum v4l2_buf_type i)
464 {
465         struct soc_camera_file *icf = file->private_data;
466         struct soc_camera_device *icd = icf->icd;
467
468         WARN_ON(priv != file->private_data);
469
470         dev_dbg(&icd->dev, "%s\n", __func__);
471
472         if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
473                 return -EINVAL;
474
475         /* This calls buf_release from host driver's videobuf_queue_ops for all
476          * remaining buffers. When the last buffer is freed, stop capture */
477         videobuf_streamoff(&icf->vb_vidq);
478
479         icd->ops->stop_capture(icd);
480
481         return 0;
482 }
483
484 static int soc_camera_queryctrl(struct file *file, void *priv,
485                                 struct v4l2_queryctrl *qc)
486 {
487         struct soc_camera_file *icf = file->private_data;
488         struct soc_camera_device *icd = icf->icd;
489         int i;
490
491         WARN_ON(priv != file->private_data);
492
493         if (!qc->id)
494                 return -EINVAL;
495
496         for (i = 0; i < icd->ops->num_controls; i++)
497                 if (qc->id == icd->ops->controls[i].id) {
498                         memcpy(qc, &(icd->ops->controls[i]),
499                                 sizeof(*qc));
500                         return 0;
501                 }
502
503         return -EINVAL;
504 }
505
506 static int soc_camera_g_ctrl(struct file *file, void *priv,
507                              struct v4l2_control *ctrl)
508 {
509         struct soc_camera_file *icf = file->private_data;
510         struct soc_camera_device *icd = icf->icd;
511
512         WARN_ON(priv != file->private_data);
513
514         switch (ctrl->id) {
515         case V4L2_CID_GAIN:
516                 if (icd->gain == (unsigned short)~0)
517                         return -EINVAL;
518                 ctrl->value = icd->gain;
519                 return 0;
520         case V4L2_CID_EXPOSURE:
521                 if (icd->exposure == (unsigned short)~0)
522                         return -EINVAL;
523                 ctrl->value = icd->exposure;
524                 return 0;
525         }
526
527         if (icd->ops->get_control)
528                 return icd->ops->get_control(icd, ctrl);
529         return -EINVAL;
530 }
531
532 static int soc_camera_s_ctrl(struct file *file, void *priv,
533                              struct v4l2_control *ctrl)
534 {
535         struct soc_camera_file *icf = file->private_data;
536         struct soc_camera_device *icd = icf->icd;
537
538         WARN_ON(priv != file->private_data);
539
540         if (icd->ops->set_control)
541                 return icd->ops->set_control(icd, ctrl);
542         return -EINVAL;
543 }
544
545 static int soc_camera_cropcap(struct file *file, void *fh,
546                               struct v4l2_cropcap *a)
547 {
548         struct soc_camera_file *icf = file->private_data;
549         struct soc_camera_device *icd = icf->icd;
550
551         a->type                         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
552         a->bounds.left                  = icd->x_min;
553         a->bounds.top                   = icd->y_min;
554         a->bounds.width                 = icd->width_max;
555         a->bounds.height                = icd->height_max;
556         a->defrect.left                 = icd->x_min;
557         a->defrect.top                  = icd->y_min;
558         a->defrect.width                = 640;
559         a->defrect.height               = 480;
560         a->pixelaspect.numerator        = 1;
561         a->pixelaspect.denominator      = 1;
562
563         return 0;
564 }
565
566 static int soc_camera_g_crop(struct file *file, void *fh,
567                              struct v4l2_crop *a)
568 {
569         struct soc_camera_file *icf = file->private_data;
570         struct soc_camera_device *icd = icf->icd;
571
572         a->type         = V4L2_BUF_TYPE_VIDEO_CAPTURE;
573         a->c.left       = icd->x_current;
574         a->c.top        = icd->y_current;
575         a->c.width      = icd->width;
576         a->c.height     = icd->height;
577
578         return 0;
579 }
580
581 static int soc_camera_s_crop(struct file *file, void *fh,
582                              struct v4l2_crop *a)
583 {
584         struct soc_camera_file *icf = file->private_data;
585         struct soc_camera_device *icd = icf->icd;
586         struct soc_camera_host *ici =
587                 to_soc_camera_host(icd->dev.parent);
588         int ret;
589
590         if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
591                 return -EINVAL;
592
593         ret = ici->ops->set_fmt_cap(icd, 0, &a->c);
594         if (!ret) {
595                 icd->width      = a->c.width;
596                 icd->height     = a->c.height;
597                 icd->x_current  = a->c.left;
598                 icd->y_current  = a->c.top;
599         }
600
601         return ret;
602 }
603
604 static int soc_camera_g_chip_ident(struct file *file, void *fh,
605                                    struct v4l2_chip_ident *id)
606 {
607         struct soc_camera_file *icf = file->private_data;
608         struct soc_camera_device *icd = icf->icd;
609
610         if (!icd->ops->get_chip_id)
611                 return -EINVAL;
612
613         return icd->ops->get_chip_id(icd, id);
614 }
615
616 #ifdef CONFIG_VIDEO_ADV_DEBUG
617 static int soc_camera_g_register(struct file *file, void *fh,
618                                  struct v4l2_register *reg)
619 {
620         struct soc_camera_file *icf = file->private_data;
621         struct soc_camera_device *icd = icf->icd;
622
623         if (!icd->ops->get_register)
624                 return -EINVAL;
625
626         return icd->ops->get_register(icd, reg);
627 }
628
629 static int soc_camera_s_register(struct file *file, void *fh,
630                                  struct v4l2_register *reg)
631 {
632         struct soc_camera_file *icf = file->private_data;
633         struct soc_camera_device *icd = icf->icd;
634
635         if (!icd->ops->set_register)
636                 return -EINVAL;
637
638         return icd->ops->set_register(icd, reg);
639 }
640 #endif
641
642 static int device_register_link(struct soc_camera_device *icd)
643 {
644         int ret = device_register(&icd->dev);
645
646         if (ret < 0) {
647                 /* Prevent calling device_unregister() */
648                 icd->dev.parent = NULL;
649                 dev_err(&icd->dev, "Cannot register device: %d\n", ret);
650         /* Even if probe() was unsuccessful for all registered drivers,
651          * device_register() returns 0, and we add the link, just to
652          * document this camera's control device */
653         } else if (icd->control)
654                 /* Have to sysfs_remove_link() before device_unregister()? */
655                 if (sysfs_create_link(&icd->dev.kobj, &icd->control->kobj,
656                                       "control"))
657                         dev_warn(&icd->dev,
658                                  "Failed creating the control symlink\n");
659         return ret;
660 }
661
662 /* So far this function cannot fail */
663 static void scan_add_host(struct soc_camera_host *ici)
664 {
665         struct soc_camera_device *icd;
666
667         mutex_lock(&list_lock);
668
669         list_for_each_entry(icd, &devices, list) {
670                 if (icd->iface == ici->nr) {
671                         icd->dev.parent = &ici->dev;
672                         device_register_link(icd);
673                 }
674         }
675
676         mutex_unlock(&list_lock);
677 }
678
679 /* return: 0 if no match found or a match found and
680  * device_register() successful, error code otherwise */
681 static int scan_add_device(struct soc_camera_device *icd)
682 {
683         struct soc_camera_host *ici;
684         int ret = 0;
685
686         mutex_lock(&list_lock);
687
688         list_add_tail(&icd->list, &devices);
689
690         /* Watch out for class_for_each_device / class_find_device API by
691          * Dave Young <hidave.darkstar@gmail.com> */
692         list_for_each_entry(ici, &hosts, list) {
693                 if (icd->iface == ici->nr) {
694                         ret = 1;
695                         icd->dev.parent = &ici->dev;
696                         break;
697                 }
698         }
699
700         mutex_unlock(&list_lock);
701
702         if (ret)
703                 ret = device_register_link(icd);
704
705         return ret;
706 }
707
708 static int soc_camera_probe(struct device *dev)
709 {
710         struct soc_camera_device *icd = to_soc_camera_dev(dev);
711         struct soc_camera_host *ici =
712                 to_soc_camera_host(icd->dev.parent);
713         int ret;
714
715         if (!icd->ops->probe)
716                 return -ENODEV;
717
718         /* We only call ->add() here to activate and probe the camera.
719          * We shall ->remove() and deactivate it immediately afterwards. */
720         ret = ici->ops->add(icd);
721         if (ret < 0)
722                 return ret;
723
724         ret = icd->ops->probe(icd);
725         if (ret >= 0) {
726                 const struct v4l2_queryctrl *qctrl;
727
728                 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
729                 icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
730                 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
731                 icd->exposure = qctrl ? qctrl->default_value :
732                         (unsigned short)~0;
733         }
734         ici->ops->remove(icd);
735
736         return ret;
737 }
738
739 /* This is called on device_unregister, which only means we have to disconnect
740  * from the host, but not remove ourselves from the device list */
741 static int soc_camera_remove(struct device *dev)
742 {
743         struct soc_camera_device *icd = to_soc_camera_dev(dev);
744
745         if (icd->ops->remove)
746                 icd->ops->remove(icd);
747
748         return 0;
749 }
750
751 static struct bus_type soc_camera_bus_type = {
752         .name           = "soc-camera",
753         .probe          = soc_camera_probe,
754         .remove         = soc_camera_remove,
755 };
756
757 static struct device_driver ic_drv = {
758         .name   = "camera",
759         .bus    = &soc_camera_bus_type,
760         .owner  = THIS_MODULE,
761 };
762
763 static void dummy_release(struct device *dev)
764 {
765 }
766
767 static spinlock_t *spinlock_alloc(struct soc_camera_file *icf)
768 {
769         spinlock_t *lock = kmalloc(sizeof(spinlock_t), GFP_KERNEL);
770
771         if (lock)
772                 spin_lock_init(lock);
773
774         return lock;
775 }
776
777 static void spinlock_free(spinlock_t *lock)
778 {
779         kfree(lock);
780 }
781
782 int soc_camera_host_register(struct soc_camera_host *ici)
783 {
784         int ret;
785         struct soc_camera_host *ix;
786
787         if (!ici->ops->init_videobuf || !ici->ops->add || !ici->ops->remove)
788                 return -EINVAL;
789
790         /* Number might be equal to the platform device ID */
791         sprintf(ici->dev.bus_id, "camera_host%d", ici->nr);
792
793         mutex_lock(&list_lock);
794         list_for_each_entry(ix, &hosts, list) {
795                 if (ix->nr == ici->nr) {
796                         mutex_unlock(&list_lock);
797                         return -EBUSY;
798                 }
799         }
800
801         list_add_tail(&ici->list, &hosts);
802         mutex_unlock(&list_lock);
803
804         ici->dev.release = dummy_release;
805
806         ret = device_register(&ici->dev);
807
808         if (ret)
809                 goto edevr;
810
811         if (!ici->ops->spinlock_alloc) {
812                 ici->ops->spinlock_alloc = spinlock_alloc;
813                 ici->ops->spinlock_free = spinlock_free;
814         }
815
816         scan_add_host(ici);
817
818         return 0;
819
820 edevr:
821         mutex_lock(&list_lock);
822         list_del(&ici->list);
823         mutex_unlock(&list_lock);
824
825         return ret;
826 }
827 EXPORT_SYMBOL(soc_camera_host_register);
828
829 /* Unregister all clients! */
830 void soc_camera_host_unregister(struct soc_camera_host *ici)
831 {
832         struct soc_camera_device *icd;
833
834         mutex_lock(&list_lock);
835
836         list_del(&ici->list);
837
838         list_for_each_entry(icd, &devices, list) {
839                 if (icd->dev.parent == &ici->dev) {
840                         device_unregister(&icd->dev);
841                         /* Not before device_unregister(), .remove
842                          * needs parent to call ici->ops->remove() */
843                         icd->dev.parent = NULL;
844                         memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
845                 }
846         }
847
848         mutex_unlock(&list_lock);
849
850         device_unregister(&ici->dev);
851 }
852 EXPORT_SYMBOL(soc_camera_host_unregister);
853
854 /* Image capture device */
855 int soc_camera_device_register(struct soc_camera_device *icd)
856 {
857         struct soc_camera_device *ix;
858         int num = -1, i;
859
860         if (!icd)
861                 return -EINVAL;
862
863         for (i = 0; i < 256 && num < 0; i++) {
864                 num = i;
865                 list_for_each_entry(ix, &devices, list) {
866                         if (ix->iface == icd->iface && ix->devnum == i) {
867                                 num = -1;
868                                 break;
869                         }
870                 }
871         }
872
873         if (num < 0)
874                 /* ok, we have 256 cameras on this host...
875                  * man, stay reasonable... */
876                 return -ENOMEM;
877
878         icd->devnum = num;
879         icd->dev.bus = &soc_camera_bus_type;
880         snprintf(icd->dev.bus_id, sizeof(icd->dev.bus_id),
881                  "%u-%u", icd->iface, icd->devnum);
882
883         icd->dev.release = dummy_release;
884
885         return scan_add_device(icd);
886 }
887 EXPORT_SYMBOL(soc_camera_device_register);
888
889 void soc_camera_device_unregister(struct soc_camera_device *icd)
890 {
891         mutex_lock(&list_lock);
892         list_del(&icd->list);
893
894         /* The bus->remove will be eventually called */
895         if (icd->dev.parent)
896                 device_unregister(&icd->dev);
897         mutex_unlock(&list_lock);
898 }
899 EXPORT_SYMBOL(soc_camera_device_unregister);
900
901 int soc_camera_video_start(struct soc_camera_device *icd)
902 {
903         struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
904         int err = -ENOMEM;
905         struct video_device *vdev;
906
907         if (!icd->dev.parent)
908                 return -ENODEV;
909
910         vdev = video_device_alloc();
911         if (!vdev)
912                 goto evidallocd;
913         dev_dbg(&ici->dev, "Allocated video_device %p\n", vdev);
914
915         strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
916         /* Maybe better &ici->dev */
917         vdev->dev               = &icd->dev;
918         vdev->type              = VID_TYPE_CAPTURE;
919         vdev->current_norm      = V4L2_STD_UNKNOWN;
920         vdev->fops              = &soc_camera_fops;
921         vdev->release           = video_device_release;
922         vdev->minor             = -1;
923         vdev->tvnorms           = V4L2_STD_UNKNOWN,
924         vdev->vidioc_querycap   = soc_camera_querycap;
925         vdev->vidioc_g_fmt_vid_cap = soc_camera_g_fmt_vid_cap;
926         vdev->vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap;
927         vdev->vidioc_s_fmt_vid_cap = soc_camera_s_fmt_vid_cap;
928         vdev->vidioc_enum_input = soc_camera_enum_input;
929         vdev->vidioc_g_input    = soc_camera_g_input;
930         vdev->vidioc_s_input    = soc_camera_s_input;
931         vdev->vidioc_s_std      = soc_camera_s_std;
932         vdev->vidioc_reqbufs    = soc_camera_reqbufs;
933         vdev->vidioc_try_fmt_vid_cap = soc_camera_try_fmt_vid_cap;
934         vdev->vidioc_querybuf   = soc_camera_querybuf;
935         vdev->vidioc_qbuf       = soc_camera_qbuf;
936         vdev->vidioc_dqbuf      = soc_camera_dqbuf;
937         vdev->vidioc_streamon   = soc_camera_streamon;
938         vdev->vidioc_streamoff  = soc_camera_streamoff;
939         vdev->vidioc_queryctrl  = soc_camera_queryctrl;
940         vdev->vidioc_g_ctrl     = soc_camera_g_ctrl;
941         vdev->vidioc_s_ctrl     = soc_camera_s_ctrl;
942         vdev->vidioc_cropcap    = soc_camera_cropcap;
943         vdev->vidioc_g_crop     = soc_camera_g_crop;
944         vdev->vidioc_s_crop     = soc_camera_s_crop;
945         vdev->vidioc_g_chip_ident = soc_camera_g_chip_ident;
946 #ifdef CONFIG_VIDEO_ADV_DEBUG
947         vdev->vidioc_g_register = soc_camera_g_register;
948         vdev->vidioc_s_register = soc_camera_s_register;
949 #endif
950
951         icd->current_fmt = &icd->formats[0];
952
953         err = video_register_device(vdev, VFL_TYPE_GRABBER, vdev->minor);
954         if (err < 0) {
955                 dev_err(vdev->dev, "video_register_device failed\n");
956                 goto evidregd;
957         }
958         icd->vdev = vdev;
959
960         return 0;
961
962 evidregd:
963         video_device_release(vdev);
964 evidallocd:
965         return err;
966 }
967 EXPORT_SYMBOL(soc_camera_video_start);
968
969 void soc_camera_video_stop(struct soc_camera_device *icd)
970 {
971         struct video_device *vdev = icd->vdev;
972
973         dev_dbg(&icd->dev, "%s\n", __func__);
974
975         if (!icd->dev.parent || !vdev)
976                 return;
977
978         mutex_lock(&video_lock);
979         video_unregister_device(vdev);
980         icd->vdev = NULL;
981         mutex_unlock(&video_lock);
982 }
983 EXPORT_SYMBOL(soc_camera_video_stop);
984
985 static int __init soc_camera_init(void)
986 {
987         int ret = bus_register(&soc_camera_bus_type);
988         if (ret)
989                 return ret;
990         ret = driver_register(&ic_drv);
991         if (ret)
992                 goto edrvr;
993
994         return 0;
995
996 edrvr:
997         bus_unregister(&soc_camera_bus_type);
998         return ret;
999 }
1000
1001 static void __exit soc_camera_exit(void)
1002 {
1003         driver_unregister(&ic_drv);
1004         bus_unregister(&soc_camera_bus_type);
1005 }
1006
1007 module_init(soc_camera_init);
1008 module_exit(soc_camera_exit);
1009
1010 MODULE_DESCRIPTION("Image capture bus driver");
1011 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
1012 MODULE_LICENSE("GPL");