1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * MIPI-DSI Samsung s6d16d0 panel driver. This is a 864x480
4 * AMOLED panel with a command-only DSI interface.
5 */
6
7 #include <drm/drm_modes.h>
8 #include <drm/drm_mipi_dsi.h>
9 #include <drm/drm_panel.h>
10
11 #include <linux/gpio/consumer.h>
12 #include <linux/regulator/consumer.h>
13 #include <linux/delay.h>
14 #include <linux/module.h>
15
16 struct s6d16d0 {
17 struct device *dev;
18 struct drm_panel panel;
19 struct regulator *supply;
20 struct gpio_desc *reset_gpio;
21 };
22
23 /*
24 * The timings are not very helpful as the display is used in
25 * command mode.
26 */
27 static const struct drm_display_mode samsung_s6d16d0_mode = {
28 /* HS clock, (htotal*vtotal*vrefresh)/1000 */
29 .clock = 420160,
30 .hdisplay = 864,
31 .hsync_start = 864 + 154,
32 .hsync_end = 864 + 154 + 16,
33 .htotal = 864 + 154 + 16 + 32,
34 .vdisplay = 480,
35 .vsync_start = 480 + 1,
36 .vsync_end = 480 + 1 + 1,
37 .vtotal = 480 + 1 + 1 + 1,
38 .width_mm = 84,
39 .height_mm = 48,
40 };
41
panel_to_s6d16d0(struct drm_panel * panel)42 static inline struct s6d16d0 *panel_to_s6d16d0(struct drm_panel *panel)
43 {
44 return container_of(panel, struct s6d16d0, panel);
45 }
46
s6d16d0_unprepare(struct drm_panel * panel)47 static int s6d16d0_unprepare(struct drm_panel *panel)
48 {
49 struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
50 struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
51 int ret;
52
53 /* Enter sleep mode */
54 ret = mipi_dsi_dcs_enter_sleep_mode(dsi);
55 if (ret) {
56 dev_err(s6->dev, "failed to enter sleep mode (%d)\n", ret);
57 return ret;
58 }
59
60 /* Assert RESET */
61 gpiod_set_value_cansleep(s6->reset_gpio, 1);
62 regulator_disable(s6->supply);
63
64 return 0;
65 }
66
s6d16d0_prepare(struct drm_panel * panel)67 static int s6d16d0_prepare(struct drm_panel *panel)
68 {
69 struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
70 struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
71 int ret;
72
73 ret = regulator_enable(s6->supply);
74 if (ret) {
75 dev_err(s6->dev, "failed to enable supply (%d)\n", ret);
76 return ret;
77 }
78
79 /* Assert RESET */
80 gpiod_set_value_cansleep(s6->reset_gpio, 1);
81 udelay(10);
82 /* De-assert RESET */
83 gpiod_set_value_cansleep(s6->reset_gpio, 0);
84 msleep(120);
85
86 /* Enabe tearing mode: send TE (tearing effect) at VBLANK */
87 ret = mipi_dsi_dcs_set_tear_on(dsi,
88 MIPI_DSI_DCS_TEAR_MODE_VBLANK);
89 if (ret) {
90 dev_err(s6->dev, "failed to enable vblank TE (%d)\n", ret);
91 goto err_power_off;
92 }
93 /* Exit sleep mode and power on */
94 ret = mipi_dsi_dcs_exit_sleep_mode(dsi);
95 if (ret) {
96 dev_err(s6->dev, "failed to exit sleep mode (%d)\n", ret);
97 goto err_power_off;
98 }
99
100 return 0;
101
102 err_power_off:
103 gpiod_set_value_cansleep(s6->reset_gpio, 1);
104 regulator_disable(s6->supply);
105
106 return ret;
107 }
108
s6d16d0_enable(struct drm_panel * panel)109 static int s6d16d0_enable(struct drm_panel *panel)
110 {
111 struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
112 struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
113 int ret;
114
115 ret = mipi_dsi_dcs_set_display_on(dsi);
116 if (ret) {
117 dev_err(s6->dev, "failed to turn display on (%d)\n", ret);
118 return ret;
119 }
120
121 return 0;
122 }
123
s6d16d0_disable(struct drm_panel * panel)124 static int s6d16d0_disable(struct drm_panel *panel)
125 {
126 struct s6d16d0 *s6 = panel_to_s6d16d0(panel);
127 struct mipi_dsi_device *dsi = to_mipi_dsi_device(s6->dev);
128 int ret;
129
130 ret = mipi_dsi_dcs_set_display_off(dsi);
131 if (ret) {
132 dev_err(s6->dev, "failed to turn display off (%d)\n", ret);
133 return ret;
134 }
135
136 return 0;
137 }
138
s6d16d0_get_modes(struct drm_panel * panel,struct drm_connector * connector)139 static int s6d16d0_get_modes(struct drm_panel *panel,
140 struct drm_connector *connector)
141 {
142 struct drm_display_mode *mode;
143
144 mode = drm_mode_duplicate(connector->dev, &samsung_s6d16d0_mode);
145 if (!mode) {
146 dev_err(panel->dev, "bad mode or failed to add mode\n");
147 return -EINVAL;
148 }
149 drm_mode_set_name(mode);
150 mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
151
152 connector->display_info.width_mm = mode->width_mm;
153 connector->display_info.height_mm = mode->height_mm;
154
155 drm_mode_probed_add(connector, mode);
156
157 return 1; /* Number of modes */
158 }
159
160 static const struct drm_panel_funcs s6d16d0_drm_funcs = {
161 .disable = s6d16d0_disable,
162 .unprepare = s6d16d0_unprepare,
163 .prepare = s6d16d0_prepare,
164 .enable = s6d16d0_enable,
165 .get_modes = s6d16d0_get_modes,
166 };
167
s6d16d0_probe(struct mipi_dsi_device * dsi)168 static int s6d16d0_probe(struct mipi_dsi_device *dsi)
169 {
170 struct device *dev = &dsi->dev;
171 struct s6d16d0 *s6;
172 int ret;
173
174 s6 = devm_drm_panel_alloc(dev, struct s6d16d0, panel,
175 &s6d16d0_drm_funcs,
176 DRM_MODE_CONNECTOR_DSI);
177 if (IS_ERR(s6))
178 return PTR_ERR(s6);
179
180 mipi_dsi_set_drvdata(dsi, s6);
181 s6->dev = dev;
182
183 dsi->lanes = 2;
184 dsi->format = MIPI_DSI_FMT_RGB888;
185 dsi->hs_rate = 420160000;
186 dsi->lp_rate = 19200000;
187 /*
188 * This display uses command mode so no MIPI_DSI_MODE_VIDEO
189 * or MIPI_DSI_MODE_VIDEO_SYNC_PULSE
190 *
191 * As we only send commands we do not need to be continuously
192 * clocked.
193 */
194 dsi->mode_flags = MIPI_DSI_CLOCK_NON_CONTINUOUS;
195
196 s6->supply = devm_regulator_get(dev, "vdd1");
197 if (IS_ERR(s6->supply))
198 return PTR_ERR(s6->supply);
199
200 /* This asserts RESET by default */
201 s6->reset_gpio = devm_gpiod_get_optional(dev, "reset",
202 GPIOD_OUT_HIGH);
203 if (IS_ERR(s6->reset_gpio)) {
204 ret = PTR_ERR(s6->reset_gpio);
205 if (ret != -EPROBE_DEFER)
206 dev_err(dev, "failed to request GPIO (%d)\n", ret);
207 return ret;
208 }
209
210 drm_panel_add(&s6->panel);
211
212 ret = mipi_dsi_attach(dsi);
213 if (ret < 0)
214 drm_panel_remove(&s6->panel);
215
216 return ret;
217 }
218
s6d16d0_remove(struct mipi_dsi_device * dsi)219 static void s6d16d0_remove(struct mipi_dsi_device *dsi)
220 {
221 struct s6d16d0 *s6 = mipi_dsi_get_drvdata(dsi);
222
223 mipi_dsi_detach(dsi);
224 drm_panel_remove(&s6->panel);
225 }
226
227 static const struct of_device_id s6d16d0_of_match[] = {
228 { .compatible = "samsung,s6d16d0" },
229 { }
230 };
231 MODULE_DEVICE_TABLE(of, s6d16d0_of_match);
232
233 static struct mipi_dsi_driver s6d16d0_driver = {
234 .probe = s6d16d0_probe,
235 .remove = s6d16d0_remove,
236 .driver = {
237 .name = "panel-samsung-s6d16d0",
238 .of_match_table = s6d16d0_of_match,
239 },
240 };
241 module_mipi_dsi_driver(s6d16d0_driver);
242
243 MODULE_AUTHOR("Linus Wallei <linus.walleij@linaro.org>");
244 MODULE_DESCRIPTION("MIPI-DSI s6d16d0 Panel Driver");
245 MODULE_LICENSE("GPL v2");
246