forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
605 lines
16 KiB
605 lines
16 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/*************************************************************************** |
|
* Copyright (C) 2010-2012 by Bruno Prémont <[email protected]> * |
|
* * |
|
* Based on Logitech G13 driver (v0.4) * |
|
* Copyright (C) 2009 by Rick L. Vinyard, Jr. <[email protected]> * |
|
* * |
|
***************************************************************************/ |
|
|
|
#include <linux/hid.h> |
|
#include <linux/vmalloc.h> |
|
|
|
#include <linux/fb.h> |
|
#include <linux/module.h> |
|
|
|
#include "hid-picolcd.h" |
|
|
|
/* Framebuffer |
|
* |
|
* The PicoLCD use a Topway LCD module of 256x64 pixel |
|
* This display area is tiled over 4 controllers with 8 tiles |
|
* each. Each tile has 8x64 pixel, each data byte representing |
|
* a 1-bit wide vertical line of the tile. |
|
* |
|
* The display can be updated at a tile granularity. |
|
* |
|
* Chip 1 Chip 2 Chip 3 Chip 4 |
|
* +----------------+----------------+----------------+----------------+ |
|
* | Tile 1 | Tile 1 | Tile 1 | Tile 1 | |
|
* +----------------+----------------+----------------+----------------+ |
|
* | Tile 2 | Tile 2 | Tile 2 | Tile 2 | |
|
* +----------------+----------------+----------------+----------------+ |
|
* ... |
|
* +----------------+----------------+----------------+----------------+ |
|
* | Tile 8 | Tile 8 | Tile 8 | Tile 8 | |
|
* +----------------+----------------+----------------+----------------+ |
|
*/ |
|
#define PICOLCDFB_NAME "picolcdfb" |
|
#define PICOLCDFB_WIDTH (256) |
|
#define PICOLCDFB_HEIGHT (64) |
|
#define PICOLCDFB_SIZE (PICOLCDFB_WIDTH * PICOLCDFB_HEIGHT / 8) |
|
|
|
#define PICOLCDFB_UPDATE_RATE_LIMIT 10 |
|
#define PICOLCDFB_UPDATE_RATE_DEFAULT 2 |
|
|
|
/* Framebuffer visual structures */ |
|
static const struct fb_fix_screeninfo picolcdfb_fix = { |
|
.id = PICOLCDFB_NAME, |
|
.type = FB_TYPE_PACKED_PIXELS, |
|
.visual = FB_VISUAL_MONO01, |
|
.xpanstep = 0, |
|
.ypanstep = 0, |
|
.ywrapstep = 0, |
|
.line_length = PICOLCDFB_WIDTH / 8, |
|
.accel = FB_ACCEL_NONE, |
|
}; |
|
|
|
static const struct fb_var_screeninfo picolcdfb_var = { |
|
.xres = PICOLCDFB_WIDTH, |
|
.yres = PICOLCDFB_HEIGHT, |
|
.xres_virtual = PICOLCDFB_WIDTH, |
|
.yres_virtual = PICOLCDFB_HEIGHT, |
|
.width = 103, |
|
.height = 26, |
|
.bits_per_pixel = 1, |
|
.grayscale = 1, |
|
.red = { |
|
.offset = 0, |
|
.length = 1, |
|
.msb_right = 0, |
|
}, |
|
.green = { |
|
.offset = 0, |
|
.length = 1, |
|
.msb_right = 0, |
|
}, |
|
.blue = { |
|
.offset = 0, |
|
.length = 1, |
|
.msb_right = 0, |
|
}, |
|
.transp = { |
|
.offset = 0, |
|
.length = 0, |
|
.msb_right = 0, |
|
}, |
|
}; |
|
|
|
/* Send a given tile to PicoLCD */ |
|
static int picolcd_fb_send_tile(struct picolcd_data *data, u8 *vbitmap, |
|
int chip, int tile) |
|
{ |
|
struct hid_report *report1, *report2; |
|
unsigned long flags; |
|
u8 *tdata; |
|
int i; |
|
|
|
report1 = picolcd_out_report(REPORT_LCD_CMD_DATA, data->hdev); |
|
if (!report1 || report1->maxfield != 1) |
|
return -ENODEV; |
|
report2 = picolcd_out_report(REPORT_LCD_DATA, data->hdev); |
|
if (!report2 || report2->maxfield != 1) |
|
return -ENODEV; |
|
|
|
spin_lock_irqsave(&data->lock, flags); |
|
if ((data->status & PICOLCD_FAILED)) { |
|
spin_unlock_irqrestore(&data->lock, flags); |
|
return -ENODEV; |
|
} |
|
hid_set_field(report1->field[0], 0, chip << 2); |
|
hid_set_field(report1->field[0], 1, 0x02); |
|
hid_set_field(report1->field[0], 2, 0x00); |
|
hid_set_field(report1->field[0], 3, 0x00); |
|
hid_set_field(report1->field[0], 4, 0xb8 | tile); |
|
hid_set_field(report1->field[0], 5, 0x00); |
|
hid_set_field(report1->field[0], 6, 0x00); |
|
hid_set_field(report1->field[0], 7, 0x40); |
|
hid_set_field(report1->field[0], 8, 0x00); |
|
hid_set_field(report1->field[0], 9, 0x00); |
|
hid_set_field(report1->field[0], 10, 32); |
|
|
|
hid_set_field(report2->field[0], 0, (chip << 2) | 0x01); |
|
hid_set_field(report2->field[0], 1, 0x00); |
|
hid_set_field(report2->field[0], 2, 0x00); |
|
hid_set_field(report2->field[0], 3, 32); |
|
|
|
tdata = vbitmap + (tile * 4 + chip) * 64; |
|
for (i = 0; i < 64; i++) |
|
if (i < 32) |
|
hid_set_field(report1->field[0], 11 + i, tdata[i]); |
|
else |
|
hid_set_field(report2->field[0], 4 + i - 32, tdata[i]); |
|
|
|
hid_hw_request(data->hdev, report1, HID_REQ_SET_REPORT); |
|
hid_hw_request(data->hdev, report2, HID_REQ_SET_REPORT); |
|
spin_unlock_irqrestore(&data->lock, flags); |
|
return 0; |
|
} |
|
|
|
/* Translate a single tile*/ |
|
static int picolcd_fb_update_tile(u8 *vbitmap, const u8 *bitmap, int bpp, |
|
int chip, int tile) |
|
{ |
|
int i, b, changed = 0; |
|
u8 tdata[64]; |
|
u8 *vdata = vbitmap + (tile * 4 + chip) * 64; |
|
|
|
if (bpp == 1) { |
|
for (b = 7; b >= 0; b--) { |
|
const u8 *bdata = bitmap + tile * 256 + chip * 8 + b * 32; |
|
for (i = 0; i < 64; i++) { |
|
tdata[i] <<= 1; |
|
tdata[i] |= (bdata[i/8] >> (i % 8)) & 0x01; |
|
} |
|
} |
|
} else if (bpp == 8) { |
|
for (b = 7; b >= 0; b--) { |
|
const u8 *bdata = bitmap + (tile * 256 + chip * 8 + b * 32) * 8; |
|
for (i = 0; i < 64; i++) { |
|
tdata[i] <<= 1; |
|
tdata[i] |= (bdata[i] & 0x80) ? 0x01 : 0x00; |
|
} |
|
} |
|
} else { |
|
/* Oops, we should never get here! */ |
|
WARN_ON(1); |
|
return 0; |
|
} |
|
|
|
for (i = 0; i < 64; i++) |
|
if (tdata[i] != vdata[i]) { |
|
changed = 1; |
|
vdata[i] = tdata[i]; |
|
} |
|
return changed; |
|
} |
|
|
|
void picolcd_fb_refresh(struct picolcd_data *data) |
|
{ |
|
if (data->fb_info) |
|
schedule_delayed_work(&data->fb_info->deferred_work, 0); |
|
} |
|
|
|
/* Reconfigure LCD display */ |
|
int picolcd_fb_reset(struct picolcd_data *data, int clear) |
|
{ |
|
struct hid_report *report = picolcd_out_report(REPORT_LCD_CMD, data->hdev); |
|
struct picolcd_fb_data *fbdata = data->fb_info->par; |
|
int i, j; |
|
unsigned long flags; |
|
static const u8 mapcmd[8] = { 0x00, 0x02, 0x00, 0x64, 0x3f, 0x00, 0x64, 0xc0 }; |
|
|
|
if (!report || report->maxfield != 1) |
|
return -ENODEV; |
|
|
|
spin_lock_irqsave(&data->lock, flags); |
|
for (i = 0; i < 4; i++) { |
|
for (j = 0; j < report->field[0]->maxusage; j++) |
|
if (j == 0) |
|
hid_set_field(report->field[0], j, i << 2); |
|
else if (j < sizeof(mapcmd)) |
|
hid_set_field(report->field[0], j, mapcmd[j]); |
|
else |
|
hid_set_field(report->field[0], j, 0); |
|
hid_hw_request(data->hdev, report, HID_REQ_SET_REPORT); |
|
} |
|
spin_unlock_irqrestore(&data->lock, flags); |
|
|
|
if (clear) { |
|
memset(fbdata->vbitmap, 0, PICOLCDFB_SIZE); |
|
memset(fbdata->bitmap, 0, PICOLCDFB_SIZE*fbdata->bpp); |
|
} |
|
fbdata->force = 1; |
|
|
|
/* schedule first output of framebuffer */ |
|
if (fbdata->ready) |
|
schedule_delayed_work(&data->fb_info->deferred_work, 0); |
|
else |
|
fbdata->ready = 1; |
|
|
|
return 0; |
|
} |
|
|
|
/* Update fb_vbitmap from the screen_base and send changed tiles to device */ |
|
static void picolcd_fb_update(struct fb_info *info) |
|
{ |
|
int chip, tile, n; |
|
unsigned long flags; |
|
struct picolcd_fb_data *fbdata = info->par; |
|
struct picolcd_data *data; |
|
|
|
mutex_lock(&info->lock); |
|
|
|
spin_lock_irqsave(&fbdata->lock, flags); |
|
if (!fbdata->ready && fbdata->picolcd) |
|
picolcd_fb_reset(fbdata->picolcd, 0); |
|
spin_unlock_irqrestore(&fbdata->lock, flags); |
|
|
|
/* |
|
* Translate the framebuffer into the format needed by the PicoLCD. |
|
* See display layout above. |
|
* Do this one tile after the other and push those tiles that changed. |
|
* |
|
* Wait for our IO to complete as otherwise we might flood the queue! |
|
*/ |
|
n = 0; |
|
for (chip = 0; chip < 4; chip++) |
|
for (tile = 0; tile < 8; tile++) { |
|
if (!fbdata->force && !picolcd_fb_update_tile( |
|
fbdata->vbitmap, fbdata->bitmap, |
|
fbdata->bpp, chip, tile)) |
|
continue; |
|
n += 2; |
|
if (n >= HID_OUTPUT_FIFO_SIZE / 2) { |
|
spin_lock_irqsave(&fbdata->lock, flags); |
|
data = fbdata->picolcd; |
|
spin_unlock_irqrestore(&fbdata->lock, flags); |
|
mutex_unlock(&info->lock); |
|
if (!data) |
|
return; |
|
hid_hw_wait(data->hdev); |
|
mutex_lock(&info->lock); |
|
n = 0; |
|
} |
|
spin_lock_irqsave(&fbdata->lock, flags); |
|
data = fbdata->picolcd; |
|
spin_unlock_irqrestore(&fbdata->lock, flags); |
|
if (!data || picolcd_fb_send_tile(data, |
|
fbdata->vbitmap, chip, tile)) |
|
goto out; |
|
} |
|
fbdata->force = false; |
|
if (n) { |
|
spin_lock_irqsave(&fbdata->lock, flags); |
|
data = fbdata->picolcd; |
|
spin_unlock_irqrestore(&fbdata->lock, flags); |
|
mutex_unlock(&info->lock); |
|
if (data) |
|
hid_hw_wait(data->hdev); |
|
return; |
|
} |
|
out: |
|
mutex_unlock(&info->lock); |
|
} |
|
|
|
/* Stub to call the system default and update the image on the picoLCD */ |
|
static void picolcd_fb_fillrect(struct fb_info *info, |
|
const struct fb_fillrect *rect) |
|
{ |
|
if (!info->par) |
|
return; |
|
sys_fillrect(info, rect); |
|
|
|
schedule_delayed_work(&info->deferred_work, 0); |
|
} |
|
|
|
/* Stub to call the system default and update the image on the picoLCD */ |
|
static void picolcd_fb_copyarea(struct fb_info *info, |
|
const struct fb_copyarea *area) |
|
{ |
|
if (!info->par) |
|
return; |
|
sys_copyarea(info, area); |
|
|
|
schedule_delayed_work(&info->deferred_work, 0); |
|
} |
|
|
|
/* Stub to call the system default and update the image on the picoLCD */ |
|
static void picolcd_fb_imageblit(struct fb_info *info, const struct fb_image *image) |
|
{ |
|
if (!info->par) |
|
return; |
|
sys_imageblit(info, image); |
|
|
|
schedule_delayed_work(&info->deferred_work, 0); |
|
} |
|
|
|
/* |
|
* this is the slow path from userspace. they can seek and write to |
|
* the fb. it's inefficient to do anything less than a full screen draw |
|
*/ |
|
static ssize_t picolcd_fb_write(struct fb_info *info, const char __user *buf, |
|
size_t count, loff_t *ppos) |
|
{ |
|
ssize_t ret; |
|
if (!info->par) |
|
return -ENODEV; |
|
ret = fb_sys_write(info, buf, count, ppos); |
|
if (ret >= 0) |
|
schedule_delayed_work(&info->deferred_work, 0); |
|
return ret; |
|
} |
|
|
|
static int picolcd_fb_blank(int blank, struct fb_info *info) |
|
{ |
|
/* We let fb notification do this for us via lcd/backlight device */ |
|
return 0; |
|
} |
|
|
|
static void picolcd_fb_destroy(struct fb_info *info) |
|
{ |
|
struct picolcd_fb_data *fbdata = info->par; |
|
|
|
/* make sure no work is deferred */ |
|
fb_deferred_io_cleanup(info); |
|
|
|
/* No thridparty should ever unregister our framebuffer! */ |
|
WARN_ON(fbdata->picolcd != NULL); |
|
|
|
vfree((u8 *)info->fix.smem_start); |
|
framebuffer_release(info); |
|
} |
|
|
|
static int picolcd_fb_check_var(struct fb_var_screeninfo *var, struct fb_info *info) |
|
{ |
|
__u32 bpp = var->bits_per_pixel; |
|
__u32 activate = var->activate; |
|
|
|
/* only allow 1/8 bit depth (8-bit is grayscale) */ |
|
*var = picolcdfb_var; |
|
var->activate = activate; |
|
if (bpp >= 8) { |
|
var->bits_per_pixel = 8; |
|
var->red.length = 8; |
|
var->green.length = 8; |
|
var->blue.length = 8; |
|
} else { |
|
var->bits_per_pixel = 1; |
|
var->red.length = 1; |
|
var->green.length = 1; |
|
var->blue.length = 1; |
|
} |
|
return 0; |
|
} |
|
|
|
static int picolcd_set_par(struct fb_info *info) |
|
{ |
|
struct picolcd_fb_data *fbdata = info->par; |
|
u8 *tmp_fb, *o_fb; |
|
if (info->var.bits_per_pixel == fbdata->bpp) |
|
return 0; |
|
/* switch between 1/8 bit depths */ |
|
if (info->var.bits_per_pixel != 1 && info->var.bits_per_pixel != 8) |
|
return -EINVAL; |
|
|
|
o_fb = fbdata->bitmap; |
|
tmp_fb = kmalloc_array(PICOLCDFB_SIZE, info->var.bits_per_pixel, |
|
GFP_KERNEL); |
|
if (!tmp_fb) |
|
return -ENOMEM; |
|
|
|
/* translate FB content to new bits-per-pixel */ |
|
if (info->var.bits_per_pixel == 1) { |
|
int i, b; |
|
for (i = 0; i < PICOLCDFB_SIZE; i++) { |
|
u8 p = 0; |
|
for (b = 0; b < 8; b++) { |
|
p <<= 1; |
|
p |= o_fb[i*8+b] ? 0x01 : 0x00; |
|
} |
|
tmp_fb[i] = p; |
|
} |
|
memcpy(o_fb, tmp_fb, PICOLCDFB_SIZE); |
|
info->fix.visual = FB_VISUAL_MONO01; |
|
info->fix.line_length = PICOLCDFB_WIDTH / 8; |
|
} else { |
|
int i; |
|
memcpy(tmp_fb, o_fb, PICOLCDFB_SIZE); |
|
for (i = 0; i < PICOLCDFB_SIZE * 8; i++) |
|
o_fb[i] = tmp_fb[i/8] & (0x01 << (7 - i % 8)) ? 0xff : 0x00; |
|
info->fix.visual = FB_VISUAL_DIRECTCOLOR; |
|
info->fix.line_length = PICOLCDFB_WIDTH; |
|
} |
|
|
|
kfree(tmp_fb); |
|
fbdata->bpp = info->var.bits_per_pixel; |
|
return 0; |
|
} |
|
|
|
static const struct fb_ops picolcdfb_ops = { |
|
.owner = THIS_MODULE, |
|
.fb_destroy = picolcd_fb_destroy, |
|
.fb_read = fb_sys_read, |
|
.fb_write = picolcd_fb_write, |
|
.fb_blank = picolcd_fb_blank, |
|
.fb_fillrect = picolcd_fb_fillrect, |
|
.fb_copyarea = picolcd_fb_copyarea, |
|
.fb_imageblit = picolcd_fb_imageblit, |
|
.fb_check_var = picolcd_fb_check_var, |
|
.fb_set_par = picolcd_set_par, |
|
}; |
|
|
|
|
|
/* Callback from deferred IO workqueue */ |
|
static void picolcd_fb_deferred_io(struct fb_info *info, struct list_head *pagelist) |
|
{ |
|
picolcd_fb_update(info); |
|
} |
|
|
|
static const struct fb_deferred_io picolcd_fb_defio = { |
|
.delay = HZ / PICOLCDFB_UPDATE_RATE_DEFAULT, |
|
.deferred_io = picolcd_fb_deferred_io, |
|
}; |
|
|
|
|
|
/* |
|
* The "fb_update_rate" sysfs attribute |
|
*/ |
|
static ssize_t picolcd_fb_update_rate_show(struct device *dev, |
|
struct device_attribute *attr, char *buf) |
|
{ |
|
struct picolcd_data *data = dev_get_drvdata(dev); |
|
struct picolcd_fb_data *fbdata = data->fb_info->par; |
|
unsigned i, fb_update_rate = fbdata->update_rate; |
|
size_t ret = 0; |
|
|
|
for (i = 1; i <= PICOLCDFB_UPDATE_RATE_LIMIT; i++) |
|
if (ret >= PAGE_SIZE) |
|
break; |
|
else if (i == fb_update_rate) |
|
ret += scnprintf(buf+ret, PAGE_SIZE-ret, "[%u] ", i); |
|
else |
|
ret += scnprintf(buf+ret, PAGE_SIZE-ret, "%u ", i); |
|
if (ret > 0) |
|
buf[min(ret, (size_t)PAGE_SIZE)-1] = '\n'; |
|
return ret; |
|
} |
|
|
|
static ssize_t picolcd_fb_update_rate_store(struct device *dev, |
|
struct device_attribute *attr, const char *buf, size_t count) |
|
{ |
|
struct picolcd_data *data = dev_get_drvdata(dev); |
|
struct picolcd_fb_data *fbdata = data->fb_info->par; |
|
int i; |
|
unsigned u; |
|
|
|
if (count < 1 || count > 10) |
|
return -EINVAL; |
|
|
|
i = sscanf(buf, "%u", &u); |
|
if (i != 1) |
|
return -EINVAL; |
|
|
|
if (u > PICOLCDFB_UPDATE_RATE_LIMIT) |
|
return -ERANGE; |
|
else if (u == 0) |
|
u = PICOLCDFB_UPDATE_RATE_DEFAULT; |
|
|
|
fbdata->update_rate = u; |
|
data->fb_info->fbdefio->delay = HZ / fbdata->update_rate; |
|
return count; |
|
} |
|
|
|
static DEVICE_ATTR(fb_update_rate, 0664, picolcd_fb_update_rate_show, |
|
picolcd_fb_update_rate_store); |
|
|
|
/* initialize Framebuffer device */ |
|
int picolcd_init_framebuffer(struct picolcd_data *data) |
|
{ |
|
struct device *dev = &data->hdev->dev; |
|
struct fb_info *info = NULL; |
|
struct picolcd_fb_data *fbdata = NULL; |
|
int i, error = -ENOMEM; |
|
u32 *palette; |
|
|
|
/* The extra memory is: |
|
* - 256*u32 for pseudo_palette |
|
* - struct fb_deferred_io |
|
*/ |
|
info = framebuffer_alloc(256 * sizeof(u32) + |
|
sizeof(struct fb_deferred_io) + |
|
sizeof(struct picolcd_fb_data) + |
|
PICOLCDFB_SIZE, dev); |
|
if (!info) |
|
goto err_nomem; |
|
|
|
info->fbdefio = info->par; |
|
*info->fbdefio = picolcd_fb_defio; |
|
info->par += sizeof(struct fb_deferred_io); |
|
palette = info->par; |
|
info->par += 256 * sizeof(u32); |
|
for (i = 0; i < 256; i++) |
|
palette[i] = i > 0 && i < 16 ? 0xff : 0; |
|
info->pseudo_palette = palette; |
|
info->fbops = &picolcdfb_ops; |
|
info->var = picolcdfb_var; |
|
info->fix = picolcdfb_fix; |
|
info->fix.smem_len = PICOLCDFB_SIZE*8; |
|
info->flags = FBINFO_FLAG_DEFAULT; |
|
|
|
fbdata = info->par; |
|
spin_lock_init(&fbdata->lock); |
|
fbdata->picolcd = data; |
|
fbdata->update_rate = PICOLCDFB_UPDATE_RATE_DEFAULT; |
|
fbdata->bpp = picolcdfb_var.bits_per_pixel; |
|
fbdata->force = 1; |
|
fbdata->vbitmap = info->par + sizeof(struct picolcd_fb_data); |
|
fbdata->bitmap = vmalloc(PICOLCDFB_SIZE*8); |
|
if (fbdata->bitmap == NULL) { |
|
dev_err(dev, "can't get a free page for framebuffer\n"); |
|
goto err_nomem; |
|
} |
|
info->screen_base = (char __force __iomem *)fbdata->bitmap; |
|
info->fix.smem_start = (unsigned long)fbdata->bitmap; |
|
memset(fbdata->vbitmap, 0xff, PICOLCDFB_SIZE); |
|
data->fb_info = info; |
|
|
|
error = picolcd_fb_reset(data, 1); |
|
if (error) { |
|
dev_err(dev, "failed to configure display\n"); |
|
goto err_cleanup; |
|
} |
|
|
|
error = device_create_file(dev, &dev_attr_fb_update_rate); |
|
if (error) { |
|
dev_err(dev, "failed to create sysfs attributes\n"); |
|
goto err_cleanup; |
|
} |
|
|
|
fb_deferred_io_init(info); |
|
error = register_framebuffer(info); |
|
if (error) { |
|
dev_err(dev, "failed to register framebuffer\n"); |
|
goto err_sysfs; |
|
} |
|
return 0; |
|
|
|
err_sysfs: |
|
device_remove_file(dev, &dev_attr_fb_update_rate); |
|
fb_deferred_io_cleanup(info); |
|
err_cleanup: |
|
data->fb_info = NULL; |
|
|
|
err_nomem: |
|
if (fbdata) |
|
vfree(fbdata->bitmap); |
|
framebuffer_release(info); |
|
return error; |
|
} |
|
|
|
void picolcd_exit_framebuffer(struct picolcd_data *data) |
|
{ |
|
struct fb_info *info = data->fb_info; |
|
struct picolcd_fb_data *fbdata; |
|
unsigned long flags; |
|
|
|
if (!info) |
|
return; |
|
|
|
device_remove_file(&data->hdev->dev, &dev_attr_fb_update_rate); |
|
fbdata = info->par; |
|
|
|
/* disconnect framebuffer from HID dev */ |
|
spin_lock_irqsave(&fbdata->lock, flags); |
|
fbdata->picolcd = NULL; |
|
spin_unlock_irqrestore(&fbdata->lock, flags); |
|
|
|
/* make sure there is no running update - thus that fbdata->picolcd |
|
* once obtained under lock is guaranteed not to get free() under |
|
* the feet of the deferred work */ |
|
flush_delayed_work(&info->deferred_work); |
|
|
|
data->fb_info = NULL; |
|
unregister_framebuffer(info); |
|
}
|
|
|