2 * Samsung EXYNOS4x12 FIMC-IS (Imaging Subsystem) driver
4 * Copyright (C) 2013 Samsung Electronics Co., Ltd.
6 * Authors: Sylwester Nawrocki <s.nawrocki@samsung.com>
7 * Younghwan Joo <yhwan.joo@samsung.com>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 #define pr_fmt(fmt) "%s:%d " fmt, __func__, __LINE__
15 #include <linux/device.h>
16 #include <linux/debugfs.h>
17 #include <linux/delay.h>
18 #include <linux/dma-contiguous.h>
19 #include <linux/errno.h>
20 #include <linux/firmware.h>
21 #include <linux/interrupt.h>
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/of_i2c.h>
25 #include <linux/of_irq.h>
26 #include <linux/of_address.h>
27 #include <linux/of_platform.h>
28 #include <linux/platform_device.h>
29 #include <linux/pm_runtime.h>
30 #include <linux/slab.h>
31 #include <linux/types.h>
32 #include <linux/videodev2.h>
33 #include <media/v4l2-of.h>
34 #include <media/videobuf2-dma-contig.h>
36 #include "media-dev.h"
38 #include "fimc-is-command.h"
39 #include "fimc-is-errno.h"
40 #include "fimc-is-i2c.h"
41 #include "fimc-is-param.h"
42 #include "fimc-is-regs.h"
45 static char *fimc_is_clocks
[ISS_CLKS_MAX
] = {
46 [ISS_CLK_PPMUISPX
] = "ppmuispx",
47 [ISS_CLK_PPMUISPMX
] = "ppmuispmx",
48 [ISS_CLK_LITE0
] = "lite0",
49 [ISS_CLK_LITE1
] = "lite1",
50 [ISS_CLK_MPLL
] = "mpll",
51 [ISS_CLK_SYSREG
] = "sysreg",
52 [ISS_CLK_ISP
] = "isp",
53 [ISS_CLK_DRC
] = "drc",
55 [ISS_CLK_MCUISP
] = "mcuisp",
56 [ISS_CLK_UART
] = "uart",
57 [ISS_CLK_ISP_DIV0
] = "ispdiv0",
58 [ISS_CLK_ISP_DIV1
] = "ispdiv1",
59 [ISS_CLK_MCUISP_DIV0
] = "mcuispdiv0",
60 [ISS_CLK_MCUISP_DIV1
] = "mcuispdiv1",
61 [ISS_CLK_ACLK200
] = "aclk200",
62 [ISS_CLK_ACLK200_DIV
] = "div_aclk200",
63 [ISS_CLK_ACLK400MCUISP
] = "aclk400mcuisp",
64 [ISS_CLK_ACLK400MCUISP_DIV
] = "div_aclk400mcuisp",
67 static void fimc_is_put_clocks(struct fimc_is
*is
)
71 for (i
= 0; i
< ISS_CLKS_MAX
; i
++) {
72 if (IS_ERR(is
->clocks
[i
]))
74 clk_put(is
->clocks
[i
]);
75 is
->clocks
[i
] = ERR_PTR(-EINVAL
);
79 static int fimc_is_get_clocks(struct fimc_is
*is
)
83 for (i
= 0; i
< ISS_CLKS_MAX
; i
++)
84 is
->clocks
[i
] = ERR_PTR(-EINVAL
);
86 for (i
= 0; i
< ISS_CLKS_MAX
; i
++) {
87 is
->clocks
[i
] = clk_get(&is
->pdev
->dev
, fimc_is_clocks
[i
]);
88 if (IS_ERR(is
->clocks
[i
])) {
89 ret
= PTR_ERR(is
->clocks
[i
]);
96 fimc_is_put_clocks(is
);
97 dev_err(&is
->pdev
->dev
, "failed to get clock: %s\n",
102 static int fimc_is_setup_clocks(struct fimc_is
*is
)
106 ret
= clk_set_parent(is
->clocks
[ISS_CLK_ACLK200
],
107 is
->clocks
[ISS_CLK_ACLK200_DIV
]);
111 ret
= clk_set_parent(is
->clocks
[ISS_CLK_ACLK400MCUISP
],
112 is
->clocks
[ISS_CLK_ACLK400MCUISP_DIV
]);
116 ret
= clk_set_rate(is
->clocks
[ISS_CLK_ISP_DIV0
], ACLK_AXI_FREQUENCY
);
120 ret
= clk_set_rate(is
->clocks
[ISS_CLK_ISP_DIV1
], ACLK_AXI_FREQUENCY
);
124 ret
= clk_set_rate(is
->clocks
[ISS_CLK_MCUISP_DIV0
],
125 ATCLK_MCUISP_FREQUENCY
);
129 return clk_set_rate(is
->clocks
[ISS_CLK_MCUISP_DIV1
],
130 ATCLK_MCUISP_FREQUENCY
);
133 int fimc_is_enable_clocks(struct fimc_is
*is
)
137 for (i
= 0; i
< ISS_GATE_CLKS_MAX
; i
++) {
138 if (IS_ERR(is
->clocks
[i
]))
140 ret
= clk_prepare_enable(is
->clocks
[i
]);
142 dev_err(&is
->pdev
->dev
, "clock %s enable failed\n",
144 for (--i
; i
>= 0; i
--)
145 clk_disable(is
->clocks
[i
]);
148 pr_debug("enabled clock: %s\n", fimc_is_clocks
[i
]);
153 void fimc_is_disable_clocks(struct fimc_is
*is
)
157 for (i
= 0; i
< ISS_GATE_CLKS_MAX
; i
++) {
158 if (!IS_ERR(is
->clocks
[i
])) {
159 clk_disable_unprepare(is
->clocks
[i
]);
160 pr_debug("disabled clock: %s\n", fimc_is_clocks
[i
]);
165 static int fimc_is_parse_sensor_config(struct fimc_is_sensor
*sensor
,
166 struct device_node
*np
)
171 np
= v4l2_of_get_next_endpoint(np
, NULL
);
174 np
= v4l2_of_get_remote_port(np
);
178 /* Use MIPI-CSIS channel id to determine the ISP I2C bus index. */
179 ret
= of_property_read_u32(np
, "reg", &tmp
);
180 sensor
->i2c_bus
= tmp
- FIMC_INPUT_MIPI_CSI2_0
;
185 static int fimc_is_register_subdevs(struct fimc_is
*is
)
187 struct device_node
*adapter
, *child
;
190 ret
= fimc_isp_subdev_create(&is
->isp
);
194 for_each_compatible_node(adapter
, NULL
, FIMC_IS_I2C_COMPATIBLE
) {
195 if (!of_find_device_by_node(adapter
)) {
196 of_node_put(adapter
);
197 return -EPROBE_DEFER
;
200 for_each_available_child_of_node(adapter
, child
) {
201 struct i2c_client
*client
;
202 struct v4l2_subdev
*sd
;
204 client
= of_find_i2c_device_by_node(child
);
208 sd
= i2c_get_clientdata(client
);
212 /* FIXME: Add support for multiple sensors. */
213 if (WARN_ON(is
->sensor
))
216 is
->sensor
= sd_to_fimc_is_sensor(sd
);
218 if (fimc_is_parse_sensor_config(is
->sensor
, child
)) {
219 dev_warn(&is
->pdev
->dev
, "DT parse error: %s\n",
222 pr_debug("%s(): registered subdev: %p\n",
230 return -EPROBE_DEFER
;
233 static int fimc_is_unregister_subdevs(struct fimc_is
*is
)
235 fimc_isp_subdev_destroy(&is
->isp
);
240 static int fimc_is_load_setfile(struct fimc_is
*is
, char *file_name
)
242 const struct firmware
*fw
;
246 ret
= request_firmware(&fw
, file_name
, &is
->pdev
->dev
);
248 dev_err(&is
->pdev
->dev
, "firmware request failed (%d)\n", ret
);
251 buf
= is
->memory
.vaddr
+ is
->setfile
.base
;
252 memcpy(buf
, fw
->data
, fw
->size
);
253 fimc_is_mem_barrier();
254 is
->setfile
.size
= fw
->size
;
256 pr_debug("mem vaddr: %p, setfile buf: %p\n", is
->memory
.vaddr
, buf
);
258 memcpy(is
->fw
.setfile_info
,
259 fw
->data
+ fw
->size
- FIMC_IS_SETFILE_INFO_LEN
,
260 FIMC_IS_SETFILE_INFO_LEN
- 1);
262 is
->fw
.setfile_info
[FIMC_IS_SETFILE_INFO_LEN
- 1] = '\0';
263 is
->setfile
.state
= 1;
265 pr_debug("FIMC-IS setfile loaded: base: %#x, size: %zu B\n",
266 is
->setfile
.base
, fw
->size
);
268 release_firmware(fw
);
272 int fimc_is_cpu_set_power(struct fimc_is
*is
, int on
)
274 unsigned int timeout
= FIMC_IS_POWER_ON_TIMEOUT
;
277 /* Disable watchdog */
278 mcuctl_write(0, is
, REG_WDT_ISP
);
280 /* Cortex-A5 start address setting */
281 mcuctl_write(is
->memory
.paddr
, is
, MCUCTL_REG_BBOAR
);
283 /* Enable and start Cortex-A5 */
284 pmuisp_write(0x18000, is
, REG_PMU_ISP_ARM_OPTION
);
285 pmuisp_write(0x1, is
, REG_PMU_ISP_ARM_CONFIGURATION
);
288 pmuisp_write(0x10000, is
, REG_PMU_ISP_ARM_OPTION
);
289 pmuisp_write(0x0, is
, REG_PMU_ISP_ARM_CONFIGURATION
);
291 while (pmuisp_read(is
, REG_PMU_ISP_ARM_STATUS
) & 1) {
302 /* Wait until @bit of @is->state is set to @state in the interrupt handler. */
303 int fimc_is_wait_event(struct fimc_is
*is
, unsigned long bit
,
304 unsigned int state
, unsigned int timeout
)
307 int ret
= wait_event_timeout(is
->irq_queue
,
308 !state
^ test_bit(bit
, &is
->state
),
311 dev_WARN(&is
->pdev
->dev
, "%s() timed out\n", __func__
);
317 int fimc_is_start_firmware(struct fimc_is
*is
)
319 struct device
*dev
= &is
->pdev
->dev
;
322 if (is
->fw
.f_w
== NULL
) {
323 dev_err(dev
, "firmware is not loaded\n");
327 memcpy(is
->memory
.vaddr
, is
->fw
.f_w
->data
, is
->fw
.f_w
->size
);
330 ret
= fimc_is_cpu_set_power(is
, 1);
334 ret
= fimc_is_wait_event(is
, IS_ST_A5_PWR_ON
, 1,
335 msecs_to_jiffies(FIMC_IS_FW_LOAD_TIMEOUT
));
337 dev_err(dev
, "FIMC-IS CPU power on failed\n");
342 /* Allocate working memory for the FIMC-IS CPU. */
343 static int fimc_is_alloc_cpu_memory(struct fimc_is
*is
)
345 struct device
*dev
= &is
->pdev
->dev
;
347 is
->memory
.vaddr
= dma_alloc_coherent(dev
, FIMC_IS_CPU_MEM_SIZE
,
348 &is
->memory
.paddr
, GFP_KERNEL
);
349 if (is
->memory
.vaddr
== NULL
)
352 is
->memory
.size
= FIMC_IS_CPU_MEM_SIZE
;
353 memset(is
->memory
.vaddr
, 0, is
->memory
.size
);
355 dev_info(dev
, "FIMC-IS CPU memory base: %#x\n", (u32
)is
->memory
.paddr
);
357 if (((u32
)is
->memory
.paddr
) & FIMC_IS_FW_ADDR_MASK
) {
358 dev_err(dev
, "invalid firmware memory alignment: %#x\n",
359 (u32
)is
->memory
.paddr
);
360 dma_free_coherent(dev
, is
->memory
.size
, is
->memory
.vaddr
,
365 is
->is_p_region
= (struct is_region
*)(is
->memory
.vaddr
+
366 FIMC_IS_CPU_MEM_SIZE
- FIMC_IS_REGION_SIZE
);
368 is
->is_dma_p_region
= is
->memory
.paddr
+
369 FIMC_IS_CPU_MEM_SIZE
- FIMC_IS_REGION_SIZE
;
371 is
->is_shared_region
= (struct is_share_region
*)(is
->memory
.vaddr
+
372 FIMC_IS_SHARED_REGION_OFFSET
);
376 static void fimc_is_free_cpu_memory(struct fimc_is
*is
)
378 struct device
*dev
= &is
->pdev
->dev
;
380 dma_free_coherent(dev
, is
->memory
.size
, is
->memory
.vaddr
,
384 static void fimc_is_load_firmware(const struct firmware
*fw
, void *context
)
386 struct fimc_is
*is
= context
;
387 struct device
*dev
= &is
->pdev
->dev
;
392 dev_err(dev
, "firmware request failed\n");
395 mutex_lock(&is
->lock
);
397 if (fw
->size
< FIMC_IS_FW_SIZE_MIN
|| fw
->size
> FIMC_IS_FW_SIZE_MAX
) {
398 dev_err(dev
, "wrong firmware size: %d\n", fw
->size
);
402 is
->fw
.size
= fw
->size
;
404 ret
= fimc_is_alloc_cpu_memory(is
);
406 dev_err(dev
, "failed to allocate FIMC-IS CPU memory\n");
410 memcpy(is
->memory
.vaddr
, fw
->data
, fw
->size
);
413 /* Read firmware description. */
414 buf
= (void *)(is
->memory
.vaddr
+ fw
->size
- FIMC_IS_FW_DESC_LEN
);
415 memcpy(&is
->fw
.info
, buf
, FIMC_IS_FW_INFO_LEN
);
416 is
->fw
.info
[FIMC_IS_FW_INFO_LEN
] = 0;
418 buf
= (void *)(is
->memory
.vaddr
+ fw
->size
- FIMC_IS_FW_VER_LEN
);
419 memcpy(&is
->fw
.version
, buf
, FIMC_IS_FW_VER_LEN
);
420 is
->fw
.version
[FIMC_IS_FW_VER_LEN
- 1] = 0;
424 dev_info(dev
, "loaded firmware: %s, rev. %s\n",
425 is
->fw
.info
, is
->fw
.version
);
426 dev_dbg(dev
, "FW size: %d, paddr: %#x\n", fw
->size
, is
->memory
.paddr
);
428 is
->is_shared_region
->chip_id
= 0xe4412;
429 is
->is_shared_region
->chip_rev_no
= 1;
431 fimc_is_mem_barrier();
434 * FIXME: The firmware is not being released for now, as it is
435 * needed around for copying to the IS working memory every
436 * time before the Cortex-A5 is restarted.
439 release_firmware(is
->fw
.f_w
);
442 mutex_unlock(&is
->lock
);
445 static int fimc_is_request_firmware(struct fimc_is
*is
, const char *fw_name
)
447 return request_firmware_nowait(THIS_MODULE
,
448 FW_ACTION_HOTPLUG
, fw_name
, &is
->pdev
->dev
,
449 GFP_KERNEL
, is
, fimc_is_load_firmware
);
452 /* General IS interrupt handler */
453 static void fimc_is_general_irq_handler(struct fimc_is
*is
)
455 is
->i2h_cmd
.cmd
= mcuctl_read(is
, MCUCTL_REG_ISSR(10));
457 switch (is
->i2h_cmd
.cmd
) {
458 case IHC_GET_SENSOR_NUM
:
459 fimc_is_hw_get_params(is
, 1);
460 fimc_is_hw_wait_intmsr0_intmsd0(is
);
461 fimc_is_hw_set_sensor_num(is
);
462 pr_debug("ISP FW version: %#x\n", is
->i2h_cmd
.args
[0]);
464 case IHC_SET_FACE_MARK
:
466 fimc_is_hw_get_params(is
, 2);
468 case IHC_SET_SHOT_MARK
:
471 fimc_is_hw_get_params(is
, 3);
473 case IH_REPLY_NOT_DONE
:
474 fimc_is_hw_get_params(is
, 4);
479 pr_info("unknown command: %#x\n", is
->i2h_cmd
.cmd
);
482 fimc_is_fw_clear_irq1(is
, FIMC_IS_INT_GENERAL
);
484 switch (is
->i2h_cmd
.cmd
) {
485 case IHC_GET_SENSOR_NUM
:
486 fimc_is_hw_set_intgr0_gd0(is
);
487 set_bit(IS_ST_A5_PWR_ON
, &is
->state
);
490 case IHC_SET_SHOT_MARK
:
493 case IHC_SET_FACE_MARK
:
494 is
->fd_header
.count
= is
->i2h_cmd
.args
[0];
495 is
->fd_header
.index
= is
->i2h_cmd
.args
[1];
496 is
->fd_header
.offset
= 0;
503 pr_debug("AA_DONE - %d, %d, %d\n", is
->i2h_cmd
.args
[0],
504 is
->i2h_cmd
.args
[1], is
->i2h_cmd
.args
[2]);
508 pr_debug("ISR_DONE: args[0]: %#x\n", is
->i2h_cmd
.args
[0]);
510 switch (is
->i2h_cmd
.args
[0]) {
511 case HIC_PREVIEW_STILL
...HIC_CAPTURE_VIDEO
:
513 set_bit(IS_ST_CHANGE_MODE
, &is
->state
);
514 is
->isp
.cac_margin_x
= is
->i2h_cmd
.args
[1];
515 is
->isp
.cac_margin_y
= is
->i2h_cmd
.args
[2];
516 pr_debug("CAC margin (x,y): (%d,%d)\n",
517 is
->isp
.cac_margin_x
, is
->isp
.cac_margin_y
);
521 clear_bit(IS_ST_STREAM_OFF
, &is
->state
);
522 set_bit(IS_ST_STREAM_ON
, &is
->state
);
526 clear_bit(IS_ST_STREAM_ON
, &is
->state
);
527 set_bit(IS_ST_STREAM_OFF
, &is
->state
);
530 case HIC_SET_PARAMETER
:
531 is
->config
[is
->config_index
].p_region_index1
= 0;
532 is
->config
[is
->config_index
].p_region_index2
= 0;
533 set_bit(IS_ST_BLOCK_CMD_CLEARED
, &is
->state
);
534 pr_debug("HIC_SET_PARAMETER\n");
537 case HIC_GET_PARAMETER
:
546 case HIC_OPEN_SENSOR
:
547 set_bit(IS_ST_OPEN_SENSOR
, &is
->state
);
548 pr_debug("data lanes: %d, settle line: %d\n",
549 is
->i2h_cmd
.args
[2], is
->i2h_cmd
.args
[1]);
552 case HIC_CLOSE_SENSOR
:
553 clear_bit(IS_ST_OPEN_SENSOR
, &is
->state
);
554 is
->sensor_index
= 0;
558 pr_debug("config MSG level completed\n");
562 clear_bit(IS_ST_PWR_SUBIP_ON
, &is
->state
);
565 case HIC_GET_SET_FILE_ADDR
:
566 is
->setfile
.base
= is
->i2h_cmd
.args
[1];
567 set_bit(IS_ST_SETFILE_LOADED
, &is
->state
);
570 case HIC_LOAD_SET_FILE
:
571 set_bit(IS_ST_SETFILE_LOADED
, &is
->state
);
576 case IH_REPLY_NOT_DONE
:
577 pr_err("ISR_NDONE: %d: %#x, %s\n", is
->i2h_cmd
.args
[0],
579 fimc_is_strerr(is
->i2h_cmd
.args
[1]));
581 if (is
->i2h_cmd
.args
[1] & IS_ERROR_TIME_OUT_FLAG
)
582 pr_err("IS_ERROR_TIME_OUT\n");
584 switch (is
->i2h_cmd
.args
[1]) {
585 case IS_ERROR_SET_PARAMETER
:
586 fimc_is_mem_barrier();
589 switch (is
->i2h_cmd
.args
[0]) {
590 case HIC_SET_PARAMETER
:
591 is
->config
[is
->config_index
].p_region_index1
= 0;
592 is
->config
[is
->config_index
].p_region_index2
= 0;
593 set_bit(IS_ST_BLOCK_CMD_CLEARED
, &is
->state
);
599 pr_err("IS control sequence error: Not Ready\n");
603 wake_up(&is
->irq_queue
);
606 static irqreturn_t
fimc_is_irq_handler(int irq
, void *priv
)
608 struct fimc_is
*is
= priv
;
612 spin_lock_irqsave(&is
->slock
, flags
);
613 status
= mcuctl_read(is
, MCUCTL_REG_INTSR1
);
615 if (status
& (1UL << FIMC_IS_INT_GENERAL
))
616 fimc_is_general_irq_handler(is
);
618 if (status
& (1UL << FIMC_IS_INT_FRAME_DONE_ISP
))
619 fimc_isp_irq_handler(is
);
621 spin_unlock_irqrestore(&is
->slock
, flags
);
625 static int fimc_is_hw_open_sensor(struct fimc_is
*is
,
626 struct fimc_is_sensor
*sensor
)
628 struct sensor_open_extended
*soe
= (void *)&is
->is_p_region
->shared
;
630 fimc_is_hw_wait_intmsr0_intmsd0(is
);
632 soe
->self_calibration_mode
= 1;
633 soe
->actuator_type
= 0;
634 soe
->mipi_lane_num
= 0;
637 soe
->fast_open_sensor
= 0;
638 soe
->i2c_sclk
= 88000000;
640 fimc_is_mem_barrier();
642 mcuctl_write(HIC_OPEN_SENSOR
, is
, MCUCTL_REG_ISSR(0));
643 mcuctl_write(is
->sensor_index
, is
, MCUCTL_REG_ISSR(1));
644 mcuctl_write(sensor
->drvdata
->id
, is
, MCUCTL_REG_ISSR(2));
645 mcuctl_write(sensor
->i2c_bus
, is
, MCUCTL_REG_ISSR(3));
646 mcuctl_write(is
->is_dma_p_region
, is
, MCUCTL_REG_ISSR(4));
648 fimc_is_hw_set_intgr0_gd0(is
);
650 return fimc_is_wait_event(is
, IS_ST_OPEN_SENSOR
, 1,
651 FIMC_IS_SENSOR_OPEN_TIMEOUT
);
655 int fimc_is_hw_initialize(struct fimc_is
*is
)
657 const int config_ids
[] = {
658 IS_SC_PREVIEW_STILL
, IS_SC_PREVIEW_VIDEO
,
659 IS_SC_CAPTURE_STILL
, IS_SC_CAPTURE_VIDEO
661 struct device
*dev
= &is
->pdev
->dev
;
665 /* Sensor initialization. */
666 ret
= fimc_is_hw_open_sensor(is
, is
->sensor
);
670 /* Get the setfile address. */
671 fimc_is_hw_get_setfile_addr(is
);
673 ret
= fimc_is_wait_event(is
, IS_ST_SETFILE_LOADED
, 1,
674 FIMC_IS_CONFIG_TIMEOUT
);
676 dev_err(dev
, "get setfile address timed out\n");
679 pr_debug("setfile.base: %#x\n", is
->setfile
.base
);
681 /* Load the setfile. */
682 fimc_is_load_setfile(is
, FIMC_IS_SETFILE_6A3
);
683 clear_bit(IS_ST_SETFILE_LOADED
, &is
->state
);
684 fimc_is_hw_load_setfile(is
);
685 ret
= fimc_is_wait_event(is
, IS_ST_SETFILE_LOADED
, 1,
686 FIMC_IS_CONFIG_TIMEOUT
);
688 dev_err(dev
, "loading setfile timed out\n");
692 pr_debug("setfile: base: %#x, size: %d\n",
693 is
->setfile
.base
, is
->setfile
.size
);
694 pr_info("FIMC-IS Setfile info: %s\n", is
->fw
.setfile_info
);
696 /* Check magic number. */
697 if (is
->is_p_region
->shared
[MAX_SHARED_COUNT
- 1] !=
698 FIMC_IS_MAGIC_NUMBER
) {
699 dev_err(dev
, "magic number error!\n");
703 pr_debug("shared region: %#x, parameter region: %#x\n",
704 is
->memory
.paddr
+ FIMC_IS_SHARED_REGION_OFFSET
,
705 is
->is_dma_p_region
);
707 is
->setfile
.sub_index
= 0;
710 fimc_is_hw_stream_off(is
);
711 ret
= fimc_is_wait_event(is
, IS_ST_STREAM_OFF
, 1,
712 FIMC_IS_CONFIG_TIMEOUT
);
714 dev_err(dev
, "stream off timeout\n");
718 /* Preserve previous mode. */
719 prev_id
= is
->config_index
;
721 /* Set initial parameter values. */
722 for (i
= 0; i
< ARRAY_SIZE(config_ids
); i
++) {
723 is
->config_index
= config_ids
[i
];
724 fimc_is_set_initial_params(is
);
725 ret
= fimc_is_itf_s_param(is
, true);
727 is
->config_index
= prev_id
;
731 is
->config_index
= prev_id
;
733 set_bit(IS_ST_INIT_DONE
, &is
->state
);
734 dev_info(dev
, "initialization sequence completed (%d)\n",
739 static int fimc_is_log_show(struct seq_file
*s
, void *data
)
741 struct fimc_is
*is
= s
->private;
742 const u8
*buf
= is
->memory
.vaddr
+ FIMC_IS_DEBUG_REGION_OFFSET
;
744 if (is
->memory
.vaddr
== NULL
) {
745 dev_err(&is
->pdev
->dev
, "firmware memory is not initialized\n");
749 seq_printf(s
, "%s\n", buf
);
753 static int fimc_is_debugfs_open(struct inode
*inode
, struct file
*file
)
755 return single_open(file
, fimc_is_log_show
, inode
->i_private
);
758 static const struct file_operations fimc_is_debugfs_fops
= {
759 .open
= fimc_is_debugfs_open
,
762 .release
= single_release
,
765 static void fimc_is_debugfs_remove(struct fimc_is
*is
)
767 debugfs_remove_recursive(is
->debugfs_entry
);
768 is
->debugfs_entry
= NULL
;
771 static int fimc_is_debugfs_create(struct fimc_is
*is
)
773 struct dentry
*dentry
;
775 is
->debugfs_entry
= debugfs_create_dir("fimc_is", NULL
);
777 dentry
= debugfs_create_file("fw_log", S_IRUGO
, is
->debugfs_entry
,
778 is
, &fimc_is_debugfs_fops
);
780 fimc_is_debugfs_remove(is
);
782 return is
->debugfs_entry
== NULL
? -EIO
: 0;
785 static int fimc_is_probe(struct platform_device
*pdev
)
787 struct device
*dev
= &pdev
->dev
;
790 struct device_node
*node
;
793 is
= devm_kzalloc(&pdev
->dev
, sizeof(*is
), GFP_KERNEL
);
800 init_waitqueue_head(&is
->irq_queue
);
801 spin_lock_init(&is
->slock
);
802 mutex_init(&is
->lock
);
804 ret
= of_address_to_resource(dev
->of_node
, 0, &res
);
808 is
->regs
= devm_ioremap_resource(dev
, &res
);
809 if (IS_ERR(is
->regs
))
810 return PTR_ERR(is
->regs
);
812 node
= of_get_child_by_name(dev
->of_node
, "pmu");
816 is
->pmu_regs
= of_iomap(node
, 0);
820 is
->irq
= irq_of_parse_and_map(dev
->of_node
, 0);
822 dev_err(dev
, "no irq found\n");
826 ret
= fimc_is_get_clocks(is
);
830 platform_set_drvdata(pdev
, is
);
832 ret
= request_irq(is
->irq
, fimc_is_irq_handler
, 0, dev_name(dev
), is
);
834 dev_err(dev
, "irq request failed\n");
837 pm_runtime_enable(dev
);
839 * Enable only the ISP power domain, keep FIMC-IS clocks off until
840 * the whole clock tree is configured. The ISP power domain needs
841 * be active in order to acces any CMU_ISP clock registers.
843 ret
= pm_runtime_get_sync(dev
);
847 ret
= fimc_is_setup_clocks(is
);
848 pm_runtime_put_sync(dev
);
855 is
->alloc_ctx
= vb2_dma_contig_init_ctx(dev
);
856 if (IS_ERR(is
->alloc_ctx
)) {
857 ret
= PTR_ERR(is
->alloc_ctx
);
861 * Register FIMC-IS V4L2 subdevs to this driver. The video nodes
862 * will be created within the subdev's registered() callback.
864 ret
= fimc_is_register_subdevs(is
);
868 ret
= fimc_is_debugfs_create(is
);
872 ret
= fimc_is_request_firmware(is
, FIMC_IS_FW_FILENAME
);
876 dev_dbg(dev
, "FIMC-IS registered successfully\n");
880 fimc_is_debugfs_remove(is
);
882 vb2_dma_contig_cleanup_ctx(is
->alloc_ctx
);
884 fimc_is_unregister_subdevs(is
);
886 free_irq(is
->irq
, is
);
888 fimc_is_put_clocks(is
);
892 static int fimc_is_runtime_resume(struct device
*dev
)
894 struct fimc_is
*is
= dev_get_drvdata(dev
);
899 return fimc_is_enable_clocks(is
);
902 static int fimc_is_runtime_suspend(struct device
*dev
)
904 struct fimc_is
*is
= dev_get_drvdata(dev
);
907 fimc_is_disable_clocks(is
);
912 #ifdef CONFIG_PM_SLEEP
913 static int fimc_is_resume(struct device
*dev
)
919 static int fimc_is_suspend(struct device
*dev
)
921 struct fimc_is
*is
= dev_get_drvdata(dev
);
924 if (test_bit(IS_ST_A5_PWR_ON
, &is
->state
))
929 #endif /* CONFIG_PM_SLEEP */
931 static int fimc_is_remove(struct platform_device
*pdev
)
933 struct fimc_is
*is
= platform_get_drvdata(pdev
);
935 pm_runtime_disable(&pdev
->dev
);
936 pm_runtime_set_suspended(&pdev
->dev
);
937 free_irq(is
->irq
, is
);
938 fimc_is_unregister_subdevs(is
);
939 vb2_dma_contig_cleanup_ctx(is
->alloc_ctx
);
940 fimc_is_put_clocks(is
);
941 fimc_is_debugfs_remove(is
);
943 release_firmware(is
->fw
.f_w
);
944 fimc_is_free_cpu_memory(is
);
949 static const struct of_device_id fimc_is_of_match
[] = {
950 { .compatible
= "samsung,exynos4212-fimc-is" },
953 MODULE_DEVICE_TABLE(of
, fimc_is_of_match
);
955 static const struct dev_pm_ops fimc_is_pm_ops
= {
956 SET_SYSTEM_SLEEP_PM_OPS(fimc_is_suspend
, fimc_is_resume
)
957 SET_RUNTIME_PM_OPS(fimc_is_runtime_suspend
, fimc_is_runtime_resume
,
961 static struct platform_driver fimc_is_driver
= {
962 .probe
= fimc_is_probe
,
963 .remove
= fimc_is_remove
,
965 .of_match_table
= fimc_is_of_match
,
966 .name
= FIMC_IS_DRV_NAME
,
967 .owner
= THIS_MODULE
,
968 .pm
= &fimc_is_pm_ops
,
972 static int fimc_is_module_init(void)
976 ret
= fimc_is_register_sensor_driver();
980 ret
= fimc_is_register_i2c_driver();
984 ret
= platform_driver_register(&fimc_is_driver
);
988 fimc_is_unregister_i2c_driver();
990 fimc_is_unregister_sensor_driver();
994 static void fimc_is_module_exit(void)
996 fimc_is_unregister_sensor_driver();
997 fimc_is_unregister_i2c_driver();
998 platform_driver_unregister(&fimc_is_driver
);
1001 module_init(fimc_is_module_init
);
1002 module_exit(fimc_is_module_exit
);
1004 MODULE_ALIAS("platform:" FIMC_IS_DRV_NAME
);
1005 MODULE_AUTHOR("Younghwan Joo <yhwan.joo@samsung.com>");
1006 MODULE_AUTHOR("Sylwester Nawrocki <s.nawrocki@samsung.com>");