dc-de.c

  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};