drivers/video: implement a simple framebuffer driver
A simple frame-buffer describes a raw memory region that may be rendered
to, with the assumption that the display hardware has already been set
up to scan out from that buffer.
This is useful in cases where a bootloader exists and has set up the
display hardware, but a Linux driver doesn't yet exist for the display
hardware.
Examples use-cases include:
* The built-in LCD panels on the Samsung ARM chromebook, and Tegra
devices, and likely many other ARM or embedded systems. These cannot
yet be supported using a full graphics driver, since the panel control
should be provided by the CDF (Common Display Framework), which has been
stuck in design/review for quite some time. One could support these
panels using custom SoC-specific code, but there is a desire to use
common infra-structure rather than having each SoC vendor invent their
own code, hence the desire to wait for CDF.
* Hardware for which a full graphics driver is not yet available, and
the path to obtain one upstream isn't yet clear. For example, the
Raspberry Pi.
* Any hardware in early stages of upstreaming, before a full graphics
driver has been tackled. This driver can provide a graphical boot
console (even full X support) much earlier in the upstreaming process,
thus making new SoC or board support more generally useful earlier.
[akpm@linux-foundation.org: make simplefb_formats[] static]
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Olof Johansson <olof@lixom.net>
Cc: Rob Clark <robclark@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Tomasz Figa <tomasz.figa@gmail.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-25 02:55:13 +04:00
|
|
|
/*
|
|
|
|
* Simplest possible simple frame-buffer driver, as a platform device
|
|
|
|
*
|
|
|
|
* Copyright (c) 2013, Stephen Warren
|
|
|
|
*
|
|
|
|
* Based on q40fb.c, which was:
|
|
|
|
* Copyright (C) 2001 Richard Zidlicky <rz@linux-m68k.org>
|
|
|
|
*
|
|
|
|
* Also based on offb.c, which was:
|
|
|
|
* Copyright (C) 1997 Geert Uytterhoeven
|
|
|
|
* Copyright (C) 1996 Paul Mackerras
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms and conditions of the GNU General Public License,
|
|
|
|
* version 2, as published by the Free Software Foundation.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope it will be useful, but WITHOUT
|
|
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
|
|
|
* more details.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/fb.h>
|
|
|
|
#include <linux/io.h>
|
|
|
|
#include <linux/module.h>
|
2013-08-02 16:05:20 +04:00
|
|
|
#include <linux/platform_data/simplefb.h>
|
drivers/video: implement a simple framebuffer driver
A simple frame-buffer describes a raw memory region that may be rendered
to, with the assumption that the display hardware has already been set
up to scan out from that buffer.
This is useful in cases where a bootloader exists and has set up the
display hardware, but a Linux driver doesn't yet exist for the display
hardware.
Examples use-cases include:
* The built-in LCD panels on the Samsung ARM chromebook, and Tegra
devices, and likely many other ARM or embedded systems. These cannot
yet be supported using a full graphics driver, since the panel control
should be provided by the CDF (Common Display Framework), which has been
stuck in design/review for quite some time. One could support these
panels using custom SoC-specific code, but there is a desire to use
common infra-structure rather than having each SoC vendor invent their
own code, hence the desire to wait for CDF.
* Hardware for which a full graphics driver is not yet available, and
the path to obtain one upstream isn't yet clear. For example, the
Raspberry Pi.
* Any hardware in early stages of upstreaming, before a full graphics
driver has been tackled. This driver can provide a graphical boot
console (even full X support) much earlier in the upstreaming process,
thus making new SoC or board support more generally useful earlier.
[akpm@linux-foundation.org: make simplefb_formats[] static]
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Olof Johansson <olof@lixom.net>
Cc: Rob Clark <robclark@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Tomasz Figa <tomasz.figa@gmail.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-25 02:55:13 +04:00
|
|
|
#include <linux/platform_device.h>
|
|
|
|
|
|
|
|
static struct fb_fix_screeninfo simplefb_fix = {
|
|
|
|
.id = "simple",
|
|
|
|
.type = FB_TYPE_PACKED_PIXELS,
|
|
|
|
.visual = FB_VISUAL_TRUECOLOR,
|
|
|
|
.accel = FB_ACCEL_NONE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct fb_var_screeninfo simplefb_var = {
|
|
|
|
.height = -1,
|
|
|
|
.width = -1,
|
|
|
|
.activate = FB_ACTIVATE_NOW,
|
|
|
|
.vmode = FB_VMODE_NONINTERLACED,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int simplefb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
|
|
|
|
u_int transp, struct fb_info *info)
|
|
|
|
{
|
|
|
|
u32 *pal = info->pseudo_palette;
|
|
|
|
u32 cr = red >> (16 - info->var.red.length);
|
|
|
|
u32 cg = green >> (16 - info->var.green.length);
|
|
|
|
u32 cb = blue >> (16 - info->var.blue.length);
|
|
|
|
u32 value;
|
|
|
|
|
|
|
|
if (regno >= 16)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
value = (cr << info->var.red.offset) |
|
|
|
|
(cg << info->var.green.offset) |
|
|
|
|
(cb << info->var.blue.offset);
|
|
|
|
if (info->var.transp.length > 0) {
|
|
|
|
u32 mask = (1 << info->var.transp.length) - 1;
|
|
|
|
mask <<= info->var.transp.offset;
|
|
|
|
value |= mask;
|
|
|
|
}
|
|
|
|
pal[regno] = value;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct fb_ops simplefb_ops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.fb_setcolreg = simplefb_setcolreg,
|
|
|
|
.fb_fillrect = cfb_fillrect,
|
|
|
|
.fb_copyarea = cfb_copyarea,
|
|
|
|
.fb_imageblit = cfb_imageblit,
|
|
|
|
};
|
|
|
|
|
2013-08-02 16:05:20 +04:00
|
|
|
static struct simplefb_format simplefb_formats[] = SIMPLEFB_FORMATS;
|
drivers/video: implement a simple framebuffer driver
A simple frame-buffer describes a raw memory region that may be rendered
to, with the assumption that the display hardware has already been set
up to scan out from that buffer.
This is useful in cases where a bootloader exists and has set up the
display hardware, but a Linux driver doesn't yet exist for the display
hardware.
Examples use-cases include:
* The built-in LCD panels on the Samsung ARM chromebook, and Tegra
devices, and likely many other ARM or embedded systems. These cannot
yet be supported using a full graphics driver, since the panel control
should be provided by the CDF (Common Display Framework), which has been
stuck in design/review for quite some time. One could support these
panels using custom SoC-specific code, but there is a desire to use
common infra-structure rather than having each SoC vendor invent their
own code, hence the desire to wait for CDF.
* Hardware for which a full graphics driver is not yet available, and
the path to obtain one upstream isn't yet clear. For example, the
Raspberry Pi.
* Any hardware in early stages of upstreaming, before a full graphics
driver has been tackled. This driver can provide a graphical boot
console (even full X support) much earlier in the upstreaming process,
thus making new SoC or board support more generally useful earlier.
[akpm@linux-foundation.org: make simplefb_formats[] static]
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Olof Johansson <olof@lixom.net>
Cc: Rob Clark <robclark@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Tomasz Figa <tomasz.figa@gmail.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-25 02:55:13 +04:00
|
|
|
|
|
|
|
struct simplefb_params {
|
|
|
|
u32 width;
|
|
|
|
u32 height;
|
|
|
|
u32 stride;
|
|
|
|
struct simplefb_format *format;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int simplefb_parse_dt(struct platform_device *pdev,
|
|
|
|
struct simplefb_params *params)
|
|
|
|
{
|
|
|
|
struct device_node *np = pdev->dev.of_node;
|
|
|
|
int ret;
|
|
|
|
const char *format;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
ret = of_property_read_u32(np, "width", ¶ms->width);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "Can't parse width property\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = of_property_read_u32(np, "height", ¶ms->height);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "Can't parse height property\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = of_property_read_u32(np, "stride", ¶ms->stride);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "Can't parse stride property\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = of_property_read_string(np, "format", &format);
|
|
|
|
if (ret) {
|
|
|
|
dev_err(&pdev->dev, "Can't parse format property\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
params->format = NULL;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
|
|
|
|
if (strcmp(format, simplefb_formats[i].name))
|
|
|
|
continue;
|
|
|
|
params->format = &simplefb_formats[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!params->format) {
|
|
|
|
dev_err(&pdev->dev, "Invalid format value\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-08-02 16:05:20 +04:00
|
|
|
static int simplefb_parse_pd(struct platform_device *pdev,
|
|
|
|
struct simplefb_params *params)
|
|
|
|
{
|
|
|
|
struct simplefb_platform_data *pd = pdev->dev.platform_data;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
params->width = pd->width;
|
|
|
|
params->height = pd->height;
|
|
|
|
params->stride = pd->stride;
|
|
|
|
|
|
|
|
params->format = NULL;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(simplefb_formats); i++) {
|
|
|
|
if (strcmp(pd->format, simplefb_formats[i].name))
|
|
|
|
continue;
|
|
|
|
|
|
|
|
params->format = &simplefb_formats[i];
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!params->format) {
|
|
|
|
dev_err(&pdev->dev, "Invalid format value\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
drivers/video: implement a simple framebuffer driver
A simple frame-buffer describes a raw memory region that may be rendered
to, with the assumption that the display hardware has already been set
up to scan out from that buffer.
This is useful in cases where a bootloader exists and has set up the
display hardware, but a Linux driver doesn't yet exist for the display
hardware.
Examples use-cases include:
* The built-in LCD panels on the Samsung ARM chromebook, and Tegra
devices, and likely many other ARM or embedded systems. These cannot
yet be supported using a full graphics driver, since the panel control
should be provided by the CDF (Common Display Framework), which has been
stuck in design/review for quite some time. One could support these
panels using custom SoC-specific code, but there is a desire to use
common infra-structure rather than having each SoC vendor invent their
own code, hence the desire to wait for CDF.
* Hardware for which a full graphics driver is not yet available, and
the path to obtain one upstream isn't yet clear. For example, the
Raspberry Pi.
* Any hardware in early stages of upstreaming, before a full graphics
driver has been tackled. This driver can provide a graphical boot
console (even full X support) much earlier in the upstreaming process,
thus making new SoC or board support more generally useful earlier.
[akpm@linux-foundation.org: make simplefb_formats[] static]
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Olof Johansson <olof@lixom.net>
Cc: Rob Clark <robclark@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Tomasz Figa <tomasz.figa@gmail.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-25 02:55:13 +04:00
|
|
|
static int simplefb_probe(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct simplefb_params params;
|
|
|
|
struct fb_info *info;
|
|
|
|
struct resource *mem;
|
|
|
|
|
|
|
|
if (fb_get_options("simplefb", NULL))
|
|
|
|
return -ENODEV;
|
|
|
|
|
2013-08-02 16:05:20 +04:00
|
|
|
ret = -ENODEV;
|
|
|
|
if (pdev->dev.platform_data)
|
|
|
|
ret = simplefb_parse_pd(pdev, ¶ms);
|
|
|
|
else if (pdev->dev.of_node)
|
|
|
|
ret = simplefb_parse_dt(pdev, ¶ms);
|
|
|
|
|
drivers/video: implement a simple framebuffer driver
A simple frame-buffer describes a raw memory region that may be rendered
to, with the assumption that the display hardware has already been set
up to scan out from that buffer.
This is useful in cases where a bootloader exists and has set up the
display hardware, but a Linux driver doesn't yet exist for the display
hardware.
Examples use-cases include:
* The built-in LCD panels on the Samsung ARM chromebook, and Tegra
devices, and likely many other ARM or embedded systems. These cannot
yet be supported using a full graphics driver, since the panel control
should be provided by the CDF (Common Display Framework), which has been
stuck in design/review for quite some time. One could support these
panels using custom SoC-specific code, but there is a desire to use
common infra-structure rather than having each SoC vendor invent their
own code, hence the desire to wait for CDF.
* Hardware for which a full graphics driver is not yet available, and
the path to obtain one upstream isn't yet clear. For example, the
Raspberry Pi.
* Any hardware in early stages of upstreaming, before a full graphics
driver has been tackled. This driver can provide a graphical boot
console (even full X support) much earlier in the upstreaming process,
thus making new SoC or board support more generally useful earlier.
[akpm@linux-foundation.org: make simplefb_formats[] static]
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Olof Johansson <olof@lixom.net>
Cc: Rob Clark <robclark@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Tomasz Figa <tomasz.figa@gmail.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-25 02:55:13 +04:00
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
|
|
|
|
if (!mem) {
|
|
|
|
dev_err(&pdev->dev, "No memory resource\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
info = framebuffer_alloc(sizeof(u32) * 16, &pdev->dev);
|
|
|
|
if (!info)
|
|
|
|
return -ENOMEM;
|
|
|
|
platform_set_drvdata(pdev, info);
|
|
|
|
|
|
|
|
info->fix = simplefb_fix;
|
|
|
|
info->fix.smem_start = mem->start;
|
|
|
|
info->fix.smem_len = resource_size(mem);
|
|
|
|
info->fix.line_length = params.stride;
|
|
|
|
|
|
|
|
info->var = simplefb_var;
|
|
|
|
info->var.xres = params.width;
|
|
|
|
info->var.yres = params.height;
|
|
|
|
info->var.xres_virtual = params.width;
|
|
|
|
info->var.yres_virtual = params.height;
|
|
|
|
info->var.bits_per_pixel = params.format->bits_per_pixel;
|
|
|
|
info->var.red = params.format->red;
|
|
|
|
info->var.green = params.format->green;
|
|
|
|
info->var.blue = params.format->blue;
|
|
|
|
info->var.transp = params.format->transp;
|
|
|
|
|
2013-08-02 16:05:21 +04:00
|
|
|
info->apertures = alloc_apertures(1);
|
|
|
|
if (!info->apertures) {
|
|
|
|
framebuffer_release(info);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
info->apertures->ranges[0].base = info->fix.smem_start;
|
|
|
|
info->apertures->ranges[0].size = info->fix.smem_len;
|
|
|
|
|
drivers/video: implement a simple framebuffer driver
A simple frame-buffer describes a raw memory region that may be rendered
to, with the assumption that the display hardware has already been set
up to scan out from that buffer.
This is useful in cases where a bootloader exists and has set up the
display hardware, but a Linux driver doesn't yet exist for the display
hardware.
Examples use-cases include:
* The built-in LCD panels on the Samsung ARM chromebook, and Tegra
devices, and likely many other ARM or embedded systems. These cannot
yet be supported using a full graphics driver, since the panel control
should be provided by the CDF (Common Display Framework), which has been
stuck in design/review for quite some time. One could support these
panels using custom SoC-specific code, but there is a desire to use
common infra-structure rather than having each SoC vendor invent their
own code, hence the desire to wait for CDF.
* Hardware for which a full graphics driver is not yet available, and
the path to obtain one upstream isn't yet clear. For example, the
Raspberry Pi.
* Any hardware in early stages of upstreaming, before a full graphics
driver has been tackled. This driver can provide a graphical boot
console (even full X support) much earlier in the upstreaming process,
thus making new SoC or board support more generally useful earlier.
[akpm@linux-foundation.org: make simplefb_formats[] static]
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Olof Johansson <olof@lixom.net>
Cc: Rob Clark <robclark@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Tomasz Figa <tomasz.figa@gmail.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-25 02:55:13 +04:00
|
|
|
info->fbops = &simplefb_ops;
|
2013-08-02 16:05:21 +04:00
|
|
|
info->flags = FBINFO_DEFAULT | FBINFO_MISC_FIRMWARE;
|
drivers/video: implement a simple framebuffer driver
A simple frame-buffer describes a raw memory region that may be rendered
to, with the assumption that the display hardware has already been set
up to scan out from that buffer.
This is useful in cases where a bootloader exists and has set up the
display hardware, but a Linux driver doesn't yet exist for the display
hardware.
Examples use-cases include:
* The built-in LCD panels on the Samsung ARM chromebook, and Tegra
devices, and likely many other ARM or embedded systems. These cannot
yet be supported using a full graphics driver, since the panel control
should be provided by the CDF (Common Display Framework), which has been
stuck in design/review for quite some time. One could support these
panels using custom SoC-specific code, but there is a desire to use
common infra-structure rather than having each SoC vendor invent their
own code, hence the desire to wait for CDF.
* Hardware for which a full graphics driver is not yet available, and
the path to obtain one upstream isn't yet clear. For example, the
Raspberry Pi.
* Any hardware in early stages of upstreaming, before a full graphics
driver has been tackled. This driver can provide a graphical boot
console (even full X support) much earlier in the upstreaming process,
thus making new SoC or board support more generally useful earlier.
[akpm@linux-foundation.org: make simplefb_formats[] static]
Signed-off-by: Stephen Warren <swarren@wwwdotorg.org>
Cc: Arnd Bergmann <arnd@arndb.de>
Acked-by: Olof Johansson <olof@lixom.net>
Cc: Rob Clark <robclark@gmail.com>
Cc: Florian Tobias Schandinat <FlorianSchandinat@gmx.de>
Cc: Tomasz Figa <tomasz.figa@gmail.com>
Cc: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2013-05-25 02:55:13 +04:00
|
|
|
info->screen_base = devm_ioremap(&pdev->dev, info->fix.smem_start,
|
|
|
|
info->fix.smem_len);
|
|
|
|
if (!info->screen_base) {
|
|
|
|
framebuffer_release(info);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
info->pseudo_palette = (void *)(info + 1);
|
|
|
|
|
|
|
|
ret = register_framebuffer(info);
|
|
|
|
if (ret < 0) {
|
|
|
|
dev_err(&pdev->dev, "Unable to register simplefb: %d\n", ret);
|
|
|
|
framebuffer_release(info);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev_info(&pdev->dev, "fb%d: simplefb registered!\n", info->node);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int simplefb_remove(struct platform_device *pdev)
|
|
|
|
{
|
|
|
|
struct fb_info *info = platform_get_drvdata(pdev);
|
|
|
|
|
|
|
|
unregister_framebuffer(info);
|
|
|
|
framebuffer_release(info);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct of_device_id simplefb_of_match[] = {
|
|
|
|
{ .compatible = "simple-framebuffer", },
|
|
|
|
{ },
|
|
|
|
};
|
|
|
|
MODULE_DEVICE_TABLE(of, simplefb_of_match);
|
|
|
|
|
|
|
|
static struct platform_driver simplefb_driver = {
|
|
|
|
.driver = {
|
|
|
|
.name = "simple-framebuffer",
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.of_match_table = simplefb_of_match,
|
|
|
|
},
|
|
|
|
.probe = simplefb_probe,
|
|
|
|
.remove = simplefb_remove,
|
|
|
|
};
|
|
|
|
module_platform_driver(simplefb_driver);
|
|
|
|
|
|
|
|
MODULE_AUTHOR("Stephen Warren <swarren@wwwdotorg.org>");
|
|
|
|
MODULE_DESCRIPTION("Simple framebuffer driver");
|
|
|
|
MODULE_LICENSE("GPL v2");
|