Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2017 NXP Semiconductors.
4 * Author: Marco Franchi <marco.franchi@nxp.com>
5 *
6 * Based on Panel Simple driver by Thierry Reding <treding@nvidia.com>
7 */
8
9#include <linux/delay.h>
10#include <linux/gpio/consumer.h>
11#include <linux/media-bus-format.h>
12#include <linux/module.h>
13#include <linux/of.h>
14#include <linux/platform_device.h>
15#include <linux/regulator/consumer.h>
16
17#include <video/display_timing.h>
18#include <video/videomode.h>
19
20#include <drm/drm_crtc.h>
21#include <drm/drm_device.h>
22#include <drm/drm_panel.h>
23
24struct seiko_panel_desc {
25 const struct drm_display_mode *modes;
26 unsigned int num_modes;
27 const struct display_timing *timings;
28 unsigned int num_timings;
29
30 unsigned int bpc;
31
32 /**
33 * @width: width (in millimeters) of the panel's active display area
34 * @height: height (in millimeters) of the panel's active display area
35 */
36 struct {
37 unsigned int width;
38 unsigned int height;
39 } size;
40
41 u32 bus_format;
42 u32 bus_flags;
43};
44
45struct seiko_panel {
46 struct drm_panel base;
47 const struct seiko_panel_desc *desc;
48 struct regulator *dvdd;
49 struct regulator *avdd;
50 struct gpio_desc *enable_gpio;
51};
52
53static inline struct seiko_panel *to_seiko_panel(struct drm_panel *panel)
54{
55 return container_of(panel, struct seiko_panel, base);
56}
57
58static int seiko_panel_get_fixed_modes(struct seiko_panel *panel,
59 struct drm_connector *connector)
60{
61 struct drm_display_mode *mode;
62 unsigned int i, num = 0;
63
64 if (!panel->desc)
65 return 0;
66
67 for (i = 0; i < panel->desc->num_timings; i++) {
68 const struct display_timing *dt = &panel->desc->timings[i];
69 struct videomode vm;
70
71 videomode_from_timing(dt, &vm);
72 mode = drm_mode_create(connector->dev);
73 if (!mode) {
74 dev_err(panel->base.dev, "failed to add mode %ux%u\n",
75 dt->hactive.typ, dt->vactive.typ);
76 continue;
77 }
78
79 drm_display_mode_from_videomode(&vm, mode);
80
81 mode->type |= DRM_MODE_TYPE_DRIVER;
82
83 if (panel->desc->num_timings == 1)
84 mode->type |= DRM_MODE_TYPE_PREFERRED;
85
86 drm_mode_probed_add(connector, mode);
87 num++;
88 }
89
90 for (i = 0; i < panel->desc->num_modes; i++) {
91 const struct drm_display_mode *m = &panel->desc->modes[i];
92
93 mode = drm_mode_duplicate(connector->dev, m);
94 if (!mode) {
95 dev_err(panel->base.dev, "failed to add mode %ux%u@%u\n",
96 m->hdisplay, m->vdisplay,
97 drm_mode_vrefresh(m));
98 continue;
99 }
100
101 mode->type |= DRM_MODE_TYPE_DRIVER;
102
103 if (panel->desc->num_modes == 1)
104 mode->type |= DRM_MODE_TYPE_PREFERRED;
105
106 drm_mode_set_name(mode);
107
108 drm_mode_probed_add(connector, mode);
109 num++;
110 }
111
112 connector->display_info.bpc = panel->desc->bpc;
113 connector->display_info.width_mm = panel->desc->size.width;
114 connector->display_info.height_mm = panel->desc->size.height;
115 if (panel->desc->bus_format)
116 drm_display_info_set_bus_formats(&connector->display_info,
117 &panel->desc->bus_format, 1);
118 connector->display_info.bus_flags = panel->desc->bus_flags;
119
120 return num;
121}
122
123static int seiko_panel_unprepare(struct drm_panel *panel)
124{
125 struct seiko_panel *p = to_seiko_panel(panel);
126
127 gpiod_set_value_cansleep(p->enable_gpio, 0);
128
129 regulator_disable(p->avdd);
130
131 /* Add a 100ms delay as per the panel datasheet */
132 msleep(100);
133
134 regulator_disable(p->dvdd);
135
136 return 0;
137}
138
139static int seiko_panel_prepare(struct drm_panel *panel)
140{
141 struct seiko_panel *p = to_seiko_panel(panel);
142 int err;
143
144 err = regulator_enable(p->dvdd);
145 if (err < 0) {
146 dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
147 return err;
148 }
149
150 /* Add a 100ms delay as per the panel datasheet */
151 msleep(100);
152
153 err = regulator_enable(p->avdd);
154 if (err < 0) {
155 dev_err(panel->dev, "failed to enable avdd: %d\n", err);
156 goto disable_dvdd;
157 }
158
159 gpiod_set_value_cansleep(p->enable_gpio, 1);
160
161 return 0;
162
163disable_dvdd:
164 regulator_disable(p->dvdd);
165 return err;
166}
167
168static int seiko_panel_get_modes(struct drm_panel *panel,
169 struct drm_connector *connector)
170{
171 struct seiko_panel *p = to_seiko_panel(panel);
172
173 /* add hard-coded panel modes */
174 return seiko_panel_get_fixed_modes(p, connector);
175}
176
177static int seiko_panel_get_timings(struct drm_panel *panel,
178 unsigned int num_timings,
179 struct display_timing *timings)
180{
181 struct seiko_panel *p = to_seiko_panel(panel);
182 unsigned int i;
183
184 if (p->desc->num_timings < num_timings)
185 num_timings = p->desc->num_timings;
186
187 if (timings)
188 for (i = 0; i < num_timings; i++)
189 timings[i] = p->desc->timings[i];
190
191 return p->desc->num_timings;
192}
193
194static const struct drm_panel_funcs seiko_panel_funcs = {
195 .unprepare = seiko_panel_unprepare,
196 .prepare = seiko_panel_prepare,
197 .get_modes = seiko_panel_get_modes,
198 .get_timings = seiko_panel_get_timings,
199};
200
201static int seiko_panel_probe(struct device *dev,
202 const struct seiko_panel_desc *desc)
203{
204 struct seiko_panel *panel;
205 int err;
206
207 panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
208 if (!panel)
209 return -ENOMEM;
210
211 panel->desc = desc;
212
213 panel->dvdd = devm_regulator_get(dev, "dvdd");
214 if (IS_ERR(panel->dvdd))
215 return PTR_ERR(panel->dvdd);
216
217 panel->avdd = devm_regulator_get(dev, "avdd");
218 if (IS_ERR(panel->avdd))
219 return PTR_ERR(panel->avdd);
220
221 panel->enable_gpio = devm_gpiod_get_optional(dev, "enable",
222 GPIOD_OUT_LOW);
223 if (IS_ERR(panel->enable_gpio))
224 return dev_err_probe(dev, PTR_ERR(panel->enable_gpio),
225 "failed to request GPIO\n");
226
227 drm_panel_init(&panel->base, dev, &seiko_panel_funcs,
228 DRM_MODE_CONNECTOR_DPI);
229
230 err = drm_panel_of_backlight(&panel->base);
231 if (err)
232 return err;
233
234 drm_panel_add(&panel->base);
235
236 dev_set_drvdata(dev, panel);
237
238 return 0;
239}
240
241static void seiko_panel_remove(struct platform_device *pdev)
242{
243 struct seiko_panel *panel = platform_get_drvdata(pdev);
244
245 drm_panel_remove(&panel->base);
246}
247
248static const struct display_timing seiko_43wvf1g_timing = {
249 .pixelclock = { 33500000, 33500000, 33500000 },
250 .hactive = { 800, 800, 800 },
251 .hfront_porch = { 164, 164, 164 },
252 .hback_porch = { 89, 89, 89 },
253 .hsync_len = { 10, 10, 10 },
254 .vactive = { 480, 480, 480 },
255 .vfront_porch = { 10, 10, 10 },
256 .vback_porch = { 23, 23, 23 },
257 .vsync_len = { 10, 10, 10 },
258 .flags = DISPLAY_FLAGS_DE_LOW,
259};
260
261static const struct seiko_panel_desc seiko_43wvf1g = {
262 .timings = &seiko_43wvf1g_timing,
263 .num_timings = 1,
264 .bpc = 8,
265 .size = {
266 .width = 93,
267 .height = 57,
268 },
269 .bus_format = MEDIA_BUS_FMT_RGB888_1X24,
270 .bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE,
271};
272
273static const struct of_device_id platform_of_match[] = {
274 {
275 .compatible = "sii,43wvf1g",
276 .data = &seiko_43wvf1g,
277 }, {
278 /* sentinel */
279 }
280};
281MODULE_DEVICE_TABLE(of, platform_of_match);
282
283static int seiko_panel_platform_probe(struct platform_device *pdev)
284{
285 const struct of_device_id *id;
286
287 id = of_match_node(platform_of_match, pdev->dev.of_node);
288 if (!id)
289 return -ENODEV;
290
291 return seiko_panel_probe(&pdev->dev, id->data);
292}
293
294static struct platform_driver seiko_panel_platform_driver = {
295 .driver = {
296 .name = "seiko_panel",
297 .of_match_table = platform_of_match,
298 },
299 .probe = seiko_panel_platform_probe,
300 .remove = seiko_panel_remove,
301};
302module_platform_driver(seiko_panel_platform_driver);
303
304MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>");
305MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
306MODULE_LICENSE("GPL v2");
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2017 NXP Semiconductors.
4 * Author: Marco Franchi <marco.franchi@nxp.com>
5 *
6 * Based on Panel Simple driver by Thierry Reding <treding@nvidia.com>
7 */
8
9#include <linux/delay.h>
10#include <linux/module.h>
11#include <linux/of.h>
12#include <linux/platform_device.h>
13#include <linux/regulator/consumer.h>
14
15#include <video/display_timing.h>
16#include <video/videomode.h>
17
18#include <drm/drm_crtc.h>
19#include <drm/drm_device.h>
20#include <drm/drm_panel.h>
21
22struct seiko_panel_desc {
23 const struct drm_display_mode *modes;
24 unsigned int num_modes;
25 const struct display_timing *timings;
26 unsigned int num_timings;
27
28 unsigned int bpc;
29
30 /**
31 * @width: width (in millimeters) of the panel's active display area
32 * @height: height (in millimeters) of the panel's active display area
33 */
34 struct {
35 unsigned int width;
36 unsigned int height;
37 } size;
38
39 u32 bus_format;
40 u32 bus_flags;
41};
42
43struct seiko_panel {
44 struct drm_panel base;
45 bool prepared;
46 bool enabled;
47 const struct seiko_panel_desc *desc;
48 struct regulator *dvdd;
49 struct regulator *avdd;
50};
51
52static inline struct seiko_panel *to_seiko_panel(struct drm_panel *panel)
53{
54 return container_of(panel, struct seiko_panel, base);
55}
56
57static int seiko_panel_get_fixed_modes(struct seiko_panel *panel,
58 struct drm_connector *connector)
59{
60 struct drm_display_mode *mode;
61 unsigned int i, num = 0;
62
63 if (!panel->desc)
64 return 0;
65
66 for (i = 0; i < panel->desc->num_timings; i++) {
67 const struct display_timing *dt = &panel->desc->timings[i];
68 struct videomode vm;
69
70 videomode_from_timing(dt, &vm);
71 mode = drm_mode_create(connector->dev);
72 if (!mode) {
73 dev_err(panel->base.dev, "failed to add mode %ux%u\n",
74 dt->hactive.typ, dt->vactive.typ);
75 continue;
76 }
77
78 drm_display_mode_from_videomode(&vm, mode);
79
80 mode->type |= DRM_MODE_TYPE_DRIVER;
81
82 if (panel->desc->num_timings == 1)
83 mode->type |= DRM_MODE_TYPE_PREFERRED;
84
85 drm_mode_probed_add(connector, mode);
86 num++;
87 }
88
89 for (i = 0; i < panel->desc->num_modes; i++) {
90 const struct drm_display_mode *m = &panel->desc->modes[i];
91
92 mode = drm_mode_duplicate(connector->dev, m);
93 if (!mode) {
94 dev_err(panel->base.dev, "failed to add mode %ux%u@%u\n",
95 m->hdisplay, m->vdisplay,
96 drm_mode_vrefresh(m));
97 continue;
98 }
99
100 mode->type |= DRM_MODE_TYPE_DRIVER;
101
102 if (panel->desc->num_modes == 1)
103 mode->type |= DRM_MODE_TYPE_PREFERRED;
104
105 drm_mode_set_name(mode);
106
107 drm_mode_probed_add(connector, mode);
108 num++;
109 }
110
111 connector->display_info.bpc = panel->desc->bpc;
112 connector->display_info.width_mm = panel->desc->size.width;
113 connector->display_info.height_mm = panel->desc->size.height;
114 if (panel->desc->bus_format)
115 drm_display_info_set_bus_formats(&connector->display_info,
116 &panel->desc->bus_format, 1);
117 connector->display_info.bus_flags = panel->desc->bus_flags;
118
119 return num;
120}
121
122static int seiko_panel_disable(struct drm_panel *panel)
123{
124 struct seiko_panel *p = to_seiko_panel(panel);
125
126 if (!p->enabled)
127 return 0;
128
129 p->enabled = false;
130
131 return 0;
132}
133
134static int seiko_panel_unprepare(struct drm_panel *panel)
135{
136 struct seiko_panel *p = to_seiko_panel(panel);
137
138 if (!p->prepared)
139 return 0;
140
141 regulator_disable(p->avdd);
142
143 /* Add a 100ms delay as per the panel datasheet */
144 msleep(100);
145
146 regulator_disable(p->dvdd);
147
148 p->prepared = false;
149
150 return 0;
151}
152
153static int seiko_panel_prepare(struct drm_panel *panel)
154{
155 struct seiko_panel *p = to_seiko_panel(panel);
156 int err;
157
158 if (p->prepared)
159 return 0;
160
161 err = regulator_enable(p->dvdd);
162 if (err < 0) {
163 dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
164 return err;
165 }
166
167 /* Add a 100ms delay as per the panel datasheet */
168 msleep(100);
169
170 err = regulator_enable(p->avdd);
171 if (err < 0) {
172 dev_err(panel->dev, "failed to enable avdd: %d\n", err);
173 goto disable_dvdd;
174 }
175
176 p->prepared = true;
177
178 return 0;
179
180disable_dvdd:
181 regulator_disable(p->dvdd);
182 return err;
183}
184
185static int seiko_panel_enable(struct drm_panel *panel)
186{
187 struct seiko_panel *p = to_seiko_panel(panel);
188
189 if (p->enabled)
190 return 0;
191
192 p->enabled = true;
193
194 return 0;
195}
196
197static int seiko_panel_get_modes(struct drm_panel *panel,
198 struct drm_connector *connector)
199{
200 struct seiko_panel *p = to_seiko_panel(panel);
201
202 /* add hard-coded panel modes */
203 return seiko_panel_get_fixed_modes(p, connector);
204}
205
206static int seiko_panel_get_timings(struct drm_panel *panel,
207 unsigned int num_timings,
208 struct display_timing *timings)
209{
210 struct seiko_panel *p = to_seiko_panel(panel);
211 unsigned int i;
212
213 if (p->desc->num_timings < num_timings)
214 num_timings = p->desc->num_timings;
215
216 if (timings)
217 for (i = 0; i < num_timings; i++)
218 timings[i] = p->desc->timings[i];
219
220 return p->desc->num_timings;
221}
222
223static const struct drm_panel_funcs seiko_panel_funcs = {
224 .disable = seiko_panel_disable,
225 .unprepare = seiko_panel_unprepare,
226 .prepare = seiko_panel_prepare,
227 .enable = seiko_panel_enable,
228 .get_modes = seiko_panel_get_modes,
229 .get_timings = seiko_panel_get_timings,
230};
231
232static int seiko_panel_probe(struct device *dev,
233 const struct seiko_panel_desc *desc)
234{
235 struct seiko_panel *panel;
236 int err;
237
238 panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
239 if (!panel)
240 return -ENOMEM;
241
242 panel->enabled = false;
243 panel->prepared = false;
244 panel->desc = desc;
245
246 panel->dvdd = devm_regulator_get(dev, "dvdd");
247 if (IS_ERR(panel->dvdd))
248 return PTR_ERR(panel->dvdd);
249
250 panel->avdd = devm_regulator_get(dev, "avdd");
251 if (IS_ERR(panel->avdd))
252 return PTR_ERR(panel->avdd);
253
254 drm_panel_init(&panel->base, dev, &seiko_panel_funcs,
255 DRM_MODE_CONNECTOR_DPI);
256
257 err = drm_panel_of_backlight(&panel->base);
258 if (err)
259 return err;
260
261 drm_panel_add(&panel->base);
262
263 dev_set_drvdata(dev, panel);
264
265 return 0;
266}
267
268static int seiko_panel_remove(struct platform_device *pdev)
269{
270 struct seiko_panel *panel = platform_get_drvdata(pdev);
271
272 drm_panel_remove(&panel->base);
273 drm_panel_disable(&panel->base);
274
275 return 0;
276}
277
278static void seiko_panel_shutdown(struct platform_device *pdev)
279{
280 struct seiko_panel *panel = platform_get_drvdata(pdev);
281
282 drm_panel_disable(&panel->base);
283}
284
285static const struct display_timing seiko_43wvf1g_timing = {
286 .pixelclock = { 33500000, 33500000, 33500000 },
287 .hactive = { 800, 800, 800 },
288 .hfront_porch = { 164, 164, 164 },
289 .hback_porch = { 89, 89, 89 },
290 .hsync_len = { 10, 10, 10 },
291 .vactive = { 480, 480, 480 },
292 .vfront_porch = { 10, 10, 10 },
293 .vback_porch = { 23, 23, 23 },
294 .vsync_len = { 10, 10, 10 },
295 .flags = DISPLAY_FLAGS_DE_LOW,
296};
297
298static const struct seiko_panel_desc seiko_43wvf1g = {
299 .timings = &seiko_43wvf1g_timing,
300 .num_timings = 1,
301 .bpc = 8,
302 .size = {
303 .width = 93,
304 .height = 57,
305 },
306 .bus_format = MEDIA_BUS_FMT_RGB888_1X24,
307 .bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_DRIVE_NEGEDGE,
308};
309
310static const struct of_device_id platform_of_match[] = {
311 {
312 .compatible = "sii,43wvf1g",
313 .data = &seiko_43wvf1g,
314 }, {
315 /* sentinel */
316 }
317};
318MODULE_DEVICE_TABLE(of, platform_of_match);
319
320static int seiko_panel_platform_probe(struct platform_device *pdev)
321{
322 const struct of_device_id *id;
323
324 id = of_match_node(platform_of_match, pdev->dev.of_node);
325 if (!id)
326 return -ENODEV;
327
328 return seiko_panel_probe(&pdev->dev, id->data);
329}
330
331static struct platform_driver seiko_panel_platform_driver = {
332 .driver = {
333 .name = "seiko_panel",
334 .of_match_table = platform_of_match,
335 },
336 .probe = seiko_panel_platform_probe,
337 .remove = seiko_panel_remove,
338 .shutdown = seiko_panel_shutdown,
339};
340module_platform_driver(seiko_panel_platform_driver);
341
342MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com>");
343MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
344MODULE_LICENSE("GPL v2");