?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfd: wm8350-i2c: Make sure the i2c regmap functions are compiled
[linux/fpc-iii.git] / drivers / media / platform / soc_camera / soc_camera.c
blob387a232d95a4b63d74a9e3d2ef8030d8cdfee08c
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/module.h>
25 #include <linux/mutex.h>
26 #include <linux/platform_device.h>
27 #include <linux/pm_runtime.h>
28 #include <linux/regulator/consumer.h>
29 #include <linux/slab.h>
30 #include <linux/vmalloc.h>
31
32 #include <media/soc_camera.h>
33 #include <media/soc_mediabus.h>
34 #include <media/v4l2-async.h>
35 #include <media/v4l2-clk.h>
36 #include <media/v4l2-common.h>
37 #include <media/v4l2-ioctl.h>
38 #include <media/v4l2-dev.h>
39 #include <media/videobuf-core.h>
40 #include <media/videobuf2-core.h>
41
42 /* Default to VGA resolution */
43 #define DEFAULT_WIDTH 640
44 #define DEFAULT_HEIGHT 480
45
46 #define is_streaming(ici, icd) \
47 (((ici)->ops->init_videobuf) ? \
48 (icd)->vb_vidq.streaming : \
49 vb2_is_streaming(&(icd)->vb2_vidq))
50
51 #define MAP_MAX_NUM 32
52 static DECLARE_BITMAP(device_map, MAP_MAX_NUM);
53 static LIST_HEAD(hosts);
54 static LIST_HEAD(devices);
55 /*
56 * Protects lists and bitmaps of hosts and devices.
57 * Lock nesting: Ok to take ->host_lock under list_lock.
58 */
59 static DEFINE_MUTEX(list_lock);
60
61 struct soc_camera_async_client {
62 struct v4l2_async_subdev *sensor;
63 struct v4l2_async_notifier notifier;
64 struct platform_device *pdev;
65 struct list_head list; /* needed for clean up */
66 };
67
68 static int soc_camera_video_start(struct soc_camera_device *icd);
69 static int video_dev_create(struct soc_camera_device *icd);
70
71 int soc_camera_power_on(struct device *dev, struct soc_camera_subdev_desc *ssdd,
72 struct v4l2_clk *clk)
73 {
74 int ret = clk ? v4l2_clk_enable(clk) : 0;
75 if (ret < 0) {
76 dev_err(dev, "Cannot enable clock: %d\n", ret);
77 return ret;
78 }
79 ret = regulator_bulk_enable(ssdd->num_regulators,
80 ssdd->regulators);
81 if (ret < 0) {
82 dev_err(dev, "Cannot enable regulators\n");
83 goto eregenable;
84 }
85
86 if (ssdd->power) {
87 ret = ssdd->power(dev, 1);
88 if (ret < 0) {
89 dev_err(dev,
90 "Platform failed to power-on the camera.\n");
91 goto epwron;
92 }
93 }
94
95 return 0;
96
97 epwron:
98 regulator_bulk_disable(ssdd->num_regulators,
99 ssdd->regulators);
100 eregenable:
101 if (clk)
102 v4l2_clk_disable(clk);
103
104 return ret;
105 }
106 EXPORT_SYMBOL(soc_camera_power_on);
107
108 int soc_camera_power_off(struct device *dev, struct soc_camera_subdev_desc *ssdd,
109 struct v4l2_clk *clk)
110 {
111 int ret = 0;
112 int err;
113
114 if (ssdd->power) {
115 err = ssdd->power(dev, 0);
116 if (err < 0) {
117 dev_err(dev,
118 "Platform failed to power-off the camera.\n");
119 ret = err;
120 }
121 }
122
123 err = regulator_bulk_disable(ssdd->num_regulators,
124 ssdd->regulators);
125 if (err < 0) {
126 dev_err(dev, "Cannot disable regulators\n");
127 ret = ret ? : err;
128 }
129
130 if (clk)
131 v4l2_clk_disable(clk);
132
133 return ret;
134 }
135 EXPORT_SYMBOL(soc_camera_power_off);
136
137 int soc_camera_power_init(struct device *dev, struct soc_camera_subdev_desc *ssdd)
138 {
139 /* Should not have any effect in synchronous case */
140 return devm_regulator_bulk_get(dev, ssdd->num_regulators,
141 ssdd->regulators);
142 }
143 EXPORT_SYMBOL(soc_camera_power_init);
144
145 static int __soc_camera_power_on(struct soc_camera_device *icd)
146 {
147 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
148 int ret;
149
150 ret = v4l2_subdev_call(sd, core, s_power, 1);
151 if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
152 return ret;
153
154 return 0;
155 }
156
157 static int __soc_camera_power_off(struct soc_camera_device *icd)
158 {
159 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
160 int ret;
161
162 ret = v4l2_subdev_call(sd, core, s_power, 0);
163 if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
164 return ret;
165
166 return 0;
167 }
168
169 const struct soc_camera_format_xlate *soc_camera_xlate_by_fourcc(
170 struct soc_camera_device *icd, unsigned int fourcc)
171 {
172 unsigned int i;
173
174 for (i = 0; i < icd->num_user_formats; i++)
175 if (icd->user_formats[i].host_fmt->fourcc == fourcc)
176 return icd->user_formats + i;
177 return NULL;
178 }
179 EXPORT_SYMBOL(soc_camera_xlate_by_fourcc);
180
181 /**
182 * soc_camera_apply_board_flags() - apply platform SOCAM_SENSOR_INVERT_* flags
183 * @ssdd: camera platform parameters
184 * @cfg: media bus configuration
185 * @return: resulting flags
186 */
187 unsigned long soc_camera_apply_board_flags(struct soc_camera_subdev_desc *ssdd,
188 const struct v4l2_mbus_config *cfg)
189 {
190 unsigned long f, flags = cfg->flags;
191
192 /* If only one of the two polarities is supported, switch to the opposite */
193 if (ssdd->flags & SOCAM_SENSOR_INVERT_HSYNC) {
194 f = flags & (V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW);
195 if (f == V4L2_MBUS_HSYNC_ACTIVE_HIGH || f == V4L2_MBUS_HSYNC_ACTIVE_LOW)
196 flags ^= V4L2_MBUS_HSYNC_ACTIVE_HIGH | V4L2_MBUS_HSYNC_ACTIVE_LOW;
197 }
198
199 if (ssdd->flags & SOCAM_SENSOR_INVERT_VSYNC) {
200 f = flags & (V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW);
201 if (f == V4L2_MBUS_VSYNC_ACTIVE_HIGH || f == V4L2_MBUS_VSYNC_ACTIVE_LOW)
202 flags ^= V4L2_MBUS_VSYNC_ACTIVE_HIGH | V4L2_MBUS_VSYNC_ACTIVE_LOW;
203 }
204
205 if (ssdd->flags & SOCAM_SENSOR_INVERT_PCLK) {
206 f = flags & (V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING);
207 if (f == V4L2_MBUS_PCLK_SAMPLE_RISING || f == V4L2_MBUS_PCLK_SAMPLE_FALLING)
208 flags ^= V4L2_MBUS_PCLK_SAMPLE_RISING | V4L2_MBUS_PCLK_SAMPLE_FALLING;
209 }
210
211 return flags;
212 }
213 EXPORT_SYMBOL(soc_camera_apply_board_flags);
214
215 #define pixfmtstr(x) (x) & 0xff, ((x) >> 8) & 0xff, ((x) >> 16) & 0xff, \
216 ((x) >> 24) & 0xff
217
218 static int soc_camera_try_fmt(struct soc_camera_device *icd,
219 struct v4l2_format *f)
220 {
221 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
222 const struct soc_camera_format_xlate *xlate;
223 struct v4l2_pix_format *pix = &f->fmt.pix;
224 int ret;
225
226 dev_dbg(icd->pdev, "TRY_FMT(%c%c%c%c, %ux%u)\n",
227 pixfmtstr(pix->pixelformat), pix->width, pix->height);
228
229 if (pix->pixelformat != V4L2_PIX_FMT_JPEG &&
230 !(ici->capabilities & SOCAM_HOST_CAP_STRIDE)) {
231 pix->bytesperline = 0;
232 pix->sizeimage = 0;
233 }
234
235 ret = ici->ops->try_fmt(icd, f);
236 if (ret < 0)
237 return ret;
238
239 xlate = soc_camera_xlate_by_fourcc(icd, pix->pixelformat);
240 if (!xlate)
241 return -EINVAL;
242
243 ret = soc_mbus_bytes_per_line(pix->width, xlate->host_fmt);
244 if (ret < 0)
245 return ret;
246
247 pix->bytesperline = max_t(u32, pix->bytesperline, ret);
248
249 ret = soc_mbus_image_size(xlate->host_fmt, pix->bytesperline,
250 pix->height);
251 if (ret < 0)
252 return ret;
253
254 pix->sizeimage = max_t(u32, pix->sizeimage, ret);
255
256 return 0;
257 }
258
259 static int soc_camera_try_fmt_vid_cap(struct file *file, void *priv,
260 struct v4l2_format *f)
261 {
262 struct soc_camera_device *icd = file->private_data;
263
264 WARN_ON(priv != file->private_data);
265
266 /* Only single-plane capture is supported so far */
267 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
268 return -EINVAL;
269
270 /* limit format to hardware capabilities */
271 return soc_camera_try_fmt(icd, f);
272 }
273
274 static int soc_camera_enum_input(struct file *file, void *priv,
275 struct v4l2_input *inp)
276 {
277 if (inp->index != 0)
278 return -EINVAL;
279
280 /* default is camera */
281 inp->type = V4L2_INPUT_TYPE_CAMERA;
282 strcpy(inp->name, "Camera");
283
284 return 0;
285 }
286
287 static int soc_camera_g_input(struct file *file, void *priv, unsigned int *i)
288 {
289 *i = 0;
290
291 return 0;
292 }
293
294 static int soc_camera_s_input(struct file *file, void *priv, unsigned int i)
295 {
296 if (i > 0)
297 return -EINVAL;
298
299 return 0;
300 }
301
302 static int soc_camera_s_std(struct file *file, void *priv, v4l2_std_id a)
303 {
304 struct soc_camera_device *icd = file->private_data;
305 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
306
307 return v4l2_subdev_call(sd, core, s_std, a);
308 }
309
310 static int soc_camera_g_std(struct file *file, void *priv, v4l2_std_id *a)
311 {
312 struct soc_camera_device *icd = file->private_data;
313 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
314
315 return v4l2_subdev_call(sd, core, g_std, a);
316 }
317
318 static int soc_camera_enum_framesizes(struct file *file, void *fh,
319 struct v4l2_frmsizeenum *fsize)
320 {
321 struct soc_camera_device *icd = file->private_data;
322 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
323
324 return ici->ops->enum_framesizes(icd, fsize);
325 }
326
327 static int soc_camera_reqbufs(struct file *file, void *priv,
328 struct v4l2_requestbuffers *p)
329 {
330 int ret;
331 struct soc_camera_device *icd = file->private_data;
332 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
333
334 WARN_ON(priv != file->private_data);
335
336 if (icd->streamer && icd->streamer != file)
337 return -EBUSY;
338
339 if (ici->ops->init_videobuf) {
340 ret = videobuf_reqbufs(&icd->vb_vidq, p);
341 if (ret < 0)
342 return ret;
343
344 ret = ici->ops->reqbufs(icd, p);
345 } else {
346 ret = vb2_reqbufs(&icd->vb2_vidq, p);
347 }
348
349 if (!ret && !icd->streamer)
350 icd->streamer = file;
351
352 return ret;
353 }
354
355 static int soc_camera_querybuf(struct file *file, void *priv,
356 struct v4l2_buffer *p)
357 {
358 struct soc_camera_device *icd = file->private_data;
359 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
360
361 WARN_ON(priv != file->private_data);
362
363 if (ici->ops->init_videobuf)
364 return videobuf_querybuf(&icd->vb_vidq, p);
365 else
366 return vb2_querybuf(&icd->vb2_vidq, p);
367 }
368
369 static int soc_camera_qbuf(struct file *file, void *priv,
370 struct v4l2_buffer *p)
371 {
372 struct soc_camera_device *icd = file->private_data;
373 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
374
375 WARN_ON(priv != file->private_data);
376
377 if (icd->streamer != file)
378 return -EBUSY;
379
380 if (ici->ops->init_videobuf)
381 return videobuf_qbuf(&icd->vb_vidq, p);
382 else
383 return vb2_qbuf(&icd->vb2_vidq, p);
384 }
385
386 static int soc_camera_dqbuf(struct file *file, void *priv,
387 struct v4l2_buffer *p)
388 {
389 struct soc_camera_device *icd = file->private_data;
390 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
391
392 WARN_ON(priv != file->private_data);
393
394 if (icd->streamer != file)
395 return -EBUSY;
396
397 if (ici->ops->init_videobuf)
398 return videobuf_dqbuf(&icd->vb_vidq, p, file->f_flags & O_NONBLOCK);
399 else
400 return vb2_dqbuf(&icd->vb2_vidq, p, file->f_flags & O_NONBLOCK);
401 }
402
403 static int soc_camera_create_bufs(struct file *file, void *priv,
404 struct v4l2_create_buffers *create)
405 {
406 struct soc_camera_device *icd = file->private_data;
407 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
408
409 /* videobuf2 only */
410 if (ici->ops->init_videobuf)
411 return -EINVAL;
412 else
413 return vb2_create_bufs(&icd->vb2_vidq, create);
414 }
415
416 static int soc_camera_prepare_buf(struct file *file, void *priv,
417 struct v4l2_buffer *b)
418 {
419 struct soc_camera_device *icd = file->private_data;
420 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
421
422 /* videobuf2 only */
423 if (ici->ops->init_videobuf)
424 return -EINVAL;
425 else
426 return vb2_prepare_buf(&icd->vb2_vidq, b);
427 }
428
429 /* Always entered with .host_lock held */
430 static int soc_camera_init_user_formats(struct soc_camera_device *icd)
431 {
432 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
433 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
434 unsigned int i, fmts = 0, raw_fmts = 0;
435 int ret;
436 enum v4l2_mbus_pixelcode code;
437
438 while (!v4l2_subdev_call(sd, video, enum_mbus_fmt, raw_fmts, &code))
439 raw_fmts++;
440
441 if (!ici->ops->get_formats)
442 /*
443 * Fallback mode - the host will have to serve all
444 * sensor-provided formats one-to-one to the user
445 */
446 fmts = raw_fmts;
447 else
448 /*
449 * First pass - only count formats this host-sensor
450 * configuration can provide
451 */
452 for (i = 0; i < raw_fmts; i++) {
453 ret = ici->ops->get_formats(icd, i, NULL);
454 if (ret < 0)
455 return ret;
456 fmts += ret;
457 }
458
459 if (!fmts)
460 return -ENXIO;
461
462 icd->user_formats =
463 vmalloc(fmts * sizeof(struct soc_camera_format_xlate));
464 if (!icd->user_formats)
465 return -ENOMEM;
466
467 dev_dbg(icd->pdev, "Found %d supported formats.\n", fmts);
468
469 /* Second pass - actually fill data formats */
470 fmts = 0;
471 for (i = 0; i < raw_fmts; i++)
472 if (!ici->ops->get_formats) {
473 v4l2_subdev_call(sd, video, enum_mbus_fmt, i, &code);
474 icd->user_formats[fmts].host_fmt =
475 soc_mbus_get_fmtdesc(code);
476 if (icd->user_formats[fmts].host_fmt)
477 icd->user_formats[fmts++].code = code;
478 } else {
479 ret = ici->ops->get_formats(icd, i,
480 &icd->user_formats[fmts]);
481 if (ret < 0)
482 goto egfmt;
483 fmts += ret;
484 }
485
486 icd->num_user_formats = fmts;
487 icd->current_fmt = &icd->user_formats[0];
488
489 return 0;
490
491 egfmt:
492 vfree(icd->user_formats);
493 return ret;
494 }
495
496 /* Always entered with .host_lock held */
497 static void soc_camera_free_user_formats(struct soc_camera_device *icd)
498 {
499 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
500
501 if (ici->ops->put_formats)
502 ici->ops->put_formats(icd);
503 icd->current_fmt = NULL;
504 icd->num_user_formats = 0;
505 vfree(icd->user_formats);
506 icd->user_formats = NULL;
507 }
508
509 /* Called with .vb_lock held, or from the first open(2), see comment there */
510 static int soc_camera_set_fmt(struct soc_camera_device *icd,
511 struct v4l2_format *f)
512 {
513 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
514 struct v4l2_pix_format *pix = &f->fmt.pix;
515 int ret;
516
517 dev_dbg(icd->pdev, "S_FMT(%c%c%c%c, %ux%u)\n",
518 pixfmtstr(pix->pixelformat), pix->width, pix->height);
519
520 /* We always call try_fmt() before set_fmt() or set_crop() */
521 ret = soc_camera_try_fmt(icd, f);
522 if (ret < 0)
523 return ret;
524
525 ret = ici->ops->set_fmt(icd, f);
526 if (ret < 0) {
527 return ret;
528 } else if (!icd->current_fmt ||
529 icd->current_fmt->host_fmt->fourcc != pix->pixelformat) {
530 dev_err(icd->pdev,
531 "Host driver hasn't set up current format correctly!\n");
532 return -EINVAL;
533 }
534
535 icd->user_width = pix->width;
536 icd->user_height = pix->height;
537 icd->bytesperline = pix->bytesperline;
538 icd->sizeimage = pix->sizeimage;
539 icd->colorspace = pix->colorspace;
540 icd->field = pix->field;
541 if (ici->ops->init_videobuf)
542 icd->vb_vidq.field = pix->field;
543
544 dev_dbg(icd->pdev, "set width: %d height: %d\n",
545 icd->user_width, icd->user_height);
546
547 /* set physical bus parameters */
548 return ici->ops->set_bus_param(icd);
549 }
550
551 static int soc_camera_add_device(struct soc_camera_device *icd)
552 {
553 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
554 int ret;
555
556 if (ici->icd)
557 return -EBUSY;
558
559 if (!icd->clk) {
560 mutex_lock(&ici->clk_lock);
561 ret = ici->ops->clock_start(ici);
562 mutex_unlock(&ici->clk_lock);
563 if (ret < 0)
564 return ret;
565 }
566
567 if (ici->ops->add) {
568 ret = ici->ops->add(icd);
569 if (ret < 0)
570 goto eadd;
571 }
572
573 ici->icd = icd;
574
575 return 0;
576
577 eadd:
578 if (!icd->clk) {
579 mutex_lock(&ici->clk_lock);
580 ici->ops->clock_stop(ici);
581 mutex_unlock(&ici->clk_lock);
582 }
583 return ret;
584 }
585
586 static void soc_camera_remove_device(struct soc_camera_device *icd)
587 {
588 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
589
590 if (WARN_ON(icd != ici->icd))
591 return;
592
593 if (ici->ops->remove)
594 ici->ops->remove(icd);
595 if (!icd->clk) {
596 mutex_lock(&ici->clk_lock);
597 ici->ops->clock_stop(ici);
598 mutex_unlock(&ici->clk_lock);
599 }
600 ici->icd = NULL;
601 }
602
603 static int soc_camera_open(struct file *file)
604 {
605 struct video_device *vdev = video_devdata(file);
606 struct soc_camera_device *icd;
607 struct soc_camera_host *ici;
608 int ret;
609
610 /*
611 * Don't mess with the host during probe: wait until the loop in
612 * scan_add_host() completes. Also protect against a race with
613 * soc_camera_host_unregister().
614 */
615 if (mutex_lock_interruptible(&list_lock))
616 return -ERESTARTSYS;
617
618 if (!vdev || !video_is_registered(vdev)) {
619 mutex_unlock(&list_lock);
620 return -ENODEV;
621 }
622
623 icd = video_get_drvdata(vdev);
624 ici = to_soc_camera_host(icd->parent);
625
626 ret = try_module_get(ici->ops->owner) ? 0 : -ENODEV;
627 mutex_unlock(&list_lock);
628
629 if (ret < 0) {
630 dev_err(icd->pdev, "Couldn't lock capture bus driver.\n");
631 return ret;
632 }
633
634 if (!to_soc_camera_control(icd)) {
635 /* No device driver attached */
636 ret = -ENODEV;
637 goto econtrol;
638 }
639
640 if (mutex_lock_interruptible(&ici->host_lock)) {
641 ret = -ERESTARTSYS;
642 goto elockhost;
643 }
644 icd->use_count++;
645
646 /* Now we really have to activate the camera */
647 if (icd->use_count == 1) {
648 struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
649 /* Restore parameters before the last close() per V4L2 API */
650 struct v4l2_format f = {
651 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
652 .fmt.pix = {
653 .width = icd->user_width,
654 .height = icd->user_height,
655 .field = icd->field,
656 .colorspace = icd->colorspace,
657 .pixelformat =
658 icd->current_fmt->host_fmt->fourcc,
659 },
660 };
661
662 /* The camera could have been already on, try to reset */
663 if (sdesc->subdev_desc.reset)
664 sdesc->subdev_desc.reset(icd->pdev);
665
666 ret = soc_camera_add_device(icd);
667 if (ret < 0) {
668 dev_err(icd->pdev, "Couldn't activate the camera: %d\n", ret);
669 goto eiciadd;
670 }
671
672 ret = __soc_camera_power_on(icd);
673 if (ret < 0)
674 goto epower;
675
676 pm_runtime_enable(&icd->vdev->dev);
677 ret = pm_runtime_resume(&icd->vdev->dev);
678 if (ret < 0 && ret != -ENOSYS)
679 goto eresume;
680
681 /*
682 * Try to configure with default parameters. Notice: this is the
683 * very first open, so, we cannot race against other calls,
684 * apart from someone else calling open() simultaneously, but
685 * .host_lock is protecting us against it.
686 */
687 ret = soc_camera_set_fmt(icd, &f);
688 if (ret < 0)
689 goto esfmt;
690
691 if (ici->ops->init_videobuf) {
692 ici->ops->init_videobuf(&icd->vb_vidq, icd);
693 } else {
694 ret = ici->ops->init_videobuf2(&icd->vb2_vidq, icd);
695 if (ret < 0)
696 goto einitvb;
697 }
698 v4l2_ctrl_handler_setup(&icd->ctrl_handler);
699 }
700 mutex_unlock(&ici->host_lock);
701
702 file->private_data = icd;
703 dev_dbg(icd->pdev, "camera device open\n");
704
705 return 0;
706
707 /*
708 * All errors are entered with the .host_lock held, first four also
709 * with use_count == 1
710 */
711 einitvb:
712 esfmt:
713 pm_runtime_disable(&icd->vdev->dev);
714 eresume:
715 __soc_camera_power_off(icd);
716 epower:
717 soc_camera_remove_device(icd);
718 eiciadd:
719 icd->use_count--;
720 mutex_unlock(&ici->host_lock);
721 elockhost:
722 econtrol:
723 module_put(ici->ops->owner);
724
725 return ret;
726 }
727
728 static int soc_camera_close(struct file *file)
729 {
730 struct soc_camera_device *icd = file->private_data;
731 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
732
733 mutex_lock(&ici->host_lock);
734 icd->use_count--;
735 if (!icd->use_count) {
736 pm_runtime_suspend(&icd->vdev->dev);
737 pm_runtime_disable(&icd->vdev->dev);
738
739 if (ici->ops->init_videobuf2)
740 vb2_queue_release(&icd->vb2_vidq);
741 __soc_camera_power_off(icd);
742
743 soc_camera_remove_device(icd);
744 }
745
746 if (icd->streamer == file)
747 icd->streamer = NULL;
748 mutex_unlock(&ici->host_lock);
749
750 module_put(ici->ops->owner);
751
752 dev_dbg(icd->pdev, "camera device close\n");
753
754 return 0;
755 }
756
757 static ssize_t soc_camera_read(struct file *file, char __user *buf,
758 size_t count, loff_t *ppos)
759 {
760 struct soc_camera_device *icd = file->private_data;
761 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
762
763 dev_dbg(icd->pdev, "read called, buf %p\n", buf);
764
765 if (ici->ops->init_videobuf2 && icd->vb2_vidq.io_modes & VB2_READ)
766 return vb2_read(&icd->vb2_vidq, buf, count, ppos,
767 file->f_flags & O_NONBLOCK);
768
769 dev_err(icd->pdev, "camera device read not implemented\n");
770
771 return -EINVAL;
772 }
773
774 static int soc_camera_mmap(struct file *file, struct vm_area_struct *vma)
775 {
776 struct soc_camera_device *icd = file->private_data;
777 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
778 int err;
779
780 dev_dbg(icd->pdev, "mmap called, vma=0x%08lx\n", (unsigned long)vma);
781
782 if (icd->streamer != file)
783 return -EBUSY;
784
785 if (mutex_lock_interruptible(&ici->host_lock))
786 return -ERESTARTSYS;
787 if (ici->ops->init_videobuf)
788 err = videobuf_mmap_mapper(&icd->vb_vidq, vma);
789 else
790 err = vb2_mmap(&icd->vb2_vidq, vma);
791 mutex_unlock(&ici->host_lock);
792
793 dev_dbg(icd->pdev, "vma start=0x%08lx, size=%ld, ret=%d\n",
794 (unsigned long)vma->vm_start,
795 (unsigned long)vma->vm_end - (unsigned long)vma->vm_start,
796 err);
797
798 return err;
799 }
800
801 static unsigned int soc_camera_poll(struct file *file, poll_table *pt)
802 {
803 struct soc_camera_device *icd = file->private_data;
804 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
805 unsigned res = POLLERR;
806
807 if (icd->streamer != file)
808 return POLLERR;
809
810 mutex_lock(&ici->host_lock);
811 if (ici->ops->init_videobuf && list_empty(&icd->vb_vidq.stream))
812 dev_err(icd->pdev, "Trying to poll with no queued buffers!\n");
813 else
814 res = ici->ops->poll(file, pt);
815 mutex_unlock(&ici->host_lock);
816 return res;
817 }
818
819 void soc_camera_lock(struct vb2_queue *vq)
820 {
821 struct soc_camera_device *icd = vb2_get_drv_priv(vq);
822 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
823 mutex_lock(&ici->host_lock);
824 }
825 EXPORT_SYMBOL(soc_camera_lock);
826
827 void soc_camera_unlock(struct vb2_queue *vq)
828 {
829 struct soc_camera_device *icd = vb2_get_drv_priv(vq);
830 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
831 mutex_unlock(&ici->host_lock);
832 }
833 EXPORT_SYMBOL(soc_camera_unlock);
834
835 static struct v4l2_file_operations soc_camera_fops = {
836 .owner = THIS_MODULE,
837 .open = soc_camera_open,
838 .release = soc_camera_close,
839 .unlocked_ioctl = video_ioctl2,
840 .read = soc_camera_read,
841 .mmap = soc_camera_mmap,
842 .poll = soc_camera_poll,
843 };
844
845 static int soc_camera_s_fmt_vid_cap(struct file *file, void *priv,
846 struct v4l2_format *f)
847 {
848 struct soc_camera_device *icd = file->private_data;
849 int ret;
850
851 WARN_ON(priv != file->private_data);
852
853 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
854 dev_warn(icd->pdev, "Wrong buf-type %d\n", f->type);
855 return -EINVAL;
856 }
857
858 if (icd->streamer && icd->streamer != file)
859 return -EBUSY;
860
861 if (is_streaming(to_soc_camera_host(icd->parent), icd)) {
862 dev_err(icd->pdev, "S_FMT denied: queue initialised\n");
863 return -EBUSY;
864 }
865
866 ret = soc_camera_set_fmt(icd, f);
867
868 if (!ret && !icd->streamer)
869 icd->streamer = file;
870
871 return ret;
872 }
873
874 static int soc_camera_enum_fmt_vid_cap(struct file *file, void *priv,
875 struct v4l2_fmtdesc *f)
876 {
877 struct soc_camera_device *icd = file->private_data;
878 const struct soc_mbus_pixelfmt *format;
879
880 WARN_ON(priv != file->private_data);
881
882 if (f->index >= icd->num_user_formats)
883 return -EINVAL;
884
885 format = icd->user_formats[f->index].host_fmt;
886
887 if (format->name)
888 strlcpy(f->description, format->name, sizeof(f->description));
889 f->pixelformat = format->fourcc;
890 return 0;
891 }
892
893 static int soc_camera_g_fmt_vid_cap(struct file *file, void *priv,
894 struct v4l2_format *f)
895 {
896 struct soc_camera_device *icd = file->private_data;
897 struct v4l2_pix_format *pix = &f->fmt.pix;
898
899 WARN_ON(priv != file->private_data);
900
901 if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
902 return -EINVAL;
903
904 pix->width = icd->user_width;
905 pix->height = icd->user_height;
906 pix->bytesperline = icd->bytesperline;
907 pix->sizeimage = icd->sizeimage;
908 pix->field = icd->field;
909 pix->pixelformat = icd->current_fmt->host_fmt->fourcc;
910 pix->colorspace = icd->colorspace;
911 dev_dbg(icd->pdev, "current_fmt->fourcc: 0x%08x\n",
912 icd->current_fmt->host_fmt->fourcc);
913 return 0;
914 }
915
916 static int soc_camera_querycap(struct file *file, void *priv,
917 struct v4l2_capability *cap)
918 {
919 struct soc_camera_device *icd = file->private_data;
920 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
921
922 WARN_ON(priv != file->private_data);
923
924 strlcpy(cap->driver, ici->drv_name, sizeof(cap->driver));
925 return ici->ops->querycap(ici, cap);
926 }
927
928 static int soc_camera_streamon(struct file *file, void *priv,
929 enum v4l2_buf_type i)
930 {
931 struct soc_camera_device *icd = file->private_data;
932 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
933 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
934 int ret;
935
936 WARN_ON(priv != file->private_data);
937
938 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
939 return -EINVAL;
940
941 if (icd->streamer != file)
942 return -EBUSY;
943
944 /* This calls buf_queue from host driver's videobuf_queue_ops */
945 if (ici->ops->init_videobuf)
946 ret = videobuf_streamon(&icd->vb_vidq);
947 else
948 ret = vb2_streamon(&icd->vb2_vidq, i);
949
950 if (!ret)
951 v4l2_subdev_call(sd, video, s_stream, 1);
952
953 return ret;
954 }
955
956 static int soc_camera_streamoff(struct file *file, void *priv,
957 enum v4l2_buf_type i)
958 {
959 struct soc_camera_device *icd = file->private_data;
960 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
961 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
962
963 WARN_ON(priv != file->private_data);
964
965 if (i != V4L2_BUF_TYPE_VIDEO_CAPTURE)
966 return -EINVAL;
967
968 if (icd->streamer != file)
969 return -EBUSY;
970
971 /*
972 * This calls buf_release from host driver's videobuf_queue_ops for all
973 * remaining buffers. When the last buffer is freed, stop capture
974 */
975 if (ici->ops->init_videobuf)
976 videobuf_streamoff(&icd->vb_vidq);
977 else
978 vb2_streamoff(&icd->vb2_vidq, i);
979
980 v4l2_subdev_call(sd, video, s_stream, 0);
981
982 return 0;
983 }
984
985 static int soc_camera_cropcap(struct file *file, void *fh,
986 struct v4l2_cropcap *a)
987 {
988 struct soc_camera_device *icd = file->private_data;
989 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
990
991 return ici->ops->cropcap(icd, a);
992 }
993
994 static int soc_camera_g_crop(struct file *file, void *fh,
995 struct v4l2_crop *a)
996 {
997 struct soc_camera_device *icd = file->private_data;
998 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
999 int ret;
1000
1001 ret = ici->ops->get_crop(icd, a);
1002
1003 return ret;
1004 }
1005
1006 /*
1007 * According to the V4L2 API, drivers shall not update the struct v4l2_crop
1008 * argument with the actual geometry, instead, the user shall use G_CROP to
1009 * retrieve it.
1010 */
1011 static int soc_camera_s_crop(struct file *file, void *fh,
1012 const struct v4l2_crop *a)
1013 {
1014 struct soc_camera_device *icd = file->private_data;
1015 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1016 const struct v4l2_rect *rect = &a->c;
1017 struct v4l2_crop current_crop;
1018 int ret;
1019
1020 if (a->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1021 return -EINVAL;
1022
1023 dev_dbg(icd->pdev, "S_CROP(%ux%u@%u:%u)\n",
1024 rect->width, rect->height, rect->left, rect->top);
1025
1026 current_crop.type = a->type;
1027
1028 /* If get_crop fails, we'll let host and / or client drivers decide */
1029 ret = ici->ops->get_crop(icd, &current_crop);
1030
1031 /* Prohibit window size change with initialised buffers */
1032 if (ret < 0) {
1033 dev_err(icd->pdev,
1034 "S_CROP denied: getting current crop failed\n");
1035 } else if ((a->c.width == current_crop.c.width &&
1036 a->c.height == current_crop.c.height) ||
1037 !is_streaming(ici, icd)) {
1038 /* same size or not streaming - use .set_crop() */
1039 ret = ici->ops->set_crop(icd, a);
1040 } else if (ici->ops->set_livecrop) {
1041 ret = ici->ops->set_livecrop(icd, a);
1042 } else {
1043 dev_err(icd->pdev,
1044 "S_CROP denied: queue initialised and sizes differ\n");
1045 ret = -EBUSY;
1046 }
1047
1048 return ret;
1049 }
1050
1051 static int soc_camera_g_selection(struct file *file, void *fh,
1052 struct v4l2_selection *s)
1053 {
1054 struct soc_camera_device *icd = file->private_data;
1055 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1056
1057 /* With a wrong type no need to try to fall back to cropping */
1058 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
1059 return -EINVAL;
1060
1061 if (!ici->ops->get_selection)
1062 return -ENOTTY;
1063
1064 return ici->ops->get_selection(icd, s);
1065 }
1066
1067 static int soc_camera_s_selection(struct file *file, void *fh,
1068 struct v4l2_selection *s)
1069 {
1070 struct soc_camera_device *icd = file->private_data;
1071 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1072 int ret;
1073
1074 /* In all these cases cropping emulation will not help */
1075 if (s->type != V4L2_BUF_TYPE_VIDEO_CAPTURE ||
1076 (s->target != V4L2_SEL_TGT_COMPOSE &&
1077 s->target != V4L2_SEL_TGT_CROP))
1078 return -EINVAL;
1079
1080 if (s->target == V4L2_SEL_TGT_COMPOSE) {
1081 /* No output size change during a running capture! */
1082 if (is_streaming(ici, icd) &&
1083 (icd->user_width != s->r.width ||
1084 icd->user_height != s->r.height))
1085 return -EBUSY;
1086
1087 /*
1088 * Only one user is allowed to change the output format, touch
1089 * buffers, start / stop streaming, poll for data
1090 */
1091 if (icd->streamer && icd->streamer != file)
1092 return -EBUSY;
1093 }
1094
1095 if (!ici->ops->set_selection)
1096 return -ENOTTY;
1097
1098 ret = ici->ops->set_selection(icd, s);
1099 if (!ret &&
1100 s->target == V4L2_SEL_TGT_COMPOSE) {
1101 icd->user_width = s->r.width;
1102 icd->user_height = s->r.height;
1103 if (!icd->streamer)
1104 icd->streamer = file;
1105 }
1106
1107 return ret;
1108 }
1109
1110 static int soc_camera_g_parm(struct file *file, void *fh,
1111 struct v4l2_streamparm *a)
1112 {
1113 struct soc_camera_device *icd = file->private_data;
1114 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1115
1116 if (ici->ops->get_parm)
1117 return ici->ops->get_parm(icd, a);
1118
1119 return -ENOIOCTLCMD;
1120 }
1121
1122 static int soc_camera_s_parm(struct file *file, void *fh,
1123 struct v4l2_streamparm *a)
1124 {
1125 struct soc_camera_device *icd = file->private_data;
1126 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1127
1128 if (ici->ops->set_parm)
1129 return ici->ops->set_parm(icd, a);
1130
1131 return -ENOIOCTLCMD;
1132 }
1133
1134 static int soc_camera_probe(struct soc_camera_host *ici,
1135 struct soc_camera_device *icd);
1136
1137 /* So far this function cannot fail */
1138 static void scan_add_host(struct soc_camera_host *ici)
1139 {
1140 struct soc_camera_device *icd;
1141
1142 mutex_lock(&list_lock);
1143
1144 list_for_each_entry(icd, &devices, list)
1145 if (icd->iface == ici->nr) {
1146 struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
1147 struct soc_camera_subdev_desc *ssdd = &sdesc->subdev_desc;
1148
1149 /* The camera could have been already on, try to reset */
1150 if (ssdd->reset)
1151 ssdd->reset(icd->pdev);
1152
1153 icd->parent = ici->v4l2_dev.dev;
1154
1155 /* Ignore errors */
1156 soc_camera_probe(ici, icd);
1157 }
1158
1159 mutex_unlock(&list_lock);
1160 }
1161
1162 /*
1163 * It is invalid to call v4l2_clk_enable() after a successful probing
1164 * asynchronously outside of V4L2 operations, i.e. with .host_lock not held.
1165 */
1166 static int soc_camera_clk_enable(struct v4l2_clk *clk)
1167 {
1168 struct soc_camera_device *icd = clk->priv;
1169 struct soc_camera_host *ici;
1170 int ret;
1171
1172 if (!icd || !icd->parent)
1173 return -ENODEV;
1174
1175 ici = to_soc_camera_host(icd->parent);
1176
1177 if (!try_module_get(ici->ops->owner))
1178 return -ENODEV;
1179
1180 /*
1181 * If a different client is currently being probed, the host will tell
1182 * you to go
1183 */
1184 mutex_lock(&ici->clk_lock);
1185 ret = ici->ops->clock_start(ici);
1186 mutex_unlock(&ici->clk_lock);
1187 return ret;
1188 }
1189
1190 static void soc_camera_clk_disable(struct v4l2_clk *clk)
1191 {
1192 struct soc_camera_device *icd = clk->priv;
1193 struct soc_camera_host *ici;
1194
1195 if (!icd || !icd->parent)
1196 return;
1197
1198 ici = to_soc_camera_host(icd->parent);
1199
1200 mutex_lock(&ici->clk_lock);
1201 ici->ops->clock_stop(ici);
1202 mutex_unlock(&ici->clk_lock);
1203
1204 module_put(ici->ops->owner);
1205 }
1206
1207 /*
1208 * Eventually, it would be more logical to make the respective host the clock
1209 * owner, but then we would have to copy this struct for each ici. Besides, it
1210 * would introduce the circular dependency problem, unless we port all client
1211 * drivers to release the clock, when not in use.
1212 */
1213 static const struct v4l2_clk_ops soc_camera_clk_ops = {
1214 .owner = THIS_MODULE,
1215 .enable = soc_camera_clk_enable,
1216 .disable = soc_camera_clk_disable,
1217 };
1218
1219 static int soc_camera_dyn_pdev(struct soc_camera_desc *sdesc,
1220 struct soc_camera_async_client *sasc)
1221 {
1222 struct platform_device *pdev;
1223 int ret, i;
1224
1225 mutex_lock(&list_lock);
1226 i = find_first_zero_bit(device_map, MAP_MAX_NUM);
1227 if (i < MAP_MAX_NUM)
1228 set_bit(i, device_map);
1229 mutex_unlock(&list_lock);
1230 if (i >= MAP_MAX_NUM)
1231 return -ENOMEM;
1232
1233 pdev = platform_device_alloc("soc-camera-pdrv", i);
1234 if (!pdev)
1235 return -ENOMEM;
1236
1237 ret = platform_device_add_data(pdev, sdesc, sizeof(*sdesc));
1238 if (ret < 0) {
1239 platform_device_put(pdev);
1240 return ret;
1241 }
1242
1243 sasc->pdev = pdev;
1244
1245 return 0;
1246 }
1247
1248 static struct soc_camera_device *soc_camera_add_pdev(struct soc_camera_async_client *sasc)
1249 {
1250 struct platform_device *pdev = sasc->pdev;
1251 int ret;
1252
1253 ret = platform_device_add(pdev);
1254 if (ret < 0 || !pdev->dev.driver)
1255 return NULL;
1256
1257 return platform_get_drvdata(pdev);
1258 }
1259
1260 /* Locking: called with .host_lock held */
1261 static int soc_camera_probe_finish(struct soc_camera_device *icd)
1262 {
1263 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1264 struct v4l2_mbus_framefmt mf;
1265 int ret;
1266
1267 sd->grp_id = soc_camera_grp_id(icd);
1268 v4l2_set_subdev_hostdata(sd, icd);
1269
1270 ret = v4l2_ctrl_add_handler(&icd->ctrl_handler, sd->ctrl_handler, NULL);
1271 if (ret < 0)
1272 return ret;
1273
1274 ret = soc_camera_add_device(icd);
1275 if (ret < 0) {
1276 dev_err(icd->pdev, "Couldn't activate the camera: %d\n", ret);
1277 return ret;
1278 }
1279
1280 /* At this point client .probe() should have run already */
1281 ret = soc_camera_init_user_formats(icd);
1282 if (ret < 0)
1283 goto eusrfmt;
1284
1285 icd->field = V4L2_FIELD_ANY;
1286
1287 ret = soc_camera_video_start(icd);
1288 if (ret < 0)
1289 goto evidstart;
1290
1291 /* Try to improve our guess of a reasonable window format */
1292 if (!v4l2_subdev_call(sd, video, g_mbus_fmt, &mf)) {
1293 icd->user_width = mf.width;
1294 icd->user_height = mf.height;
1295 icd->colorspace = mf.colorspace;
1296 icd->field = mf.field;
1297 }
1298 soc_camera_remove_device(icd);
1299
1300 return 0;
1301
1302 evidstart:
1303 soc_camera_free_user_formats(icd);
1304 eusrfmt:
1305 soc_camera_remove_device(icd);
1306
1307 return ret;
1308 }
1309
1310 #ifdef CONFIG_I2C_BOARDINFO
1311 static int soc_camera_i2c_init(struct soc_camera_device *icd,
1312 struct soc_camera_desc *sdesc)
1313 {
1314 struct soc_camera_subdev_desc *ssdd;
1315 struct i2c_client *client;
1316 struct soc_camera_host *ici;
1317 struct soc_camera_host_desc *shd = &sdesc->host_desc;
1318 struct i2c_adapter *adap;
1319 struct v4l2_subdev *subdev;
1320 char clk_name[V4L2_SUBDEV_NAME_SIZE];
1321 int ret;
1322
1323 /* First find out how we link the main client */
1324 if (icd->sasc) {
1325 /* Async non-OF probing handled by the subdevice list */
1326 return -EPROBE_DEFER;
1327 }
1328
1329 ici = to_soc_camera_host(icd->parent);
1330 adap = i2c_get_adapter(shd->i2c_adapter_id);
1331 if (!adap) {
1332 dev_err(icd->pdev, "Cannot get I2C adapter #%d. No driver?\n",
1333 shd->i2c_adapter_id);
1334 return -ENODEV;
1335 }
1336
1337 ssdd = kzalloc(sizeof(*ssdd), GFP_KERNEL);
1338 if (!ssdd) {
1339 ret = -ENOMEM;
1340 goto ealloc;
1341 }
1342
1343 memcpy(ssdd, &sdesc->subdev_desc, sizeof(*ssdd));
1344 /*
1345 * In synchronous case we request regulators ourselves in
1346 * soc_camera_pdrv_probe(), make sure the subdevice driver doesn't try
1347 * to allocate them again.
1348 */
1349 ssdd->num_regulators = 0;
1350 ssdd->regulators = NULL;
1351 shd->board_info->platform_data = ssdd;
1352
1353 snprintf(clk_name, sizeof(clk_name), "%d-%04x",
1354 shd->i2c_adapter_id, shd->board_info->addr);
1355
1356 icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, "mclk", icd);
1357 if (IS_ERR(icd->clk)) {
1358 ret = PTR_ERR(icd->clk);
1359 goto eclkreg;
1360 }
1361
1362 subdev = v4l2_i2c_new_subdev_board(&ici->v4l2_dev, adap,
1363 shd->board_info, NULL);
1364 if (!subdev) {
1365 ret = -ENODEV;
1366 goto ei2cnd;
1367 }
1368
1369 client = v4l2_get_subdevdata(subdev);
1370
1371 /* Use to_i2c_client(dev) to recover the i2c client */
1372 icd->control = &client->dev;
1373
1374 return 0;
1375 ei2cnd:
1376 v4l2_clk_unregister(icd->clk);
1377 icd->clk = NULL;
1378 eclkreg:
1379 kfree(ssdd);
1380 ealloc:
1381 i2c_put_adapter(adap);
1382 return ret;
1383 }
1384
1385 static void soc_camera_i2c_free(struct soc_camera_device *icd)
1386 {
1387 struct i2c_client *client =
1388 to_i2c_client(to_soc_camera_control(icd));
1389 struct i2c_adapter *adap;
1390 struct soc_camera_subdev_desc *ssdd;
1391
1392 icd->control = NULL;
1393 if (icd->sasc)
1394 return;
1395
1396 adap = client->adapter;
1397 ssdd = client->dev.platform_data;
1398 v4l2_device_unregister_subdev(i2c_get_clientdata(client));
1399 i2c_unregister_device(client);
1400 i2c_put_adapter(adap);
1401 kfree(ssdd);
1402 v4l2_clk_unregister(icd->clk);
1403 icd->clk = NULL;
1404 }
1405
1406 /*
1407 * V4L2 asynchronous notifier callbacks. They are all called under a v4l2-async
1408 * internal global mutex, therefore cannot race against other asynchronous
1409 * events. Until notifier->complete() (soc_camera_async_complete()) is called,
1410 * the video device node is not registered and no V4L fops can occur. Unloading
1411 * of the host driver also calls a v4l2-async function, so also there we're
1412 * protected.
1413 */
1414 static int soc_camera_async_bound(struct v4l2_async_notifier *notifier,
1415 struct v4l2_subdev *sd,
1416 struct v4l2_async_subdev *asd)
1417 {
1418 struct soc_camera_async_client *sasc = container_of(notifier,
1419 struct soc_camera_async_client, notifier);
1420 struct soc_camera_device *icd = platform_get_drvdata(sasc->pdev);
1421
1422 if (asd == sasc->sensor && !WARN_ON(icd->control)) {
1423 struct i2c_client *client = v4l2_get_subdevdata(sd);
1424
1425 /*
1426 * Only now we get subdevice-specific information like
1427 * regulators, flags, callbacks, etc.
1428 */
1429 if (client) {
1430 struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
1431 struct soc_camera_subdev_desc *ssdd =
1432 soc_camera_i2c_to_desc(client);
1433 if (ssdd) {
1434 memcpy(&sdesc->subdev_desc, ssdd,
1435 sizeof(sdesc->subdev_desc));
1436 if (ssdd->reset)
1437 ssdd->reset(icd->pdev);
1438 }
1439
1440 icd->control = &client->dev;
1441 }
1442 }
1443
1444 return 0;
1445 }
1446
1447 static void soc_camera_async_unbind(struct v4l2_async_notifier *notifier,
1448 struct v4l2_subdev *sd,
1449 struct v4l2_async_subdev *asd)
1450 {
1451 struct soc_camera_async_client *sasc = container_of(notifier,
1452 struct soc_camera_async_client, notifier);
1453 struct soc_camera_device *icd = platform_get_drvdata(sasc->pdev);
1454
1455 if (icd->clk) {
1456 v4l2_clk_unregister(icd->clk);
1457 icd->clk = NULL;
1458 }
1459 }
1460
1461 static int soc_camera_async_complete(struct v4l2_async_notifier *notifier)
1462 {
1463 struct soc_camera_async_client *sasc = container_of(notifier,
1464 struct soc_camera_async_client, notifier);
1465 struct soc_camera_device *icd = platform_get_drvdata(sasc->pdev);
1466
1467 if (to_soc_camera_control(icd)) {
1468 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1469 int ret;
1470
1471 mutex_lock(&list_lock);
1472 ret = soc_camera_probe(ici, icd);
1473 mutex_unlock(&list_lock);
1474 if (ret < 0)
1475 return ret;
1476 }
1477
1478 return 0;
1479 }
1480
1481 static int scan_async_group(struct soc_camera_host *ici,
1482 struct v4l2_async_subdev **asd, unsigned int size)
1483 {
1484 struct soc_camera_async_subdev *sasd;
1485 struct soc_camera_async_client *sasc;
1486 struct soc_camera_device *icd;
1487 struct soc_camera_desc sdesc = {.host_desc.bus_id = ici->nr,};
1488 char clk_name[V4L2_SUBDEV_NAME_SIZE];
1489 unsigned int i;
1490 int ret;
1491
1492 /* First look for a sensor */
1493 for (i = 0; i < size; i++) {
1494 sasd = container_of(asd[i], struct soc_camera_async_subdev, asd);
1495 if (sasd->role == SOCAM_SUBDEV_DATA_SOURCE)
1496 break;
1497 }
1498
1499 if (i >= size || asd[i]->match_type != V4L2_ASYNC_MATCH_I2C) {
1500 /* All useless */
1501 dev_err(ici->v4l2_dev.dev, "No I2C data source found!\n");
1502 return -ENODEV;
1503 }
1504
1505 /* Or shall this be managed by the soc-camera device? */
1506 sasc = devm_kzalloc(ici->v4l2_dev.dev, sizeof(*sasc), GFP_KERNEL);
1507 if (!sasc)
1508 return -ENOMEM;
1509
1510 /* HACK: just need a != NULL */
1511 sdesc.host_desc.board_info = ERR_PTR(-ENODATA);
1512
1513 ret = soc_camera_dyn_pdev(&sdesc, sasc);
1514 if (ret < 0)
1515 return ret;
1516
1517 sasc->sensor = &sasd->asd;
1518
1519 icd = soc_camera_add_pdev(sasc);
1520 if (!icd) {
1521 platform_device_put(sasc->pdev);
1522 return -ENOMEM;
1523 }
1524
1525 sasc->notifier.subdevs = asd;
1526 sasc->notifier.num_subdevs = size;
1527 sasc->notifier.bound = soc_camera_async_bound;
1528 sasc->notifier.unbind = soc_camera_async_unbind;
1529 sasc->notifier.complete = soc_camera_async_complete;
1530
1531 icd->sasc = sasc;
1532 icd->parent = ici->v4l2_dev.dev;
1533
1534 snprintf(clk_name, sizeof(clk_name), "%d-%04x",
1535 sasd->asd.match.i2c.adapter_id, sasd->asd.match.i2c.address);
1536
1537 icd->clk = v4l2_clk_register(&soc_camera_clk_ops, clk_name, "mclk", icd);
1538 if (IS_ERR(icd->clk)) {
1539 ret = PTR_ERR(icd->clk);
1540 goto eclkreg;
1541 }
1542
1543 ret = v4l2_async_notifier_register(&ici->v4l2_dev, &sasc->notifier);
1544 if (!ret)
1545 return 0;
1546
1547 v4l2_clk_unregister(icd->clk);
1548 eclkreg:
1549 icd->clk = NULL;
1550 platform_device_unregister(sasc->pdev);
1551 dev_err(ici->v4l2_dev.dev, "group probe failed: %d\n", ret);
1552
1553 return ret;
1554 }
1555
1556 static void scan_async_host(struct soc_camera_host *ici)
1557 {
1558 struct v4l2_async_subdev **asd;
1559 int j;
1560
1561 for (j = 0, asd = ici->asd; ici->asd_sizes[j]; j++) {
1562 scan_async_group(ici, asd, ici->asd_sizes[j]);
1563 asd += ici->asd_sizes[j];
1564 }
1565 }
1566 #else
1567 #define soc_camera_i2c_init(icd, sdesc) (-ENODEV)
1568 #define soc_camera_i2c_free(icd) do {} while (0)
1569 #define scan_async_host(ici) do {} while (0)
1570 #endif
1571
1572 /* Called during host-driver probe */
1573 static int soc_camera_probe(struct soc_camera_host *ici,
1574 struct soc_camera_device *icd)
1575 {
1576 struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
1577 struct soc_camera_host_desc *shd = &sdesc->host_desc;
1578 struct device *control = NULL;
1579 int ret;
1580
1581 dev_info(icd->pdev, "Probing %s\n", dev_name(icd->pdev));
1582
1583 /*
1584 * Currently the subdev with the largest number of controls (13) is
1585 * ov6550. So let's pick 16 as a hint for the control handler. Note
1586 * that this is a hint only: too large and you waste some memory, too
1587 * small and there is a (very) small performance hit when looking up
1588 * controls in the internal hash.
1589 */
1590 ret = v4l2_ctrl_handler_init(&icd->ctrl_handler, 16);
1591 if (ret < 0)
1592 return ret;
1593
1594 /* Must have icd->vdev before registering the device */
1595 ret = video_dev_create(icd);
1596 if (ret < 0)
1597 goto evdc;
1598
1599 /*
1600 * ..._video_start() will create a device node, video_register_device()
1601 * itself is protected against concurrent open() calls, but we also have
1602 * to protect our data also during client probing.
1603 */
1604
1605 /* Non-i2c cameras, e.g., soc_camera_platform, have no board_info */
1606 if (shd->board_info) {
1607 ret = soc_camera_i2c_init(icd, sdesc);
1608 if (ret < 0 && ret != -EPROBE_DEFER)
1609 goto eadd;
1610 } else if (!shd->add_device || !shd->del_device) {
1611 ret = -EINVAL;
1612 goto eadd;
1613 } else {
1614 mutex_lock(&ici->clk_lock);
1615 ret = ici->ops->clock_start(ici);
1616 mutex_unlock(&ici->clk_lock);
1617 if (ret < 0)
1618 goto eadd;
1619
1620 if (shd->module_name)
1621 ret = request_module(shd->module_name);
1622
1623 ret = shd->add_device(icd);
1624 if (ret < 0)
1625 goto eadddev;
1626
1627 /*
1628 * FIXME: this is racy, have to use driver-binding notification,
1629 * when it is available
1630 */
1631 control = to_soc_camera_control(icd);
1632 if (!control || !control->driver || !dev_get_drvdata(control) ||
1633 !try_module_get(control->driver->owner)) {
1634 shd->del_device(icd);
1635 ret = -ENODEV;
1636 goto enodrv;
1637 }
1638 }
1639
1640 mutex_lock(&ici->host_lock);
1641 ret = soc_camera_probe_finish(icd);
1642 mutex_unlock(&ici->host_lock);
1643 if (ret < 0)
1644 goto efinish;
1645
1646 return 0;
1647
1648 efinish:
1649 if (shd->board_info) {
1650 soc_camera_i2c_free(icd);
1651 } else {
1652 shd->del_device(icd);
1653 module_put(control->driver->owner);
1654 enodrv:
1655 eadddev:
1656 mutex_lock(&ici->clk_lock);
1657 ici->ops->clock_stop(ici);
1658 mutex_unlock(&ici->clk_lock);
1659 }
1660 eadd:
1661 video_device_release(icd->vdev);
1662 icd->vdev = NULL;
1663 if (icd->vdev) {
1664 video_device_release(icd->vdev);
1665 icd->vdev = NULL;
1666 }
1667 evdc:
1668 v4l2_ctrl_handler_free(&icd->ctrl_handler);
1669 return ret;
1670 }
1671
1672 /*
1673 * This is called on device_unregister, which only means we have to disconnect
1674 * from the host, but not remove ourselves from the device list. With
1675 * asynchronous client probing this can also be called without
1676 * soc_camera_probe_finish() having run. Careful with clean up.
1677 */
1678 static int soc_camera_remove(struct soc_camera_device *icd)
1679 {
1680 struct soc_camera_desc *sdesc = to_soc_camera_desc(icd);
1681 struct video_device *vdev = icd->vdev;
1682
1683 v4l2_ctrl_handler_free(&icd->ctrl_handler);
1684 if (vdev) {
1685 video_unregister_device(vdev);
1686 icd->vdev = NULL;
1687 }
1688
1689 if (sdesc->host_desc.board_info) {
1690 soc_camera_i2c_free(icd);
1691 } else {
1692 struct device *dev = to_soc_camera_control(icd);
1693 struct device_driver *drv = dev ? dev->driver : NULL;
1694 if (drv) {
1695 sdesc->host_desc.del_device(icd);
1696 module_put(drv->owner);
1697 }
1698 }
1699
1700 if (icd->num_user_formats)
1701 soc_camera_free_user_formats(icd);
1702
1703 if (icd->clk) {
1704 /* For the synchronous case */
1705 v4l2_clk_unregister(icd->clk);
1706 icd->clk = NULL;
1707 }
1708
1709 if (icd->sasc)
1710 platform_device_unregister(icd->sasc->pdev);
1711
1712 return 0;
1713 }
1714
1715 static int default_cropcap(struct soc_camera_device *icd,
1716 struct v4l2_cropcap *a)
1717 {
1718 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1719 return v4l2_subdev_call(sd, video, cropcap, a);
1720 }
1721
1722 static int default_g_crop(struct soc_camera_device *icd, struct v4l2_crop *a)
1723 {
1724 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1725 return v4l2_subdev_call(sd, video, g_crop, a);
1726 }
1727
1728 static int default_s_crop(struct soc_camera_device *icd, const struct v4l2_crop *a)
1729 {
1730 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1731 return v4l2_subdev_call(sd, video, s_crop, a);
1732 }
1733
1734 static int default_g_parm(struct soc_camera_device *icd,
1735 struct v4l2_streamparm *parm)
1736 {
1737 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1738 return v4l2_subdev_call(sd, video, g_parm, parm);
1739 }
1740
1741 static int default_s_parm(struct soc_camera_device *icd,
1742 struct v4l2_streamparm *parm)
1743 {
1744 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1745 return v4l2_subdev_call(sd, video, s_parm, parm);
1746 }
1747
1748 static int default_enum_framesizes(struct soc_camera_device *icd,
1749 struct v4l2_frmsizeenum *fsize)
1750 {
1751 int ret;
1752 struct v4l2_subdev *sd = soc_camera_to_subdev(icd);
1753 const struct soc_camera_format_xlate *xlate;
1754 __u32 pixfmt = fsize->pixel_format;
1755 struct v4l2_frmsizeenum fsize_mbus = *fsize;
1756
1757 xlate = soc_camera_xlate_by_fourcc(icd, pixfmt);
1758 if (!xlate)
1759 return -EINVAL;
1760 /* map xlate-code to pixel_format, sensor only handle xlate-code*/
1761 fsize_mbus.pixel_format = xlate->code;
1762
1763 ret = v4l2_subdev_call(sd, video, enum_framesizes, &fsize_mbus);
1764 if (ret < 0)
1765 return ret;
1766
1767 *fsize = fsize_mbus;
1768 fsize->pixel_format = pixfmt;
1769
1770 return 0;
1771 }
1772
1773 int soc_camera_host_register(struct soc_camera_host *ici)
1774 {
1775 struct soc_camera_host *ix;
1776 int ret;
1777
1778 if (!ici || !ici->ops ||
1779 !ici->ops->try_fmt ||
1780 !ici->ops->set_fmt ||
1781 !ici->ops->set_bus_param ||
1782 !ici->ops->querycap ||
1783 ((!ici->ops->init_videobuf ||
1784 !ici->ops->reqbufs) &&
1785 !ici->ops->init_videobuf2) ||
1786 !ici->ops->clock_start ||
1787 !ici->ops->clock_stop ||
1788 !ici->ops->poll ||
1789 !ici->v4l2_dev.dev)
1790 return -EINVAL;
1791
1792 if (!ici->ops->set_crop)
1793 ici->ops->set_crop = default_s_crop;
1794 if (!ici->ops->get_crop)
1795 ici->ops->get_crop = default_g_crop;
1796 if (!ici->ops->cropcap)
1797 ici->ops->cropcap = default_cropcap;
1798 if (!ici->ops->set_parm)
1799 ici->ops->set_parm = default_s_parm;
1800 if (!ici->ops->get_parm)
1801 ici->ops->get_parm = default_g_parm;
1802 if (!ici->ops->enum_framesizes)
1803 ici->ops->enum_framesizes = default_enum_framesizes;
1804
1805 mutex_lock(&list_lock);
1806 list_for_each_entry(ix, &hosts, list) {
1807 if (ix->nr == ici->nr) {
1808 ret = -EBUSY;
1809 goto edevreg;
1810 }
1811 }
1812
1813 ret = v4l2_device_register(ici->v4l2_dev.dev, &ici->v4l2_dev);
1814 if (ret < 0)
1815 goto edevreg;
1816
1817 list_add_tail(&ici->list, &hosts);
1818 mutex_unlock(&list_lock);
1819
1820 mutex_init(&ici->host_lock);
1821 mutex_init(&ici->clk_lock);
1822
1823 if (ici->asd_sizes)
1824 /*
1825 * No OF, host with a list of subdevices. Don't try to mix
1826 * modes by initialising some groups statically and some
1827 * dynamically!
1828 */
1829 scan_async_host(ici);
1830 else
1831 /* Legacy: static platform devices from board data */
1832 scan_add_host(ici);
1833
1834 return 0;
1835
1836 edevreg:
1837 mutex_unlock(&list_lock);
1838 return ret;
1839 }
1840 EXPORT_SYMBOL(soc_camera_host_register);
1841
1842 /* Unregister all clients! */
1843 void soc_camera_host_unregister(struct soc_camera_host *ici)
1844 {
1845 struct soc_camera_device *icd, *tmp;
1846 struct soc_camera_async_client *sasc;
1847 LIST_HEAD(notifiers);
1848
1849 mutex_lock(&list_lock);
1850 list_del(&ici->list);
1851 list_for_each_entry(icd, &devices, list)
1852 if (icd->iface == ici->nr && icd->sasc) {
1853 /* as long as we hold the device, sasc won't be freed */
1854 get_device(icd->pdev);
1855 list_add(&icd->sasc->list, &notifiers);
1856 }
1857 mutex_unlock(&list_lock);
1858
1859 list_for_each_entry(sasc, &notifiers, list) {
1860 /* Must call unlocked to avoid AB-BA dead-lock */
1861 v4l2_async_notifier_unregister(&sasc->notifier);
1862 put_device(&sasc->pdev->dev);
1863 }
1864
1865 mutex_lock(&list_lock);
1866
1867 list_for_each_entry_safe(icd, tmp, &devices, list)
1868 if (icd->iface == ici->nr)
1869 soc_camera_remove(icd);
1870
1871 mutex_unlock(&list_lock);
1872
1873 v4l2_device_unregister(&ici->v4l2_dev);
1874 }
1875 EXPORT_SYMBOL(soc_camera_host_unregister);
1876
1877 /* Image capture device */
1878 static int soc_camera_device_register(struct soc_camera_device *icd)
1879 {
1880 struct soc_camera_device *ix;
1881 int num = -1, i;
1882
1883 mutex_lock(&list_lock);
1884 for (i = 0; i < 256 && num < 0; i++) {
1885 num = i;
1886 /* Check if this index is available on this interface */
1887 list_for_each_entry(ix, &devices, list) {
1888 if (ix->iface == icd->iface && ix->devnum == i) {
1889 num = -1;
1890 break;
1891 }
1892 }
1893 }
1894
1895 if (num < 0) {
1896 /*
1897 * ok, we have 256 cameras on this host...
1898 * man, stay reasonable...
1899 */
1900 mutex_unlock(&list_lock);
1901 return -ENOMEM;
1902 }
1903
1904 icd->devnum = num;
1905 icd->use_count = 0;
1906 icd->host_priv = NULL;
1907
1908 /*
1909 * Dynamically allocated devices set the bit earlier, but it doesn't hurt setting
1910 * it again
1911 */
1912 i = to_platform_device(icd->pdev)->id;
1913 if (i < 0)
1914 /* One static (legacy) soc-camera platform device */
1915 i = 0;
1916 if (i >= MAP_MAX_NUM) {
1917 mutex_unlock(&list_lock);
1918 return -EBUSY;
1919 }
1920 set_bit(i, device_map);
1921 list_add_tail(&icd->list, &devices);
1922 mutex_unlock(&list_lock);
1923
1924 return 0;
1925 }
1926
1927 static const struct v4l2_ioctl_ops soc_camera_ioctl_ops = {
1928 .vidioc_querycap = soc_camera_querycap,
1929 .vidioc_try_fmt_vid_cap = soc_camera_try_fmt_vid_cap,
1930 .vidioc_g_fmt_vid_cap = soc_camera_g_fmt_vid_cap,
1931 .vidioc_s_fmt_vid_cap = soc_camera_s_fmt_vid_cap,
1932 .vidioc_enum_fmt_vid_cap = soc_camera_enum_fmt_vid_cap,
1933 .vidioc_enum_input = soc_camera_enum_input,
1934 .vidioc_g_input = soc_camera_g_input,
1935 .vidioc_s_input = soc_camera_s_input,
1936 .vidioc_s_std = soc_camera_s_std,
1937 .vidioc_g_std = soc_camera_g_std,
1938 .vidioc_enum_framesizes = soc_camera_enum_framesizes,
1939 .vidioc_reqbufs = soc_camera_reqbufs,
1940 .vidioc_querybuf = soc_camera_querybuf,
1941 .vidioc_qbuf = soc_camera_qbuf,
1942 .vidioc_dqbuf = soc_camera_dqbuf,
1943 .vidioc_create_bufs = soc_camera_create_bufs,
1944 .vidioc_prepare_buf = soc_camera_prepare_buf,
1945 .vidioc_streamon = soc_camera_streamon,
1946 .vidioc_streamoff = soc_camera_streamoff,
1947 .vidioc_cropcap = soc_camera_cropcap,
1948 .vidioc_g_crop = soc_camera_g_crop,
1949 .vidioc_s_crop = soc_camera_s_crop,
1950 .vidioc_g_selection = soc_camera_g_selection,
1951 .vidioc_s_selection = soc_camera_s_selection,
1952 .vidioc_g_parm = soc_camera_g_parm,
1953 .vidioc_s_parm = soc_camera_s_parm,
1954 };
1955
1956 static int video_dev_create(struct soc_camera_device *icd)
1957 {
1958 struct soc_camera_host *ici = to_soc_camera_host(icd->parent);
1959 struct video_device *vdev = video_device_alloc();
1960
1961 if (!vdev)
1962 return -ENOMEM;
1963
1964 strlcpy(vdev->name, ici->drv_name, sizeof(vdev->name));
1965
1966 vdev->v4l2_dev = &ici->v4l2_dev;
1967 vdev->fops = &soc_camera_fops;
1968 vdev->ioctl_ops = &soc_camera_ioctl_ops;
1969 vdev->release = video_device_release;
1970 vdev->ctrl_handler = &icd->ctrl_handler;
1971 vdev->lock = &ici->host_lock;
1972
1973 icd->vdev = vdev;
1974
1975 return 0;
1976 }
1977
1978 /*
1979 * Called from soc_camera_probe() above with .host_lock held
1980 */
1981 static int soc_camera_video_start(struct soc_camera_device *icd)
1982 {
1983 const struct device_type *type = icd->vdev->dev.type;
1984 int ret;
1985
1986 if (!icd->parent)
1987 return -ENODEV;
1988
1989 video_set_drvdata(icd->vdev, icd);
1990 ret = video_register_device(icd->vdev, VFL_TYPE_GRABBER, -1);
1991 if (ret < 0) {
1992 dev_err(icd->pdev, "video_register_device failed: %d\n", ret);
1993 return ret;
1994 }
1995
1996 /* Restore device type, possibly set by the subdevice driver */
1997 icd->vdev->dev.type = type;
1998
1999 return 0;
2000 }
2001
2002 static int soc_camera_pdrv_probe(struct platform_device *pdev)
2003 {
2004 struct soc_camera_desc *sdesc = pdev->dev.platform_data;
2005 struct soc_camera_subdev_desc *ssdd = &sdesc->subdev_desc;
2006 struct soc_camera_device *icd;
2007 int ret;
2008
2009 if (!sdesc)
2010 return -EINVAL;
2011
2012 icd = devm_kzalloc(&pdev->dev, sizeof(*icd), GFP_KERNEL);
2013 if (!icd)
2014 return -ENOMEM;
2015
2016 /*
2017 * In the asynchronous case ssdd->num_regulators == 0 yet, so, the below
2018 * regulator allocation is a dummy. They are actually requested by the
2019 * subdevice driver, using soc_camera_power_init(). Also note, that in
2020 * that case regulators are attached to the I2C device and not to the
2021 * camera platform device.
2022 */
2023 ret = devm_regulator_bulk_get(&pdev->dev, ssdd->num_regulators,
2024 ssdd->regulators);
2025 if (ret < 0)
2026 return ret;
2027
2028 icd->iface = sdesc->host_desc.bus_id;
2029 icd->sdesc = sdesc;
2030 icd->pdev = &pdev->dev;
2031 platform_set_drvdata(pdev, icd);
2032
2033 icd->user_width = DEFAULT_WIDTH;
2034 icd->user_height = DEFAULT_HEIGHT;
2035
2036 return soc_camera_device_register(icd);
2037 }
2038
2039 /*
2040 * Only called on rmmod for each platform device, since they are not
2041 * hot-pluggable. Now we know, that all our users - hosts and devices have
2042 * been unloaded already
2043 */
2044 static int soc_camera_pdrv_remove(struct platform_device *pdev)
2045 {
2046 struct soc_camera_device *icd = platform_get_drvdata(pdev);
2047 int i;
2048
2049 if (!icd)
2050 return -EINVAL;
2051
2052 i = pdev->id;
2053 if (i < 0)
2054 i = 0;
2055
2056 /*
2057 * In synchronous mode with static platform devices this is called in a
2058 * loop from drivers/base/dd.c::driver_detach(), no parallel execution,
2059 * no need to lock. In asynchronous case the caller -
2060 * soc_camera_host_unregister() - already holds the lock
2061 */
2062 if (test_bit(i, device_map)) {
2063 clear_bit(i, device_map);
2064 list_del(&icd->list);
2065 }
2066
2067 return 0;
2068 }
2069
2070 static struct platform_driver __refdata soc_camera_pdrv = {
2071 .probe = soc_camera_pdrv_probe,
2072 .remove = soc_camera_pdrv_remove,
2073 .driver = {
2074 .name = "soc-camera-pdrv",
2075 .owner = THIS_MODULE,
2076 },
2077 };
2078
2079 module_platform_driver(soc_camera_pdrv);
2080
2081 MODULE_DESCRIPTION("Image capture bus driver");
2082 MODULE_AUTHOR("Guennadi Liakhovetski <kernel@pengutronix.de>");
2083 MODULE_LICENSE("GPL");
2084 MODULE_ALIAS("platform:soc-camera-pdrv");
Linux with added FPC-III support