1
2
3
4
5
6
7
8
9
10
11
12#include <linux/backlight.h>
13#include <linux/module.h>
14#include <linux/of.h>
15#include <linux/regulator/consumer.h>
16
17#include <drm/drmP.h>
18#include <drm/drm_crtc.h>
19#include <drm/drm_panel.h>
20
21#include <video/display_timing.h>
22#include <video/videomode.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
34
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 bool prepared;
48 bool enabled;
49 const struct seiko_panel_desc *desc;
50 struct backlight_device *backlight;
51 struct regulator *dvdd;
52 struct regulator *avdd;
53};
54
55static inline struct seiko_panel *to_seiko_panel(struct drm_panel *panel)
56{
57 return container_of(panel, struct seiko_panel, base);
58}
59
60static int seiko_panel_get_fixed_modes(struct seiko_panel *panel)
61{
62 struct drm_connector *connector = panel->base.connector;
63 struct drm_device *drm = panel->base.drm;
64 struct drm_display_mode *mode;
65 unsigned int i, num = 0;
66
67 if (!panel->desc)
68 return 0;
69
70 for (i = 0; i < panel->desc->num_timings; i++) {
71 const struct display_timing *dt = &panel->desc->timings[i];
72 struct videomode vm;
73
74 videomode_from_timing(dt, &vm);
75 mode = drm_mode_create(drm);
76 if (!mode) {
77 dev_err(drm->dev, "failed to add mode %ux%u\n",
78 dt->hactive.typ, dt->vactive.typ);
79 continue;
80 }
81
82 drm_display_mode_from_videomode(&vm, mode);
83
84 mode->type |= DRM_MODE_TYPE_DRIVER;
85
86 if (panel->desc->num_timings == 1)
87 mode->type |= DRM_MODE_TYPE_PREFERRED;
88
89 drm_mode_probed_add(connector, mode);
90 num++;
91 }
92
93 for (i = 0; i < panel->desc->num_modes; i++) {
94 const struct drm_display_mode *m = &panel->desc->modes[i];
95
96 mode = drm_mode_duplicate(drm, m);
97 if (!mode) {
98 dev_err(drm->dev, "failed to add mode %ux%u@%u\n",
99 m->hdisplay, m->vdisplay, m->vrefresh);
100 continue;
101 }
102
103 mode->type |= DRM_MODE_TYPE_DRIVER;
104
105 if (panel->desc->num_modes == 1)
106 mode->type |= DRM_MODE_TYPE_PREFERRED;
107
108 drm_mode_set_name(mode);
109
110 drm_mode_probed_add(connector, mode);
111 num++;
112 }
113
114 connector->display_info.bpc = panel->desc->bpc;
115 connector->display_info.width_mm = panel->desc->size.width;
116 connector->display_info.height_mm = panel->desc->size.height;
117 if (panel->desc->bus_format)
118 drm_display_info_set_bus_formats(&connector->display_info,
119 &panel->desc->bus_format, 1);
120 connector->display_info.bus_flags = panel->desc->bus_flags;
121
122 return num;
123}
124
125static int seiko_panel_disable(struct drm_panel *panel)
126{
127 struct seiko_panel *p = to_seiko_panel(panel);
128
129 if (!p->enabled)
130 return 0;
131
132 if (p->backlight) {
133 p->backlight->props.power = FB_BLANK_POWERDOWN;
134 p->backlight->props.state |= BL_CORE_FBBLANK;
135 backlight_update_status(p->backlight);
136 }
137
138 p->enabled = false;
139
140 return 0;
141}
142
143static int seiko_panel_unprepare(struct drm_panel *panel)
144{
145 struct seiko_panel *p = to_seiko_panel(panel);
146
147 if (!p->prepared)
148 return 0;
149
150 regulator_disable(p->avdd);
151
152
153 msleep(100);
154
155 regulator_disable(p->dvdd);
156
157 p->prepared = false;
158
159 return 0;
160}
161
162static int seiko_panel_prepare(struct drm_panel *panel)
163{
164 struct seiko_panel *p = to_seiko_panel(panel);
165 int err;
166
167 if (p->prepared)
168 return 0;
169
170 err = regulator_enable(p->dvdd);
171 if (err < 0) {
172 dev_err(panel->dev, "failed to enable dvdd: %d\n", err);
173 return err;
174 }
175
176
177 msleep(100);
178
179 err = regulator_enable(p->avdd);
180 if (err < 0) {
181 dev_err(panel->dev, "failed to enable avdd: %d\n", err);
182 goto disable_dvdd;
183 }
184
185 p->prepared = true;
186
187 return 0;
188
189disable_dvdd:
190 regulator_disable(p->dvdd);
191 return err;
192}
193
194static int seiko_panel_enable(struct drm_panel *panel)
195{
196 struct seiko_panel *p = to_seiko_panel(panel);
197
198 if (p->enabled)
199 return 0;
200
201 if (p->backlight) {
202 p->backlight->props.state &= ~BL_CORE_FBBLANK;
203 p->backlight->props.power = FB_BLANK_UNBLANK;
204 backlight_update_status(p->backlight);
205 }
206
207 p->enabled = true;
208
209 return 0;
210}
211
212static int seiko_panel_get_modes(struct drm_panel *panel)
213{
214 struct seiko_panel *p = to_seiko_panel(panel);
215
216
217 return seiko_panel_get_fixed_modes(p);
218}
219
220static int seiko_panel_get_timings(struct drm_panel *panel,
221 unsigned int num_timings,
222 struct display_timing *timings)
223{
224 struct seiko_panel *p = to_seiko_panel(panel);
225 unsigned int i;
226
227 if (p->desc->num_timings < num_timings)
228 num_timings = p->desc->num_timings;
229
230 if (timings)
231 for (i = 0; i < num_timings; i++)
232 timings[i] = p->desc->timings[i];
233
234 return p->desc->num_timings;
235}
236
237static const struct drm_panel_funcs seiko_panel_funcs = {
238 .disable = seiko_panel_disable,
239 .unprepare = seiko_panel_unprepare,
240 .prepare = seiko_panel_prepare,
241 .enable = seiko_panel_enable,
242 .get_modes = seiko_panel_get_modes,
243 .get_timings = seiko_panel_get_timings,
244};
245
246static int seiko_panel_probe(struct device *dev,
247 const struct seiko_panel_desc *desc)
248{
249 struct device_node *backlight;
250 struct seiko_panel *panel;
251 int err;
252
253 panel = devm_kzalloc(dev, sizeof(*panel), GFP_KERNEL);
254 if (!panel)
255 return -ENOMEM;
256
257 panel->enabled = false;
258 panel->prepared = false;
259 panel->desc = desc;
260
261 panel->dvdd = devm_regulator_get(dev, "dvdd");
262 if (IS_ERR(panel->dvdd))
263 return PTR_ERR(panel->dvdd);
264
265 panel->avdd = devm_regulator_get(dev, "avdd");
266 if (IS_ERR(panel->avdd))
267 return PTR_ERR(panel->avdd);
268
269 backlight = of_parse_phandle(dev->of_node, "backlight", 0);
270 if (backlight) {
271 panel->backlight = of_find_backlight_by_node(backlight);
272 of_node_put(backlight);
273
274 if (!panel->backlight)
275 return -EPROBE_DEFER;
276 }
277
278 drm_panel_init(&panel->base);
279 panel->base.dev = dev;
280 panel->base.funcs = &seiko_panel_funcs;
281
282 err = drm_panel_add(&panel->base);
283 if (err < 0)
284 return err;
285
286 dev_set_drvdata(dev, panel);
287
288 return 0;
289}
290
291static int seiko_panel_remove(struct platform_device *pdev)
292{
293 struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);
294
295 drm_panel_remove(&panel->base);
296
297 seiko_panel_disable(&panel->base);
298
299 if (panel->backlight)
300 put_device(&panel->backlight->dev);
301
302 return 0;
303}
304
305static void seiko_panel_shutdown(struct platform_device *pdev)
306{
307 struct seiko_panel *panel = dev_get_drvdata(&pdev->dev);
308
309 seiko_panel_disable(&panel->base);
310}
311
312static const struct display_timing seiko_43wvf1g_timing = {
313 .pixelclock = { 33500000, 33500000, 33500000 },
314 .hactive = { 800, 800, 800 },
315 .hfront_porch = { 164, 164, 164 },
316 .hback_porch = { 89, 89, 89 },
317 .hsync_len = { 10, 10, 10 },
318 .vactive = { 480, 480, 480 },
319 .vfront_porch = { 10, 10, 10 },
320 .vback_porch = { 23, 23, 23 },
321 .vsync_len = { 10, 10, 10 },
322 .flags = DISPLAY_FLAGS_DE_LOW,
323};
324
325static const struct seiko_panel_desc seiko_43wvf1g = {
326 .timings = &seiko_43wvf1g_timing,
327 .num_timings = 1,
328 .bpc = 8,
329 .size = {
330 .width = 93,
331 .height = 57,
332 },
333 .bus_format = MEDIA_BUS_FMT_RGB888_1X24,
334 .bus_flags = DRM_BUS_FLAG_DE_HIGH | DRM_BUS_FLAG_PIXDATA_NEGEDGE,
335};
336
337static const struct of_device_id platform_of_match[] = {
338 {
339 .compatible = "sii,43wvf1g",
340 .data = &seiko_43wvf1g,
341 }, {
342
343 }
344};
345MODULE_DEVICE_TABLE(of, platform_of_match);
346
347static int seiko_panel_platform_probe(struct platform_device *pdev)
348{
349 const struct of_device_id *id;
350
351 id = of_match_node(platform_of_match, pdev->dev.of_node);
352 if (!id)
353 return -ENODEV;
354
355 return seiko_panel_probe(&pdev->dev, id->data);
356}
357
358static struct platform_driver seiko_panel_platform_driver = {
359 .driver = {
360 .name = "seiko_panel",
361 .of_match_table = platform_of_match,
362 },
363 .probe = seiko_panel_platform_probe,
364 .remove = seiko_panel_remove,
365 .shutdown = seiko_panel_shutdown,
366};
367module_platform_driver(seiko_panel_platform_driver);
368
369MODULE_AUTHOR("Marco Franchi <marco.franchi@nxp.com");
370MODULE_DESCRIPTION("Seiko 43WVF1G panel driver");
371MODULE_LICENSE("GPL v2");
372
