?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rt2800: initialize BBP_R104 on proper subroutines
[linux/fpc-iii.git] / drivers / media / platform / exynos4-is / media-dev.c
blob15ef8f28239b797df583fa910720847cd4e14947
1 /*
2 * S5P/EXYNOS4 SoC series camera host interface media device driver
3 *
4 * Copyright (C) 2011 - 2012 Samsung Electronics Co., Ltd.
5 * Sylwester Nawrocki <s.nawrocki@samsung.com>
6 *
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.
11 */
12
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/of.h>
21 #include <linux/of_platform.h>
22 #include <linux/of_device.h>
23 #include <linux/of_i2c.h>
24 #include <linux/platform_device.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/types.h>
27 #include <linux/slab.h>
28 #include <media/v4l2-ctrls.h>
29 #include <media/v4l2-of.h>
30 #include <media/media-device.h>
31 #include <media/s5p_fimc.h>
32
33 #include "media-dev.h"
34 #include "fimc-core.h"
35 #include "fimc-is.h"
36 #include "fimc-lite.h"
37 #include "mipi-csis.h"
38
39 static int __fimc_md_set_camclk(struct fimc_md *fmd,
40 struct fimc_source_info *si,
41 bool on);
42 /**
43 * fimc_pipeline_prepare - update pipeline information with subdevice pointers
44 * @me: media entity terminating the pipeline
45 *
46 * Caller holds the graph mutex.
47 */
48 static void fimc_pipeline_prepare(struct fimc_pipeline *p,
49 struct media_entity *me)
50 {
51 struct v4l2_subdev *sd;
52 int i;
53
54 for (i = 0; i < IDX_MAX; i++)
55 p->subdevs[i] = NULL;
56
57 while (1) {
58 struct media_pad *pad = NULL;
59
60 /* Find remote source pad */
61 for (i = 0; i < me->num_pads; i++) {
62 struct media_pad *spad = &me->pads[i];
63 if (!(spad->flags & MEDIA_PAD_FL_SINK))
64 continue;
65 pad = media_entity_remote_source(spad);
66 if (pad)
67 break;
68 }
69
70 if (pad == NULL ||
71 media_entity_type(pad->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
72 break;
73 sd = media_entity_to_v4l2_subdev(pad->entity);
74
75 switch (sd->grp_id) {
76 case GRP_ID_FIMC_IS_SENSOR:
77 case GRP_ID_SENSOR:
78 p->subdevs[IDX_SENSOR] = sd;
79 break;
80 case GRP_ID_CSIS:
81 p->subdevs[IDX_CSIS] = sd;
82 break;
83 case GRP_ID_FLITE:
84 p->subdevs[IDX_FLITE] = sd;
85 break;
86 case GRP_ID_FIMC:
87 /* No need to control FIMC subdev through subdev ops */
88 break;
89 case GRP_ID_FIMC_IS:
90 p->subdevs[IDX_IS_ISP] = sd;
91 break;
92 default:
93 break;
94 }
95 me = &sd->entity;
96 if (me->num_pads == 1)
97 break;
98 }
99 }
100
101 /**
102 * __subdev_set_power - change power state of a single subdev
103 * @sd: subdevice to change power state for
104 * @on: 1 to enable power or 0 to disable
105 *
106 * Return result of s_power subdev operation or -ENXIO if sd argument
107 * is NULL. Return 0 if the subdevice does not implement s_power.
108 */
109 static int __subdev_set_power(struct v4l2_subdev *sd, int on)
110 {
111 int *use_count;
112 int ret;
113
114 if (sd == NULL)
115 return -ENXIO;
116
117 use_count = &sd->entity.use_count;
118 if (on && (*use_count)++ > 0)
119 return 0;
120 else if (!on && (*use_count == 0 || --(*use_count) > 0))
121 return 0;
122 ret = v4l2_subdev_call(sd, core, s_power, on);
123
124 return ret != -ENOIOCTLCMD ? ret : 0;
125 }
126
127 /**
128 * fimc_pipeline_s_power - change power state of all pipeline subdevs
129 * @fimc: fimc device terminating the pipeline
130 * @state: true to power on, false to power off
131 *
132 * Needs to be called with the graph mutex held.
133 */
134 static int fimc_pipeline_s_power(struct fimc_pipeline *p, bool on)
135 {
136 static const u8 seq[2][IDX_MAX - 1] = {
137 { IDX_IS_ISP, IDX_SENSOR, IDX_CSIS, IDX_FLITE },
138 { IDX_CSIS, IDX_FLITE, IDX_SENSOR, IDX_IS_ISP },
139 };
140 int i, ret = 0;
141
142 if (p->subdevs[IDX_SENSOR] == NULL)
143 return -ENXIO;
144
145 for (i = 0; i < IDX_MAX - 1; i++) {
146 unsigned int idx = seq[on][i];
147
148 ret = __subdev_set_power(p->subdevs[idx], on);
149
150
151 if (ret < 0 && ret != -ENXIO)
152 goto error;
153 }
154 return 0;
155 error:
156 for (; i >= 0; i--) {
157 unsigned int idx = seq[on][i];
158 __subdev_set_power(p->subdevs[idx], !on);
159 }
160 return ret;
161 }
162
163 /**
164 * __fimc_pipeline_open - update the pipeline information, enable power
165 * of all pipeline subdevs and the sensor clock
166 * @me: media entity to start graph walk with
167 * @prepare: true to walk the current pipeline and acquire all subdevs
168 *
169 * Called with the graph mutex held.
170 */
171 static int __fimc_pipeline_open(struct fimc_pipeline *p,
172 struct media_entity *me, bool prepare)
173 {
174 struct fimc_md *fmd = entity_to_fimc_mdev(me);
175 struct v4l2_subdev *sd;
176 int ret;
177
178 if (WARN_ON(p == NULL || me == NULL))
179 return -EINVAL;
180
181 if (prepare)
182 fimc_pipeline_prepare(p, me);
183
184 sd = p->subdevs[IDX_SENSOR];
185 if (sd == NULL)
186 return -EINVAL;
187
188 /* Disable PXLASYNC clock if this pipeline includes FIMC-IS */
189 if (!IS_ERR(fmd->wbclk[CLK_IDX_WB_B]) && p->subdevs[IDX_IS_ISP]) {
190 ret = clk_prepare_enable(fmd->wbclk[CLK_IDX_WB_B]);
191 if (ret < 0)
192 return ret;
193 }
194 ret = fimc_md_set_camclk(sd, true);
195 if (ret < 0)
196 goto err_wbclk;
197
198 ret = fimc_pipeline_s_power(p, 1);
199 if (!ret)
200 return 0;
201
202 fimc_md_set_camclk(sd, false);
203
204 err_wbclk:
205 if (!IS_ERR(fmd->wbclk[CLK_IDX_WB_B]) && p->subdevs[IDX_IS_ISP])
206 clk_disable_unprepare(fmd->wbclk[CLK_IDX_WB_B]);
207
208 return ret;
209 }
210
211 /**
212 * __fimc_pipeline_close - disable the sensor clock and pipeline power
213 * @fimc: fimc device terminating the pipeline
214 *
215 * Disable power of all subdevs and turn the external sensor clock off.
216 */
217 static int __fimc_pipeline_close(struct fimc_pipeline *p)
218 {
219 struct v4l2_subdev *sd = p ? p->subdevs[IDX_SENSOR] : NULL;
220 struct fimc_md *fmd;
221 int ret = 0;
222
223 if (WARN_ON(sd == NULL))
224 return -EINVAL;
225
226 if (p->subdevs[IDX_SENSOR]) {
227 ret = fimc_pipeline_s_power(p, 0);
228 fimc_md_set_camclk(sd, false);
229 }
230
231 fmd = entity_to_fimc_mdev(&sd->entity);
232
233 /* Disable PXLASYNC clock if this pipeline includes FIMC-IS */
234 if (!IS_ERR(fmd->wbclk[CLK_IDX_WB_B]) && p->subdevs[IDX_IS_ISP])
235 clk_disable_unprepare(fmd->wbclk[CLK_IDX_WB_B]);
236
237 return ret == -ENXIO ? 0 : ret;
238 }
239
240 /**
241 * __fimc_pipeline_s_stream - call s_stream() on pipeline subdevs
242 * @pipeline: video pipeline structure
243 * @on: passed as the s_stream() callback argument
244 */
245 static int __fimc_pipeline_s_stream(struct fimc_pipeline *p, bool on)
246 {
247 static const u8 seq[2][IDX_MAX] = {
248 { IDX_FIMC, IDX_SENSOR, IDX_IS_ISP, IDX_CSIS, IDX_FLITE },
249 { IDX_CSIS, IDX_FLITE, IDX_FIMC, IDX_SENSOR, IDX_IS_ISP },
250 };
251 int i, ret = 0;
252
253 if (p->subdevs[IDX_SENSOR] == NULL)
254 return -ENODEV;
255
256 for (i = 0; i < IDX_MAX; i++) {
257 unsigned int idx = seq[on][i];
258
259 ret = v4l2_subdev_call(p->subdevs[idx], video, s_stream, on);
260
261 if (ret < 0 && ret != -ENOIOCTLCMD && ret != -ENODEV)
262 goto error;
263 }
264 return 0;
265 error:
266 for (; i >= 0; i--) {
267 unsigned int idx = seq[on][i];
268 v4l2_subdev_call(p->subdevs[idx], video, s_stream, !on);
269 }
270 return ret;
271 }
272
273 /* Media pipeline operations for the FIMC/FIMC-LITE video device driver */
274 static const struct fimc_pipeline_ops fimc_pipeline_ops = {
275 .open = __fimc_pipeline_open,
276 .close = __fimc_pipeline_close,
277 .set_stream = __fimc_pipeline_s_stream,
278 };
279
280 /*
281 * Sensor subdevice helper functions
282 */
283 static struct v4l2_subdev *fimc_md_register_sensor(struct fimc_md *fmd,
284 struct fimc_source_info *si)
285 {
286 struct i2c_adapter *adapter;
287 struct v4l2_subdev *sd = NULL;
288
289 if (!si || !fmd)
290 return NULL;
291 /*
292 * If FIMC bus type is not Writeback FIFO assume it is same
293 * as sensor_bus_type.
294 */
295 si->fimc_bus_type = si->sensor_bus_type;
296
297 adapter = i2c_get_adapter(si->i2c_bus_num);
298 if (!adapter) {
299 v4l2_warn(&fmd->v4l2_dev,
300 "Failed to get I2C adapter %d, deferring probe\n",
301 si->i2c_bus_num);
302 return ERR_PTR(-EPROBE_DEFER);
303 }
304 sd = v4l2_i2c_new_subdev_board(&fmd->v4l2_dev, adapter,
305 si->board_info, NULL);
306 if (IS_ERR_OR_NULL(sd)) {
307 i2c_put_adapter(adapter);
308 v4l2_warn(&fmd->v4l2_dev,
309 "Failed to acquire subdev %s, deferring probe\n",
310 si->board_info->type);
311 return ERR_PTR(-EPROBE_DEFER);
312 }
313 v4l2_set_subdev_hostdata(sd, si);
314 sd->grp_id = GRP_ID_SENSOR;
315
316 v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice %s\n",
317 sd->name);
318 return sd;
319 }
320
321 static void fimc_md_unregister_sensor(struct v4l2_subdev *sd)
322 {
323 struct i2c_client *client = v4l2_get_subdevdata(sd);
324 struct i2c_adapter *adapter;
325
326 if (!client)
327 return;
328
329 v4l2_device_unregister_subdev(sd);
330
331 if (!client->dev.of_node) {
332 adapter = client->adapter;
333 i2c_unregister_device(client);
334 if (adapter)
335 i2c_put_adapter(adapter);
336 }
337 }
338
339 #ifdef CONFIG_OF
340 /* Register I2C client subdev associated with @node. */
341 static int fimc_md_of_add_sensor(struct fimc_md *fmd,
342 struct device_node *node, int index)
343 {
344 struct fimc_sensor_info *si;
345 struct i2c_client *client;
346 struct v4l2_subdev *sd;
347 int ret;
348
349 if (WARN_ON(index >= ARRAY_SIZE(fmd->sensor)))
350 return -EINVAL;
351 si = &fmd->sensor[index];
352
353 client = of_find_i2c_device_by_node(node);
354 if (!client)
355 return -EPROBE_DEFER;
356
357 device_lock(&client->dev);
358
359 if (!client->driver ||
360 !try_module_get(client->driver->driver.owner)) {
361 ret = -EPROBE_DEFER;
362 v4l2_info(&fmd->v4l2_dev, "No driver found for %s\n",
363 node->full_name);
364 goto dev_put;
365 }
366
367 /* Enable sensor's master clock */
368 ret = __fimc_md_set_camclk(fmd, &si->pdata, true);
369 if (ret < 0)
370 goto mod_put;
371 sd = i2c_get_clientdata(client);
372
373 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
374 __fimc_md_set_camclk(fmd, &si->pdata, false);
375 if (ret < 0)
376 goto mod_put;
377
378 v4l2_set_subdev_hostdata(sd, &si->pdata);
379 if (si->pdata.fimc_bus_type == FIMC_BUS_TYPE_ISP_WRITEBACK)
380 sd->grp_id = GRP_ID_FIMC_IS_SENSOR;
381 else
382 sd->grp_id = GRP_ID_SENSOR;
383
384 si->subdev = sd;
385 v4l2_info(&fmd->v4l2_dev, "Registered sensor subdevice: %s (%d)\n",
386 sd->name, fmd->num_sensors);
387 fmd->num_sensors++;
388
389 mod_put:
390 module_put(client->driver->driver.owner);
391 dev_put:
392 device_unlock(&client->dev);
393 put_device(&client->dev);
394 return ret;
395 }
396
397 /* Parse port node and register as a sub-device any sensor specified there. */
398 static int fimc_md_parse_port_node(struct fimc_md *fmd,
399 struct device_node *port,
400 unsigned int index)
401 {
402 struct device_node *rem, *ep, *np;
403 struct fimc_source_info *pd;
404 struct v4l2_of_endpoint endpoint;
405 int ret;
406 u32 val;
407
408 pd = &fmd->sensor[index].pdata;
409
410 /* Assume here a port node can have only one endpoint node. */
411 ep = of_get_next_child(port, NULL);
412 if (!ep)
413 return 0;
414
415 v4l2_of_parse_endpoint(ep, &endpoint);
416 if (WARN_ON(endpoint.port == 0) || index >= FIMC_MAX_SENSORS)
417 return -EINVAL;
418
419 pd->mux_id = (endpoint.port - 1) & 0x1;
420
421 rem = v4l2_of_get_remote_port_parent(ep);
422 of_node_put(ep);
423 if (rem == NULL) {
424 v4l2_info(&fmd->v4l2_dev, "Remote device at %s not found\n",
425 ep->full_name);
426 return 0;
427 }
428 if (!of_property_read_u32(rem, "samsung,camclk-out", &val))
429 pd->clk_id = val;
430
431 if (!of_property_read_u32(rem, "clock-frequency", &val))
432 pd->clk_frequency = val;
433
434 if (pd->clk_frequency == 0) {
435 v4l2_err(&fmd->v4l2_dev, "Wrong clock frequency at node %s\n",
436 rem->full_name);
437 of_node_put(rem);
438 return -EINVAL;
439 }
440
441 if (fimc_input_is_parallel(endpoint.port)) {
442 if (endpoint.bus_type == V4L2_MBUS_PARALLEL)
443 pd->sensor_bus_type = FIMC_BUS_TYPE_ITU_601;
444 else
445 pd->sensor_bus_type = FIMC_BUS_TYPE_ITU_656;
446 pd->flags = endpoint.bus.parallel.flags;
447 } else if (fimc_input_is_mipi_csi(endpoint.port)) {
448 /*
449 * MIPI CSI-2: only input mux selection and
450 * the sensor's clock frequency is needed.
451 */
452 pd->sensor_bus_type = FIMC_BUS_TYPE_MIPI_CSI2;
453 } else {
454 v4l2_err(&fmd->v4l2_dev, "Wrong port id (%u) at node %s\n",
455 endpoint.port, rem->full_name);
456 }
457 /*
458 * For FIMC-IS handled sensors, that are placed under i2c-isp device
459 * node, FIMC is connected to the FIMC-IS through its ISP Writeback
460 * input. Sensors are attached to the FIMC-LITE hostdata interface
461 * directly or through MIPI-CSIS, depending on the external media bus
462 * used. This needs to be handled in a more reliable way, not by just
463 * checking parent's node name.
464 */
465 np = of_get_parent(rem);
466
467 if (np && !of_node_cmp(np->name, "i2c-isp"))
468 pd->fimc_bus_type = FIMC_BUS_TYPE_ISP_WRITEBACK;
469 else
470 pd->fimc_bus_type = pd->sensor_bus_type;
471
472 ret = fimc_md_of_add_sensor(fmd, rem, index);
473 of_node_put(rem);
474
475 return ret;
476 }
477
478 /* Register all SoC external sub-devices */
479 static int fimc_md_of_sensors_register(struct fimc_md *fmd,
480 struct device_node *np)
481 {
482 struct device_node *parent = fmd->pdev->dev.of_node;
483 struct device_node *node, *ports;
484 int index = 0;
485 int ret;
486
487 /* Attach sensors linked to MIPI CSI-2 receivers */
488 for_each_available_child_of_node(parent, node) {
489 struct device_node *port;
490
491 if (of_node_cmp(node->name, "csis"))
492 continue;
493 /* The csis node can have only port subnode. */
494 port = of_get_next_child(node, NULL);
495 if (!port)
496 continue;
497
498 ret = fimc_md_parse_port_node(fmd, port, index);
499 if (ret < 0)
500 return ret;
501 index++;
502 }
503
504 /* Attach sensors listed in the parallel-ports node */
505 ports = of_get_child_by_name(parent, "parallel-ports");
506 if (!ports)
507 return 0;
508
509 for_each_child_of_node(ports, node) {
510 ret = fimc_md_parse_port_node(fmd, node, index);
511 if (ret < 0)
512 break;
513 index++;
514 }
515
516 return 0;
517 }
518
519 static int __of_get_csis_id(struct device_node *np)
520 {
521 u32 reg = 0;
522
523 np = of_get_child_by_name(np, "port");
524 if (!np)
525 return -EINVAL;
526 of_property_read_u32(np, "reg", &reg);
527 return reg - FIMC_INPUT_MIPI_CSI2_0;
528 }
529 #else
530 #define fimc_md_of_sensors_register(fmd, np) (-ENOSYS)
531 #define __of_get_csis_id(np) (-ENOSYS)
532 #endif
533
534 static int fimc_md_register_sensor_entities(struct fimc_md *fmd)
535 {
536 struct s5p_platform_fimc *pdata = fmd->pdev->dev.platform_data;
537 struct device_node *of_node = fmd->pdev->dev.of_node;
538 int num_clients = 0;
539 int ret, i;
540
541 /*
542 * Runtime resume one of the FIMC entities to make sure
543 * the sclk_cam clocks are not globally disabled.
544 */
545 if (!fmd->pmf)
546 return -ENXIO;
547
548 ret = pm_runtime_get_sync(fmd->pmf);
549 if (ret < 0)
550 return ret;
551
552 if (of_node) {
553 fmd->num_sensors = 0;
554 ret = fimc_md_of_sensors_register(fmd, of_node);
555 } else if (pdata) {
556 WARN_ON(pdata->num_clients > ARRAY_SIZE(fmd->sensor));
557 num_clients = min_t(u32, pdata->num_clients,
558 ARRAY_SIZE(fmd->sensor));
559 fmd->num_sensors = num_clients;
560
561 for (i = 0; i < num_clients; i++) {
562 struct fimc_sensor_info *si = &fmd->sensor[i];
563 struct v4l2_subdev *sd;
564
565 si->pdata = pdata->source_info[i];
566 ret = __fimc_md_set_camclk(fmd, &si->pdata, true);
567 if (ret)
568 break;
569 sd = fimc_md_register_sensor(fmd, &si->pdata);
570 ret = __fimc_md_set_camclk(fmd, &si->pdata, false);
571
572 if (IS_ERR(sd)) {
573 si->subdev = NULL;
574 ret = PTR_ERR(sd);
575 break;
576 }
577 si->subdev = sd;
578 if (ret)
579 break;
580 }
581 }
582
583 pm_runtime_put(fmd->pmf);
584 return ret;
585 }
586
587 /*
588 * MIPI-CSIS, FIMC and FIMC-LITE platform devices registration.
589 */
590
591 static int register_fimc_lite_entity(struct fimc_md *fmd,
592 struct fimc_lite *fimc_lite)
593 {
594 struct v4l2_subdev *sd;
595 int ret;
596
597 if (WARN_ON(fimc_lite->index >= FIMC_LITE_MAX_DEVS ||
598 fmd->fimc_lite[fimc_lite->index]))
599 return -EBUSY;
600
601 sd = &fimc_lite->subdev;
602 sd->grp_id = GRP_ID_FLITE;
603 v4l2_set_subdev_hostdata(sd, (void *)&fimc_pipeline_ops);
604
605 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
606 if (!ret)
607 fmd->fimc_lite[fimc_lite->index] = fimc_lite;
608 else
609 v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.LITE%d\n",
610 fimc_lite->index);
611 return ret;
612 }
613
614 static int register_fimc_entity(struct fimc_md *fmd, struct fimc_dev *fimc)
615 {
616 struct v4l2_subdev *sd;
617 int ret;
618
619 if (WARN_ON(fimc->id >= FIMC_MAX_DEVS || fmd->fimc[fimc->id]))
620 return -EBUSY;
621
622 sd = &fimc->vid_cap.subdev;
623 sd->grp_id = GRP_ID_FIMC;
624 v4l2_set_subdev_hostdata(sd, (void *)&fimc_pipeline_ops);
625
626 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
627 if (!ret) {
628 if (!fmd->pmf && fimc->pdev)
629 fmd->pmf = &fimc->pdev->dev;
630 fmd->fimc[fimc->id] = fimc;
631 fimc->vid_cap.user_subdev_api = fmd->user_subdev_api;
632 } else {
633 v4l2_err(&fmd->v4l2_dev, "Failed to register FIMC.%d (%d)\n",
634 fimc->id, ret);
635 }
636 return ret;
637 }
638
639 static int register_csis_entity(struct fimc_md *fmd,
640 struct platform_device *pdev,
641 struct v4l2_subdev *sd)
642 {
643 struct device_node *node = pdev->dev.of_node;
644 int id, ret;
645
646 id = node ? __of_get_csis_id(node) : max(0, pdev->id);
647
648 if (WARN_ON(id < 0 || id >= CSIS_MAX_ENTITIES))
649 return -ENOENT;
650
651 if (WARN_ON(fmd->csis[id].sd))
652 return -EBUSY;
653
654 sd->grp_id = GRP_ID_CSIS;
655 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
656 if (!ret)
657 fmd->csis[id].sd = sd;
658 else
659 v4l2_err(&fmd->v4l2_dev,
660 "Failed to register MIPI-CSIS.%d (%d)\n", id, ret);
661 return ret;
662 }
663
664 static int register_fimc_is_entity(struct fimc_md *fmd, struct fimc_is *is)
665 {
666 struct v4l2_subdev *sd = &is->isp.subdev;
667 int ret;
668
669 ret = v4l2_device_register_subdev(&fmd->v4l2_dev, sd);
670 if (ret) {
671 v4l2_err(&fmd->v4l2_dev,
672 "Failed to register FIMC-ISP (%d)\n", ret);
673 return ret;
674 }
675
676 fmd->fimc_is = is;
677 return 0;
678 }
679
680 static int fimc_md_register_platform_entity(struct fimc_md *fmd,
681 struct platform_device *pdev,
682 int plat_entity)
683 {
684 struct device *dev = &pdev->dev;
685 int ret = -EPROBE_DEFER;
686 void *drvdata;
687
688 /* Lock to ensure dev->driver won't change. */
689 device_lock(dev);
690
691 if (!dev->driver || !try_module_get(dev->driver->owner))
692 goto dev_unlock;
693
694 drvdata = dev_get_drvdata(dev);
695 /* Some subdev didn't probe succesfully id drvdata is NULL */
696 if (drvdata) {
697 switch (plat_entity) {
698 case IDX_FIMC:
699 ret = register_fimc_entity(fmd, drvdata);
700 break;
701 case IDX_FLITE:
702 ret = register_fimc_lite_entity(fmd, drvdata);
703 break;
704 case IDX_CSIS:
705 ret = register_csis_entity(fmd, pdev, drvdata);
706 break;
707 case IDX_IS_ISP:
708 ret = register_fimc_is_entity(fmd, drvdata);
709 break;
710 default:
711 ret = -ENODEV;
712 }
713 }
714
715 module_put(dev->driver->owner);
716 dev_unlock:
717 device_unlock(dev);
718 if (ret == -EPROBE_DEFER)
719 dev_info(&fmd->pdev->dev, "deferring %s device registration\n",
720 dev_name(dev));
721 else if (ret < 0)
722 dev_err(&fmd->pdev->dev, "%s device registration failed (%d)\n",
723 dev_name(dev), ret);
724 return ret;
725 }
726
727 static int fimc_md_pdev_match(struct device *dev, void *data)
728 {
729 struct platform_device *pdev = to_platform_device(dev);
730 int plat_entity = -1;
731 int ret;
732 char *p;
733
734 if (!get_device(dev))
735 return -ENODEV;
736
737 if (!strcmp(pdev->name, CSIS_DRIVER_NAME)) {
738 plat_entity = IDX_CSIS;
739 } else if (!strcmp(pdev->name, FIMC_LITE_DRV_NAME)) {
740 plat_entity = IDX_FLITE;
741 } else {
742 p = strstr(pdev->name, "fimc");
743 if (p && *(p + 4) == 0)
744 plat_entity = IDX_FIMC;
745 }
746
747 if (plat_entity >= 0)
748 ret = fimc_md_register_platform_entity(data, pdev,
749 plat_entity);
750 put_device(dev);
751 return 0;
752 }
753
754 /* Register FIMC, FIMC-LITE and CSIS media entities */
755 #ifdef CONFIG_OF
756 static int fimc_md_register_of_platform_entities(struct fimc_md *fmd,
757 struct device_node *parent)
758 {
759 struct device_node *node;
760 int ret = 0;
761
762 for_each_available_child_of_node(parent, node) {
763 struct platform_device *pdev;
764 int plat_entity = -1;
765
766 pdev = of_find_device_by_node(node);
767 if (!pdev)
768 continue;
769
770 /* If driver of any entity isn't ready try all again later. */
771 if (!strcmp(node->name, CSIS_OF_NODE_NAME))
772 plat_entity = IDX_CSIS;
773 else if (!strcmp(node->name, FIMC_IS_OF_NODE_NAME))
774 plat_entity = IDX_IS_ISP;
775 else if (!strcmp(node->name, FIMC_LITE_OF_NODE_NAME))
776 plat_entity = IDX_FLITE;
777 else if (!strcmp(node->name, FIMC_OF_NODE_NAME) &&
778 !of_property_read_bool(node, "samsung,lcd-wb"))
779 plat_entity = IDX_FIMC;
780
781 if (plat_entity >= 0)
782 ret = fimc_md_register_platform_entity(fmd, pdev,
783 plat_entity);
784 put_device(&pdev->dev);
785 if (ret < 0)
786 break;
787 }
788
789 return ret;
790 }
791 #else
792 #define fimc_md_register_of_platform_entities(fmd, node) (-ENOSYS)
793 #endif
794
795 static void fimc_md_unregister_entities(struct fimc_md *fmd)
796 {
797 int i;
798
799 for (i = 0; i < FIMC_MAX_DEVS; i++) {
800 if (fmd->fimc[i] == NULL)
801 continue;
802 v4l2_device_unregister_subdev(&fmd->fimc[i]->vid_cap.subdev);
803 fmd->fimc[i]->pipeline_ops = NULL;
804 fmd->fimc[i] = NULL;
805 }
806 for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) {
807 if (fmd->fimc_lite[i] == NULL)
808 continue;
809 v4l2_device_unregister_subdev(&fmd->fimc_lite[i]->subdev);
810 fmd->fimc_lite[i]->pipeline_ops = NULL;
811 fmd->fimc_lite[i] = NULL;
812 }
813 for (i = 0; i < CSIS_MAX_ENTITIES; i++) {
814 if (fmd->csis[i].sd == NULL)
815 continue;
816 v4l2_device_unregister_subdev(fmd->csis[i].sd);
817 fmd->csis[i].sd = NULL;
818 }
819 for (i = 0; i < fmd->num_sensors; i++) {
820 if (fmd->sensor[i].subdev == NULL)
821 continue;
822 fimc_md_unregister_sensor(fmd->sensor[i].subdev);
823 fmd->sensor[i].subdev = NULL;
824 }
825
826 if (fmd->fimc_is)
827 v4l2_device_unregister_subdev(&fmd->fimc_is->isp.subdev);
828
829 v4l2_info(&fmd->v4l2_dev, "Unregistered all entities\n");
830 }
831
832 /**
833 * __fimc_md_create_fimc_links - create links to all FIMC entities
834 * @fmd: fimc media device
835 * @source: the source entity to create links to all fimc entities from
836 * @sensor: sensor subdev linked to FIMC[fimc_id] entity, may be null
837 * @pad: the source entity pad index
838 * @link_mask: bitmask of the fimc devices for which link should be enabled
839 */
840 static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
841 struct media_entity *source,
842 struct v4l2_subdev *sensor,
843 int pad, int link_mask)
844 {
845 struct fimc_source_info *si = NULL;
846 struct media_entity *sink;
847 unsigned int flags = 0;
848 int i, ret = 0;
849
850 if (sensor) {
851 si = v4l2_get_subdev_hostdata(sensor);
852 /* Skip direct FIMC links in the logical FIMC-IS sensor path */
853 if (si && si->fimc_bus_type == FIMC_BUS_TYPE_ISP_WRITEBACK)
854 ret = 1;
855 }
856
857 for (i = 0; !ret && i < FIMC_MAX_DEVS; i++) {
858 if (!fmd->fimc[i])
859 continue;
860 /*
861 * Some FIMC variants are not fitted with camera capture
862 * interface. Skip creating a link from sensor for those.
863 */
864 if (!fmd->fimc[i]->variant->has_cam_if)
865 continue;
866
867 flags = ((1 << i) & link_mask) ? MEDIA_LNK_FL_ENABLED : 0;
868
869 sink = &fmd->fimc[i]->vid_cap.subdev.entity;
870 ret = media_entity_create_link(source, pad, sink,
871 FIMC_SD_PAD_SINK_CAM, flags);
872 if (ret)
873 return ret;
874
875 /* Notify FIMC capture subdev entity */
876 ret = media_entity_call(sink, link_setup, &sink->pads[0],
877 &source->pads[pad], flags);
878 if (ret)
879 break;
880
881 v4l2_info(&fmd->v4l2_dev, "created link [%s] %c> [%s]\n",
882 source->name, flags ? '=' : '-', sink->name);
883
884 if (flags == 0 || sensor == NULL)
885 continue;
886
887 if (!WARN_ON(si == NULL)) {
888 unsigned long irq_flags;
889 struct fimc_sensor_info *inf = source_to_sensor_info(si);
890
891 spin_lock_irqsave(&fmd->slock, irq_flags);
892 inf->host = fmd->fimc[i];
893 spin_unlock_irqrestore(&fmd->slock, irq_flags);
894 }
895 }
896
897 for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) {
898 if (!fmd->fimc_lite[i])
899 continue;
900
901 sink = &fmd->fimc_lite[i]->subdev.entity;
902 ret = media_entity_create_link(source, pad, sink,
903 FLITE_SD_PAD_SINK, 0);
904 if (ret)
905 return ret;
906
907 /* Notify FIMC-LITE subdev entity */
908 ret = media_entity_call(sink, link_setup, &sink->pads[0],
909 &source->pads[pad], 0);
910 if (ret)
911 break;
912
913 v4l2_info(&fmd->v4l2_dev, "created link [%s] -> [%s]\n",
914 source->name, sink->name);
915 }
916 return 0;
917 }
918
919 /* Create links from FIMC-LITE source pads to other entities */
920 static int __fimc_md_create_flite_source_links(struct fimc_md *fmd)
921 {
922 struct media_entity *source, *sink;
923 int i, ret = 0;
924
925 for (i = 0; i < FIMC_LITE_MAX_DEVS; i++) {
926 struct fimc_lite *fimc = fmd->fimc_lite[i];
927
928 if (fimc == NULL)
929 continue;
930
931 source = &fimc->subdev.entity;
932 sink = &fimc->vfd.entity;
933 /* FIMC-LITE's subdev and video node */
934 ret = media_entity_create_link(source, FLITE_SD_PAD_SOURCE_DMA,
935 sink, 0, 0);
936 if (ret)
937 break;
938 /* Link from FIMC-LITE to IS-ISP subdev */
939 sink = &fmd->fimc_is->isp.subdev.entity;
940 ret = media_entity_create_link(source, FLITE_SD_PAD_SOURCE_ISP,
941 sink, 0, 0);
942 if (ret)
943 break;
944 }
945
946 return ret;
947 }
948
949 /* Create FIMC-IS links */
950 static int __fimc_md_create_fimc_is_links(struct fimc_md *fmd)
951 {
952 struct media_entity *source, *sink;
953 int i, ret;
954
955 source = &fmd->fimc_is->isp.subdev.entity;
956
957 for (i = 0; i < FIMC_MAX_DEVS; i++) {
958 if (fmd->fimc[i] == NULL)
959 continue;
960
961 /* Link from IS-ISP subdev to FIMC */
962 sink = &fmd->fimc[i]->vid_cap.subdev.entity;
963 ret = media_entity_create_link(source, FIMC_ISP_SD_PAD_SRC_FIFO,
964 sink, FIMC_SD_PAD_SINK_FIFO, 0);
965 if (ret)
966 return ret;
967 }
968
969 return ret;
970 }
971
972 /**
973 * fimc_md_create_links - create default links between registered entities
974 *
975 * Parallel interface sensor entities are connected directly to FIMC capture
976 * entities. The sensors using MIPI CSIS bus are connected through immutable
977 * link with CSI receiver entity specified by mux_id. Any registered CSIS
978 * entity has a link to each registered FIMC capture entity. Enabled links
979 * are created by default between each subsequent registered sensor and
980 * subsequent FIMC capture entity. The number of default active links is
981 * determined by the number of available sensors or FIMC entities,
982 * whichever is less.
983 */
984 static int fimc_md_create_links(struct fimc_md *fmd)
985 {
986 struct v4l2_subdev *csi_sensors[CSIS_MAX_ENTITIES] = { NULL };
987 struct v4l2_subdev *sensor, *csis;
988 struct fimc_source_info *pdata;
989 struct media_entity *source, *sink;
990 int i, pad, fimc_id = 0, ret = 0;
991 u32 flags, link_mask = 0;
992
993 for (i = 0; i < fmd->num_sensors; i++) {
994 if (fmd->sensor[i].subdev == NULL)
995 continue;
996
997 sensor = fmd->sensor[i].subdev;
998 pdata = v4l2_get_subdev_hostdata(sensor);
999 if (!pdata)
1000 continue;
1001
1002 source = NULL;
1003
1004 switch (pdata->sensor_bus_type) {
1005 case FIMC_BUS_TYPE_MIPI_CSI2:
1006 if (WARN(pdata->mux_id >= CSIS_MAX_ENTITIES,
1007 "Wrong CSI channel id: %d\n", pdata->mux_id))
1008 return -EINVAL;
1009
1010 csis = fmd->csis[pdata->mux_id].sd;
1011 if (WARN(csis == NULL,
1012 "MIPI-CSI interface specified "
1013 "but s5p-csis module is not loaded!\n"))
1014 return -EINVAL;
1015
1016 pad = sensor->entity.num_pads - 1;
1017 ret = media_entity_create_link(&sensor->entity, pad,
1018 &csis->entity, CSIS_PAD_SINK,
1019 MEDIA_LNK_FL_IMMUTABLE |
1020 MEDIA_LNK_FL_ENABLED);
1021 if (ret)
1022 return ret;
1023
1024 v4l2_info(&fmd->v4l2_dev, "created link [%s] => [%s]\n",
1025 sensor->entity.name, csis->entity.name);
1026
1027 source = NULL;
1028 csi_sensors[pdata->mux_id] = sensor;
1029 break;
1030
1031 case FIMC_BUS_TYPE_ITU_601...FIMC_BUS_TYPE_ITU_656:
1032 source = &sensor->entity;
1033 pad = 0;
1034 break;
1035
1036 default:
1037 v4l2_err(&fmd->v4l2_dev, "Wrong bus_type: %x\n",
1038 pdata->sensor_bus_type);
1039 return -EINVAL;
1040 }
1041 if (source == NULL)
1042 continue;
1043
1044 link_mask = 1 << fimc_id++;
1045 ret = __fimc_md_create_fimc_sink_links(fmd, source, sensor,
1046 pad, link_mask);
1047 }
1048
1049 for (i = 0; i < CSIS_MAX_ENTITIES; i++) {
1050 if (fmd->csis[i].sd == NULL)
1051 continue;
1052
1053 source = &fmd->csis[i].sd->entity;
1054 pad = CSIS_PAD_SOURCE;
1055 sensor = csi_sensors[i];
1056
1057 link_mask = 1 << fimc_id++;
1058 ret = __fimc_md_create_fimc_sink_links(fmd, source, sensor,
1059 pad, link_mask);
1060 }
1061
1062 /* Create immutable links between each FIMC's subdev and video node */
1063 flags = MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED;
1064 for (i = 0; i < FIMC_MAX_DEVS; i++) {
1065 if (!fmd->fimc[i])
1066 continue;
1067
1068 source = &fmd->fimc[i]->vid_cap.subdev.entity;
1069 sink = &fmd->fimc[i]->vid_cap.vfd.entity;
1070
1071 ret = media_entity_create_link(source, FIMC_SD_PAD_SOURCE,
1072 sink, 0, flags);
1073 if (ret)
1074 break;
1075 }
1076
1077 ret = __fimc_md_create_flite_source_links(fmd);
1078 if (ret < 0)
1079 return ret;
1080
1081 if (fmd->use_isp)
1082 ret = __fimc_md_create_fimc_is_links(fmd);
1083
1084 return ret;
1085 }
1086
1087 /*
1088 * The peripheral sensor and CAM_BLK (PIXELASYNCMx) clocks management.
1089 */
1090 static void fimc_md_put_clocks(struct fimc_md *fmd)
1091 {
1092 int i = FIMC_MAX_CAMCLKS;
1093
1094 while (--i >= 0) {
1095 if (IS_ERR(fmd->camclk[i].clock))
1096 continue;
1097 clk_unprepare(fmd->camclk[i].clock);
1098 clk_put(fmd->camclk[i].clock);
1099 fmd->camclk[i].clock = ERR_PTR(-EINVAL);
1100 }
1101
1102 /* Writeback (PIXELASYNCMx) clocks */
1103 for (i = 0; i < FIMC_MAX_WBCLKS; i++) {
1104 if (IS_ERR(fmd->wbclk[i]))
1105 continue;
1106 clk_put(fmd->wbclk[i]);
1107 fmd->wbclk[i] = ERR_PTR(-EINVAL);
1108 }
1109 }
1110
1111 static int fimc_md_get_clocks(struct fimc_md *fmd)
1112 {
1113 struct device *dev = NULL;
1114 char clk_name[32];
1115 struct clk *clock;
1116 int ret, i;
1117
1118 for (i = 0; i < FIMC_MAX_CAMCLKS; i++)
1119 fmd->camclk[i].clock = ERR_PTR(-EINVAL);
1120
1121 if (fmd->pdev->dev.of_node)
1122 dev = &fmd->pdev->dev;
1123
1124 for (i = 0; i < FIMC_MAX_CAMCLKS; i++) {
1125 snprintf(clk_name, sizeof(clk_name), "sclk_cam%u", i);
1126 clock = clk_get(dev, clk_name);
1127
1128 if (IS_ERR(clock)) {
1129 dev_err(&fmd->pdev->dev, "Failed to get clock: %s\n",
1130 clk_name);
1131 ret = PTR_ERR(clock);
1132 break;
1133 }
1134 ret = clk_prepare(clock);
1135 if (ret < 0) {
1136 clk_put(clock);
1137 fmd->camclk[i].clock = ERR_PTR(-EINVAL);
1138 break;
1139 }
1140 fmd->camclk[i].clock = clock;
1141 }
1142 if (ret)
1143 fimc_md_put_clocks(fmd);
1144
1145 if (!fmd->use_isp)
1146 return 0;
1147 /*
1148 * For now get only PIXELASYNCM1 clock (Writeback B/ISP),
1149 * leave PIXELASYNCM0 out for the LCD Writeback driver.
1150 */
1151 fmd->wbclk[CLK_IDX_WB_A] = ERR_PTR(-EINVAL);
1152
1153 for (i = CLK_IDX_WB_B; i < FIMC_MAX_WBCLKS; i++) {
1154 snprintf(clk_name, sizeof(clk_name), "pxl_async%u", i);
1155 clock = clk_get(dev, clk_name);
1156 if (IS_ERR(clock)) {
1157 v4l2_err(&fmd->v4l2_dev, "Failed to get clock: %s\n",
1158 clk_name);
1159 ret = PTR_ERR(clock);
1160 break;
1161 }
1162 fmd->wbclk[i] = clock;
1163 }
1164 if (ret)
1165 fimc_md_put_clocks(fmd);
1166
1167 return ret;
1168 }
1169
1170 static int __fimc_md_set_camclk(struct fimc_md *fmd,
1171 struct fimc_source_info *si,
1172 bool on)
1173 {
1174 struct fimc_camclk_info *camclk;
1175 int ret = 0;
1176
1177 if (WARN_ON(si->clk_id >= FIMC_MAX_CAMCLKS) || !fmd || !fmd->pmf)
1178 return -EINVAL;
1179
1180 camclk = &fmd->camclk[si->clk_id];
1181
1182 dbg("camclk %d, f: %lu, use_count: %d, on: %d",
1183 si->clk_id, si->clk_frequency, camclk->use_count, on);
1184
1185 if (on) {
1186 if (camclk->use_count > 0 &&
1187 camclk->frequency != si->clk_frequency)
1188 return -EINVAL;
1189
1190 if (camclk->use_count++ == 0) {
1191 clk_set_rate(camclk->clock, si->clk_frequency);
1192 camclk->frequency = si->clk_frequency;
1193 ret = pm_runtime_get_sync(fmd->pmf);
1194 if (ret < 0)
1195 return ret;
1196 ret = clk_enable(camclk->clock);
1197 dbg("Enabled camclk %d: f: %lu", si->clk_id,
1198 clk_get_rate(camclk->clock));
1199 }
1200 return ret;
1201 }
1202
1203 if (WARN_ON(camclk->use_count == 0))
1204 return 0;
1205
1206 if (--camclk->use_count == 0) {
1207 clk_disable(camclk->clock);
1208 pm_runtime_put(fmd->pmf);
1209 dbg("Disabled camclk %d", si->clk_id);
1210 }
1211 return ret;
1212 }
1213
1214 /**
1215 * fimc_md_set_camclk - peripheral sensor clock setup
1216 * @sd: sensor subdev to configure sclk_cam clock for
1217 * @on: 1 to enable or 0 to disable the clock
1218 *
1219 * There are 2 separate clock outputs available in the SoC for external
1220 * image processors. These clocks are shared between all registered FIMC
1221 * devices to which sensors can be attached, either directly or through
1222 * the MIPI CSI receiver. The clock is allowed here to be used by
1223 * multiple sensors concurrently if they use same frequency.
1224 * This function should only be called when the graph mutex is held.
1225 */
1226 int fimc_md_set_camclk(struct v4l2_subdev *sd, bool on)
1227 {
1228 struct fimc_source_info *si = v4l2_get_subdev_hostdata(sd);
1229 struct fimc_md *fmd = entity_to_fimc_mdev(&sd->entity);
1230
1231 return __fimc_md_set_camclk(fmd, si, on);
1232 }
1233
1234 static int fimc_md_link_notify(struct media_pad *source,
1235 struct media_pad *sink, u32 flags)
1236 {
1237 struct fimc_lite *fimc_lite = NULL;
1238 struct fimc_dev *fimc = NULL;
1239 struct fimc_pipeline *pipeline;
1240 struct v4l2_subdev *sd;
1241 struct mutex *lock;
1242 int i, ret = 0;
1243 int ref_count;
1244
1245 if (media_entity_type(sink->entity) != MEDIA_ENT_T_V4L2_SUBDEV)
1246 return 0;
1247
1248 sd = media_entity_to_v4l2_subdev(sink->entity);
1249
1250 switch (sd->grp_id) {
1251 case GRP_ID_FLITE:
1252 fimc_lite = v4l2_get_subdevdata(sd);
1253 if (WARN_ON(fimc_lite == NULL))
1254 return 0;
1255 pipeline = &fimc_lite->pipeline;
1256 lock = &fimc_lite->lock;
1257 break;
1258 case GRP_ID_FIMC:
1259 fimc = v4l2_get_subdevdata(sd);
1260 if (WARN_ON(fimc == NULL))
1261 return 0;
1262 pipeline = &fimc->pipeline;
1263 lock = &fimc->lock;
1264 break;
1265 default:
1266 return 0;
1267 }
1268
1269 mutex_lock(lock);
1270 ref_count = fimc ? fimc->vid_cap.refcnt : fimc_lite->ref_count;
1271
1272 if (!(flags & MEDIA_LNK_FL_ENABLED)) {
1273 if (ref_count > 0) {
1274 ret = __fimc_pipeline_close(pipeline);
1275 if (!ret && fimc)
1276 fimc_ctrls_delete(fimc->vid_cap.ctx);
1277 }
1278 for (i = 0; i < IDX_MAX; i++)
1279 pipeline->subdevs[i] = NULL;
1280 } else if (ref_count > 0) {
1281 /*
1282 * Link activation. Enable power of pipeline elements only if
1283 * the pipeline is already in use, i.e. its video node is open.
1284 * Recreate the controls destroyed during the link deactivation.
1285 */
1286 ret = __fimc_pipeline_open(pipeline,
1287 source->entity, true);
1288 if (!ret && fimc)
1289 ret = fimc_capture_ctrls_create(fimc);
1290 }
1291
1292 mutex_unlock(lock);
1293 return ret ? -EPIPE : ret;
1294 }
1295
1296 static ssize_t fimc_md_sysfs_show(struct device *dev,
1297 struct device_attribute *attr, char *buf)
1298 {
1299 struct platform_device *pdev = to_platform_device(dev);
1300 struct fimc_md *fmd = platform_get_drvdata(pdev);
1301
1302 if (fmd->user_subdev_api)
1303 return strlcpy(buf, "Sub-device API (sub-dev)\n", PAGE_SIZE);
1304
1305 return strlcpy(buf, "V4L2 video node only API (vid-dev)\n", PAGE_SIZE);
1306 }
1307
1308 static ssize_t fimc_md_sysfs_store(struct device *dev,
1309 struct device_attribute *attr,
1310 const char *buf, size_t count)
1311 {
1312 struct platform_device *pdev = to_platform_device(dev);
1313 struct fimc_md *fmd = platform_get_drvdata(pdev);
1314 bool subdev_api;
1315 int i;
1316
1317 if (!strcmp(buf, "vid-dev\n"))
1318 subdev_api = false;
1319 else if (!strcmp(buf, "sub-dev\n"))
1320 subdev_api = true;
1321 else
1322 return count;
1323
1324 fmd->user_subdev_api = subdev_api;
1325 for (i = 0; i < FIMC_MAX_DEVS; i++)
1326 if (fmd->fimc[i])
1327 fmd->fimc[i]->vid_cap.user_subdev_api = subdev_api;
1328 return count;
1329 }
1330 /*
1331 * This device attribute is to select video pipeline configuration method.
1332 * There are following valid values:
1333 * vid-dev - for V4L2 video node API only, subdevice will be configured
1334 * by the host driver.
1335 * sub-dev - for media controller API, subdevs must be configured in user
1336 * space before starting streaming.
1337 */
1338 static DEVICE_ATTR(subdev_conf_mode, S_IWUSR | S_IRUGO,
1339 fimc_md_sysfs_show, fimc_md_sysfs_store);
1340
1341 static int fimc_md_get_pinctrl(struct fimc_md *fmd)
1342 {
1343 struct device *dev = &fmd->pdev->dev;
1344 struct fimc_pinctrl *pctl = &fmd->pinctl;
1345
1346 pctl->pinctrl = devm_pinctrl_get(dev);
1347 if (IS_ERR(pctl->pinctrl))
1348 return PTR_ERR(pctl->pinctrl);
1349
1350 pctl->state_default = pinctrl_lookup_state(pctl->pinctrl,
1351 PINCTRL_STATE_DEFAULT);
1352 if (IS_ERR(pctl->state_default))
1353 return PTR_ERR(pctl->state_default);
1354
1355 pctl->state_idle = pinctrl_lookup_state(pctl->pinctrl,
1356 PINCTRL_STATE_IDLE);
1357 return 0;
1358 }
1359
1360 static int fimc_md_probe(struct platform_device *pdev)
1361 {
1362 struct device *dev = &pdev->dev;
1363 struct v4l2_device *v4l2_dev;
1364 struct fimc_md *fmd;
1365 int ret;
1366
1367 fmd = devm_kzalloc(dev, sizeof(*fmd), GFP_KERNEL);
1368 if (!fmd)
1369 return -ENOMEM;
1370
1371 spin_lock_init(&fmd->slock);
1372 fmd->pdev = pdev;
1373
1374 strlcpy(fmd->media_dev.model, "SAMSUNG S5P FIMC",
1375 sizeof(fmd->media_dev.model));
1376 fmd->media_dev.link_notify = fimc_md_link_notify;
1377 fmd->media_dev.dev = dev;
1378
1379 v4l2_dev = &fmd->v4l2_dev;
1380 v4l2_dev->mdev = &fmd->media_dev;
1381 v4l2_dev->notify = fimc_sensor_notify;
1382 strlcpy(v4l2_dev->name, "s5p-fimc-md", sizeof(v4l2_dev->name));
1383
1384 fmd->use_isp = fimc_md_is_isp_available(dev->of_node);
1385
1386 ret = v4l2_device_register(dev, &fmd->v4l2_dev);
1387 if (ret < 0) {
1388 v4l2_err(v4l2_dev, "Failed to register v4l2_device: %d\n", ret);
1389 return ret;
1390 }
1391 ret = media_device_register(&fmd->media_dev);
1392 if (ret < 0) {
1393 v4l2_err(v4l2_dev, "Failed to register media device: %d\n", ret);
1394 goto err_md;
1395 }
1396 ret = fimc_md_get_clocks(fmd);
1397 if (ret)
1398 goto err_clk;
1399
1400 fmd->user_subdev_api = (dev->of_node != NULL);
1401
1402 /* Protect the media graph while we're registering entities */
1403 mutex_lock(&fmd->media_dev.graph_mutex);
1404
1405 ret = fimc_md_get_pinctrl(fmd);
1406 if (ret < 0) {
1407 if (ret != EPROBE_DEFER)
1408 dev_err(dev, "Failed to get pinctrl: %d\n", ret);
1409 goto err_unlock;
1410 }
1411
1412 if (dev->of_node)
1413 ret = fimc_md_register_of_platform_entities(fmd, dev->of_node);
1414 else
1415 ret = bus_for_each_dev(&platform_bus_type, NULL, fmd,
1416 fimc_md_pdev_match);
1417 if (ret)
1418 goto err_unlock;
1419
1420 if (dev->platform_data || dev->of_node) {
1421 ret = fimc_md_register_sensor_entities(fmd);
1422 if (ret)
1423 goto err_unlock;
1424 }
1425
1426 ret = fimc_md_create_links(fmd);
1427 if (ret)
1428 goto err_unlock;
1429 ret = v4l2_device_register_subdev_nodes(&fmd->v4l2_dev);
1430 if (ret)
1431 goto err_unlock;
1432
1433 ret = device_create_file(&pdev->dev, &dev_attr_subdev_conf_mode);
1434 if (ret)
1435 goto err_unlock;
1436
1437 platform_set_drvdata(pdev, fmd);
1438 mutex_unlock(&fmd->media_dev.graph_mutex);
1439 return 0;
1440
1441 err_unlock:
1442 mutex_unlock(&fmd->media_dev.graph_mutex);
1443 err_clk:
1444 media_device_unregister(&fmd->media_dev);
1445 fimc_md_put_clocks(fmd);
1446 fimc_md_unregister_entities(fmd);
1447 err_md:
1448 v4l2_device_unregister(&fmd->v4l2_dev);
1449 return ret;
1450 }
1451
1452 static int fimc_md_remove(struct platform_device *pdev)
1453 {
1454 struct fimc_md *fmd = platform_get_drvdata(pdev);
1455
1456 if (!fmd)
1457 return 0;
1458 device_remove_file(&pdev->dev, &dev_attr_subdev_conf_mode);
1459 fimc_md_unregister_entities(fmd);
1460 media_device_unregister(&fmd->media_dev);
1461 fimc_md_put_clocks(fmd);
1462 return 0;
1463 }
1464
1465 static struct platform_device_id fimc_driver_ids[] __always_unused = {
1466 { .name = "s5p-fimc-md" },
1467 { },
1468 };
1469 MODULE_DEVICE_TABLE(platform, fimc_driver_ids);
1470
1471 static const struct of_device_id fimc_md_of_match[] = {
1472 { .compatible = "samsung,fimc" },
1473 { },
1474 };
1475 MODULE_DEVICE_TABLE(of, fimc_md_of_match);
1476
1477 static struct platform_driver fimc_md_driver = {
1478 .probe = fimc_md_probe,
1479 .remove = fimc_md_remove,
1480 .driver = {
1481 .of_match_table = of_match_ptr(fimc_md_of_match),
1482 .name = "s5p-fimc-md",
1483 .owner = THIS_MODULE,
1484 }
1485 };
1486
1487 static int __init fimc_md_init(void)
1488 {
1489 int ret;
1490
1491 request_module("s5p-csis");
1492 ret = fimc_register_driver();
1493 if (ret)
1494 return ret;
1495
1496 return platform_driver_register(&fimc_md_driver);
1497 }
1498
1499 static void __exit fimc_md_exit(void)
1500 {
1501 platform_driver_unregister(&fimc_md_driver);
1502 fimc_unregister_driver();
1503 }
1504
1505 module_init(fimc_md_init);
1506 module_exit(fimc_md_exit);
1507
1508 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");
1509 MODULE_DESCRIPTION("S5P FIMC camera host interface/video postprocessor driver");
1510 MODULE_LICENSE("GPL");
1511 MODULE_VERSION("2.0.1");
Linux with added FPC-III support