blob: 6d8bfd4d97e20ba49303b26b133665045f5a61a9 [file] [log] [blame]
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001/*
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>
Hans Verkuil35ea11f2008-07-20 08:12:02 -030028#include <media/v4l2-ioctl.h>
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -030029#include <media/v4l2-dev.h>
Paulius Zaleckas092d3922008-07-11 20:50:31 -030030#include <media/videobuf-core.h>
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -030031#include <media/soc_camera.h>
32
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -030033/* Default to VGA resolution */
34#define DEFAULT_WIDTH 640
35#define DEFAULT_HEIGHT 480
36
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -030037static LIST_HEAD(hosts);
38static LIST_HEAD(devices);
39static DEFINE_MUTEX(list_lock);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -030040
Guennadi Liakhovetski25c4d742008-12-01 09:44:59 -030041const struct soc_camera_data_format *soc_camera_format_by_fourcc(
Guennadi Liakhovetskiabe4c472008-12-01 09:44:56 -030042 struct soc_camera_device *icd, unsigned int fourcc)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -030043{
44 unsigned int i;
45
Guennadi Liakhovetski26f1b942008-03-24 12:18:36 -030046 for (i = 0; i < icd->num_formats; i++)
47 if (icd->formats[i].fourcc == fourcc)
48 return icd->formats + i;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -030049 return NULL;
50}
Guennadi Liakhovetski25c4d742008-12-01 09:44:59 -030051EXPORT_SYMBOL(soc_camera_format_by_fourcc);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -030052
Guennadi Liakhovetskic2786ad2008-12-01 09:45:27 -030053const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
54 struct soc_camera_device *icd, unsigned int fourcc)
55{
56 unsigned int i;
57
58 for (i = 0; i < icd->num_user_formats; i++)
59 if (icd->user_formats[i].host_fmt->fourcc == fourcc)
60 return icd->user_formats + i;
61 return NULL;
62}
63EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
64
Guennadi Liakhovetskibd73b362008-12-23 05:54:45 -030065/**
66 * soc_camera_apply_sensor_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
67 * @icl: camera platform parameters
68 * @flags: flags to be inverted according to platform configuration
69 * @return: resulting flags
70 */
71unsigned long soc_camera_apply_sensor_flags(struct soc_camera_link *icl,
72 unsigned long flags)
73{
74 unsigned long f;
75
76 /* If only one of the two polarities is supported, switch to the opposite */
77 if (icl->flags & SOCAM_SENSOR_INVERT_HSYNC) {
78 f = flags & (SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW);
79 if (f == SOCAM_HSYNC_ACTIVE_HIGH || f == SOCAM_HSYNC_ACTIVE_LOW)
80 flags ^= SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW;
81 }
82
83 if (icl->flags & SOCAM_SENSOR_INVERT_VSYNC) {
84 f = flags & (SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW);
85 if (f == SOCAM_VSYNC_ACTIVE_HIGH || f == SOCAM_VSYNC_ACTIVE_LOW)
86 flags ^= SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW;
87 }
88
89 if (icl->flags & SOCAM_SENSOR_INVERT_PCLK) {
90 f = flags & (SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING);
91 if (f == SOCAM_PCLK_SAMPLE_RISING || f == SOCAM_PCLK_SAMPLE_FALLING)
92 flags ^= SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING;
93 }
94
95 return flags;
96}
97EXPORT_SYMBOL(soc_camera_apply_sensor_flags);
98
Hans Verkuil72937892008-06-01 10:35:18 -030099static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
Guennadi Liakhovetskiabe4c472008-12-01 09:44:56 -0300100 struct v4l2_format *f)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300101{
102 struct soc_camera_file *icf = file->private_data;
103 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300104 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300105
106 WARN_ON(priv != file->private_data);
107
Guennadi Liakhovetskiad5f2e82008-03-07 21:57:18 -0300108 /* limit format to hardware capabilities */
Guennadi Liakhovetski06daa1a2008-12-18 12:52:08 -0300109 return ici->ops->try_fmt(icd, f);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300110}
111
112static int soc_camera_enum_input(struct file *file, void *priv,
113 struct v4l2_input *inp)
114{
Kuninori Morimoto34d359d2008-12-18 12:47:46 -0300115 struct soc_camera_file *icf = file->private_data;
116 struct soc_camera_device *icd = icf->icd;
117 int ret = 0;
118
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300119 if (inp->index != 0)
120 return -EINVAL;
121
Kuninori Morimoto34d359d2008-12-18 12:47:46 -0300122 if (icd->ops->enum_input)
123 ret = icd->ops->enum_input(icd, inp);
124 else {
125 /* default is camera */
126 inp->type = V4L2_INPUT_TYPE_CAMERA;
127 inp->std = V4L2_STD_UNKNOWN;
128 strcpy(inp->name, "Camera");
129 }
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300130
Kuninori Morimoto34d359d2008-12-18 12:47:46 -0300131 return ret;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300132}
133
134static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
135{
136 *i = 0;
137
138 return 0;
139}
140
141static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
142{
143 if (i > 0)
144 return -EINVAL;
145
146 return 0;
147}
148
149static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id *a)
150{
Kuninori Morimoto513791a2008-12-18 12:46:45 -0300151 struct soc_camera_file *icf = file->private_data;
152 struct soc_camera_device *icd = icf->icd;
153 int ret = 0;
154
155 if (icd->ops->set_std)
156 ret = icd->ops->set_std(icd, a);
157
158 return ret;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300159}
160
161static int soc_camera_reqbufs(struct file *file, void *priv,
162 struct v4l2_requestbuffers *p)
163{
164 int ret;
165 struct soc_camera_file *icf = file->private_data;
166 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300167 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300168
169 WARN_ON(priv != file->private_data);
170
Harvey Harrison7e28adb2008-04-08 23:20:00 -0300171 dev_dbg(&icd->dev, "%s: %d\n", __func__, p->memory);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300172
173 ret = videobuf_reqbufs(&icf->vb_vidq, p);
174 if (ret < 0)
175 return ret;
176
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300177 return ici->ops->reqbufs(icf, p);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300178}
179
180static int soc_camera_querybuf(struct file *file, void *priv,
181 struct v4l2_buffer *p)
182{
183 struct soc_camera_file *icf = file->private_data;
184
185 WARN_ON(priv != file->private_data);
186
187 return videobuf_querybuf(&icf->vb_vidq, p);
188}
189
190static int soc_camera_qbuf(struct file *file, void *priv,
191 struct v4l2_buffer *p)
192{
193 struct soc_camera_file *icf = file->private_data;
194
195 WARN_ON(priv != file->private_data);
196
197 return videobuf_qbuf(&icf->vb_vidq, p);
198}
199
200static int soc_camera_dqbuf(struct file *file, void *priv,
201 struct v4l2_buffer *p)
202{
203 struct soc_camera_file *icf = file->private_data;
204
205 WARN_ON(priv != file->private_data);
206
207 return videobuf_dqbuf(&icf->vb_vidq, p, file->f_flags & O_NONBLOCK);
208}
209
Guennadi Liakhovetskic2786ad2008-12-01 09:45:27 -0300210static int soc_camera_init_user_formats(struct soc_camera_device *icd)
211{
212 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
213 int i, fmts = 0;
214
215 if (!ici->ops->get_formats)
216 /*
217 * Fallback mode - the host will have to serve all
218 * sensor-provided formats one-to-one to the user
219 */
220 fmts = icd->num_formats;
221 else
222 /*
223 * First pass - only count formats this host-sensor
224 * configuration can provide
225 */
226 for (i = 0; i < icd->num_formats; i++)
227 fmts += ici->ops->get_formats(icd, i, NULL);
228
229 if (!fmts)
230 return -ENXIO;
231
232 icd->user_formats =
233 vmalloc(fmts * sizeof(struct soc_camera_format_xlate));
234 if (!icd->user_formats)
235 return -ENOMEM;
236
237 icd->num_user_formats = fmts;
238 fmts = 0;
239
240 dev_dbg(&icd->dev, "Found %d supported formats.\n", fmts);
241
242 /* Second pass - actually fill data formats */
243 for (i = 0; i < icd->num_formats; i++)
244 if (!ici->ops->get_formats) {
245 icd->user_formats[i].host_fmt = icd->formats + i;
246 icd->user_formats[i].cam_fmt = icd->formats + i;
247 icd->user_formats[i].buswidth = icd->formats[i].depth;
248 } else {
249 fmts += ici->ops->get_formats(icd, i,
250 &icd->user_formats[fmts]);
251 }
252
253 icd->current_fmt = icd->user_formats[0].host_fmt;
254
255 return 0;
256}
257
258static void soc_camera_free_user_formats(struct soc_camera_device *icd)
259{
260 vfree(icd->user_formats);
261}
262
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300263/* Called with .vb_lock held */
264static int soc_camera_set_fmt(struct soc_camera_file *icf,
265 struct v4l2_format *f)
266{
267 struct soc_camera_device *icd = icf->icd;
268 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
269 struct v4l2_pix_format *pix = &f->fmt.pix;
270 int ret;
271
272 /* We always call try_fmt() before set_fmt() or set_crop() */
273 ret = ici->ops->try_fmt(icd, f);
274 if (ret < 0)
275 return ret;
276
277 ret = ici->ops->set_fmt(icd, f);
278 if (ret < 0) {
279 return ret;
280 } else if (!icd->current_fmt ||
281 icd->current_fmt->fourcc != pix->pixelformat) {
282 dev_err(&ici->dev,
283 "Host driver hasn't set up current format correctly!\n");
284 return -EINVAL;
285 }
286
287 icd->width = pix->width;
288 icd->height = pix->height;
Guennadi Liakhovetski025c18a2009-03-13 06:08:20 -0300289 icf->vb_vidq.field =
290 icd->field = pix->field;
291
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300292 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
293 dev_warn(&icd->dev, "Attention! Wrong buf-type %d\n",
294 f->type);
295
296 dev_dbg(&icd->dev, "set width: %d height: %d\n",
297 icd->width, icd->height);
298
299 /* set physical bus parameters */
300 return ici->ops->set_bus_param(icd, pix->pixelformat);
301}
302
Hans Verkuilbec43662008-12-30 06:58:20 -0300303static int soc_camera_open(struct file *file)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300304{
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300305 struct video_device *vdev;
306 struct soc_camera_device *icd;
307 struct soc_camera_host *ici;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300308 struct soc_camera_file *icf;
309 int ret;
310
311 icf = vmalloc(sizeof(*icf));
312 if (!icf)
313 return -ENOMEM;
314
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300315 /*
316 * It is safe to dereference these pointers now as long as a user has
317 * the video device open - we are protected by the held cdev reference.
318 */
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300319
320 vdev = video_devdata(file);
Hans Verkuil5e85e732008-07-20 06:31:39 -0300321 icd = container_of(vdev->parent, struct soc_camera_device, dev);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300322 ici = to_soc_camera_host(icd->dev.parent);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300323
324 if (!try_module_get(icd->ops->owner)) {
325 dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
326 ret = -EINVAL;
327 goto emgd;
328 }
329
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300330 if (!try_module_get(ici->ops->owner)) {
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300331 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
332 ret = -EINVAL;
333 goto emgi;
334 }
335
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300336 /* Protect against icd->remove() until we module_get() both drivers. */
337 mutex_lock(&icd->video_lock);
338
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300339 icf->icd = icd;
Guennadi Liakhovetski1a0063a2008-04-04 13:46:34 -0300340 icd->use_count++;
341
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300342 /* Now we really have to activate the camera */
343 if (icd->use_count == 1) {
Guennadi Liakhovetski025c18a2009-03-13 06:08:20 -0300344 /* Restore parameters before the last close() per V4L2 API */
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300345 struct v4l2_format f = {
346 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
347 .fmt.pix = {
Guennadi Liakhovetski025c18a2009-03-13 06:08:20 -0300348 .width = icd->width,
349 .height = icd->height,
350 .field = icd->field,
351 .pixelformat = icd->current_fmt->fourcc,
352 .colorspace = icd->current_fmt->colorspace,
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300353 },
354 };
355
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300356 ret = ici->ops->add(icd);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300357 if (ret < 0) {
358 dev_err(&icd->dev, "Couldn't activate the camera: %d\n", ret);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300359 goto eiciadd;
360 }
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300361
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300362 /* Try to configure with default parameters */
363 ret = soc_camera_set_fmt(icf, &f);
364 if (ret < 0)
365 goto esfmt;
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300366 }
367
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300368 mutex_unlock(&icd->video_lock);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300369
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300370 file->private_data = icf;
371 dev_dbg(&icd->dev, "camera device open\n");
372
Magnus Damma034d1b2008-07-11 20:59:34 -0300373 ici->ops->init_videobuf(&icf->vb_vidq, icd);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300374
375 return 0;
376
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300377 /*
378 * First three errors are entered with the .video_lock held
379 * and use_count == 1
380 */
381esfmt:
382 ici->ops->remove(icd);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300383eiciadd:
Guennadi Liakhovetskic2786ad2008-12-01 09:45:27 -0300384 icd->use_count--;
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300385 mutex_unlock(&icd->video_lock);
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300386 module_put(ici->ops->owner);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300387emgi:
388 module_put(icd->ops->owner);
389emgd:
390 vfree(icf);
391 return ret;
392}
393
Hans Verkuilbec43662008-12-30 06:58:20 -0300394static int soc_camera_close(struct file *file)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300395{
396 struct soc_camera_file *icf = file->private_data;
397 struct soc_camera_device *icd = icf->icd;
398 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
399 struct video_device *vdev = icd->vdev;
400
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300401 mutex_lock(&icd->video_lock);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300402 icd->use_count--;
Guennadi Liakhovetski025c18a2009-03-13 06:08:20 -0300403 if (!icd->use_count)
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300404 ici->ops->remove(icd);
Guennadi Liakhovetski025c18a2009-03-13 06:08:20 -0300405
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300406 mutex_unlock(&icd->video_lock);
407
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300408 module_put(icd->ops->owner);
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300409 module_put(ici->ops->owner);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300410
Guennadi Liakhovetski1a0063a2008-04-04 13:46:34 -0300411 vfree(icf);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300412
Hans Verkuil5e85e732008-07-20 06:31:39 -0300413 dev_dbg(vdev->parent, "camera device close\n");
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300414
415 return 0;
416}
417
Andrew Mortonaba360d2008-04-22 14:45:59 -0300418static ssize_t soc_camera_read(struct file *file, char __user *buf,
Guennadi Liakhovetskiabe4c472008-12-01 09:44:56 -0300419 size_t count, loff_t *ppos)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300420{
421 struct soc_camera_file *icf = file->private_data;
422 struct soc_camera_device *icd = icf->icd;
423 struct video_device *vdev = icd->vdev;
424 int err = -EINVAL;
425
Hans Verkuil5e85e732008-07-20 06:31:39 -0300426 dev_err(vdev->parent, "camera device read not implemented\n");
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300427
428 return err;
429}
430
431static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
432{
433 struct soc_camera_file *icf = file->private_data;
434 struct soc_camera_device *icd = icf->icd;
435 int err;
436
437 dev_dbg(&icd->dev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
438
439 err = videobuf_mmap_mapper(&icf->vb_vidq, vma);
440
441 dev_dbg(&icd->dev, "vma start=0x%08lx, size=%ld, ret=%d\n",
442 (unsigned long)vma->vm_start,
443 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
444 err);
445
446 return err;
447}
448
449static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
450{
451 struct soc_camera_file *icf = file->private_data;
452 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300453 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300454
455 if (list_empty(&icf->vb_vidq.stream)) {
456 dev_err(&icd->dev, "Trying to poll with no queued buffers!\n");
457 return POLLERR;
458 }
459
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300460 return ici->ops->poll(file, pt);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300461}
462
Hans Verkuilbec43662008-12-30 06:58:20 -0300463static struct v4l2_file_operations soc_camera_fops = {
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300464 .owner = THIS_MODULE,
465 .open = soc_camera_open,
466 .release = soc_camera_close,
467 .ioctl = video_ioctl2,
468 .read = soc_camera_read,
469 .mmap = soc_camera_mmap,
470 .poll = soc_camera_poll,
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300471};
472
Hans Verkuil72937892008-06-01 10:35:18 -0300473static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
Guennadi Liakhovetskiabe4c472008-12-01 09:44:56 -0300474 struct v4l2_format *f)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300475{
476 struct soc_camera_file *icf = file->private_data;
477 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300478 int ret;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300479
480 WARN_ON(priv != file->private_data);
481
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300482 mutex_lock(&icf->vb_vidq.vb_lock);
483
484 if (videobuf_queue_is_busy(&icf->vb_vidq)) {
485 dev_err(&icd->dev, "S_FMT denied: queue busy\n");
486 ret = -EBUSY;
487 goto unlock;
488 }
489
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300490 ret = soc_camera_set_fmt(icf, f);
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300491
492unlock:
493 mutex_unlock(&icf->vb_vidq.vb_lock);
494
495 return ret;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300496}
497
Hans Verkuil72937892008-06-01 10:35:18 -0300498static int soc_camera_enum_fmt_vid_cap(struct file *file, void *priv,
Guennadi Liakhovetskiabe4c472008-12-01 09:44:56 -0300499 struct v4l2_fmtdesc *f)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300500{
501 struct soc_camera_file *icf = file->private_data;
502 struct soc_camera_device *icd = icf->icd;
503 const struct soc_camera_data_format *format;
504
505 WARN_ON(priv != file->private_data);
506
Guennadi Liakhovetskic2786ad2008-12-01 09:45:27 -0300507 if (f->index >= icd->num_user_formats)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300508 return -EINVAL;
509
Guennadi Liakhovetskic2786ad2008-12-01 09:45:27 -0300510 format = icd->user_formats[f->index].host_fmt;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300511
512 strlcpy(f->description, format->name, sizeof(f->description));
513 f->pixelformat = format->fourcc;
514 return 0;
515}
516
Hans Verkuil72937892008-06-01 10:35:18 -0300517static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
Guennadi Liakhovetskiabe4c472008-12-01 09:44:56 -0300518 struct v4l2_format *f)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300519{
520 struct soc_camera_file *icf = file->private_data;
521 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300522 struct v4l2_pix_format *pix = &f->fmt.pix;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300523
524 WARN_ON(priv != file->private_data);
525
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300526 pix->width = icd->width;
527 pix->height = icd->height;
528 pix->field = icf->vb_vidq.field;
529 pix->pixelformat = icd->current_fmt->fourcc;
530 pix->bytesperline = pix->width *
Guennadi Liakhovetski25c4d742008-12-01 09:44:59 -0300531 DIV_ROUND_UP(icd->current_fmt->depth, 8);
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300532 pix->sizeimage = pix->height * pix->bytesperline;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300533 dev_dbg(&icd->dev, "current_fmt->fourcc: 0x%08x\n",
534 icd->current_fmt->fourcc);
535 return 0;
536}
537
538static int soc_camera_querycap(struct file *file, void *priv,
539 struct v4l2_capability *cap)
540{
541 struct soc_camera_file *icf = file->private_data;
542 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300543 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300544
545 WARN_ON(priv != file->private_data);
546
547 strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300548 return ici->ops->querycap(ici, cap);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300549}
550
551static int soc_camera_streamon(struct file *file, void *priv,
552 enum v4l2_buf_type i)
553{
554 struct soc_camera_file *icf = file->private_data;
555 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300556 int ret;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300557
558 WARN_ON(priv != file->private_data);
559
Harvey Harrison7e28adb2008-04-08 23:20:00 -0300560 dev_dbg(&icd->dev, "%s\n", __func__);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300561
562 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
563 return -EINVAL;
564
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300565 mutex_lock(&icd->video_lock);
566
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300567 icd->ops->start_capture(icd);
568
569 /* This calls buf_queue from host driver's videobuf_queue_ops */
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300570 ret = videobuf_streamon(&icf->vb_vidq);
571
572 mutex_unlock(&icd->video_lock);
573
574 return ret;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300575}
576
577static int soc_camera_streamoff(struct file *file, void *priv,
578 enum v4l2_buf_type i)
579{
580 struct soc_camera_file *icf = file->private_data;
581 struct soc_camera_device *icd = icf->icd;
582
583 WARN_ON(priv != file->private_data);
584
Harvey Harrison7e28adb2008-04-08 23:20:00 -0300585 dev_dbg(&icd->dev, "%s\n", __func__);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300586
587 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
588 return -EINVAL;
589
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300590 mutex_lock(&icd->video_lock);
591
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300592 /* This calls buf_release from host driver's videobuf_queue_ops for all
593 * remaining buffers. When the last buffer is freed, stop capture */
594 videobuf_streamoff(&icf->vb_vidq);
595
596 icd->ops->stop_capture(icd);
597
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300598 mutex_unlock(&icd->video_lock);
599
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300600 return 0;
601}
602
603static int soc_camera_queryctrl(struct file *file, void *priv,
604 struct v4l2_queryctrl *qc)
605{
606 struct soc_camera_file *icf = file->private_data;
607 struct soc_camera_device *icd = icf->icd;
608 int i;
609
610 WARN_ON(priv != file->private_data);
611
612 if (!qc->id)
613 return -EINVAL;
614
615 for (i = 0; i < icd->ops->num_controls; i++)
616 if (qc->id == icd->ops->controls[i].id) {
617 memcpy(qc, &(icd->ops->controls[i]),
618 sizeof(*qc));
619 return 0;
620 }
621
622 return -EINVAL;
623}
624
625static int soc_camera_g_ctrl(struct file *file, void *priv,
626 struct v4l2_control *ctrl)
627{
628 struct soc_camera_file *icf = file->private_data;
629 struct soc_camera_device *icd = icf->icd;
630
631 WARN_ON(priv != file->private_data);
632
633 switch (ctrl->id) {
634 case V4L2_CID_GAIN:
635 if (icd->gain == (unsigned short)~0)
636 return -EINVAL;
637 ctrl->value = icd->gain;
638 return 0;
639 case V4L2_CID_EXPOSURE:
640 if (icd->exposure == (unsigned short)~0)
641 return -EINVAL;
642 ctrl->value = icd->exposure;
643 return 0;
644 }
645
646 if (icd->ops->get_control)
647 return icd->ops->get_control(icd, ctrl);
648 return -EINVAL;
649}
650
651static int soc_camera_s_ctrl(struct file *file, void *priv,
652 struct v4l2_control *ctrl)
653{
654 struct soc_camera_file *icf = file->private_data;
655 struct soc_camera_device *icd = icf->icd;
656
657 WARN_ON(priv != file->private_data);
658
659 if (icd->ops->set_control)
660 return icd->ops->set_control(icd, ctrl);
661 return -EINVAL;
662}
663
664static int soc_camera_cropcap(struct file *file, void *fh,
665 struct v4l2_cropcap *a)
666{
667 struct soc_camera_file *icf = file->private_data;
668 struct soc_camera_device *icd = icf->icd;
669
670 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
671 a->bounds.left = icd->x_min;
672 a->bounds.top = icd->y_min;
673 a->bounds.width = icd->width_max;
674 a->bounds.height = icd->height_max;
675 a->defrect.left = icd->x_min;
676 a->defrect.top = icd->y_min;
Guennadi Liakhovetskidf2ed072009-03-13 06:08:20 -0300677 a->defrect.width = DEFAULT_WIDTH;
678 a->defrect.height = DEFAULT_HEIGHT;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300679 a->pixelaspect.numerator = 1;
680 a->pixelaspect.denominator = 1;
681
682 return 0;
683}
684
685static int soc_camera_g_crop(struct file *file, void *fh,
686 struct v4l2_crop *a)
687{
688 struct soc_camera_file *icf = file->private_data;
689 struct soc_camera_device *icd = icf->icd;
690
691 a->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
692 a->c.left = icd->x_current;
693 a->c.top = icd->y_current;
694 a->c.width = icd->width;
695 a->c.height = icd->height;
696
697 return 0;
698}
699
700static int soc_camera_s_crop(struct file *file, void *fh,
701 struct v4l2_crop *a)
702{
703 struct soc_camera_file *icf = file->private_data;
704 struct soc_camera_device *icd = icf->icd;
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300705 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300706 int ret;
707
708 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
709 return -EINVAL;
710
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300711 /* Cropping is allowed during a running capture, guard consistency */
712 mutex_lock(&icf->vb_vidq.vb_lock);
713
Guennadi Liakhovetski09e231b2009-03-13 06:08:20 -0300714 ret = ici->ops->set_crop(icd, &a->c);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300715 if (!ret) {
716 icd->width = a->c.width;
717 icd->height = a->c.height;
718 icd->x_current = a->c.left;
719 icd->y_current = a->c.top;
720 }
721
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300722 mutex_unlock(&icf->vb_vidq.vb_lock);
723
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300724 return ret;
725}
726
727static int soc_camera_g_chip_ident(struct file *file, void *fh,
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300728 struct v4l2_dbg_chip_ident *id)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300729{
730 struct soc_camera_file *icf = file->private_data;
731 struct soc_camera_device *icd = icf->icd;
732
733 if (!icd->ops->get_chip_id)
734 return -EINVAL;
735
736 return icd->ops->get_chip_id(icd, id);
737}
738
739#ifdef CONFIG_VIDEO_ADV_DEBUG
740static int soc_camera_g_register(struct file *file, void *fh,
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300741 struct v4l2_dbg_register *reg)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300742{
743 struct soc_camera_file *icf = file->private_data;
744 struct soc_camera_device *icd = icf->icd;
745
746 if (!icd->ops->get_register)
747 return -EINVAL;
748
749 return icd->ops->get_register(icd, reg);
750}
751
752static int soc_camera_s_register(struct file *file, void *fh,
Hans Verkuilaecde8b2008-12-30 07:14:19 -0300753 struct v4l2_dbg_register *reg)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300754{
755 struct soc_camera_file *icf = file->private_data;
756 struct soc_camera_device *icd = icf->icd;
757
758 if (!icd->ops->set_register)
759 return -EINVAL;
760
761 return icd->ops->set_register(icd, reg);
762}
763#endif
764
765static int device_register_link(struct soc_camera_device *icd)
766{
767 int ret = device_register(&icd->dev);
768
769 if (ret < 0) {
770 /* Prevent calling device_unregister() */
771 icd->dev.parent = NULL;
772 dev_err(&icd->dev, "Cannot register device: %d\n", ret);
773 /* Even if probe() was unsuccessful for all registered drivers,
774 * device_register() returns 0, and we add the link, just to
775 * document this camera's control device */
776 } else if (icd->control)
777 /* Have to sysfs_remove_link() before device_unregister()? */
778 if (sysfs_create_link(&icd->dev.kobj, &icd->control->kobj,
779 "control"))
780 dev_warn(&icd->dev,
781 "Failed creating the control symlink\n");
782 return ret;
783}
784
785/* So far this function cannot fail */
786static void scan_add_host(struct soc_camera_host *ici)
787{
788 struct soc_camera_device *icd;
789
790 mutex_lock(&list_lock);
791
792 list_for_each_entry(icd, &devices, list) {
793 if (icd->iface == ici->nr) {
794 icd->dev.parent = &ici->dev;
795 device_register_link(icd);
796 }
797 }
798
799 mutex_unlock(&list_lock);
800}
801
802/* return: 0 if no match found or a match found and
803 * device_register() successful, error code otherwise */
804static int scan_add_device(struct soc_camera_device *icd)
805{
806 struct soc_camera_host *ici;
807 int ret = 0;
808
809 mutex_lock(&list_lock);
810
811 list_add_tail(&icd->list, &devices);
812
813 /* Watch out for class_for_each_device / class_find_device API by
814 * Dave Young <hidave.darkstar@gmail.com> */
815 list_for_each_entry(ici, &hosts, list) {
816 if (icd->iface == ici->nr) {
817 ret = 1;
818 icd->dev.parent = &ici->dev;
819 break;
820 }
821 }
822
823 mutex_unlock(&list_lock);
824
825 if (ret)
826 ret = device_register_link(icd);
827
828 return ret;
829}
830
831static int soc_camera_probe(struct device *dev)
832{
833 struct soc_camera_device *icd = to_soc_camera_dev(dev);
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300834 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300835 int ret;
836
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300837 /*
838 * Possible race scenario:
839 * modprobe <camera-host-driver> triggers __func__
840 * at this moment respective <camera-sensor-driver> gets rmmod'ed
841 * to protect take module references.
842 */
843
844 if (!try_module_get(icd->ops->owner)) {
845 dev_err(&icd->dev, "Couldn't lock sensor driver.\n");
846 ret = -EINVAL;
847 goto emgd;
848 }
849
850 if (!try_module_get(ici->ops->owner)) {
851 dev_err(&icd->dev, "Couldn't lock capture bus driver.\n");
852 ret = -EINVAL;
853 goto emgi;
854 }
855
856 mutex_lock(&icd->video_lock);
857
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300858 /* We only call ->add() here to activate and probe the camera.
859 * We shall ->remove() and deactivate it immediately afterwards. */
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300860 ret = ici->ops->add(icd);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300861 if (ret < 0)
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300862 goto eiadd;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300863
Guennadi Liakhovetski26f1b942008-03-24 12:18:36 -0300864 ret = icd->ops->probe(icd);
Guennadi Liakhovetski9dc4e482008-04-22 14:45:32 -0300865 if (ret >= 0) {
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300866 const struct v4l2_queryctrl *qctrl;
867
868 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_GAIN);
869 icd->gain = qctrl ? qctrl->default_value : (unsigned short)~0;
870 qctrl = soc_camera_find_qctrl(icd->ops, V4L2_CID_EXPOSURE);
871 icd->exposure = qctrl ? qctrl->default_value :
872 (unsigned short)~0;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300873
Guennadi Liakhovetski025c18a2009-03-13 06:08:20 -0300874 ret = soc_camera_init_user_formats(icd);
875 if (ret < 0)
876 goto eiufmt;
877
878 icd->height = DEFAULT_HEIGHT;
879 icd->width = DEFAULT_WIDTH;
880 icd->field = V4L2_FIELD_ANY;
881 }
882
883eiufmt:
884 ici->ops->remove(icd);
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -0300885eiadd:
886 mutex_unlock(&icd->video_lock);
887 module_put(ici->ops->owner);
888emgi:
889 module_put(icd->ops->owner);
890emgd:
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300891 return ret;
892}
893
894/* This is called on device_unregister, which only means we have to disconnect
895 * from the host, but not remove ourselves from the device list */
896static int soc_camera_remove(struct device *dev)
897{
898 struct soc_camera_device *icd = to_soc_camera_dev(dev);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300899
Guennadi Liakhovetski26f1b942008-03-24 12:18:36 -0300900 if (icd->ops->remove)
901 icd->ops->remove(icd);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300902
Guennadi Liakhovetski025c18a2009-03-13 06:08:20 -0300903 soc_camera_free_user_formats(icd);
904
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300905 return 0;
906}
907
Robert Jarzmik2e521062008-08-01 20:14:50 -0300908static int soc_camera_suspend(struct device *dev, pm_message_t state)
909{
910 struct soc_camera_device *icd = to_soc_camera_dev(dev);
911 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
912 int ret = 0;
913
914 if (ici->ops->suspend)
915 ret = ici->ops->suspend(icd, state);
916
917 return ret;
918}
919
920static int soc_camera_resume(struct device *dev)
921{
922 struct soc_camera_device *icd = to_soc_camera_dev(dev);
923 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
924 int ret = 0;
925
926 if (ici->ops->resume)
927 ret = ici->ops->resume(icd);
928
929 return ret;
930}
931
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300932static struct bus_type soc_camera_bus_type = {
933 .name = "soc-camera",
934 .probe = soc_camera_probe,
935 .remove = soc_camera_remove,
Robert Jarzmik2e521062008-08-01 20:14:50 -0300936 .suspend = soc_camera_suspend,
937 .resume = soc_camera_resume,
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300938};
939
940static struct device_driver ic_drv = {
941 .name = "camera",
942 .bus = &soc_camera_bus_type,
943 .owner = THIS_MODULE,
944};
945
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300946static void dummy_release(struct device *dev)
947{
948}
949
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -0300950int soc_camera_host_register(struct soc_camera_host *ici)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300951{
952 int ret;
953 struct soc_camera_host *ix;
954
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300955 if (!ici || !ici->ops ||
956 !ici->ops->try_fmt ||
957 !ici->ops->set_fmt ||
Guennadi Liakhovetski09e231b2009-03-13 06:08:20 -0300958 !ici->ops->set_crop ||
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -0300959 !ici->ops->set_bus_param ||
960 !ici->ops->querycap ||
961 !ici->ops->init_videobuf ||
962 !ici->ops->reqbufs ||
963 !ici->ops->add ||
964 !ici->ops->remove ||
965 !ici->ops->poll)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300966 return -EINVAL;
967
968 /* Number might be equal to the platform device ID */
Kay Sieversaf128a12008-10-30 00:51:46 -0300969 dev_set_name(&ici->dev, "camera_host%d", ici->nr);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300970
971 mutex_lock(&list_lock);
972 list_for_each_entry(ix, &hosts, list) {
973 if (ix->nr == ici->nr) {
974 mutex_unlock(&list_lock);
975 return -EBUSY;
976 }
977 }
978
979 list_add_tail(&ici->list, &hosts);
980 mutex_unlock(&list_lock);
981
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -0300982 ici->dev.release = dummy_release;
983
984 ret = device_register(&ici->dev);
985
986 if (ret)
987 goto edevr;
988
989 scan_add_host(ici);
990
991 return 0;
992
993edevr:
994 mutex_lock(&list_lock);
995 list_del(&ici->list);
996 mutex_unlock(&list_lock);
997
998 return ret;
999}
1000EXPORT_SYMBOL(soc_camera_host_register);
1001
1002/* Unregister all clients! */
1003void soc_camera_host_unregister(struct soc_camera_host *ici)
1004{
1005 struct soc_camera_device *icd;
1006
1007 mutex_lock(&list_lock);
1008
1009 list_del(&ici->list);
1010
1011 list_for_each_entry(icd, &devices, list) {
1012 if (icd->dev.parent == &ici->dev) {
1013 device_unregister(&icd->dev);
1014 /* Not before device_unregister(), .remove
Guennadi Liakhovetskib8d99042008-04-04 13:41:25 -03001015 * needs parent to call ici->ops->remove() */
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001016 icd->dev.parent = NULL;
1017 memset(&icd->dev.kobj, 0, sizeof(icd->dev.kobj));
1018 }
1019 }
1020
1021 mutex_unlock(&list_lock);
1022
1023 device_unregister(&ici->dev);
1024}
1025EXPORT_SYMBOL(soc_camera_host_unregister);
1026
1027/* Image capture device */
1028int soc_camera_device_register(struct soc_camera_device *icd)
1029{
1030 struct soc_camera_device *ix;
1031 int num = -1, i;
1032
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -03001033 if (!icd || !icd->ops ||
1034 !icd->ops->probe ||
1035 !icd->ops->init ||
1036 !icd->ops->release ||
1037 !icd->ops->start_capture ||
1038 !icd->ops->stop_capture ||
Guennadi Liakhovetski09e231b2009-03-13 06:08:20 -03001039 !icd->ops->set_crop ||
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -03001040 !icd->ops->set_fmt ||
1041 !icd->ops->try_fmt ||
1042 !icd->ops->query_bus_param ||
1043 !icd->ops->set_bus_param)
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001044 return -EINVAL;
1045
1046 for (i = 0; i < 256 && num < 0; i++) {
1047 num = i;
1048 list_for_each_entry(ix, &devices, list) {
1049 if (ix->iface == icd->iface && ix->devnum == i) {
1050 num = -1;
1051 break;
1052 }
1053 }
1054 }
1055
1056 if (num < 0)
1057 /* ok, we have 256 cameras on this host...
1058 * man, stay reasonable... */
1059 return -ENOMEM;
1060
1061 icd->devnum = num;
1062 icd->dev.bus = &soc_camera_bus_type;
Kay Sieversaf128a12008-10-30 00:51:46 -03001063 dev_set_name(&icd->dev, "%u-%u", icd->iface, icd->devnum);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001064
Guennadi Liakhovetski64f59052008-12-18 11:51:55 -03001065 icd->dev.release = dummy_release;
1066 icd->use_count = 0;
1067 icd->host_priv = NULL;
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -03001068 mutex_init(&icd->video_lock);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001069
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001070 return scan_add_device(icd);
1071}
1072EXPORT_SYMBOL(soc_camera_device_register);
1073
1074void soc_camera_device_unregister(struct soc_camera_device *icd)
1075{
1076 mutex_lock(&list_lock);
1077 list_del(&icd->list);
1078
1079 /* The bus->remove will be eventually called */
1080 if (icd->dev.parent)
1081 device_unregister(&icd->dev);
1082 mutex_unlock(&list_lock);
1083}
1084EXPORT_SYMBOL(soc_camera_device_unregister);
1085
Hans Verkuila3998102008-07-21 02:57:38 -03001086static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
1087 .vidioc_querycap = soc_camera_querycap,
1088 .vidioc_g_fmt_vid_cap = soc_camera_g_fmt_vid_cap,
1089 .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
1090 .vidioc_s_fmt_vid_cap = soc_camera_s_fmt_vid_cap,
1091 .vidioc_enum_input = soc_camera_enum_input,
1092 .vidioc_g_input = soc_camera_g_input,
1093 .vidioc_s_input = soc_camera_s_input,
1094 .vidioc_s_std = soc_camera_s_std,
1095 .vidioc_reqbufs = soc_camera_reqbufs,
1096 .vidioc_try_fmt_vid_cap = soc_camera_try_fmt_vid_cap,
1097 .vidioc_querybuf = soc_camera_querybuf,
1098 .vidioc_qbuf = soc_camera_qbuf,
1099 .vidioc_dqbuf = soc_camera_dqbuf,
1100 .vidioc_streamon = soc_camera_streamon,
1101 .vidioc_streamoff = soc_camera_streamoff,
1102 .vidioc_queryctrl = soc_camera_queryctrl,
1103 .vidioc_g_ctrl = soc_camera_g_ctrl,
1104 .vidioc_s_ctrl = soc_camera_s_ctrl,
1105 .vidioc_cropcap = soc_camera_cropcap,
1106 .vidioc_g_crop = soc_camera_g_crop,
1107 .vidioc_s_crop = soc_camera_s_crop,
1108 .vidioc_g_chip_ident = soc_camera_g_chip_ident,
1109#ifdef CONFIG_VIDEO_ADV_DEBUG
1110 .vidioc_g_register = soc_camera_g_register,
1111 .vidioc_s_register = soc_camera_s_register,
1112#endif
1113};
1114
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -03001115/*
1116 * Usually called from the struct soc_camera_ops .probe() method, i.e., from
1117 * soc_camera_probe() above with .video_lock held
1118 */
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001119int soc_camera_video_start(struct soc_camera_device *icd)
1120{
1121 struct soc_camera_host *ici = to_soc_camera_host(icd->dev.parent);
1122 int err = -ENOMEM;
1123 struct video_device *vdev;
1124
1125 if (!icd->dev.parent)
1126 return -ENODEV;
1127
1128 vdev = video_device_alloc();
1129 if (!vdev)
1130 goto evidallocd;
1131 dev_dbg(&ici->dev, "Allocated video_device %p\n", vdev);
1132
1133 strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -03001134
Hans Verkuil5e85e732008-07-20 06:31:39 -03001135 vdev->parent = &icd->dev;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001136 vdev->current_norm = V4L2_STD_UNKNOWN;
1137 vdev->fops = &soc_camera_fops;
Hans Verkuila3998102008-07-21 02:57:38 -03001138 vdev->ioctl_ops = &soc_camera_ioctl_ops;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001139 vdev->release = video_device_release;
1140 vdev->minor = -1;
1141 vdev->tvnorms = V4L2_STD_UNKNOWN,
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001142
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001143 err = video_register_device(vdev, VFL_TYPE_GRABBER, vdev->minor);
1144 if (err < 0) {
Hans Verkuil5e85e732008-07-20 06:31:39 -03001145 dev_err(vdev->parent, "video_register_device failed\n");
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001146 goto evidregd;
1147 }
1148 icd->vdev = vdev;
1149
1150 return 0;
1151
1152evidregd:
1153 video_device_release(vdev);
1154evidallocd:
1155 return err;
1156}
1157EXPORT_SYMBOL(soc_camera_video_start);
1158
1159void soc_camera_video_stop(struct soc_camera_device *icd)
1160{
1161 struct video_device *vdev = icd->vdev;
1162
Harvey Harrison7e28adb2008-04-08 23:20:00 -03001163 dev_dbg(&icd->dev, "%s\n", __func__);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001164
1165 if (!icd->dev.parent || !vdev)
1166 return;
1167
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -03001168 mutex_lock(&icd->video_lock);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001169 video_unregister_device(vdev);
1170 icd->vdev = NULL;
Guennadi Liakhovetski1c3bb742008-12-18 12:28:54 -03001171 mutex_unlock(&icd->video_lock);
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001172}
1173EXPORT_SYMBOL(soc_camera_video_stop);
1174
1175static int __init soc_camera_init(void)
1176{
1177 int ret = bus_register(&soc_camera_bus_type);
1178 if (ret)
1179 return ret;
1180 ret = driver_register(&ic_drv);
1181 if (ret)
1182 goto edrvr;
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001183
1184 return 0;
1185
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001186edrvr:
1187 bus_unregister(&soc_camera_bus_type);
1188 return ret;
1189}
1190
1191static void __exit soc_camera_exit(void)
1192{
Guennadi Liakhovetskie55222e2008-04-22 14:42:03 -03001193 driver_unregister(&ic_drv);
1194 bus_unregister(&soc_camera_bus_type);
1195}
1196
1197module_init(soc_camera_init);
1198module_exit(soc_camera_exit);
1199
1200MODULE_DESCRIPTION("Image capture bus driver");
1201MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
1202MODULE_LICENSE("GPL");