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 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_bridge.h>
16#include <drm/drm_mipi_dsi.h>
17#include <drm/drm_of.h>
18#include <drm/drm_panel.h>
19
20struct ws_bridge {
21 struct drm_bridge bridge;
22 struct drm_bridge *next_bridge;
23 struct backlight_device *backlight;
24 struct device *dev;
25 struct regmap *reg_map;
26};
27
28static const struct regmap_config ws_regmap_config = {
29 .reg_bits = 8,
30 .val_bits = 8,
31 .max_register = 0xff,
32};
33
34static struct ws_bridge *bridge_to_ws_bridge(struct drm_bridge *bridge)
35{
36 return container_of(bridge, struct ws_bridge, bridge);
37}
38
39static int ws_bridge_attach_dsi(struct ws_bridge *ws)
40{
41 const struct mipi_dsi_device_info info = {
42 .type = "ws-bridge",
43 .channel = 0,
44 .node = NULL,
45 };
46 struct device_node *dsi_host_node;
47 struct device *dev = ws->dev;
48 struct mipi_dsi_device *dsi;
49 struct mipi_dsi_host *host;
50 int ret;
51
52 dsi_host_node = of_graph_get_remote_node(dev->of_node, 0, 0);
53 if (!dsi_host_node) {
54 dev_err(dev, "Failed to get remote port\n");
55 return -ENODEV;
56 }
57 host = of_find_mipi_dsi_host_by_node(dsi_host_node);
58 of_node_put(dsi_host_node);
59 if (!host)
60 return dev_err_probe(dev, -EPROBE_DEFER, "Failed to find dsi_host\n");
61
62 dsi = devm_mipi_dsi_device_register_full(dev, host, &info);
63 if (IS_ERR(dsi))
64 return dev_err_probe(dev, PTR_ERR(dsi), "Failed to create dsi device\n");
65
66 dsi->mode_flags = MIPI_DSI_MODE_VIDEO_HSE | MIPI_DSI_MODE_VIDEO |
67 MIPI_DSI_CLOCK_NON_CONTINUOUS;
68 dsi->format = MIPI_DSI_FMT_RGB888;
69 ret = drm_of_get_data_lanes_count_ep(dev->of_node, 0, 0, 1, 4);
70 if (ret < 0) {
71 dev_warn(dev, "Invalid or missing DSI lane count %d, falling back to 2 lanes\n",
72 ret);
73 dsi->lanes = 2; /* Old DT backward compatibility */
74 } else {
75 dsi->lanes = ret;
76 }
77
78 ret = devm_mipi_dsi_attach(dev, dsi);
79 if (ret < 0)
80 return dev_err_probe(dev, ret, "Failed to attach dsi to host\n");
81
82 return 0;
83}
84
85static int ws_bridge_bridge_attach(struct drm_bridge *bridge,
86 struct drm_encoder *encoder,
87 enum drm_bridge_attach_flags flags)
88{
89 struct ws_bridge *ws = bridge_to_ws_bridge(bridge);
90
91 return drm_bridge_attach(encoder, ws->next_bridge,
92 &ws->bridge, flags);
93}
94
95static void ws_bridge_bridge_enable(struct drm_bridge *bridge)
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
103static void ws_bridge_bridge_disable(struct drm_bridge *bridge)
104{
105 struct ws_bridge *ws = bridge_to_ws_bridge(bridge);
106
107 backlight_disable(ws->backlight);
108 regmap_write(ws->reg_map, 0xad, 0x00);
109}
110
111static const struct drm_bridge_funcs ws_bridge_bridge_funcs = {
112 .enable = ws_bridge_bridge_enable,
113 .disable = ws_bridge_bridge_disable,
114 .attach = ws_bridge_bridge_attach,
115};
116
117static int ws_bridge_bl_update_status(struct backlight_device *bl)
118{
119 struct ws_bridge *ws = bl_get_data(bl);
120
121 regmap_write(ws->reg_map, 0xab, 0xff - backlight_get_brightness(bl));
122 regmap_write(ws->reg_map, 0xaa, 0x01);
123
124 return 0;
125}
126
127static const struct backlight_ops ws_bridge_bl_ops = {
128 .update_status = ws_bridge_bl_update_status,
129};
130
131static struct backlight_device *ws_bridge_create_backlight(struct ws_bridge *ws)
132{
133 const struct backlight_properties props = {
134 .type = BACKLIGHT_RAW,
135 .brightness = 255,
136 .max_brightness = 255,
137 };
138 struct device *dev = ws->dev;
139
140 return devm_backlight_device_register(dev, dev_name(dev), dev, ws,
141 &ws_bridge_bl_ops, &props);
142}
143
144static int ws_bridge_probe(struct i2c_client *i2c)
145{
146 struct device *dev = &i2c->dev;
147 struct drm_panel *panel;
148 struct ws_bridge *ws;
149 int ret;
150
151 ws = devm_drm_bridge_alloc(dev, struct ws_bridge, bridge, &ws_bridge_bridge_funcs);
152 if (IS_ERR(ws))
153 return PTR_ERR(ws);
154
155 ws->dev = dev;
156
157 ws->reg_map = devm_regmap_init_i2c(i2c, &ws_regmap_config);
158 if (IS_ERR(ws->reg_map))
159 return dev_err_probe(dev, PTR_ERR(ws->reg_map), "Failed to allocate regmap\n");
160
161 ret = drm_of_find_panel_or_bridge(dev->of_node, 1, -1, &panel, NULL);
162 if (ret)
163 return dev_err_probe(dev, ret, "Failed to find remote panel\n");
164
165 ws->next_bridge = devm_drm_panel_bridge_add(dev, panel);
166 if (IS_ERR(ws->next_bridge))
167 return PTR_ERR(ws->next_bridge);
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 = DRM_MODE_CONNECTOR_DPI;
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
187static const struct of_device_id ws_bridge_of_ids[] = {
188 {.compatible = "waveshare,dsi2dpi",},
189 { }
190};
191
192MODULE_DEVICE_TABLE(of, ws_bridge_of_ids);
193
194static struct i2c_driver ws_bridge_driver = {
195 .driver = {
196 .name = "ws_dsi2dpi",
197 .of_match_table = ws_bridge_of_ids,
198 },
199 .probe = ws_bridge_probe,
200};
201module_i2c_driver(ws_bridge_driver);
202
203MODULE_AUTHOR("Joseph Guo <qijian.guo@nxp.com>");
204MODULE_DESCRIPTION("Waveshare DSI2DPI bridge driver");
205MODULE_LICENSE("GPL");