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_print.h>
26#include <drm/drm_probe_helper.h>
27
28#include <video/edid.h>
29#include <video/pixel_format.h>
30#include <video/vga.h>
31
32#include "drm_sysfb_helper.h"
33
34#define DRIVER_NAME "vesadrm"
35#define DRIVER_DESC "DRM driver for VESA platform devices"
36#define DRIVER_MAJOR 1
37#define DRIVER_MINOR 0
38
39#define VESADRM_GAMMA_LUT_SIZE 256
40
41static const struct drm_format_info *vesadrm_get_format_si(struct drm_device *dev,
42 const struct screen_info *si)
43{
44 static const struct drm_sysfb_format formats[] = {
45 { PIXEL_FORMAT_XRGB1555, DRM_FORMAT_XRGB1555, },
46 { PIXEL_FORMAT_RGB565, DRM_FORMAT_RGB565, },
47 { PIXEL_FORMAT_RGB888, DRM_FORMAT_RGB888, },
48 { PIXEL_FORMAT_XRGB8888, DRM_FORMAT_XRGB8888, },
49 { PIXEL_FORMAT_XBGR8888, DRM_FORMAT_XBGR8888, },
50 { PIXEL_FORMAT_C8, DRM_FORMAT_C8, },
51 };
52
53 return drm_sysfb_get_format_si(dev, formats, ARRAY_SIZE(formats), si);
54}
55
56/*
57 * VESA device
58 */
59
60struct vesadrm_device {
61 struct drm_sysfb_device sysfb;
62
63#if defined(CONFIG_X86_32)
64 /* VESA Protected Mode interface */
65 struct {
66 const u8 *PrimaryPalette;
67 } pmi;
68#endif
69
70 void (*cmap_write)(struct vesadrm_device *vesa, unsigned int index,
71 u16 red, u16 green, u16 blue);
72
73 /* modesetting */
74 u32 formats[DRM_SYSFB_PLANE_NFORMATS(1)];
75 struct drm_plane primary_plane;
76 struct drm_crtc crtc;
77 struct drm_encoder encoder;
78 struct drm_connector connector;
79};
80
81static struct vesadrm_device *to_vesadrm_device(struct drm_device *dev)
82{
83 return container_of(to_drm_sysfb_device(dev), struct vesadrm_device, sysfb);
84}
85
86/*
87 * Color LUT
88 */
89
90static void vesadrm_vga_cmap_write(struct vesadrm_device *vesa, unsigned int index,
91 u16 red, u16 green, u16 blue)
92{
93 u8 i8 = index;
94 u8 r8 = red >> 8;
95 u8 g8 = green >> 8;
96 u8 b8 = blue >> 8;
97
98 outb_p(value: i8, VGA_PEL_IW);
99 outb_p(value: r8, VGA_PEL_D);
100 outb_p(value: g8, VGA_PEL_D);
101 outb_p(value: b8, VGA_PEL_D);
102}
103
104#if defined(CONFIG_X86_32)
105static void vesadrm_pmi_cmap_write(struct vesadrm_device *vesa, unsigned int index,
106 u16 red, u16 green, u16 blue)
107{
108 u32 i32 = index;
109 struct {
110 u8 b8;
111 u8 g8;
112 u8 r8;
113 u8 x8;
114 } PaletteEntry = {
115 blue >> 8,
116 green >> 8,
117 red >> 8,
118 0x00,
119 };
120
121 __asm__ __volatile__ (
122 "call *(%%esi)"
123 : /* no return value */
124 : "a" (0x4f09),
125 "b" (0),
126 "c" (1),
127 "d" (i32),
128 "D" (&PaletteEntry),
129 "S" (&vesa->pmi.PrimaryPalette));
130}
131#endif
132
133static void vesadrm_set_color_lut(struct drm_crtc *crtc, unsigned int index,
134 u16 red, u16 green, u16 blue)
135{
136 struct drm_device *dev = crtc->dev;
137 struct vesadrm_device *vesa = to_vesadrm_device(dev);
138 u8 i8 = index & 0xff;
139
140 if (drm_WARN_ON_ONCE(dev, index != i8))
141 return; /* driver bug */
142
143 vesa->cmap_write(vesa, i8, red, green, blue);
144}
145
146static void vesadrm_fill_gamma_lut(struct vesadrm_device *vesa,
147 const struct drm_format_info *format)
148{
149 struct drm_device *dev = &vesa->sysfb.dev;
150 struct drm_crtc *crtc = &vesa->crtc;
151
152 switch (format->format) {
153 case DRM_FORMAT_XRGB1555:
154 drm_crtc_fill_gamma_555(crtc, set_gamma: vesadrm_set_color_lut);
155 break;
156 case DRM_FORMAT_RGB565:
157 drm_crtc_fill_gamma_565(crtc, set_gamma: vesadrm_set_color_lut);
158 break;
159 case DRM_FORMAT_RGB888:
160 case DRM_FORMAT_XRGB8888:
161 case DRM_FORMAT_BGRX8888:
162 drm_crtc_fill_gamma_888(crtc, set_gamma: vesadrm_set_color_lut);
163 break;
164 default:
165 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
166 &format->format);
167 break;
168 }
169}
170
171static void vesadrm_load_gamma_lut(struct vesadrm_device *vesa,
172 const struct drm_format_info *format,
173 struct drm_color_lut *lut)
174{
175 struct drm_device *dev = &vesa->sysfb.dev;
176 struct drm_crtc *crtc = &vesa->crtc;
177
178 switch (format->format) {
179 case DRM_FORMAT_XRGB1555:
180 drm_crtc_load_gamma_555_from_888(crtc, lut, set_gamma: vesadrm_set_color_lut);
181 break;
182 case DRM_FORMAT_RGB565:
183 drm_crtc_load_gamma_565_from_888(crtc, lut, set_gamma: vesadrm_set_color_lut);
184 break;
185 case DRM_FORMAT_RGB888:
186 case DRM_FORMAT_XRGB8888:
187 case DRM_FORMAT_BGRX8888:
188 drm_crtc_load_gamma_888(crtc, lut, set_gamma: vesadrm_set_color_lut);
189 break;
190 default:
191 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
192 &format->format);
193 break;
194 }
195}
196
197static void vesadrm_fill_palette_lut(struct vesadrm_device *vesa,
198 const struct drm_format_info *format)
199{
200 struct drm_device *dev = &vesa->sysfb.dev;
201 struct drm_crtc *crtc = &vesa->crtc;
202
203 switch (format->format) {
204 case DRM_FORMAT_C8:
205 drm_crtc_fill_palette_8(crtc, set_palette: vesadrm_set_color_lut);
206 break;
207 case DRM_FORMAT_RGB332:
208 drm_crtc_fill_palette_332(crtc, set_palette: vesadrm_set_color_lut);
209 break;
210 default:
211 drm_warn_once(dev, "Unsupported format %p4cc for palette\n",
212 &format->format);
213 break;
214 }
215}
216
217static void vesadrm_load_palette_lut(struct vesadrm_device *vesa,
218 const struct drm_format_info *format,
219 struct drm_color_lut *lut)
220{
221 struct drm_device *dev = &vesa->sysfb.dev;
222 struct drm_crtc *crtc = &vesa->crtc;
223
224 switch (format->format) {
225 case DRM_FORMAT_C8:
226 drm_crtc_load_palette_8(crtc, lut, set_palette: vesadrm_set_color_lut);
227 break;
228 default:
229 drm_warn_once(dev, "Unsupported format %p4cc for gamma correction\n",
230 &format->format);
231 break;
232 }
233}
234
235/*
236 * Modesetting
237 */
238
239static const u64 vesadrm_primary_plane_format_modifiers[] = {
240 DRM_SYSFB_PLANE_FORMAT_MODIFIERS,
241};
242
243static int vesadrm_primary_plane_helper_atomic_check(struct drm_plane *plane,
244 struct drm_atomic_state *new_state)
245{
246 struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev: plane->dev);
247 struct drm_plane_state *new_plane_state = drm_atomic_get_new_plane_state(state: new_state, plane);
248 struct drm_framebuffer *new_fb = new_plane_state->fb;
249 struct drm_crtc_state *new_crtc_state;
250 struct drm_sysfb_crtc_state *new_sysfb_crtc_state;
251 int ret;
252
253 ret = drm_sysfb_plane_helper_atomic_check(plane, new_state);
254 if (ret)
255 return ret;
256 else if (!new_plane_state->visible)
257 return 0;
258
259 /*
260 * Fix up format conversion for specific cases
261 */
262
263 switch (sysfb->fb_format->format) {
264 case DRM_FORMAT_C8:
265 new_crtc_state = drm_atomic_get_new_crtc_state(state: new_state, crtc: new_plane_state->crtc);
266 new_sysfb_crtc_state = to_drm_sysfb_crtc_state(base: new_crtc_state);
267
268 switch (new_fb->format->format) {
269 case DRM_FORMAT_XRGB8888:
270 /*
271 * Reduce XRGB8888 to RGB332. Each resulting pixel is an index
272 * into the C8 hardware palette, which stores RGB332 colors.
273 */
274 if (new_sysfb_crtc_state->format->format != DRM_FORMAT_RGB332) {
275 new_sysfb_crtc_state->format =
276 drm_format_info(DRM_FORMAT_RGB332);
277 new_crtc_state->color_mgmt_changed = true;
278 }
279 break;
280 case DRM_FORMAT_C8:
281 /*
282 * Restore original output. Emulation of XRGB8888 set RBG332
283 * output format and hardware palette. This needs to be undone
284 * when we switch back to DRM_FORMAT_C8.
285 */
286 if (new_sysfb_crtc_state->format->format == DRM_FORMAT_RGB332) {
287 new_sysfb_crtc_state->format = sysfb->fb_format;
288 new_crtc_state->color_mgmt_changed = true;
289 }
290 break;
291 }
292 break;
293 }
294
295 return 0;
296}
297
298static const struct drm_plane_helper_funcs vesadrm_primary_plane_helper_funcs = {
299 .begin_fb_access = drm_sysfb_plane_helper_begin_fb_access,
300 .end_fb_access = drm_gem_end_shadow_fb_access,
301 .atomic_check = vesadrm_primary_plane_helper_atomic_check,
302 .atomic_update = drm_sysfb_plane_helper_atomic_update,
303 .atomic_disable = drm_sysfb_plane_helper_atomic_disable,
304 .get_scanout_buffer = drm_sysfb_plane_helper_get_scanout_buffer,
305};
306
307static const struct drm_plane_funcs vesadrm_primary_plane_funcs = {
308 DRM_SYSFB_PLANE_FUNCS,
309 .destroy = drm_plane_cleanup,
310};
311
312static void vesadrm_crtc_helper_atomic_flush(struct drm_crtc *crtc,
313 struct drm_atomic_state *state)
314{
315 struct drm_device *dev = crtc->dev;
316 struct drm_sysfb_device *sysfb = to_drm_sysfb_device(dev);
317 struct vesadrm_device *vesa = to_vesadrm_device(dev);
318 struct drm_crtc_state *crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
319 struct drm_sysfb_crtc_state *sysfb_crtc_state = to_drm_sysfb_crtc_state(base: crtc_state);
320
321 /*
322 * The gamma LUT has to be reloaded after changing the primary
323 * plane's color format.
324 */
325 if (crtc_state->enable && crtc_state->color_mgmt_changed) {
326 switch (sysfb->fb_format->format) {
327 /*
328 * Index formats
329 */
330 case DRM_FORMAT_C8:
331 if (sysfb_crtc_state->format->format == DRM_FORMAT_RGB332) {
332 vesadrm_fill_palette_lut(vesa, format: sysfb_crtc_state->format);
333 } else if (crtc->state->gamma_lut) {
334 vesadrm_load_palette_lut(vesa,
335 format: sysfb_crtc_state->format,
336 lut: crtc_state->gamma_lut->data);
337 } else {
338 vesadrm_fill_palette_lut(vesa, format: sysfb_crtc_state->format);
339 }
340 break;
341 /*
342 * Component formats
343 */
344 default:
345 if (sysfb_crtc_state->format == sysfb->fb_format) {
346 if (crtc_state->gamma_lut)
347 vesadrm_load_gamma_lut(vesa,
348 format: sysfb_crtc_state->format,
349 lut: crtc_state->gamma_lut->data);
350 else
351 vesadrm_fill_gamma_lut(vesa, format: sysfb_crtc_state->format);
352 } else {
353 vesadrm_fill_gamma_lut(vesa, format: sysfb_crtc_state->format);
354 }
355 break;
356 }
357 }
358}
359
360static const struct drm_crtc_helper_funcs vesadrm_crtc_helper_funcs = {
361 DRM_SYSFB_CRTC_HELPER_FUNCS,
362 .atomic_flush = vesadrm_crtc_helper_atomic_flush,
363};
364
365static const struct drm_crtc_funcs vesadrm_crtc_funcs = {
366 DRM_SYSFB_CRTC_FUNCS,
367 .destroy = drm_crtc_cleanup,
368};
369
370static const struct drm_encoder_funcs vesadrm_encoder_funcs = {
371 .destroy = drm_encoder_cleanup,
372};
373
374static const struct drm_connector_helper_funcs vesadrm_connector_helper_funcs = {
375 DRM_SYSFB_CONNECTOR_HELPER_FUNCS,
376};
377
378static const struct drm_connector_funcs vesadrm_connector_funcs = {
379 DRM_SYSFB_CONNECTOR_FUNCS,
380 .destroy = drm_connector_cleanup,
381};
382
383static const struct drm_mode_config_funcs vesadrm_mode_config_funcs = {
384 DRM_SYSFB_MODE_CONFIG_FUNCS,
385};
386
387/*
388 * Init / Cleanup
389 */
390
391static struct vesadrm_device *vesadrm_device_create(struct drm_driver *drv,
392 struct platform_device *pdev)
393{
394 const struct screen_info *si;
395 const struct drm_format_info *format;
396 int width, height, stride;
397 u64 vsize;
398 struct resource resbuf;
399 struct resource *res;
400 struct vesadrm_device *vesa;
401 struct drm_sysfb_device *sysfb;
402 struct drm_device *dev;
403 struct resource *mem = NULL;
404 void __iomem *screen_base;
405 struct drm_plane *primary_plane;
406 struct drm_crtc *crtc;
407 struct drm_encoder *encoder;
408 struct drm_connector *connector;
409 unsigned long max_width, max_height;
410 size_t nformats;
411 int ret;
412
413 si = dev_get_platdata(dev: &pdev->dev);
414 if (!si)
415 return ERR_PTR(error: -ENODEV);
416 if (screen_info_video_type(si) != VIDEO_TYPE_VLFB)
417 return ERR_PTR(error: -ENODEV);
418
419 /*
420 * VESA DRM driver
421 */
422
423 vesa = devm_drm_dev_alloc(&pdev->dev, drv, struct vesadrm_device, sysfb.dev);
424 if (IS_ERR(ptr: vesa))
425 return ERR_CAST(ptr: vesa);
426 sysfb = &vesa->sysfb;
427 dev = &sysfb->dev;
428 platform_set_drvdata(pdev, data: dev);
429
430 /*
431 * Hardware settings
432 */
433
434 format = vesadrm_get_format_si(dev, si);
435 if (!format)
436 return ERR_PTR(error: -EINVAL);
437 width = drm_sysfb_get_width_si(dev, si);
438 if (width < 0)
439 return ERR_PTR(error: width);
440 height = drm_sysfb_get_height_si(dev, si);
441 if (height < 0)
442 return ERR_PTR(error: height);
443 res = drm_sysfb_get_memory_si(dev, si, res: &resbuf);
444 if (!res)
445 return ERR_PTR(error: -EINVAL);
446 stride = drm_sysfb_get_stride_si(dev, si, format, width, height, size: resource_size(res));
447 if (stride < 0)
448 return ERR_PTR(error: stride);
449 vsize = drm_sysfb_get_visible_size_si(dev, si, height, stride, size: resource_size(res));
450 if (!vsize)
451 return ERR_PTR(error: -EINVAL);
452
453 drm_dbg(dev, "framebuffer format=%p4cc, size=%dx%d, stride=%d bytes\n",
454 &format->format, width, height, stride);
455
456 if (!__screen_info_vbe_mode_nonvga(si)) {
457 vesa->cmap_write = vesadrm_vga_cmap_write;
458 } else {
459#if defined(CONFIG_X86_32)
460 phys_addr_t pmi_base = __screen_info_vesapm_info_base(si);
461
462 if (pmi_base) {
463 const u16 *pmi_addr = phys_to_virt(pmi_base);
464
465 vesa->pmi.PrimaryPalette = (u8 *)pmi_addr + pmi_addr[2];
466 vesa->cmap_write = vesadrm_pmi_cmap_write;
467 } else
468#endif
469 if (format->is_color_indexed)
470 drm_warn(dev, "hardware palette is unchangeable, colors may be incorrect\n");
471 }
472
473#if defined(CONFIG_FIRMWARE_EDID)
474 if (drm_edid_header_is_valid(edid: edid_info.dummy) == 8)
475 sysfb->edid = edid_info.dummy;
476#endif
477 sysfb->fb_mode = drm_sysfb_mode(width, height, width_mm: 0, height_mm: 0);
478 sysfb->fb_format = format;
479 sysfb->fb_pitch = stride;
480 if (vesa->cmap_write)
481 sysfb->fb_gamma_lut_size = VESADRM_GAMMA_LUT_SIZE;
482
483 /*
484 * Memory management
485 */
486
487 ret = devm_aperture_acquire_for_platform_device(pdev, base: res->start, size: vsize);
488 if (ret) {
489 drm_err(dev, "could not acquire memory range %pr: %d\n", res, ret);
490 return ERR_PTR(error: ret);
491 }
492
493 drm_dbg(dev, "using I/O memory framebuffer at %pr\n", res);
494
495 mem = devm_request_mem_region(&pdev->dev, res->start, vsize, drv->name);
496 if (!mem) {
497 /*
498 * We cannot make this fatal. Sometimes this comes from magic
499 * spaces our resource handlers simply don't know about. Use
500 * the I/O-memory resource as-is and try to map that instead.
501 */
502 drm_warn(dev, "could not acquire memory region %pr\n", res);
503 mem = res;
504 }
505
506 screen_base = devm_ioremap_wc(dev: &pdev->dev, offset: mem->start, size: resource_size(res: mem));
507 if (!screen_base)
508 return ERR_PTR(error: -ENOMEM);
509 iosys_map_set_vaddr_iomem(map: &sysfb->fb_addr, vaddr_iomem: screen_base);
510
511 /*
512 * Modesetting
513 */
514
515 ret = drmm_mode_config_init(dev);
516 if (ret)
517 return ERR_PTR(error: ret);
518
519 max_width = max_t(unsigned long, width, DRM_SHADOW_PLANE_MAX_WIDTH);
520 max_height = max_t(unsigned long, height, DRM_SHADOW_PLANE_MAX_HEIGHT);
521
522 dev->mode_config.min_width = width;
523 dev->mode_config.max_width = max_width;
524 dev->mode_config.min_height = height;
525 dev->mode_config.max_height = max_height;
526 dev->mode_config.preferred_depth = format->depth;
527 dev->mode_config.funcs = &vesadrm_mode_config_funcs;
528
529 /* Primary plane */
530
531 nformats = drm_sysfb_build_fourcc_list(dev, native_fourccs: &format->format, native_nfourccs: 1,
532 fourccs_out: vesa->formats, ARRAY_SIZE(vesa->formats));
533
534 primary_plane = &vesa->primary_plane;
535 ret = drm_universal_plane_init(dev, plane: primary_plane, possible_crtcs: 0, funcs: &vesadrm_primary_plane_funcs,
536 formats: vesa->formats, format_count: nformats,
537 format_modifiers: vesadrm_primary_plane_format_modifiers,
538 type: DRM_PLANE_TYPE_PRIMARY, NULL);
539 if (ret)
540 return ERR_PTR(error: ret);
541 drm_plane_helper_add(plane: primary_plane, funcs: &vesadrm_primary_plane_helper_funcs);
542 drm_plane_enable_fb_damage_clips(plane: primary_plane);
543
544 /* CRTC */
545
546 crtc = &vesa->crtc;
547 ret = drm_crtc_init_with_planes(dev, crtc, primary: primary_plane, NULL,
548 funcs: &vesadrm_crtc_funcs, NULL);
549 if (ret)
550 return ERR_PTR(error: ret);
551 drm_crtc_helper_add(crtc, funcs: &vesadrm_crtc_helper_funcs);
552
553 if (sysfb->fb_gamma_lut_size) {
554 ret = drm_mode_crtc_set_gamma_size(crtc, gamma_size: sysfb->fb_gamma_lut_size);
555 if (!ret)
556 drm_crtc_enable_color_mgmt(crtc, degamma_lut_size: 0, has_ctm: false, gamma_lut_size: sysfb->fb_gamma_lut_size);
557 }
558
559 /* Encoder */
560
561 encoder = &vesa->encoder;
562 ret = drm_encoder_init(dev, encoder, funcs: &vesadrm_encoder_funcs,
563 DRM_MODE_ENCODER_NONE, NULL);
564 if (ret)
565 return ERR_PTR(error: ret);
566 encoder->possible_crtcs = drm_crtc_mask(crtc);
567
568 /* Connector */
569
570 connector = &vesa->connector;
571 ret = drm_connector_init(dev, connector, funcs: &vesadrm_connector_funcs,
572 DRM_MODE_CONNECTOR_Unknown);
573 if (ret)
574 return ERR_PTR(error: ret);
575 drm_connector_helper_add(connector, funcs: &vesadrm_connector_helper_funcs);
576 drm_connector_set_panel_orientation_with_quirk(connector,
577 panel_orientation: DRM_MODE_PANEL_ORIENTATION_UNKNOWN,
578 width, height);
579 if (sysfb->edid)
580 drm_connector_attach_edid_property(connector);
581
582 ret = drm_connector_attach_encoder(connector, encoder);
583 if (ret)
584 return ERR_PTR(error: ret);
585
586 drm_mode_config_reset(dev);
587
588 return vesa;
589}
590
591/*
592 * DRM driver
593 */
594
595DEFINE_DRM_GEM_FOPS(vesadrm_fops);
596
597static struct drm_driver vesadrm_driver = {
598 DRM_GEM_SHMEM_DRIVER_OPS,
599 DRM_FBDEV_SHMEM_DRIVER_OPS,
600 .name = DRIVER_NAME,
601 .desc = DRIVER_DESC,
602 .major = DRIVER_MAJOR,
603 .minor = DRIVER_MINOR,
604 .driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
605 .fops = &vesadrm_fops,
606};
607
608/*
609 * Platform driver
610 */
611
612static int vesadrm_probe(struct platform_device *pdev)
613{
614 struct vesadrm_device *vesa;
615 struct drm_sysfb_device *sysfb;
616 struct drm_device *dev;
617 int ret;
618
619 vesa = vesadrm_device_create(drv: &vesadrm_driver, pdev);
620 if (IS_ERR(ptr: vesa))
621 return PTR_ERR(ptr: vesa);
622 sysfb = &vesa->sysfb;
623 dev = &sysfb->dev;
624
625 ret = drm_dev_register(dev, flags: 0);
626 if (ret)
627 return ret;
628
629 drm_client_setup(dev, format: sysfb->fb_format);
630
631 return 0;
632}
633
634static void vesadrm_remove(struct platform_device *pdev)
635{
636 struct drm_device *dev = platform_get_drvdata(pdev);
637
638 drm_dev_unplug(dev);
639}
640
641static struct platform_driver vesadrm_platform_driver = {
642 .driver = {
643 .name = "vesa-framebuffer",
644 },
645 .probe = vesadrm_probe,
646 .remove = vesadrm_remove,
647};
648
649module_platform_driver(vesadrm_platform_driver);
650
651MODULE_DESCRIPTION(DRIVER_DESC);
652MODULE_LICENSE("GPL");
653

source code of linux/drivers/gpu/drm/sysfb/vesadrm.c