2 * S5P/EXYNOS4 SoC series camera host interface media device driver
4 * Copyright (C) 2011 Samsung Electronics Co., Ltd.
5 * Contact: Sylwester Nawrocki, <s.nawrocki@samsung.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published
9 * by the Free Software Foundation, either version 2 of the License,
10 * or (at your option) any later version.
13 #include <linux/bug.h>
14 #include <linux/device.h>
15 #include <linux/errno.h>
16 #include <linux/i2c.h>
17 #include <linux/kernel.h>
18 #include <linux/list.h>
19 #include <linux/module.h>
20 #include <linux/platform_device.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/types.h>
23 #include <linux/slab.h>
24 #include <media/v4l2-ctrls.h>
25 #include <media/media-device.h>
26 #include <media/s5p_fimc.h>
28 #include "fimc-core.h"
29 #include "fimc-lite.h"
30 #include "fimc-mdevice.h"
31 #include "mipi-csis.h"
33 static int __fimc_md_set_camclk(struct fimc_md *fmd,
34 struct fimc_sensor_info *s_info,
37 * fimc_pipeline_prepare - update pipeline information with subdevice pointers
38 * @fimc: fimc device terminating the pipeline
40 * Caller holds the graph mutex.
42 static void fimc_pipeline_prepare(struct fimc_pipeline *p,
43 struct media_entity *me)
45 struct media_pad *pad = &me->pads[0];
46 struct v4l2_subdev *sd;
49 for (i = 0; i < IDX_MAX; i++)
53 if (!(pad->flags & MEDIA_PAD_FL_SINK))
57 pad = media_entity_remote_source(pad);
59 media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
62 sd = media_entity_to_v4l2_subdev(pad->entity);
66 p->subdevs[IDX_SENSOR] = sd;
69 p->subdevs[IDX_CSIS] = sd;
72 p->subdevs[IDX_FLITE] = sd;
75 /* No need to control FIMC subdev through subdev ops */
78 pr_warn("%s: Unknown subdev grp_id: %#x\n",
79 __func__, sd->grp_id);
82 pad = &sd->entity.pads[0];
87 * __subdev_set_power - change power state of a single subdev
88 * @sd: subdevice to change power state for
89 * @on: 1 to enable power or 0 to disable
91 * Return result of s_power subdev operation or -ENXIO if sd argument
92 * is NULL. Return 0 if the subdevice does not implement s_power.
94 static int __subdev_set_power(struct v4l2_subdev *sd, int on)
102 use_count = &sd->entity.use_count;
103 if (on && (*use_count)++ > 0)
105 else if (!on && (*use_count == 0 || --(*use_count) > 0))
107 ret = v4l2_subdev_call(sd, core, s_power, on);
109 return ret != -ENOIOCTLCMD ? ret : 0;
113 * fimc_pipeline_s_power - change power state of all pipeline subdevs
114 * @fimc: fimc device terminating the pipeline
115 * @state: true to power on, false to power off
117 * Needs to be called with the graph mutex held.
119 static int fimc_pipeline_s_power(struct fimc_pipeline *p, bool state)
124 if (p->subdevs[IDX_SENSOR] == NULL)
127 for (i = 0; i < IDX_MAX; i++) {
128 unsigned int idx = state ? (IDX_MAX - 1) - i : i;
130 ret = __subdev_set_power(p->subdevs[idx], state);
131 if (ret < 0 && ret != -ENXIO)
139 * __fimc_pipeline_open - update the pipeline information, enable power
140 * of all pipeline subdevs and the sensor clock
141 * @me: media entity to start graph walk with
142 * @prep: true to acquire sensor (and csis) subdevs
144 * This function must be called with the graph mutex held.
146 static int __fimc_pipeline_open(struct fimc_pipeline *p,
147 struct media_entity *me, bool prep)
152 fimc_pipeline_prepare(p, me);
154 if (p->subdevs[IDX_SENSOR] == NULL)
157 ret = fimc_md_set_camclk(p->subdevs[IDX_SENSOR], true);
161 return fimc_pipeline_s_power(p, 1);
164 static int fimc_pipeline_open(struct fimc_pipeline *p,
165 struct media_entity *me, bool prep)
169 mutex_lock(&me->parent->graph_mutex);
170 ret = __fimc_pipeline_open(p, me, prep);
171 mutex_unlock(&me->parent->graph_mutex);
177 * __fimc_pipeline_close - disable the sensor clock and pipeline power
178 * @fimc: fimc device terminating the pipeline
180 * Disable power of all subdevs in the pipeline and turn off the external
182 * Called with the graph mutex held.
184 static int __fimc_pipeline_close(struct fimc_pipeline *p)
188 if (p->subdevs[IDX_SENSOR]) {
189 ret = fimc_pipeline_s_power(p, 0);
190 fimc_md_set_camclk(p->subdevs[IDX_SENSOR], false);
192 return ret == -ENXIO ? 0 : ret;
195 static int fimc_pipeline_close(struct fimc_pipeline *p)
197 struct media_entity *me;
200 if (!p || !p->subdevs[IDX_SENSOR])
203 me = &p->subdevs[IDX_SENSOR]->entity;
204 mutex_lock(&me->parent->graph_mutex);
205 ret = __fimc_pipeline_close(p);
206 mutex_unlock(&me->parent->graph_mutex);
212 * fimc_pipeline_s_stream - invoke s_stream on pipeline subdevs
213 * @pipeline: video pipeline structure
214 * @on: passed as the s_stream call argument
216 static int fimc_pipeline_s_stream(struct fimc_pipeline *p, bool on)
220 if (p->subdevs[IDX_SENSOR] == NULL)
223 for (i = 0; i < IDX_MAX; i++) {
224 unsigned int idx = on ? (IDX_MAX - 1) - i : i;
226 ret = v4l2_subdev_call(p->subdevs[idx], video, s_stream, on);
228 if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
236 /* Media pipeline operations for the FIMC/FIMC-LITE video device driver */
237 static const struct fimc_pipeline_ops fimc_pipeline_ops = {
238 .open = fimc_pipeline_open,
239 .close = fimc_pipeline_close,
240 .set_stream = fimc_pipeline_s_stream,
244 * Sensor subdevice helper functions
246 static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,
247 struct fimc_sensor_info *s_info)
249 struct i2c_adapter *adapter;
250 struct v4l2_subdev *sd = NULL;
255 adapter = i2c_get_adapter(s_info->pdata.i2c_bus_num);
257 v4l2_warn(&fmd->v4l2_dev,
258 "Failed to get I2C adapter %d, deferring probe\n",
259 s_info->pdata.i2c_bus_num);
260 return ERR_PTR(-EPROBE_DEFER);
262 sd = v4l2_i2c_new_subdev_board(&fmd->v4l2_dev, adapter,
263 s_info->pdata.board_info, NULL);
264 if (IS_ERR_OR_NULL(sd)) {
265 i2c_put_adapter(adapter);
266 v4l2_warn(&fmd->v4l2_dev,
267 "Failed to acquire subdev %s, deferring probe\n",
268 s_info->pdata.board_info->type);
269 return ERR_PTR(-EPROBE_DEFER);
271 v4l2_set_subdev_hostdata(sd, s_info);
272 sd->grp_id = SENSOR_GROUP_ID;
274 v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s\n",
275 s_info->pdata.board_info->type);
279 static void fimc_md_unregister_sensor(struct v4l2_subdev *sd)
281 struct i2c_client *client = v4l2_get_subdevdata(sd);
282 struct i2c_adapter *adapter;
286 v4l2_device_unregister_subdev(sd);
287 adapter = client->adapter;
288 i2c_unregister_device(client);
290 i2c_put_adapter(adapter);
293 static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
295 struct s5p_platform_fimc *pdata = fmd->pdev->dev.platform_data;
296 struct fimc_dev *fd = NULL;
297 int num_clients, ret, i;
300 * Runtime resume one of the FIMC entities to make sure
301 * the sclk_cam clocks are not globally disabled.
303 for (i = 0; !fd && i < ARRAY_SIZE(fmd->fimc); i++)
308 ret = pm_runtime_get_sync(&fd->pdev->dev);
312 WARN_ON(pdata->num_clients > ARRAY_SIZE(fmd->sensor));
313 num_clients = min_t(u32, pdata->num_clients, ARRAY_SIZE(fmd->sensor));
315 fmd->num_sensors = num_clients;
316 for (i = 0; i < num_clients; i++) {
317 struct v4l2_subdev *sd;
319 fmd->sensor[i].pdata = pdata->isp_info[i];
320 ret = __fimc_md_set_camclk(fmd, &fmd->sensor[i], true);
323 sd = fimc_md_register_sensor(fmd, &fmd->sensor[i]);
324 ret = __fimc_md_set_camclk(fmd, &fmd->sensor[i], false);
327 fmd->sensor[i].subdev = sd;
329 fmd->sensor[i].subdev = NULL;
336 pm_runtime_put(&fd->pdev->dev);
341 * MIPI CSIS and FIMC platform devices registration.
343 static int fimc_register_callback(struct device *dev, void *p)
345 struct fimc_dev *fimc = dev_get_drvdata(dev);
346 struct v4l2_subdev *sd;
347 struct fimc_md *fmd = p;
350 if (fimc == NULL || fimc->id >= FIMC_MAX_DEVS)
353 sd = &fimc->vid_cap.subdev;
354 sd->grp_id = FIMC_GROUP_ID;
355 v4l2_set_subdev_hostdata(sd, (void *)&fimc_pipeline_ops);
357 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
359 v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.%d (%d)\n",
364 fmd->fimc[fimc->id] = fimc;
368 static int fimc_lite_register_callback(struct device *dev, void *p)
370 struct fimc_lite *fimc = dev_get_drvdata(dev);
371 struct fimc_md *fmd = p;
374 if (fimc == NULL || fimc->index >= FIMC_LITE_MAX_DEVS)
377 fimc->subdev.grp_id = FLITE_GROUP_ID;
378 v4l2_set_subdev_hostdata(&fimc->subdev, (void *)&fimc_pipeline_ops);
380 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, &fimc->subdev);
382 v4l2_err(&fmd->v4l2_dev,
383 "Failed to register FIMC-LITE.%d (%d)\n",
388 fmd->fimc_lite[fimc->index] = fimc;
392 static int csis_register_callback(struct device *dev, void *p)
394 struct v4l2_subdev *sd = dev_get_drvdata(dev);
395 struct platform_device *pdev;
396 struct fimc_md *fmd = p;
401 pdev = v4l2_get_subdevdata(sd);
402 if (!pdev || pdev->id < 0 || pdev->id >= CSIS_MAX_ENTITIES)
404 v4l2_info(sd, "csis%d sd: %s\n", pdev->id, sd->name);
406 id = pdev->id < 0 ? 0 : pdev->id;
407 sd->grp_id = CSIS_GROUP_ID;
409 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
411 fmd->csis[id].sd = sd;
413 v4l2_err(&fmd->v4l2_dev,
414 "Failed to register CSIS subdevice: %d\n", ret);
419 * fimc_md_register_platform_entities - register FIMC and CSIS media entities
421 static int fimc_md_register_platform_entities(struct fimc_md *fmd)
423 struct s5p_platform_fimc *pdata = fmd->pdev->dev.platform_data;
424 struct device_driver *driver;
427 driver = driver_find(FIMC_MODULE_NAME, &platform_bus_type);
429 v4l2_warn(&fmd->v4l2_dev,
430 "%s driver not found, deffering probe\n",
432 return -EPROBE_DEFER;
435 ret = driver_for_each_device(driver, NULL, fmd,
436 fimc_register_callback);
440 driver = driver_find(FIMC_LITE_DRV_NAME, &platform_bus_type);
441 if (driver && try_module_get(driver->owner)) {
442 ret = driver_for_each_device(driver, NULL, fmd,
443 fimc_lite_register_callback);
446 module_put(driver->owner);
449 * Check if there is any sensor on the MIPI-CSI2 bus and
450 * if not skip the s5p-csis module loading.
454 for (i = 0; i < pdata->num_clients; i++) {
455 if (pdata->isp_info[i].bus_type == FIMC_MIPI_CSI2) {
463 driver = driver_find(CSIS_DRIVER_NAME, &platform_bus_type);
464 if (!driver || !try_module_get(driver->owner)) {
465 v4l2_warn(&fmd->v4l2_dev,
466 "%s driver not found, deffering probe\n",
468 return -EPROBE_DEFER;
471 return driver_for_each_device(driver, NULL, fmd,
472 csis_register_callback);
475 static void fimc_md_unregister_entities(struct fimc_md *fmd)
479 for (i = 0; i < FIMC_MAX_DEVS; i++) {
480 if (fmd->fimc[i] == NULL)
482 v4l2_device_unregister_subdev(&fmd->fimc[i]->vid_cap.subdev);
483 fmd->fimc[i]->pipeline_ops = NULL;
486 for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) {
487 if (fmd->fimc_lite[i] == NULL)
489 v4l2_device_unregister_subdev(&fmd->fimc_lite[i]->subdev);
490 fmd->fimc[i]->pipeline_ops = NULL;
491 fmd->fimc_lite[i] = NULL;
493 for (i = 0; i < CSIS_MAX_ENTITIES; i++) {
494 if (fmd->csis[i].sd == NULL)
496 v4l2_device_unregister_subdev(fmd->csis[i].sd);
497 module_put(fmd->csis[i].sd->owner);
498 fmd->csis[i].sd = NULL;
500 for (i = 0; i < fmd->num_sensors; i++) {
501 if (fmd->sensor[i].subdev == NULL)
503 fimc_md_unregister_sensor(fmd->sensor[i].subdev);
504 fmd->sensor[i].subdev = NULL;
509 * __fimc_md_create_fimc_links - create links to all FIMC entities
510 * @fmd: fimc media device
511 * @source: the source entity to create links to all fimc entities from
512 * @sensor: sensor subdev linked to FIMC[fimc_id] entity, may be null
513 * @pad: the source entity pad index
514 * @link_mask: bitmask of the fimc devices for which link should be enabled
516 static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
517 struct media_entity *source,
518 struct v4l2_subdev *sensor,
519 int pad, int link_mask)
521 struct fimc_sensor_info *s_info;
522 struct media_entity *sink;
523 unsigned int flags = 0;
526 for (i = 0; i < FIMC_MAX_DEVS; i++) {
530 * Some FIMC variants are not fitted with camera capture
531 * interface. Skip creating a link from sensor for those.
533 if (!fmd->fimc[i]->variant->has_cam_if)
536 flags = ((1 << i) & link_mask) ? MEDIA_LNK_FL_ENABLED : 0;
538 sink = &fmd->fimc[i]->vid_cap.subdev.entity;
539 ret = media_entity_create_link(source, pad, sink,
540 FIMC_SD_PAD_SINK, flags);
544 /* Notify FIMC capture subdev entity */
545 ret = media_entity_call(sink, link_setup, &sink->pads[0],
546 &source->pads[pad], flags);
550 v4l2_info(&fmd->v4l2_dev, "created link [%s] %c> [%s]\n",
551 source->name, flags ? '=' : '-', sink->name);
553 if (flags == 0 || sensor == NULL)
555 s_info = v4l2_get_subdev_hostdata(sensor);
556 if (!WARN_ON(s_info == NULL)) {
557 unsigned long irq_flags;
558 spin_lock_irqsave(&fmd->slock, irq_flags);
559 s_info->host = fmd->fimc[i];
560 spin_unlock_irqrestore(&fmd->slock, irq_flags);
564 for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) {
565 if (!fmd->fimc_lite[i])
568 if (link_mask & (1 << (i + FIMC_MAX_DEVS)))
569 flags = MEDIA_LNK_FL_ENABLED;
573 sink = &fmd->fimc_lite[i]->subdev.entity;
574 ret = media_entity_create_link(source, pad, sink,
575 FLITE_SD_PAD_SINK, flags);
579 /* Notify FIMC-LITE subdev entity */
580 ret = media_entity_call(sink, link_setup, &sink->pads[0],
581 &source->pads[pad], flags);
585 v4l2_info(&fmd->v4l2_dev, "created link [%s] %c> [%s]",
586 source->name, flags ? '=' : '-', sink->name);
591 /* Create links from FIMC-LITE source pads to other entities */
592 static int __fimc_md_create_flite_source_links(struct fimc_md *fmd)
594 struct media_entity *source, *sink;
595 unsigned int flags = MEDIA_LNK_FL_ENABLED;
598 for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) {
599 struct fimc_lite *fimc = fmd->fimc_lite[i];
602 source = &fimc->subdev.entity;
603 sink = &fimc->vfd.entity;
604 /* FIMC-LITE's subdev and video node */
605 ret = media_entity_create_link(source, FIMC_SD_PAD_SOURCE,
609 /* TODO: create links to other entities */
616 * fimc_md_create_links - create default links between registered entities
618 * Parallel interface sensor entities are connected directly to FIMC capture
619 * entities. The sensors using MIPI CSIS bus are connected through immutable
620 * link with CSI receiver entity specified by mux_id. Any registered CSIS
621 * entity has a link to each registered FIMC capture entity. Enabled links
622 * are created by default between each subsequent registered sensor and
623 * subsequent FIMC capture entity. The number of default active links is
624 * determined by the number of available sensors or FIMC entities,
627 static int fimc_md_create_links(struct fimc_md *fmd)
629 struct v4l2_subdev *csi_sensors[2] = { NULL };
630 struct v4l2_subdev *sensor, *csis;
631 struct s5p_fimc_isp_info *pdata;
632 struct fimc_sensor_info *s_info;
633 struct media_entity *source, *sink;
634 int i, pad, fimc_id = 0, ret = 0;
635 u32 flags, link_mask = 0;
637 for (i = 0; i < fmd->num_sensors; i++) {
638 if (fmd->sensor[i].subdev == NULL)
641 sensor = fmd->sensor[i].subdev;
642 s_info = v4l2_get_subdev_hostdata(sensor);
647 pdata = &s_info->pdata;
649 switch (pdata->bus_type) {
651 if (WARN(pdata->mux_id >= CSIS_MAX_ENTITIES,
652 "Wrong CSI channel id: %d\n", pdata->mux_id))
655 csis = fmd->csis[pdata->mux_id].sd;
656 if (WARN(csis == NULL,
657 "MIPI-CSI interface specified "
658 "but s5p-csis module is not loaded!\n"))
661 ret = media_entity_create_link(&sensor->entity, 0,
662 &csis->entity, CSIS_PAD_SINK,
663 MEDIA_LNK_FL_IMMUTABLE |
664 MEDIA_LNK_FL_ENABLED);
668 v4l2_info(&fmd->v4l2_dev, "created link [%s] => [%s]",
669 sensor->entity.name, csis->entity.name);
672 csi_sensors[pdata->mux_id] = sensor;
675 case FIMC_ITU_601...FIMC_ITU_656:
676 source = &sensor->entity;
681 v4l2_err(&fmd->v4l2_dev, "Wrong bus_type: %x\n",
688 link_mask = 1 << fimc_id++;
689 ret = __fimc_md_create_fimc_sink_links(fmd, source, sensor,
693 for (i = 0; i < ARRAY_SIZE(fmd->csis); i++) {
694 if (fmd->csis[i].sd == NULL)
696 source = &fmd->csis[i].sd->entity;
697 pad = CSIS_PAD_SOURCE;
698 sensor = csi_sensors[i];
700 link_mask = 1 << fimc_id++;
701 ret = __fimc_md_create_fimc_sink_links(fmd, source, sensor,
705 /* Create immutable links between each FIMC's subdev and video node */
706 flags = MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED;
707 for (i = 0; i < FIMC_MAX_DEVS; i++) {
710 source = &fmd->fimc[i]->vid_cap.subdev.entity;
711 sink = &fmd->fimc[i]->vid_cap.vfd.entity;
712 ret = media_entity_create_link(source, FIMC_SD_PAD_SOURCE,
718 return __fimc_md_create_flite_source_links(fmd);
722 * The peripheral sensor clock management.
724 static int fimc_md_get_clocks(struct fimc_md *fmd)
730 for (i = 0; i < FIMC_MAX_CAMCLKS; i++) {
731 snprintf(clk_name, sizeof(clk_name), "sclk_cam%u", i);
732 clock = clk_get(NULL, clk_name);
733 if (IS_ERR_OR_NULL(clock)) {
734 v4l2_err(&fmd->v4l2_dev, "Failed to get clock: %s",
738 fmd->camclk[i].clock = clock;
743 static void fimc_md_put_clocks(struct fimc_md *fmd)
745 int i = FIMC_MAX_CAMCLKS;
748 if (IS_ERR_OR_NULL(fmd->camclk[i].clock))
750 clk_put(fmd->camclk[i].clock);
751 fmd->camclk[i].clock = NULL;
755 static int __fimc_md_set_camclk(struct fimc_md *fmd,
756 struct fimc_sensor_info *s_info,
759 struct s5p_fimc_isp_info *pdata = &s_info->pdata;
760 struct fimc_camclk_info *camclk;
763 if (WARN_ON(pdata->clk_id >= FIMC_MAX_CAMCLKS) || fmd == NULL)
766 camclk = &fmd->camclk[pdata->clk_id];
768 dbg("camclk %d, f: %lu, use_count: %d, on: %d",
769 pdata->clk_id, pdata->clk_frequency, camclk->use_count, on);
772 if (camclk->use_count > 0 &&
773 camclk->frequency != pdata->clk_frequency)
776 if (camclk->use_count++ == 0) {
777 clk_set_rate(camclk->clock, pdata->clk_frequency);
778 camclk->frequency = pdata->clk_frequency;
779 ret = clk_enable(camclk->clock);
780 dbg("Enabled camclk %d: f: %lu", pdata->clk_id,
781 clk_get_rate(camclk->clock));
786 if (WARN_ON(camclk->use_count == 0))
789 if (--camclk->use_count == 0) {
790 clk_disable(camclk->clock);
791 dbg("Disabled camclk %d", pdata->clk_id);
797 * fimc_md_set_camclk - peripheral sensor clock setup
798 * @sd: sensor subdev to configure sclk_cam clock for
799 * @on: 1 to enable or 0 to disable the clock
801 * There are 2 separate clock outputs available in the SoC for external
802 * image processors. These clocks are shared between all registered FIMC
803 * devices to which sensors can be attached, either directly or through
804 * the MIPI CSI receiver. The clock is allowed here to be used by
805 * multiple sensors concurrently if they use same frequency.
806 * This function should only be called when the graph mutex is held.
808 int fimc_md_set_camclk(struct v4l2_subdev *sd, bool on)
810 struct fimc_sensor_info *s_info = v4l2_get_subdev_hostdata(sd);
811 struct fimc_md *fmd = entity_to_fimc_mdev(&sd->entity);
813 return __fimc_md_set_camclk(fmd, s_info, on);
816 static int fimc_md_link_notify(struct media_pad *source,
817 struct media_pad *sink, u32 flags)
819 struct fimc_lite *fimc_lite = NULL;
820 struct fimc_dev *fimc = NULL;
821 struct fimc_pipeline *pipeline;
822 struct v4l2_subdev *sd;
825 if (media_entity_type(sink->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
828 sd = media_entity_to_v4l2_subdev(sink->entity);
830 switch (sd->grp_id) {
832 fimc_lite = v4l2_get_subdevdata(sd);
833 pipeline = &fimc_lite->pipeline;
836 fimc = v4l2_get_subdevdata(sd);
837 pipeline = &fimc->pipeline;
843 if (!(flags & MEDIA_LNK_FL_ENABLED)) {
844 ret = __fimc_pipeline_close(pipeline);
845 pipeline->subdevs[IDX_SENSOR] = NULL;
846 pipeline->subdevs[IDX_CSIS] = NULL;
849 mutex_lock(&fimc->lock);
850 fimc_ctrls_delete(fimc->vid_cap.ctx);
851 mutex_unlock(&fimc->lock);
856 * Link activation. Enable power of pipeline elements only if the
857 * pipeline is already in use, i.e. its video node is opened.
858 * Recreate the controls destroyed during the link deactivation.
861 mutex_lock(&fimc->lock);
862 if (fimc->vid_cap.refcnt > 0) {
863 ret = __fimc_pipeline_open(pipeline,
864 source->entity, true);
866 ret = fimc_capture_ctrls_create(fimc);
868 mutex_unlock(&fimc->lock);
870 mutex_lock(&fimc_lite->lock);
871 if (fimc_lite->ref_count > 0) {
872 ret = __fimc_pipeline_open(pipeline,
873 source->entity, true);
875 mutex_unlock(&fimc_lite->lock);
877 return ret ? -EPIPE : ret;
880 static ssize_t fimc_md_sysfs_show(struct device *dev,
881 struct device_attribute *attr, char *buf)
883 struct platform_device *pdev = to_platform_device(dev);
884 struct fimc_md *fmd = platform_get_drvdata(pdev);
886 if (fmd->user_subdev_api)
887 return strlcpy(buf, "Sub-device API (sub-dev)\n", PAGE_SIZE);
889 return strlcpy(buf, "V4L2 video node only API (vid-dev)\n", PAGE_SIZE);
892 static ssize_t fimc_md_sysfs_store(struct device *dev,
893 struct device_attribute *attr,
894 const char *buf, size_t count)
896 struct platform_device *pdev = to_platform_device(dev);
897 struct fimc_md *fmd = platform_get_drvdata(pdev);
901 if (!strcmp(buf, "vid-dev\n"))
903 else if (!strcmp(buf, "sub-dev\n"))
908 fmd->user_subdev_api = subdev_api;
909 for (i = 0; i < FIMC_MAX_DEVS; i++)
911 fmd->fimc[i]->vid_cap.user_subdev_api = subdev_api;
915 * This device attribute is to select video pipeline configuration method.
916 * There are following valid values:
917 * vid-dev - for V4L2 video node API only, subdevice will be configured
918 * by the host driver.
919 * sub-dev - for media controller API, subdevs must be configured in user
920 * space before starting streaming.
922 static DEVICE_ATTR(subdev_conf_mode, S_IWUSR | S_IRUGO,
923 fimc_md_sysfs_show, fimc_md_sysfs_store);
925 static int fimc_md_probe(struct platform_device *pdev)
927 struct v4l2_device *v4l2_dev;
931 fmd = devm_kzalloc(&pdev->dev, sizeof(*fmd), GFP_KERNEL);
935 spin_lock_init(&fmd->slock);
938 strlcpy(fmd->media_dev.model, "SAMSUNG S5P FIMC",
939 sizeof(fmd->media_dev.model));
940 fmd->media_dev.link_notify = fimc_md_link_notify;
941 fmd->media_dev.dev = &pdev->dev;
943 v4l2_dev = &fmd->v4l2_dev;
944 v4l2_dev->mdev = &fmd->media_dev;
945 v4l2_dev->notify = fimc_sensor_notify;
946 snprintf(v4l2_dev->name, sizeof(v4l2_dev->name), "%s",
947 dev_name(&pdev->dev));
949 ret = v4l2_device_register(&pdev->dev, &fmd->v4l2_dev);
951 v4l2_err(v4l2_dev, "Failed to register v4l2_device: %d\n", ret);
954 ret = media_device_register(&fmd->media_dev);
956 v4l2_err(v4l2_dev, "Failed to register media device: %d\n", ret);
959 ret = fimc_md_get_clocks(fmd);
963 fmd->user_subdev_api = false;
965 /* Protect the media graph while we're registering entities */
966 mutex_lock(&fmd->media_dev.graph_mutex);
968 ret = fimc_md_register_platform_entities(fmd);
972 if (pdev->dev.platform_data) {
973 ret = fimc_md_register_sensor_entities(fmd);
977 ret = fimc_md_create_links(fmd);
980 ret = v4l2_device_register_subdev_nodes(&fmd->v4l2_dev);
984 ret = device_create_file(&pdev->dev, &dev_attr_subdev_conf_mode);
988 platform_set_drvdata(pdev, fmd);
989 mutex_unlock(&fmd->media_dev.graph_mutex);
993 mutex_unlock(&fmd->media_dev.graph_mutex);
995 media_device_unregister(&fmd->media_dev);
996 fimc_md_put_clocks(fmd);
997 fimc_md_unregister_entities(fmd);
999 v4l2_device_unregister(&fmd->v4l2_dev);
1003 static int fimc_md_remove(struct platform_device *pdev)
1005 struct fimc_md *fmd = platform_get_drvdata(pdev);
1009 device_remove_file(&pdev->dev, &dev_attr_subdev_conf_mode);
1010 fimc_md_unregister_entities(fmd);
1011 media_device_unregister(&fmd->media_dev);
1012 fimc_md_put_clocks(fmd);
1016 static struct platform_driver fimc_md_driver = {
1017 .probe = fimc_md_probe,
1018 .remove = fimc_md_remove,
1020 .name = "s5p-fimc-md",
1021 .owner = THIS_MODULE,
1025 static int __init fimc_md_init(void)
1029 request_module("s5p-csis");
1030 ret = fimc_register_driver();
1034 return platform_driver_register(&fimc_md_driver);
1037 static void __exit fimc_md_exit(void)
1039 platform_driver_unregister(&fimc_md_driver);
1040 fimc_unregister_driver();
1043 module_init(fimc_md_init);
1044 module_exit(fimc_md_exit);
1046 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
1047 MODULE_DESCRIPTION("S5P FIMC camera host interface/video postprocessor driver");
1048 MODULE_LICENSE("GPL");
1049 MODULE_VERSION("2.0.1");