1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Copyright (c) 2020 Rockchip Electronics Co. Ltd.
4 *
5 * Author: Wyon Bi <bivvy.bi@rock-chips.com>
6 */
7
8 #include <linux/module.h>
9 #include <linux/clk.h>
10 #include <linux/platform_device.h>
11 #include <linux/of.h>
12 #include <linux/regmap.h>
13 #include <linux/mfd/rk628.h>
14 #include <linux/phy/phy.h>
15
16 #include <drm/drm_of.h>
17 #include <drm/drm_atomic.h>
18 #include <drm/drm_probe_helper.h>
19 #include <drm/drm_atomic_helper.h>
20 #include <drm/drm_panel.h>
21
22 #include <video/of_display_timing.h>
23 #include <video/videomode.h>
24
25 enum lvds_format {
26 LVDS_FORMAT_VESA_24BIT,
27 LVDS_FORMAT_JEIDA_24BIT,
28 LVDS_FORMAT_JEIDA_18BIT,
29 LVDS_FORMAT_VESA_18BIT,
30 };
31
32 enum lvds_link_type {
33 LVDS_SINGLE_LINK,
34 LVDS_DUAL_LINK_ODD_EVEN_PIXELS,
35 LVDS_DUAL_LINK_EVEN_ODD_PIXELS,
36 LVDS_DUAL_LINK_LEFT_RIGHT_PIXELS,
37 LVDS_DUAL_LINK_RIGHT_LEFT_PIXELS,
38 };
39
40 struct rk628_lvds {
41 struct drm_bridge base;
42 struct drm_connector connector;
43 struct drm_panel *panel;
44 struct drm_display_mode mode;
45 struct device *dev;
46 struct regmap *grf;
47 struct phy *phy;
48 struct rk628 *parent;
49 enum lvds_format format;
50 enum lvds_link_type link_type;
51 };
52
bridge_to_lvds(struct drm_bridge * b)53 static inline struct rk628_lvds *bridge_to_lvds(struct drm_bridge *b)
54 {
55 return container_of(b, struct rk628_lvds, base);
56 }
57
connector_to_lvds(struct drm_connector * c)58 static inline struct rk628_lvds *connector_to_lvds(struct drm_connector *c)
59 {
60 return container_of(c, struct rk628_lvds, connector);
61 }
62
rk628_lvds_get_format(u32 bus_format)63 static enum lvds_format rk628_lvds_get_format(u32 bus_format)
64 {
65 switch (bus_format) {
66 case MEDIA_BUS_FMT_RGB888_1X7X4_JEIDA:
67 return LVDS_FORMAT_JEIDA_24BIT;
68 case MEDIA_BUS_FMT_RGB666_1X7X3_SPWG:
69 return LVDS_FORMAT_VESA_18BIT;
70 case MEDIA_BUS_FMT_RGB888_1X7X4_SPWG:
71 default:
72 return LVDS_FORMAT_VESA_24BIT;
73 }
74 }
75
rk628_lvds_get_link_type(struct rk628_lvds * lvds)76 static enum lvds_link_type rk628_lvds_get_link_type(struct rk628_lvds *lvds)
77 {
78 struct device *dev = lvds->dev;
79 const char *str;
80 int ret;
81
82 ret = of_property_read_string(dev->of_node, "rockchip,link-type", &str);
83 if (ret < 0)
84 return LVDS_SINGLE_LINK;
85
86 if (!strcmp(str, "dual-link-odd-even-pixels"))
87 return LVDS_DUAL_LINK_ODD_EVEN_PIXELS;
88 else if (!strcmp(str, "dual-link-even-odd-pixels"))
89 return LVDS_DUAL_LINK_EVEN_ODD_PIXELS;
90 else if (!strcmp(str, "dual-link-left-right-pixels"))
91 return LVDS_DUAL_LINK_LEFT_RIGHT_PIXELS;
92 else if (!strcmp(str, "dual-link-right-left-pixels"))
93 return LVDS_DUAL_LINK_RIGHT_LEFT_PIXELS;
94 else
95 return LVDS_SINGLE_LINK;
96 }
97
98 static struct drm_encoder *
rk628_lvds_connector_best_encoder(struct drm_connector * connector)99 rk628_lvds_connector_best_encoder(struct drm_connector *connector)
100 {
101 struct rk628_lvds *lvds = connector_to_lvds(connector);
102
103 return lvds->base.encoder;
104 }
105
rk628_lvds_connector_get_modes(struct drm_connector * connector)106 static int rk628_lvds_connector_get_modes(struct drm_connector *connector)
107 {
108 struct rk628_lvds *lvds = connector_to_lvds(connector);
109 struct drm_display_info *info = &connector->display_info;
110 int num_modes = 0;
111
112 num_modes = drm_panel_get_modes(lvds->panel, connector);
113
114 if (info->num_bus_formats)
115 lvds->format = rk628_lvds_get_format(info->bus_formats[0]);
116 else
117 lvds->format = LVDS_FORMAT_VESA_24BIT;
118
119 return num_modes;
120 }
121
122 static const struct drm_connector_helper_funcs
123 rk628_lvds_connector_helper_funcs = {
124 .get_modes = rk628_lvds_connector_get_modes,
125 .best_encoder = rk628_lvds_connector_best_encoder,
126 };
127
rk628_lvds_connector_destroy(struct drm_connector * connector)128 static void rk628_lvds_connector_destroy(struct drm_connector *connector)
129 {
130 drm_connector_cleanup(connector);
131 }
132
133 static const struct drm_connector_funcs rk628_lvds_connector_funcs = {
134 .fill_modes = drm_helper_probe_single_connector_modes,
135 .destroy = rk628_lvds_connector_destroy,
136 .reset = drm_atomic_helper_connector_reset,
137 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
138 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
139 };
140
rk628_lvds_bridge_enable(struct drm_bridge * bridge)141 static void rk628_lvds_bridge_enable(struct drm_bridge *bridge)
142 {
143 struct rk628_lvds *lvds = bridge_to_lvds(bridge);
144 const struct drm_display_mode *mode = &lvds->mode;
145 u32 val, bus_width;
146 int ret;
147
148 regmap_update_bits(lvds->grf, GRF_SYSTEM_CON0, SW_OUTPUT_MODE_MASK,
149 SW_OUTPUT_MODE(OUTPUT_MODE_LVDS));
150
151 switch (lvds->link_type) {
152 case LVDS_DUAL_LINK_ODD_EVEN_PIXELS:
153 val = SW_LVDS_CON_CHASEL(1) | SW_LVDS_CON_STARTSEL(0) |
154 SW_LVDS_CON_DUAL_SEL(0);
155 bus_width = COMBTXPHY_MODULEA_EN | COMBTXPHY_MODULEB_EN;
156 break;
157 case LVDS_DUAL_LINK_EVEN_ODD_PIXELS:
158 val = SW_LVDS_CON_CHASEL(1) | SW_LVDS_CON_STARTSEL(1) |
159 SW_LVDS_CON_DUAL_SEL(0);
160 bus_width = COMBTXPHY_MODULEA_EN | COMBTXPHY_MODULEB_EN;
161 break;
162 case LVDS_DUAL_LINK_LEFT_RIGHT_PIXELS:
163 val = SW_LVDS_CON_CHASEL(1) | SW_LVDS_CON_STARTSEL(0) |
164 SW_LVDS_CON_DUAL_SEL(1);
165 regmap_update_bits(lvds->grf, GRF_POST_PROC_CON,
166 SW_SPLIT_EN, SW_SPLIT_EN);
167 bus_width = COMBTXPHY_MODULEA_EN | COMBTXPHY_MODULEB_EN;
168 break;
169 case LVDS_DUAL_LINK_RIGHT_LEFT_PIXELS:
170 val = SW_LVDS_CON_CHASEL(1) | SW_LVDS_CON_STARTSEL(1) |
171 SW_LVDS_CON_DUAL_SEL(1);
172 regmap_update_bits(lvds->grf, GRF_POST_PROC_CON,
173 SW_SPLIT_EN, SW_SPLIT_EN);
174 bus_width = COMBTXPHY_MODULEA_EN | COMBTXPHY_MODULEB_EN;
175 break;
176 case LVDS_SINGLE_LINK:
177 default:
178 val = SW_LVDS_CON_CHASEL(0) | SW_LVDS_CON_STARTSEL(0) |
179 SW_LVDS_CON_DUAL_SEL(0);
180 bus_width = COMBTXPHY_MODULEA_EN;
181 break;
182 }
183
184 val |= SW_LVDS_CON_SELECT(lvds->format) |
185 SW_LVDS_CON_MSBSEL(0) |
186 SW_LVDS_CON_CLKINV(0);
187 regmap_write(lvds->grf, GRF_LVDS_TX_CON, val);
188
189 bus_width |= (mode->clock / 1000) << 8;
190 phy_set_bus_width(lvds->phy, bus_width);
191
192 ret = phy_set_mode(lvds->phy, PHY_MODE_LVDS);
193 if (ret) {
194 dev_err(lvds->dev, "failed to set phy mode: %d\n", ret);
195 return;
196 }
197
198 phy_power_on(lvds->phy);
199
200 drm_panel_prepare(lvds->panel);
201 drm_panel_enable(lvds->panel);
202 }
203
rk628_lvds_bridge_disable(struct drm_bridge * bridge)204 static void rk628_lvds_bridge_disable(struct drm_bridge *bridge)
205 {
206 struct rk628_lvds *lvds = bridge_to_lvds(bridge);
207
208 drm_panel_disable(lvds->panel);
209 drm_panel_unprepare(lvds->panel);
210 phy_power_off(lvds->phy);
211 }
212
rk628_lvds_bridge_attach(struct drm_bridge * bridge,enum drm_bridge_attach_flags flags)213 static int rk628_lvds_bridge_attach(struct drm_bridge *bridge,
214 enum drm_bridge_attach_flags flags)
215 {
216 struct rk628_lvds *lvds = bridge_to_lvds(bridge);
217 struct drm_connector *connector = &lvds->connector;
218 struct drm_device *drm = bridge->dev;
219 int ret;
220
221 if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR)
222 return 0;
223
224 ret = drm_connector_init(drm, connector, &rk628_lvds_connector_funcs,
225 DRM_MODE_CONNECTOR_LVDS);
226 if (ret) {
227 dev_err(lvds->dev, "Failed to initialize connector with drm\n");
228 return ret;
229 }
230
231 drm_connector_helper_add(connector, &rk628_lvds_connector_helper_funcs);
232 drm_connector_attach_encoder(connector, bridge->encoder);
233
234 return 0;
235 }
236
rk628_lvds_bridge_mode_set(struct drm_bridge * bridge,const struct drm_display_mode * mode,const struct drm_display_mode * adj)237 static void rk628_lvds_bridge_mode_set(struct drm_bridge *bridge,
238 const struct drm_display_mode *mode,
239 const struct drm_display_mode *adj)
240 {
241 struct rk628_lvds *lvds = bridge_to_lvds(bridge);
242
243 drm_mode_copy(&lvds->mode, mode);
244 }
245
246 static const struct drm_bridge_funcs rk628_lvds_bridge_funcs = {
247 .attach = rk628_lvds_bridge_attach,
248 .enable = rk628_lvds_bridge_enable,
249 .disable = rk628_lvds_bridge_disable,
250 .mode_set = rk628_lvds_bridge_mode_set,
251 };
252
rk628_lvds_probe(struct platform_device * pdev)253 static int rk628_lvds_probe(struct platform_device *pdev)
254 {
255 struct rk628 *rk628 = dev_get_drvdata(pdev->dev.parent);
256 struct device *dev = &pdev->dev;
257 struct rk628_lvds *lvds;
258 int ret;
259
260 if (!of_device_is_available(dev->of_node))
261 return -ENODEV;
262
263 lvds = devm_kzalloc(dev, sizeof(*lvds), GFP_KERNEL);
264 if (!lvds)
265 return -ENOMEM;
266
267 ret = drm_of_find_panel_or_bridge(dev->of_node, 1, -1,
268 &lvds->panel, NULL);
269 if (ret)
270 return ret;
271
272 lvds->dev = dev;
273 lvds->parent = rk628;
274 lvds->grf = rk628->grf;
275 lvds->link_type = rk628_lvds_get_link_type(lvds);
276 platform_set_drvdata(pdev, lvds);
277
278 lvds->phy = devm_of_phy_get(dev, dev->of_node, NULL);
279 if (IS_ERR(lvds->phy)) {
280 ret = PTR_ERR(lvds->phy);
281 dev_err(dev, "failed to get phy: %d\n", ret);
282 return ret;
283 }
284
285 lvds->base.funcs = &rk628_lvds_bridge_funcs;
286 lvds->base.of_node = dev->of_node;
287 drm_bridge_add(&lvds->base);
288
289 return 0;
290 }
291
rk628_lvds_remove(struct platform_device * pdev)292 static int rk628_lvds_remove(struct platform_device *pdev)
293 {
294 struct rk628_lvds *lvds = platform_get_drvdata(pdev);
295
296 drm_bridge_remove(&lvds->base);
297
298 return 0;
299 }
300
301 static const struct of_device_id rk628_lvds_of_match[] = {
302 { .compatible = "rockchip,rk628-lvds", },
303 {},
304 };
305 MODULE_DEVICE_TABLE(of, rk628_lvds_of_match);
306
307 static struct platform_driver rk628_lvds_driver = {
308 .driver = {
309 .name = "rk628-lvds",
310 .of_match_table = of_match_ptr(rk628_lvds_of_match),
311 },
312 .probe = rk628_lvds_probe,
313 .remove = rk628_lvds_remove,
314 };
315 module_platform_driver(rk628_lvds_driver);
316
317 MODULE_AUTHOR("Wyon Bi <bivvy.bi@rock-chips.com>");
318 MODULE_DESCRIPTION("Rockchip RK628 LVDS driver");
319 MODULE_LICENSE("GPL v2");
320