xref: /linux/drivers/gpu/drm/bridge/waveshare-dsi.c (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright 2025 NXP
4  * Based on panel-raspberrypi-touchscreen by Broadcom
5  */
6 
7 #include <linux/backlight.h>
8 #include <linux/err.h>
9 #include <linux/i2c.h>
10 #include <linux/module.h>
11 #include <linux/of.h>
12 #include <linux/of_graph.h>
13 #include <linux/regmap.h>
14 
15 #include <drm/drm_atomic_state_helper.h>
16 #include <drm/drm_bridge.h>
17 #include <drm/drm_mipi_dsi.h>
18 #include <drm/drm_of.h>
19 
20 struct ws_bridge {
21 	struct drm_bridge bridge;
22 	struct backlight_device *backlight;
23 	struct device *dev;
24 	struct regmap *reg_map;
25 };
26 
27 static const struct regmap_config ws_regmap_config = {
28 	.reg_bits = 8,
29 	.val_bits = 8,
30 	.max_register = 0xff,
31 };
32 
33 static struct ws_bridge *bridge_to_ws_bridge(struct drm_bridge *bridge)
34 {
35 	return container_of(bridge, struct ws_bridge, bridge);
36 }
37 
38 static int ws_bridge_attach_dsi(struct ws_bridge *ws)
39 {
40 	const struct mipi_dsi_device_info info = {
41 		.type = "ws-bridge",
42 		.channel = 0,
43 		.node = NULL,
44 	};
45 	struct device_node *dsi_host_node;
46 	struct device *dev = ws->dev;
47 	struct mipi_dsi_device *dsi;
48 	struct mipi_dsi_host *host;
49 	int ret;
50 
51 	dsi_host_node = of_graph_get_remote_node(dev->of_node, 0, 0);
52 	if (!dsi_host_node) {
53 		dev_err(dev, "Failed to get remote port\n");
54 		return -ENODEV;
55 	}
56 	host = of_find_mipi_dsi_host_by_node(dsi_host_node);
57 	of_node_put(dsi_host_node);
58 	if (!host)
59 		return dev_err_probe(dev, -EPROBE_DEFER, "Failed to find dsi_host\n");
60 
61 	dsi = devm_mipi_dsi_device_register_full(dev, host, &info);
62 	if (IS_ERR(dsi))
63 		return dev_err_probe(dev, PTR_ERR(dsi), "Failed to create dsi device\n");
64 
65 	dsi->mode_flags = MIPI_DSI_MODE_VIDEO_HSE | MIPI_DSI_MODE_VIDEO |
66 			  MIPI_DSI_CLOCK_NON_CONTINUOUS;
67 	dsi->format = MIPI_DSI_FMT_RGB888;
68 	ret = drm_of_get_data_lanes_count_ep(dev->of_node, 0, 0, 1, 4);
69 	if (ret < 0) {
70 		dev_warn(dev, "Invalid or missing DSI lane count %d, falling back to 2 lanes\n",
71 			 ret);
72 		dsi->lanes = 2;	/* Old DT backward compatibility */
73 	} else {
74 		dsi->lanes = ret;
75 	}
76 
77 	ret = devm_mipi_dsi_attach(dev, dsi);
78 	if (ret < 0)
79 		return dev_err_probe(dev, ret, "Failed to attach dsi to host\n");
80 
81 	return 0;
82 }
83 
84 static int ws_bridge_bridge_attach(struct drm_bridge *bridge,
85 				   struct drm_encoder *encoder,
86 				   enum drm_bridge_attach_flags flags)
87 {
88 	struct ws_bridge *ws = bridge_to_ws_bridge(bridge);
89 
90 	return drm_bridge_attach(encoder, ws->bridge.next_bridge,
91 				 &ws->bridge, flags);
92 }
93 
94 static void ws_bridge_bridge_enable(struct drm_bridge *bridge,
95 				    struct drm_atomic_commit *commit)
96 {
97 	struct ws_bridge *ws = bridge_to_ws_bridge(bridge);
98 
99 	regmap_write(ws->reg_map, 0xad, 0x01);
100 	backlight_enable(ws->backlight);
101 }
102 
103 static void ws_bridge_bridge_disable(struct drm_bridge *bridge,
104 				     struct drm_atomic_commit *commit)
105 {
106 	struct ws_bridge *ws = bridge_to_ws_bridge(bridge);
107 
108 	backlight_disable(ws->backlight);
109 	regmap_write(ws->reg_map, 0xad, 0x00);
110 }
111 
112 static const struct drm_bridge_funcs ws_bridge_bridge_funcs = {
113 	.atomic_create_state = drm_atomic_helper_bridge_create_state,
114 	.atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
115 	.atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
116 	.atomic_enable = ws_bridge_bridge_enable,
117 	.atomic_disable = ws_bridge_bridge_disable,
118 	.attach = ws_bridge_bridge_attach,
119 };
120 
121 static int ws_bridge_bl_update_status(struct backlight_device *bl)
122 {
123 	struct ws_bridge *ws = bl_get_data(bl);
124 
125 	regmap_write(ws->reg_map, 0xab, 0xff - backlight_get_brightness(bl));
126 	regmap_write(ws->reg_map, 0xaa, 0x01);
127 
128 	return 0;
129 }
130 
131 static const struct backlight_ops ws_bridge_bl_ops = {
132 	.update_status = ws_bridge_bl_update_status,
133 };
134 
135 static struct backlight_device *ws_bridge_create_backlight(struct ws_bridge *ws)
136 {
137 	const struct backlight_properties props = {
138 		.type = BACKLIGHT_RAW,
139 		.brightness = 255,
140 		.max_brightness = 255,
141 	};
142 	struct device *dev = ws->dev;
143 
144 	return devm_backlight_device_register(dev, dev_name(dev), dev, ws,
145 					      &ws_bridge_bl_ops, &props);
146 }
147 
148 static int ws_bridge_probe(struct i2c_client *i2c)
149 {
150 	struct device *dev = &i2c->dev;
151 	struct ws_bridge *ws;
152 	int ret;
153 
154 	ws = devm_drm_bridge_alloc(dev, struct ws_bridge, bridge, &ws_bridge_bridge_funcs);
155 	if (IS_ERR(ws))
156 		return PTR_ERR(ws);
157 
158 	ws->dev = dev;
159 
160 	ws->reg_map = devm_regmap_init_i2c(i2c, &ws_regmap_config);
161 	if (IS_ERR(ws->reg_map))
162 		return dev_err_probe(dev, PTR_ERR(ws->reg_map), "Failed to allocate regmap\n");
163 
164 	ws->bridge.next_bridge = of_drm_get_bridge_by_endpoint(dev->of_node, 1, -1);
165 	if (IS_ERR(ws->bridge.next_bridge))
166 		return dev_err_probe(dev, PTR_ERR(ws->bridge.next_bridge),
167 				     "Failed to find remote bridge\n");
168 
169 	ws->backlight = ws_bridge_create_backlight(ws);
170 	if (IS_ERR(ws->backlight)) {
171 		ret = PTR_ERR(ws->backlight);
172 		dev_err(dev, "Failed to create backlight: %d\n", ret);
173 		return ret;
174 	}
175 
176 	regmap_write(ws->reg_map, 0xc0, 0x01);
177 	regmap_write(ws->reg_map, 0xc2, 0x01);
178 	regmap_write(ws->reg_map, 0xac, 0x01);
179 
180 	ws->bridge.type = (uintptr_t)i2c_get_match_data(i2c);
181 	ws->bridge.of_node = dev->of_node;
182 	devm_drm_bridge_add(dev, &ws->bridge);
183 
184 	return ws_bridge_attach_dsi(ws);
185 }
186 
187 static const struct of_device_id ws_bridge_of_ids[] = {
188 	{.compatible = "waveshare,dsi2dpi", .data = (void *)DRM_MODE_CONNECTOR_DPI, },
189 	{.compatible = "waveshare,dsi2lvds", .data = (void *)DRM_MODE_CONNECTOR_LVDS, },
190 	{ }
191 };
192 
193 MODULE_DEVICE_TABLE(of, ws_bridge_of_ids);
194 
195 static struct i2c_driver ws_bridge_driver = {
196 	.driver = {
197 		.name = "ws_dsi2dpi",
198 		.of_match_table = ws_bridge_of_ids,
199 	},
200 	.probe = ws_bridge_probe,
201 };
202 module_i2c_driver(ws_bridge_driver);
203 
204 MODULE_AUTHOR("Joseph Guo <qijian.guo@nxp.com>");
205 MODULE_DESCRIPTION("Waveshare DSI2DPI bridge driver");
206 MODULE_LICENSE("GPL");
207