1 // SPDX-License-Identifier: GPL-2.0-only
2
3 #include <linux/aperture.h>
4 #include <linux/ioport.h>
5 #include <linux/limits.h>
6 #include <linux/platform_device.h>
7 #include <linux/screen_info.h>
8
9 #include <drm/clients/drm_client_setup.h>
10 #include <drm/drm_atomic.h>
11 #include <drm/drm_atomic_state_helper.h>
12 #include <drm/drm_color_mgmt.h>
13 #include <drm/drm_connector.h>
14 #include <drm/drm_damage_helper.h>
15 #include <drm/drm_device.h>
16 #include <drm/drm_drv.h>
17 #include <drm/drm_edid.h>
18 #include <drm/drm_fbdev_shmem.h>
19 #include <drm/drm_framebuffer.h>
20 #include <drm/drm_gem_atomic_helper.h>
21 #include <drm/drm_gem_framebuffer_helper.h>
22 #include <drm/drm_gem_shmem_helper.h>
23 #include <drm/drm_managed.h>
24 #include <drm/drm_modeset_helper_vtables.h>
25 #include <drm/drm_probe_helper.h>
26
27 #include <video/edid.h>
28 #include <video/pixel_format.h>
29 #include <video/vga.h>
30
31 #include "drm_sysfb_helper.h"
32
33 #define DRIVER_NAME "vesadrm"
34 #define DRIVER_DESC "DRM driver for VESA platform devices"
35 #define DRIVER_MAJOR 1
36 #define DRIVER_MINOR 0
37
38 #define VESADRM_GAMMA_LUT_SIZE 256
39
vesadrm_get_format_si(struct drm_device * dev,const struct screen_info * si)40 static const struct drm_format_info *vesadrm_get_format_si(struct drm_device *dev,
41 const struct screen_info *si)
42 {
43 static const struct drm_sysfb_format formats[] = {
44 { PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, },
45 { PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, },
46 { PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, },
47 { PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, },
48 { PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, },
49 };
50
51 return drm_sysfb_get_format_si(dev, formats, ARRAY_SIZE(formats), si);
52 }
53
54 /*
55 * VESA device
56 */
57
58 struct vesadrm_device {
59 struct drm_sysfb_device sysfb;
60
61 #if defined(CONFIG_X86_32)
62 /* VESA Protected Mode interface */
63 struct {
64 const u8 *PrimaryPalette;
65 } pmi;
66 #endif
67
68 void (*cmap_write)(struct vesadrm_device *vesa, unsigned int index,
69 u16 red, u16 green, u16 blue);
70
71 /* modesetting */
72 u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)];
73 struct drm_plane primary_plane;
74 struct drm_crtc crtc;
75 struct drm_encoder encoder;
76 struct drm_connector connector;
77 };
78
to_vesadrm_device(struct drm_device * dev)79 static struct vesadrm_device *to_vesadrm_device(struct drm_device *dev)
80 {
81 return container_of(to_drm_sysfb_device(dev), struct vesadrm_device, sysfb);
82 }
83
84 /*
85 * Palette
86 */
87
vesadrm_vga_cmap_write(struct vesadrm_device * vesa,unsigned int index,u16 red,u16 green,u16 blue)88 static void vesadrm_vga_cmap_write(struct vesadrm_device *vesa, unsigned int index,
89 u16 red, u16 green, u16 blue)
90 {
91 u8 i8 = index;
92 u8 r8 = red >> 8;
93 u8 g8 = green >> 8;
94 u8 b8 = blue >> 8;
95
96 outb_p(i8, VGA_PEL_IW);
97 outb_p(r8, VGA_PEL_D);
98 outb_p(g8, VGA_PEL_D);
99 outb_p(b8, VGA_PEL_D);
100 }
101
102 #if defined(CONFIG_X86_32)
vesadrm_pmi_cmap_write(struct vesadrm_device * vesa,unsigned int index,u16 red,u16 green,u16 blue)103 static void vesadrm_pmi_cmap_write(struct vesadrm_device *vesa, unsigned int index,
104 u16 red, u16 green, u16 blue)
105 {
106 u32 i32 = index;
107 struct {
108 u8 b8;
109 u8 g8;
110 u8 r8;
111 u8 x8;
112 } PaletteEntry = {
113 blue >> 8,
114 green >> 8,
115 red >> 8,
116 0x00,
117 };
118
119 __asm__ __volatile__ (
120 "call *(%%esi)"
121 : /* no return value */
122 : "a" (0x4f09),
123 "b" (0),
124 "c" (1),
125 "d" (i32),
126 "D" (&PaletteEntry),
127 "S" (&vesa->pmi.PrimaryPalette));
128 }
129 #endif
130
vesadrm_set_gamma_lut(struct drm_crtc * crtc,unsigned int index,u16 red,u16 green,u16 blue)131 static void vesadrm_set_gamma_lut(struct drm_crtc *crtc, unsigned int index,
132 u16 red, u16 green, u16 blue)
133 {
134 struct drm_device *dev = crtc->dev;
135 struct vesadrm_device *vesa = to_vesadrm_device(dev);
136 u8 i8 = index & 0xff;
137
138 if (drm_WARN_ON_ONCE(dev, index != i8))
139 return; /* driver bug */
140
141 vesa->cmap_write(vesa, i8, red, green, blue);
142 }
143
vesadrm_fill_gamma_lut(struct vesadrm_device * vesa,const struct drm_format_info * format)144 static void vesadrm_fill_gamma_lut(struct vesadrm_device *vesa,
145 const struct drm_format_info *format)
146 {
147 struct drm_device *dev = &vesa->sysfb.dev;
148 struct drm_crtc *crtc = &vesa->crtc;
149
150 switch (format->format) {
151 case DRM_FORMAT_XRGB1555:
152 drm_crtc_fill_gamma_555(crtc, vesadrm_set_gamma_lut);
153 break;
154 case DRM_FORMAT_RGB565:
155 drm_crtc_fill_gamma_565(crtc, vesadrm_set_gamma_lut);
156 break;
157 case DRM_FORMAT_RGB888:
158 case DRM_FORMAT_XRGB8888:
159 case DRM_FORMAT_BGRX8888:
160 drm_crtc_fill_gamma_888(crtc, vesadrm_set_gamma_lut);
161 break;
162 default:
163 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
164 &format->format);
165 break;
166 }
167 }
168
vesadrm_load_gamma_lut(struct vesadrm_device * vesa,const struct drm_format_info * format,struct drm_color_lut * lut)169 static void vesadrm_load_gamma_lut(struct vesadrm_device *vesa,
170 const struct drm_format_info *format,
171 struct drm_color_lut *lut)
172 {
173 struct drm_device *dev = &vesa->sysfb.dev;
174 struct drm_crtc *crtc = &vesa->crtc;
175
176 switch (format->format) {
177 case DRM_FORMAT_XRGB1555:
178 drm_crtc_load_gamma_555_from_888(crtc, lut, vesadrm_set_gamma_lut);
179 break;
180 case DRM_FORMAT_RGB565:
181 drm_crtc_load_gamma_565_from_888(crtc, lut, vesadrm_set_gamma_lut);
182 break;
183 case DRM_FORMAT_RGB888:
184 case DRM_FORMAT_XRGB8888:
185 case DRM_FORMAT_BGRX8888:
186 drm_crtc_load_gamma_888(crtc, lut, vesadrm_set_gamma_lut);
187 break;
188 default:
189 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
190 &format->format);
191 break;
192 }
193 }
194
195 /*
196 * Modesetting
197 */
198
199 static const u64 vesadrm_primary_plane_format_modifiers[] = {
200 DRM_SYSFB_PLANE_FORMAT_MODIFIERS,
201 };
202
203 static const struct drm_plane_helper_funcs vesadrm_primary_plane_helper_funcs = {
204 DRM_SYSFB_PLANE_HELPER_FUNCS,
205 };
206
207 static const struct drm_plane_funcs vesadrm_primary_plane_funcs = {
208 DRM_SYSFB_PLANE_FUNCS,
209 .destroy = drm_plane_cleanup,
210 };
211
vesadrm_crtc_helper_atomic_flush(struct drm_crtc * crtc,struct drm_atomic_state * state)212 static void vesadrm_crtc_helper_atomic_flush(struct drm_crtc *crtc,
213 struct drm_atomic_state *state)
214 {
215 struct drm_device *dev = crtc->dev;
216 struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
217 struct vesadrm_device *vesa = to_vesadrm_device(dev);
218 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
219 struct drm_sysfb_crtc_state *sysfb_crtc_state = to_drm_sysfb_crtc_state(crtc_state);
220
221 /*
222 * The gamma LUT has to be reloaded after changing the primary
223 * plane's color format.
224 */
225 if (crtc_state->enable && crtc_state->color_mgmt_changed) {
226 if (sysfb_crtc_state->format == sysfb->fb_format) {
227 if (crtc_state->gamma_lut)
228 vesadrm_load_gamma_lut(vesa,
229 sysfb_crtc_state->format,
230 crtc_state->gamma_lut->data);
231 else
232 vesadrm_fill_gamma_lut(vesa, sysfb_crtc_state->format);
233 } else {
234 vesadrm_fill_gamma_lut(vesa, sysfb_crtc_state->format);
235 }
236 }
237 }
238
239 static const struct drm_crtc_helper_funcs vesadrm_crtc_helper_funcs = {
240 DRM_SYSFB_CRTC_HELPER_FUNCS,
241 .atomic_flush = vesadrm_crtc_helper_atomic_flush,
242 };
243
244 static const struct drm_crtc_funcs vesadrm_crtc_funcs = {
245 DRM_SYSFB_CRTC_FUNCS,
246 .destroy = drm_crtc_cleanup,
247 };
248
249 static const struct drm_encoder_funcs vesadrm_encoder_funcs = {
250 .destroy = drm_encoder_cleanup,
251 };
252
253 static const struct drm_connector_helper_funcs vesadrm_connector_helper_funcs = {
254 DRM_SYSFB_CONNECTOR_HELPER_FUNCS,
255 };
256
257 static const struct drm_connector_funcs vesadrm_connector_funcs = {
258 DRM_SYSFB_CONNECTOR_FUNCS,
259 .destroy = drm_connector_cleanup,
260 };
261
262 static const struct drm_mode_config_funcs vesadrm_mode_config_funcs = {
263 DRM_SYSFB_MODE_CONFIG_FUNCS,
264 };
265
266 /*
267 * Init / Cleanup
268 */
269
vesadrm_device_create(struct drm_driver * drv,struct platform_device * pdev)270 static struct vesadrm_device *vesadrm_device_create(struct drm_driver *drv,
271 struct platform_device *pdev)
272 {
273 const struct screen_info *si;
274 const struct drm_format_info *format;
275 int width, height, stride;
276 u64 vsize;
277 struct resource resbuf;
278 struct resource *res;
279 struct vesadrm_device *vesa;
280 struct drm_sysfb_device *sysfb;
281 struct drm_device *dev;
282 struct resource *mem = NULL;
283 void __iomem *screen_base;
284 struct drm_plane *primary_plane;
285 struct drm_crtc *crtc;
286 struct drm_encoder *encoder;
287 struct drm_connector *connector;
288 unsigned long max_width, max_height;
289 size_t nformats;
290 int ret;
291
292 si = dev_get_platdata(&pdev->dev);
293 if (!si)
294 return ERR_PTR(-ENODEV);
295 if (screen_info_video_type(si) != VIDEO_TYPE_VLFB)
296 return ERR_PTR(-ENODEV);
297
298 /*
299 * VESA DRM driver
300 */
301
302 vesa = devm_drm_dev_alloc(&pdev->dev, drv, struct vesadrm_device, sysfb.dev);
303 if (IS_ERR(vesa))
304 return ERR_CAST(vesa);
305 sysfb = &vesa->sysfb;
306 dev = &sysfb->dev;
307 platform_set_drvdata(pdev, dev);
308
309 /*
310 * Hardware settings
311 */
312
313 format = vesadrm_get_format_si(dev, si);
314 if (!format)
315 return ERR_PTR(-EINVAL);
316 width = drm_sysfb_get_width_si(dev, si);
317 if (width < 0)
318 return ERR_PTR(width);
319 height = drm_sysfb_get_height_si(dev, si);
320 if (height < 0)
321 return ERR_PTR(height);
322 res = drm_sysfb_get_memory_si(dev, si, &resbuf);
323 if (!res)
324 return ERR_PTR(-EINVAL);
325 stride = drm_sysfb_get_stride_si(dev, si, format, width, height, resource_size(res));
326 if (stride < 0)
327 return ERR_PTR(stride);
328 vsize = drm_sysfb_get_visible_size_si(dev, si, height, stride, resource_size(res));
329 if (!vsize)
330 return ERR_PTR(-EINVAL);
331
332 drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d bytes\n",
333 &format->format, width, height, stride);
334
335 if (!__screen_info_vbe_mode_nonvga(si)) {
336 vesa->cmap_write = vesadrm_vga_cmap_write;
337 } else {
338 #if defined(CONFIG_X86_32)
339 phys_addr_t pmi_base = __screen_info_vesapm_info_base(si);
340
341 if (pmi_base) {
342 const u16 *pmi_addr = phys_to_virt(pmi_base);
343
344 vesa->pmi.PrimaryPalette = (u8 *)pmi_addr + pmi_addr[2];
345 vesa->cmap_write = vesadrm_pmi_cmap_write;
346 } else
347 #endif
348 if (format->is_color_indexed)
349 drm_warn(dev, "hardware palette is unchangeable, colors may be incorrect\n");
350 }
351
352 #if defined(CONFIG_FIRMWARE_EDID)
353 if (drm_edid_header_is_valid(edid_info.dummy) == 8)
354 sysfb->edid = edid_info.dummy;
355 #endif
356 sysfb->fb_mode = drm_sysfb_mode(width, height, 0, 0);
357 sysfb->fb_format = format;
358 sysfb->fb_pitch = stride;
359 if (vesa->cmap_write)
360 sysfb->fb_gamma_lut_size = VESADRM_GAMMA_LUT_SIZE;
361
362 /*
363 * Memory management
364 */
365
366 ret = devm_aperture_acquire_for_platform_device(pdev, res->start, vsize);
367 if (ret) {
368 drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret);
369 return ERR_PTR(ret);
370 }
371
372 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res);
373
374 mem = devm_request_mem_region(&pdev->dev, res->start, vsize, drv->name);
375 if (!mem) {
376 /*
377 * We cannot make this fatal. Sometimes this comes from magic
378 * spaces our resource handlers simply don't know about. Use
379 * the I/O-memory resource as-is and try to map that instead.
380 */
381 drm_warn(dev, "could not acquire memory region %pr\n", res);
382 mem = res;
383 }
384
385 screen_base = devm_ioremap_wc(&pdev->dev, mem->start, resource_size(mem));
386 if (!screen_base)
387 return ERR_PTR(-ENOMEM);
388 iosys_map_set_vaddr_iomem(&sysfb->fb_addr, screen_base);
389
390 /*
391 * Modesetting
392 */
393
394 ret = drmm_mode_config_init(dev);
395 if (ret)
396 return ERR_PTR(ret);
397
398 max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH);
399 max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
400
401 dev->mode_config.min_width = width;
402 dev->mode_config.max_width = max_width;
403 dev->mode_config.min_height = height;
404 dev->mode_config.max_height = max_height;
405 dev->mode_config.preferred_depth = format->depth;
406 dev->mode_config.funcs = &vesadrm_mode_config_funcs;
407
408 /* Primary plane */
409
410 nformats = drm_sysfb_build_fourcc_list(dev, &format->format, 1,
411 vesa->formats, ARRAY_SIZE(vesa->formats));
412
413 primary_plane = &vesa->primary_plane;
414 ret = drm_universal_plane_init(dev, primary_plane, 0, &vesadrm_primary_plane_funcs,
415 vesa->formats, nformats,
416 vesadrm_primary_plane_format_modifiers,
417 DRM_PLANE_TYPE_PRIMARY, NULL);
418 if (ret)
419 return ERR_PTR(ret);
420 drm_plane_helper_add(primary_plane, &vesadrm_primary_plane_helper_funcs);
421 drm_plane_enable_fb_damage_clips(primary_plane);
422
423 /* CRTC */
424
425 crtc = &vesa->crtc;
426 ret = drm_crtc_init_with_planes(dev, crtc, primary_plane, NULL,
427 &vesadrm_crtc_funcs, NULL);
428 if (ret)
429 return ERR_PTR(ret);
430 drm_crtc_helper_add(crtc, &vesadrm_crtc_helper_funcs);
431
432 if (sysfb->fb_gamma_lut_size) {
433 ret = drm_mode_crtc_set_gamma_size(crtc, sysfb->fb_gamma_lut_size);
434 if (!ret)
435 drm_crtc_enable_color_mgmt(crtc, 0, false, sysfb->fb_gamma_lut_size);
436 }
437
438 /* Encoder */
439
440 encoder = &vesa->encoder;
441 ret = drm_encoder_init(dev, encoder, &vesadrm_encoder_funcs,
442 DRM_MODE_ENCODER_NONE, NULL);
443 if (ret)
444 return ERR_PTR(ret);
445 encoder->possible_crtcs = drm_crtc_mask(crtc);
446
447 /* Connector */
448
449 connector = &vesa->connector;
450 ret = drm_connector_init(dev, connector, &vesadrm_connector_funcs,
451 DRM_MODE_CONNECTOR_Unknown);
452 if (ret)
453 return ERR_PTR(ret);
454 drm_connector_helper_add(connector, &vesadrm_connector_helper_funcs);
455 drm_connector_set_panel_orientation_with_quirk(connector,
456 DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
457 width, height);
458 if (sysfb->edid)
459 drm_connector_attach_edid_property(connector);
460
461 ret = drm_connector_attach_encoder(connector, encoder);
462 if (ret)
463 return ERR_PTR(ret);
464
465 drm_mode_config_reset(dev);
466
467 return vesa;
468 }
469
470 /*
471 * DRM driver
472 */
473
474 DEFINE_DRM_GEM_FOPS(vesadrm_fops);
475
476 static struct drm_driver vesadrm_driver = {
477 DRM_GEM_SHMEM_DRIVER_OPS,
478 DRM_FBDEV_SHMEM_DRIVER_OPS,
479 .name = DRIVER_NAME,
480 .desc = DRIVER_DESC,
481 .major = DRIVER_MAJOR,
482 .minor = DRIVER_MINOR,
483 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
484 .fops = &vesadrm_fops,
485 };
486
487 /*
488 * Platform driver
489 */
490
vesadrm_probe(struct platform_device * pdev)491 static int vesadrm_probe(struct platform_device *pdev)
492 {
493 struct vesadrm_device *vesa;
494 struct drm_sysfb_device *sysfb;
495 struct drm_device *dev;
496 int ret;
497
498 vesa = vesadrm_device_create(&vesadrm_driver, pdev);
499 if (IS_ERR(vesa))
500 return PTR_ERR(vesa);
501 sysfb = &vesa->sysfb;
502 dev = &sysfb->dev;
503
504 ret = drm_dev_register(dev, 0);
505 if (ret)
506 return ret;
507
508 drm_client_setup(dev, sysfb->fb_format);
509
510 return 0;
511 }
512
vesadrm_remove(struct platform_device * pdev)513 static void vesadrm_remove(struct platform_device *pdev)
514 {
515 struct drm_device *dev = platform_get_drvdata(pdev);
516
517 drm_dev_unplug(dev);
518 }
519
520 static struct platform_driver vesadrm_platform_driver = {
521 .driver = {
522 .name = "vesa-framebuffer",
523 },
524 .probe = vesadrm_probe,
525 .remove = vesadrm_remove,
526 };
527
528 module_platform_driver(vesadrm_platform_driver);
529
530 MODULE_DESCRIPTION(DRIVER_DESC);
531 MODULE_LICENSE("GPL");
532