1 // SPDX-License-Identifier: GPL-2.0+
3 * Copyright (C) 2020 Amarula Solutions(India)
4 * Author: Jagan Teki <jagan@amarulasolutions.com>
7 #include <drm/drm_atomic_helper.h>
8 #include <drm/drm_of.h>
9 #include <drm/drm_print.h>
10 #include <drm/drm_mipi_dsi.h>
12 #include <linux/delay.h>
13 #include <linux/gpio/consumer.h>
14 #include <linux/module.h>
15 #include <linux/of_device.h>
16 #include <linux/regulator/consumer.h>
18 #include <video/mipi_display.h>
20 #define HACTIVE_LI 0x20
21 #define VACTIVE_LI 0x21
22 #define VACTIVE_HACTIVE_HI 0x22
26 #define HFP_HSW_HBP_HI 0x26
33 struct drm_bridge bridge;
34 struct drm_bridge *panel_bridge;
35 struct gpio_desc *enable_gpio;
36 struct regulator *vdd1;
37 struct regulator *vdd2;
38 struct regulator *vdd3;
41 static inline struct chipone *bridge_to_chipone(struct drm_bridge *bridge)
43 return container_of(bridge, struct chipone, bridge);
46 static struct drm_display_mode *bridge_to_mode(struct drm_bridge *bridge)
48 return &bridge->encoder->crtc->state->adjusted_mode;
51 static inline int chipone_dsi_write(struct chipone *icn, const void *seq,
54 struct mipi_dsi_device *dsi = to_mipi_dsi_device(icn->dev);
56 return mipi_dsi_generic_write(dsi, seq, len);
59 #define ICN6211_DSI(icn, seq...) \
61 const u8 d[] = { seq }; \
62 chipone_dsi_write(icn, d, ARRAY_SIZE(d)); \
65 static void chipone_atomic_enable(struct drm_bridge *bridge,
66 struct drm_bridge_state *old_bridge_state)
68 struct chipone *icn = bridge_to_chipone(bridge);
69 struct drm_display_mode *mode = bridge_to_mode(bridge);
71 ICN6211_DSI(icn, 0x7a, 0xc1);
73 ICN6211_DSI(icn, HACTIVE_LI, mode->hdisplay & 0xff);
75 ICN6211_DSI(icn, VACTIVE_LI, mode->vdisplay & 0xff);
78 * lsb nibble: 2nd nibble of hdisplay
79 * msb nibble: 2nd nibble of vdisplay
81 ICN6211_DSI(icn, VACTIVE_HACTIVE_HI,
82 ((mode->hdisplay >> 8) & 0xf) |
83 (((mode->vdisplay >> 8) & 0xf) << 4));
85 ICN6211_DSI(icn, HFP_LI, mode->hsync_start - mode->hdisplay);
87 ICN6211_DSI(icn, HSYNC_LI, mode->hsync_end - mode->hsync_start);
89 ICN6211_DSI(icn, HBP_LI, mode->htotal - mode->hsync_end);
91 ICN6211_DSI(icn, HFP_HSW_HBP_HI, 0x00);
93 ICN6211_DSI(icn, VFP, mode->vsync_start - mode->vdisplay);
95 ICN6211_DSI(icn, VSYNC, mode->vsync_end - mode->vsync_start);
97 ICN6211_DSI(icn, VBP, mode->vtotal - mode->vsync_end);
99 /* dsi specific sequence */
100 ICN6211_DSI(icn, MIPI_DCS_SET_TEAR_OFF, 0x80);
101 ICN6211_DSI(icn, MIPI_DCS_SET_ADDRESS_MODE, 0x28);
102 ICN6211_DSI(icn, 0xb5, 0xa0);
103 ICN6211_DSI(icn, 0x5c, 0xff);
104 ICN6211_DSI(icn, MIPI_DCS_SET_COLUMN_ADDRESS, 0x01);
105 ICN6211_DSI(icn, MIPI_DCS_GET_POWER_SAVE, 0x92);
106 ICN6211_DSI(icn, 0x6b, 0x71);
107 ICN6211_DSI(icn, 0x69, 0x2b);
108 ICN6211_DSI(icn, MIPI_DCS_ENTER_SLEEP_MODE, 0x40);
109 ICN6211_DSI(icn, MIPI_DCS_EXIT_SLEEP_MODE, 0x98);
111 /* icn6211 specific sequence */
112 ICN6211_DSI(icn, 0xb6, 0x20);
113 ICN6211_DSI(icn, 0x51, 0x20);
114 ICN6211_DSI(icn, 0x09, 0x10);
116 usleep_range(10000, 11000);
119 static void chipone_atomic_pre_enable(struct drm_bridge *bridge,
120 struct drm_bridge_state *old_bridge_state)
122 struct chipone *icn = bridge_to_chipone(bridge);
126 ret = regulator_enable(icn->vdd1);
128 DRM_DEV_ERROR(icn->dev,
129 "failed to enable VDD1 regulator: %d\n", ret);
133 ret = regulator_enable(icn->vdd2);
135 DRM_DEV_ERROR(icn->dev,
136 "failed to enable VDD2 regulator: %d\n", ret);
140 ret = regulator_enable(icn->vdd3);
142 DRM_DEV_ERROR(icn->dev,
143 "failed to enable VDD3 regulator: %d\n", ret);
146 gpiod_set_value(icn->enable_gpio, 1);
148 usleep_range(10000, 11000);
151 static void chipone_atomic_post_disable(struct drm_bridge *bridge,
152 struct drm_bridge_state *old_bridge_state)
154 struct chipone *icn = bridge_to_chipone(bridge);
157 regulator_disable(icn->vdd1);
160 regulator_disable(icn->vdd2);
163 regulator_disable(icn->vdd3);
165 gpiod_set_value(icn->enable_gpio, 0);
168 static int chipone_attach(struct drm_bridge *bridge, enum drm_bridge_attach_flags flags)
170 struct chipone *icn = bridge_to_chipone(bridge);
172 return drm_bridge_attach(bridge->encoder, icn->panel_bridge, bridge, flags);
175 static const struct drm_bridge_funcs chipone_bridge_funcs = {
176 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state,
177 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state,
178 .atomic_reset = drm_atomic_helper_bridge_reset,
179 .atomic_pre_enable = chipone_atomic_pre_enable,
180 .atomic_enable = chipone_atomic_enable,
181 .atomic_post_disable = chipone_atomic_post_disable,
182 .attach = chipone_attach,
185 static int chipone_parse_dt(struct chipone *icn)
187 struct device *dev = icn->dev;
188 struct drm_panel *panel;
191 icn->vdd1 = devm_regulator_get_optional(dev, "vdd1");
192 if (IS_ERR(icn->vdd1)) {
193 ret = PTR_ERR(icn->vdd1);
194 if (ret == -EPROBE_DEFER)
195 return -EPROBE_DEFER;
197 DRM_DEV_DEBUG(dev, "failed to get VDD1 regulator: %d\n", ret);
200 icn->vdd2 = devm_regulator_get_optional(dev, "vdd2");
201 if (IS_ERR(icn->vdd2)) {
202 ret = PTR_ERR(icn->vdd2);
203 if (ret == -EPROBE_DEFER)
204 return -EPROBE_DEFER;
206 DRM_DEV_DEBUG(dev, "failed to get VDD2 regulator: %d\n", ret);
209 icn->vdd3 = devm_regulator_get_optional(dev, "vdd3");
210 if (IS_ERR(icn->vdd3)) {
211 ret = PTR_ERR(icn->vdd3);
212 if (ret == -EPROBE_DEFER)
213 return -EPROBE_DEFER;
215 DRM_DEV_DEBUG(dev, "failed to get VDD3 regulator: %d\n", ret);
218 icn->enable_gpio = devm_gpiod_get(dev, "enable", GPIOD_OUT_LOW);
219 if (IS_ERR(icn->enable_gpio)) {
220 DRM_DEV_ERROR(dev, "failed to get enable GPIO\n");
221 return PTR_ERR(icn->enable_gpio);
224 ret = drm_of_find_panel_or_bridge(dev->of_node, 1, 0, &panel, NULL);
228 icn->panel_bridge = devm_drm_panel_bridge_add(dev, panel);
229 if (IS_ERR(icn->panel_bridge))
230 return PTR_ERR(icn->panel_bridge);
235 static int chipone_probe(struct mipi_dsi_device *dsi)
237 struct device *dev = &dsi->dev;
241 icn = devm_kzalloc(dev, sizeof(struct chipone), GFP_KERNEL);
245 mipi_dsi_set_drvdata(dsi, icn);
248 ret = chipone_parse_dt(icn);
252 icn->bridge.funcs = &chipone_bridge_funcs;
253 icn->bridge.type = DRM_MODE_CONNECTOR_DPI;
254 icn->bridge.of_node = dev->of_node;
256 drm_bridge_add(&icn->bridge);
259 dsi->format = MIPI_DSI_FMT_RGB888;
260 dsi->mode_flags = MIPI_DSI_MODE_VIDEO_SYNC_PULSE;
262 ret = mipi_dsi_attach(dsi);
264 drm_bridge_remove(&icn->bridge);
265 dev_err(dev, "failed to attach dsi\n");
271 static int chipone_remove(struct mipi_dsi_device *dsi)
273 struct chipone *icn = mipi_dsi_get_drvdata(dsi);
275 mipi_dsi_detach(dsi);
276 drm_bridge_remove(&icn->bridge);
281 static const struct of_device_id chipone_of_match[] = {
282 { .compatible = "chipone,icn6211", },
285 MODULE_DEVICE_TABLE(of, chipone_of_match);
287 static struct mipi_dsi_driver chipone_driver = {
288 .probe = chipone_probe,
289 .remove = chipone_remove,
291 .name = "chipone-icn6211",
292 .owner = THIS_MODULE,
293 .of_match_table = chipone_of_match,
296 module_mipi_dsi_driver(chipone_driver);
298 MODULE_AUTHOR("Jagan Teki <jagan@amarulasolutions.com>");
299 MODULE_DESCRIPTION("Chipone ICN6211 MIPI-DSI to RGB Converter Bridge");
300 MODULE_LICENSE("GPL");