Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2024 NXP
4 */
5
6#include <linux/component.h>
7#include <linux/mod_devicetable.h>
8#include <linux/module.h>
9#include <linux/of_platform.h>
10#include <linux/platform_device.h>
11#include <linux/pm.h>
12#include <linux/pm_runtime.h>
13#include <linux/regmap.h>
14
15#include "dc-de.h"
16#include "dc-drv.h"
17
18#define POLARITYCTRL 0xc
19#define POLEN_HIGH BIT(2)
20
21static const struct dc_subdev_info dc_de_info[] = {
22 { .reg_start = 0x5618b400, .id = 0, },
23 { .reg_start = 0x5618b420, .id = 1, },
24};
25
26static const struct regmap_range dc_de_regmap_ranges[] = {
27 regmap_reg_range(POLARITYCTRL, POLARITYCTRL),
28};
29
30static const struct regmap_access_table dc_de_regmap_access_table = {
31 .yes_ranges = dc_de_regmap_ranges,
32 .n_yes_ranges = ARRAY_SIZE(dc_de_regmap_ranges),
33};
34
35static const struct regmap_config dc_de_top_regmap_config = {
36 .name = "top",
37 .reg_bits = 32,
38 .reg_stride = 4,
39 .val_bits = 32,
40 .fast_io = true,
41 .wr_table = &dc_de_regmap_access_table,
42 .rd_table = &dc_de_regmap_access_table,
43 .max_register = POLARITYCTRL,
44};
45
46static inline void dc_dec_init(struct dc_de *de)
47{
48 regmap_write_bits(de->reg_top, POLARITYCTRL, POLARITYCTRL, POLEN_HIGH);
49}
50
51static int dc_de_bind(struct device *dev, struct device *master, void *data)
52{
53 struct platform_device *pdev = to_platform_device(dev);
54 struct dc_drm_device *dc_drm = data;
55 struct resource *res_top;
56 void __iomem *base_top;
57 struct dc_de *de;
58 int ret, id;
59
60 de = devm_kzalloc(dev, sizeof(*de), GFP_KERNEL);
61 if (!de)
62 return -ENOMEM;
63
64 base_top = devm_platform_get_and_ioremap_resource(pdev, 0, &res_top);
65 if (IS_ERR(base_top))
66 return PTR_ERR(base_top);
67
68 de->reg_top = devm_regmap_init_mmio(dev, base_top,
69 &dc_de_top_regmap_config);
70 if (IS_ERR(de->reg_top))
71 return PTR_ERR(de->reg_top);
72
73 de->irq_shdload = platform_get_irq_byname(pdev, "shdload");
74 if (de->irq_shdload < 0)
75 return de->irq_shdload;
76
77 de->irq_framecomplete = platform_get_irq_byname(pdev, "framecomplete");
78 if (de->irq_framecomplete < 0)
79 return de->irq_framecomplete;
80
81 de->irq_seqcomplete = platform_get_irq_byname(pdev, "seqcomplete");
82 if (de->irq_seqcomplete < 0)
83 return de->irq_seqcomplete;
84
85 de->dev = dev;
86
87 dev_set_drvdata(dev, de);
88
89 ret = devm_pm_runtime_enable(dev);
90 if (ret)
91 return ret;
92
93 id = dc_subdev_get_id(dc_de_info, ARRAY_SIZE(dc_de_info), res_top);
94 if (id < 0) {
95 dev_err(dev, "failed to get instance number: %d\n", id);
96 return id;
97 }
98
99 dc_drm->de[id] = de;
100
101 return 0;
102}
103
104/*
105 * It's possible to get the child device pointers from the child component
106 * bind callbacks, but it depends on the component helper behavior to bind
107 * the display engine component first. To avoid the dependency, post bind
108 * to get the pointers from dc_drm in a safe manner.
109 */
110void dc_de_post_bind(struct dc_drm_device *dc_drm)
111{
112 struct dc_de *de;
113 int i;
114
115 for (i = 0; i < DC_DISPLAYS; i++) {
116 de = dc_drm->de[i];
117 de->fg = dc_drm->fg[i];
118 de->tc = dc_drm->tc[i];
119 }
120}
121
122static const struct component_ops dc_de_ops = {
123 .bind = dc_de_bind,
124};
125
126static int dc_de_probe(struct platform_device *pdev)
127{
128 int ret;
129
130 ret = devm_of_platform_populate(&pdev->dev);
131 if (ret < 0)
132 return ret;
133
134 ret = component_add(&pdev->dev, &dc_de_ops);
135 if (ret)
136 return dev_err_probe(&pdev->dev, ret,
137 "failed to add component\n");
138
139 return 0;
140}
141
142static void dc_de_remove(struct platform_device *pdev)
143{
144 component_del(&pdev->dev, &dc_de_ops);
145}
146
147static int dc_de_runtime_resume(struct device *dev)
148{
149 struct dc_de *de = dev_get_drvdata(dev);
150
151 dc_dec_init(de);
152 dc_fg_init(de->fg);
153 dc_tc_init(de->tc);
154
155 return 0;
156}
157
158static const struct dev_pm_ops dc_de_pm_ops = {
159 RUNTIME_PM_OPS(NULL, dc_de_runtime_resume, NULL)
160};
161
162static const struct of_device_id dc_de_dt_ids[] = {
163 { .compatible = "fsl,imx8qxp-dc-display-engine" },
164 { /* sentinel */ }
165};
166MODULE_DEVICE_TABLE(of, dc_de_dt_ids);
167
168struct platform_driver dc_de_driver = {
169 .probe = dc_de_probe,
170 .remove = dc_de_remove,
171 .driver = {
172 .name = "imx8-dc-display-engine",
173 .suppress_bind_attrs = true,
174 .of_match_table = dc_de_dt_ids,
175 .pm = pm_sleep_ptr(&dc_de_pm_ops),
176 },
177};