github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

fbdev fixes and cleanups for 7.4-rc1:

Browse Source 
Fixes:
 - core: initialize modelist in framebuffer_alloc()
 - core: bitblit: fix glyph clipping when fbcon pans
 - fbcon: restore font geometry if font rotation fails
 - sh_mobile_lcdcfb: restore the per-overlay sysfs attributes
 - udlfb: don't rebuild the mode list while the framebuffer is in use
 - atmel_lcdfb: prevent FIFO work after removal
 
 Cleanups:
 - vt, fbcon, vgacon: cursor code rework & cleanups
 - MAINTAINERS: name the deller/linux-fbdev for-next branch
 - drop unused FB_IOMEM_HELPERS_DEFERRED Kconfig option
 - acornfb: remove unused code
 - atafb: fix sparse warnings and avoid casts
 - sstfb: use managed PCI device enable
 - gxt4500, kyro, nvidia: release write-combining handle on probe failure
 - various drivers: typo fixes in comments
 - various drivers: fix error path on fb_deferred_io_init() failure
 - various drivers: use FB blanking constants instead of VESA constants
 -----BEGIN PGP SIGNATURE-----
 
 iHUEABYKAB0WIQS86RI+GtKfB8BJu973ErUQojoPXwUCatp6agAKCRD3ErUQojoP
 XxeEAQCwaTwk3BQIuOi+UAGANLrLKTPkgEoTluPAhgfBYRoObgD/QJPzhRMFts1h
 Lxyrap4AJqTy3webD3PhYCqN8m2sYAE=
 =qS61
 -----END PGP SIGNATURE-----

Merge tag 'fbdev-for-7.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/linux-fbdev

Pull fbdev updates from Helge Deller:
 "A whole lot of small fixes all over many drivers, but the majority of
  changes are related to code cleanups regarding the cursor handling in
  vt and fbcon.

  Fixes:
   - core: initialize modelist in framebuffer_alloc()
   - core: bitblit: fix glyph clipping when fbcon pans
   - fbcon: restore font geometry if font rotation fails
   - sh_mobile_lcdcfb: restore the per-overlay sysfs attributes
   - udlfb: don't rebuild the mode list while the framebuffer is in use
   - atmel_lcdfb: prevent FIFO work after removal

  Cleanups:
   - vt, fbcon, vgacon: cursor code rework & cleanups
   - MAINTAINERS: name the deller/linux-fbdev for-next branch
   - drop unused FB_IOMEM_HELPERS_DEFERRED Kconfig option
   - acornfb: remove unused code
   - atafb: fix sparse warnings and avoid casts
   - sstfb: use managed PCI device enable
   - gxt4500, kyro, nvidia: release write-combining handle on probe failure
   - various drivers: typo fixes in comments
   - various drivers: fix error path on fb_deferred_io_init() failure
   - various drivers: use FB blanking constants instead of VESA constants"

* tag 'fbdev-for-7.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/deller/linux-fbdev: (53 commits)
  fbdev: xilinxfb: Use FB blanking constants
  fbdev: platinumfb: Use FB blanking constants
  fbdev: sa1100fb: Remove comment on VESA DPMS modes
  fbdev: i810fb: Use FB blanking constants
  fbdev: au1100fb: Use FB blanking constants
  fbcon: Retry rotated font allocation after failure
  fbcon: Rebuild rotated font buffer on font change
  fbcon: Include font geometry in the rotated font cache
  fbdev: bitblit: Fix glyph clipping when fbcon pans
  fbcon: Replace fbcon_fill_cursor_mask() with fbcon_cursor_glyph()
  lib/fonts: Add font_glyph_cursor() helper
  vgacon: Use vt_cursor_{start,end}()
  vgacon: Remove trailing whitespaces
  vt: Add cursor-size helpers
  MAINTAINERS: name the deller/linux-fbdev for-next branch
  fbdev: atafb: avoid cast when assigning buffer address pointer
  fbdev: atafb: fix sparse warnings
  fbdev: atyfb_base: fix typos in comments
  fbdev: aty128fb: fix typos in comments
  fbdev: mach64: fix typos in comments
  ...
This commit is contained in:
Linus Torvalds 2026-10-24 19:11:27 -10:00
commit 0dfc0090b9
61 changed files with 443 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
MAINTAINERS
View File

@ -10521,7 +10521,7 @@ L: linux-fbdev@vger.kernel.org
L: dri-devel@lists.freedesktop.org
S: Maintained
Q: http://patchwork.kernel.org/project/linux-fbdev/list/
T: git git://git.kernel.org/pub/scm/linux/kernel/git/deller/linux-fbdev.git
T: git git://git.kernel.org/pub/scm/linux/kernel/git/deller/linux-fbdev.git for-next
F: Documentation/fb/
F: drivers/video/
F: include/linux/fb.h

12
drivers/hid/hid-picolcd_fb.c
View File

@ -531,17 +531,23 @@ int picolcd_init_framebuffer(struct picolcd_data *data)
goto err_cleanup;
}
fb_deferred_io_init(info);
error = fb_deferred_io_init(info);
if (error) {
dev_err(dev, "failed to initialize deferred I/O\n");
goto err_sysfs;
}
error = register_framebuffer(info);
if (error) {
dev_err(dev, "failed to register framebuffer\n");
goto err_sysfs;
goto err_defio;
}
return 0;
err_defio:
fb_deferred_io_cleanup(info);
err_sysfs:
device_remove_file(dev, &dev_attr_fb_update_rate);
fb_deferred_io_cleanup(info);
err_cleanup:
data->fb_info = NULL;

114
drivers/tty/vt/vt.c
View File

@ -71,6 +71,7 @@
* by Adam Tla/lka <atlka@pg.gda.pl>, Aug 2006
*/
#include <linux/compiler.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/sched/signal.h>
@ -264,6 +265,119 @@ unsigned int vc_font_size(const struct vc_font *font)
}
EXPORT_SYMBOL_GPL(vc_font_size);
/*
* Cursors
*/
/**
* vc_cursor_valid_size - Computes a valid cursor size from the given value
* @cursor_size: The size constant of cursor pattern
*
* The argument given in @cursor_size is one of the CUR_ constants, as stored
* in struct @vc_data.vc_cursor_type. For unknown values, the helper draws the
* default cursor or an underline dash.
*
* Returns:
* A valid cursor size for the given size value
*/
unsigned int vc_cursor_valid_size(unsigned int cursor_size)
{
const unsigned int cursor_default_size = CUR_SIZE(READ_ONCE(cur_default));
do {
switch (cursor_size) {
case CUR_NONE:
case CUR_UNDERLINE:
case CUR_LOWER_THIRD:
case CUR_LOWER_HALF:
case CUR_TWO_THIRDS:
case CUR_BLOCK:
return cursor_size;
default:
pr_warn_once("Unknown cursor %u\n", cursor_size);
fallthrough;
case CUR_DEF:
/*
* Use user-given default size, or underline if
* the given default is invalid.
*/
if (cursor_size != cursor_default_size)
cursor_size = cursor_default_size;
else
cursor_size = CUR_UNDERLINE;
}
} while (true);
}
EXPORT_SYMBOL_GPL(vc_cursor_valid_size);
/**
* vc_cursor_start - Calculates the cursor's first scanline within a character cell
* @cell_height: The overall height of the character cell
* @cursor_size: The size constant of cursor pattern
*
* The parameter @cell_height is the height of the character cell as
* displayed by the console. The argument given in @cursor_size is one
* of the CUR_ constants. See vc_cursor_valid_size() for how to get a
* valid cursor-size constant.
*
* Returns:
* The index of the cursor's first scanline within the character cell
*/
unsigned int vc_cursor_start(unsigned int cell_height, unsigned int cursor_size)
{
switch (cursor_size) {
case CUR_NONE:
return cell_height;
case CUR_UNDERLINE:
default:
if (cell_height < 10)
return cell_height - 1;
else
return cell_height - 3;
case CUR_LOWER_THIRD:
return cell_height - cell_height / 3;
case CUR_LOWER_HALF:
return cell_height - cell_height / 2;
case CUR_TWO_THIRDS:
return cell_height - (cell_height * 2) / 3;
case CUR_BLOCK:
return 0;
}
}
EXPORT_SYMBOL_GPL(vc_cursor_start);
/**
* vc_cursor_end - Calculates the first scanline after the cursor within a character cell
* @cell_height: The overall height of the character cell
* @cursor_size: The size constant of cursor pattern
*
* The parameter @cell_height is the height of the character cell as
* displayed by the console. The argument given in @cursor_size is one
* of the CUR_ constants. See vc_cursor_valid_size() for how to get a
* valid cursor-size constant.
*
* Returns:
* The index of the first scanline after the cursor within the character cell
*/
unsigned int vc_cursor_end(unsigned int cell_height, unsigned int cursor_size)
{
switch (cursor_size) {
case CUR_UNDERLINE:
default:
if (cell_height < 10)
return cell_height;
else
return cell_height - 1;
case CUR_NONE:
case CUR_LOWER_THIRD:
case CUR_LOWER_HALF:
case CUR_TWO_THIRDS:
case CUR_BLOCK:
return cell_height;
}
}
EXPORT_SYMBOL_GPL(vc_cursor_end);
/*
* /sys/class/tty/tty0/
*

43
drivers/video/console/vgacon.c
View File

@ -506,6 +506,7 @@ static void vgacon_set_cursor_size(int from, int to)
static void vgacon_cursor(struct vc_data *c, bool enable)
{
unsigned int c_height;
unsigned int c_size;
if (c->vc_mode != KD_TEXT)
return;
@ -513,10 +514,11 @@ static void vgacon_cursor(struct vc_data *c, bool enable)
vgacon_restore_screen(c);
c_height = c->vc_cell_height;
c_size = vc_cursor_valid_size(CUR_SIZE(c->vc_cursor_type));
write_vga(14, (c->vc_pos - vga_vram_base) / 2);
if (!enable) {
if (!enable || c_size == CUR_NONE) {
if (vga_video_type >= VIDEO_TYPE_VGAC)
vgacon_set_cursor_size(31, 30);
else
@ -524,33 +526,8 @@ static void vgacon_cursor(struct vc_data *c, bool enable)
return;
}
switch (CUR_SIZE(c->vc_cursor_type)) {
case CUR_UNDERLINE:
vgacon_set_cursor_size(c_height - (c_height < 10 ? 2 : 3),
c_height - (c_height < 10 ? 1 : 2));
break;
case CUR_TWO_THIRDS:
vgacon_set_cursor_size(c_height / 3,
c_height - (c_height < 10 ? 1 : 2));
break;
case CUR_LOWER_THIRD:
vgacon_set_cursor_size(c_height * 2 / 3,
c_height - (c_height < 10 ? 1 : 2));
break;
case CUR_LOWER_HALF:
vgacon_set_cursor_size(c_height / 2,
c_height - (c_height < 10 ? 1 : 2));
break;
case CUR_NONE:
if (vga_video_type >= VIDEO_TYPE_VGAC)
vgacon_set_cursor_size(31, 30);
else
vgacon_set_cursor_size(31, 31);
break;
default:
vgacon_set_cursor_size(1, c_height);
break;
}
vgacon_set_cursor_size(vc_cursor_start(c_height, c_size),
vc_cursor_end(c_height, c_size) - 1);
}
static void vgacon_doresize(struct vc_data *c,
@ -881,14 +858,14 @@ static int vgacon_do_font_op(struct vgastate *state, char *arg, int set,
/* First, the Sequencer */
vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x1);
/* CPU writes only to map 2 */
vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x04);
/* Sequential addressing */
vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
vga_wseq(state->vgabase, VGA_SEQ_MEMORY_MODE, 0x07);
/* Clear synchronous reset */
vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x03);
/* Now, the graphics controller, select map 2 */
vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
vga_wgfx(state->vgabase, VGA_GFX_PLANE_READ, 0x02);
/* disable odd-even addressing */
vga_wgfx(state->vgabase, VGA_GFX_MODE, 0x00);
/* map start at A000:0000 */
@ -930,7 +907,7 @@ static int vgacon_do_font_op(struct vgastate *state, char *arg, int set,
raw_spin_lock_irq(&vga_lock);
/* First, the sequencer, Synchronous reset */
vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
vga_wseq(state->vgabase, VGA_SEQ_RESET, 0x01);
/* CPU writes to maps 0 and 1 */
vga_wseq(state->vgabase, VGA_SEQ_PLANE_WRITE, 0x03);
/* odd-even addressing */
@ -959,7 +936,7 @@ static int vgacon_do_font_op(struct vgastate *state, char *arg, int set,
/* Wilton (1987) mentions the following; I don't know what
it means, but it works, and it appears necessary */
inb_p(video_port_status);
vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
vga_wattr(state->vgabase, VGA_AR_ENABLE_DISPLAY, 0);
clear_attribs = true;
}
raw_spin_unlock_irq(&vga_lock);

57
drivers/video/fbdev/acornfb.c
View File

@ -1,7 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* linux/drivers/video/acornfb.c
*
* Copyright (C) 1998-2001 Russell King
*
* Frame buffer code for Acorn platforms
@ -94,7 +92,6 @@ static struct vidc_timing current_vidc;
extern unsigned int vram_size; /* set by setup.c */
#ifdef HAS_VIDC20
#include <mach/acornfb.h>
#define MAX_SIZE (2*1024*1024)
@ -306,7 +303,6 @@ acornfb_setcolreg(u_int regno, u_int red, u_int green, u_int blue,
return 0;
}
#endif
/*
* Before selecting the timing parameters, adjust
@ -390,7 +386,6 @@ acornfb_adjust_timing(struct fb_info *info, struct fb_var_screeninfo *var, u_int
/* hsync_len must be even */
var->hsync_len = (var->hsync_len + 1) & ~1;
#if defined(HAS_VIDC20)
/* left_margin must be even */
if (var->left_margin & 1) {
var->left_margin += 1;
@ -400,7 +395,6 @@ acornfb_adjust_timing(struct fb_info *info, struct fb_var_screeninfo *var, u_int
/* right_margin must be even */
if (var->right_margin & 1)
var->right_margin += 1;
#endif
if (var->vsync_len < 1)
var->vsync_len = 1;
@ -436,11 +430,7 @@ acornfb_update_dma(struct fb_info *info, struct fb_var_screeninfo *var)
{
u_int off = var->yoffset * info->fix.line_length;
#if defined(HAS_MEMC)
memc_write(VDMA_INIT, off >> 2);
#elif defined(HAS_IOMD)
iomd_writel(info->fix.smem_start + off, IOMD_VIDINIT);
#endif
}
static int
@ -469,7 +459,6 @@ acornfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
var->transp.length = 0;
break;
#ifdef HAS_VIDC20
case 16:
var->red.offset = 0;
var->red.length = 5;
@ -491,7 +480,6 @@ acornfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
var->transp.offset = 24;
var->transp.length = 4;
break;
#endif
default:
return -EINVAL;
}
@ -519,6 +507,9 @@ acornfb_check_var(struct fb_var_screeninfo *var, struct fb_info *info)
static int acornfb_set_par(struct fb_info *info)
{
unsigned long start, size;
u_int control;
switch (info->var.bits_per_pixel) {
case 1:
current_par.palette_size = 2;
@ -536,7 +527,6 @@ static int acornfb_set_par(struct fb_info *info)
current_par.palette_size = VIDC_PALETTE_SIZE;
info->fix.visual = FB_VISUAL_PSEUDOCOLOR;
break;
#ifdef HAS_VIDC20
case 16:
current_par.palette_size = 32;
info->fix.visual = FB_VISUAL_DIRECTCOLOR;
@ -545,41 +535,26 @@ static int acornfb_set_par(struct fb_info *info)
current_par.palette_size = VIDC_PALETTE_SIZE;
info->fix.visual = FB_VISUAL_DIRECTCOLOR;
break;
#endif
default:
BUG();
}
info->fix.line_length = (info->var.xres * info->var.bits_per_pixel) / 8;
#if defined(HAS_MEMC)
{
unsigned long size = info->fix.smem_len - VDMA_XFERSIZE;
start = info->fix.smem_start;
size = current_par.screen_end;
memc_write(VDMA_START, 0);
memc_write(VDMA_END, size >> 2);
if (current_par.using_vram) {
size -= current_par.vram_half_sam;
control = DMA_CR_E | (current_par.vram_half_sam / 256);
} else {
size -= 16;
control = DMA_CR_E | DMA_CR_D | 16;
}
#elif defined(HAS_IOMD)
{
unsigned long start, size;
u_int control;
start = info->fix.smem_start;
size = current_par.screen_end;
if (current_par.using_vram) {
size -= current_par.vram_half_sam;
control = DMA_CR_E | (current_par.vram_half_sam / 256);
} else {
size -= 16;
control = DMA_CR_E | DMA_CR_D | 16;
}
iomd_writel(start, IOMD_VIDSTART);
iomd_writel(size, IOMD_VIDEND);
iomd_writel(control, IOMD_VIDCR);
}
#endif
iomd_writel(start, IOMD_VIDSTART);
iomd_writel(size, IOMD_VIDEND);
iomd_writel(control, IOMD_VIDCR);
acornfb_update_dma(info, &info->var);
acornfb_set_timing(info);
@ -709,10 +684,8 @@ static void acornfb_init_fbinfo(void)
*/
memset(&fb_info.var, 0, sizeof(fb_info.var));
#if defined(HAS_VIDC20)
fb_info.var.red.length = 8;
fb_info.var.transp.length = 4;
#endif
fb_info.var.green = fb_info.var.red;
fb_info.var.blue = fb_info.var.red;
fb_info.var.nonstd = 0;
@ -991,7 +964,6 @@ static int acornfb_probe(struct platform_device *dev)
size = PAGE_ALIGN(size);
#if defined(HAS_VIDC20)
if (!current_par.using_vram) {
dma_addr_t handle;
void *base;
@ -1011,7 +983,6 @@ static int acornfb_probe(struct platform_device *dev)
fb_info.screen_base = base;
fb_info.fix.smem_start = handle;
}
#endif
fb_info.fix.smem_len = size;
current_par.palette_size = VIDC_PALETTE_SIZE;

9
drivers/video/fbdev/acornfb.h
View File

@ -1,16 +1,14 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* linux/drivers/video/acornfb.h
*
* Copyright (C) 1998,1999 Russell King
*
* Frame buffer code for Acorn platforms
*/
#if defined(HAS_VIDC20)
#include <asm/hardware/iomd.h>
#define VIDC_PALETTE_SIZE 256
#define VIDC_NAME "VIDC20"
#endif
#define EXTEND8(x) ((x)|(x)<<8)
#define EXTEND4(x) ((x)|(x)<<4|(x)<<8|(x)<<12)
@ -94,7 +92,6 @@ struct modex_params {
const struct modey_params *modey;
};
#ifdef HAS_VIDC20
/*
* VIDC20 registers
*/
@ -162,5 +159,3 @@ struct modex_params {
#define VIDC20_DCTL_VRAM_PXCLK (1 << 18)
#define VIDC20_DCTL_VRAM_PXCLK2 (2 << 18)
#define VIDC20_DCTL_VRAM_PXCLK4 (3 << 18)
#endif

28
drivers/video/fbdev/atafb.c
View File

@ -1089,7 +1089,7 @@ static int falcon_decode_var(struct fb_info *info, struct fb_var_screeninfo *var
/* Choose largest pixelclock <= wanted clock */
int i;
unsigned long pcl = ULONG_MAX;
pclock = 0;
pclock = NULL;
for (i = 1; i <= 4; i *= 2) {
if (f25.t * i >= var->pixclock &&
f25.t * i < pcl) {
@ -2454,7 +2454,7 @@ static void svblit_fillrect(struct fb_info *info,
((u32 *)info->pseudo_palette)[rect->color] : rect->color;
/* draw the first line with the CPU ... */
line = (u8 *)info->screen_base + rect->dy * pitch +
line = info->screen_buffer + rect->dy * pitch +
rect->dx * bytespp;
switch (bytespp) {
case 1:
@ -2818,29 +2818,6 @@ static void atafb_imageblit(struct fb_info *info, const struct fb_image *image)
}
}
static int
atafb_ioctl(struct fb_info *info, unsigned int cmd, unsigned long arg)
{
switch (cmd) {
#ifdef FBCMD_GET_CURRENTPAR
case FBCMD_GET_CURRENTPAR:
if (copy_to_user((void *)arg, &current_par,
sizeof(struct atafb_par)))
return -EFAULT;
return 0;
#endif
#ifdef FBCMD_SET_CURRENTPAR
case FBCMD_SET_CURRENTPAR:
if (copy_from_user(&current_par, (void *)arg,
sizeof(struct atafb_par)))
return -EFAULT;
ata_set_par(&current_par);
return 0;
#endif
}
return -EINVAL;
}
/* (un)blank/poweroff
* 0 = unblank
* 1 = blank
@ -2922,7 +2899,6 @@ static struct fb_ops atafb_ops = {
.fb_fillrect = atafb_fillrect,
.fb_copyarea = atafb_copyarea,
.fb_imageblit = atafb_imageblit,
.fb_ioctl = atafb_ioctl,
__FB_DEFAULT_IOMEM_OPS_MMAP,
};

11
drivers/video/fbdev/atmel_lcdfb.c
View File

@ -1146,6 +1146,9 @@ static int atmel_lcdfb_probe(struct platform_device *pdev)
/* Initialize PWM for contrast or backlight ("off") */
init_contrast(sinfo);
/* Some LCDC recovery operations require process context. */
INIT_WORK(&sinfo->task, atmel_lcdfb_task);
/* interrupt */
ret = request_irq(sinfo->irq_base, atmel_lcdfb_interrupt, 0, pdev->name, info);
if (ret) {
@ -1153,10 +1156,6 @@ static int atmel_lcdfb_probe(struct platform_device *pdev)
goto unmap_mmio;
}
/* Some operations on the LCDC might sleep and
* require a preemptible task context */
INIT_WORK(&sinfo->task, atmel_lcdfb_task);
ret = atmel_lcdfb_init_fbinfo(sinfo);
if (ret < 0) {
dev_err(dev, "init fbinfo failed: %d\n", ret);
@ -1192,8 +1191,8 @@ static int atmel_lcdfb_probe(struct platform_device *pdev)
dev_set_drvdata(dev, NULL);
fb_dealloc_cmap(&info->cmap);
unregister_irqs:
cancel_work_sync(&sinfo->task);
free_irq(sinfo->irq_base, info);
cancel_work_sync(&sinfo->task);
unmap_mmio:
exit_backlight(sinfo);
iounmap(sinfo->mmio);
@ -1230,6 +1229,7 @@ static void atmel_lcdfb_remove(struct platform_device *pdev)
return;
sinfo = info->par;
free_irq(sinfo->irq_base, info);
cancel_work_sync(&sinfo->task);
exit_backlight(sinfo);
atmel_lcdfb_power_control(sinfo, 0);
@ -1238,7 +1238,6 @@ static void atmel_lcdfb_remove(struct platform_device *pdev)
clk_put(sinfo->lcdc_clk);
clk_put(sinfo->bus_clk);
fb_dealloc_cmap(&info->cmap);
free_irq(sinfo->irq_base, info);
iounmap(sinfo->mmio);
release_mem_region(info->fix.mmio_start, info->fix.mmio_len);
if (platform_get_resource(pdev, IORESOURCE_MEM, 1)) {

2
drivers/video/fbdev/aty/aty128fb.c
View File

@ -753,7 +753,7 @@ static u32 depth_to_dst(u32 depth)
}
/*
* PLL informations retreival
* PLL information retreival
*/

4
drivers/video/fbdev/aty/atyfb_base.c
View File

@ -2966,7 +2966,7 @@ static int atyfb_setup_sparc(struct pci_dev *pdev, struct fb_info *info,
/*
* Figure mmap addresses from PCI config space.
* Split Framebuffer in big- and little-endian halfs.
* Split Framebuffer in big- and little-endian halves.
*/
for (i = 0; i < 6 && pdev->resource[i].start; i++)
/* nothing */ ;
@ -3387,7 +3387,7 @@ static int init_from_bios(struct atyfb_par *par)
PRINTKI("Mach64 BIOS is located at %x, mapped at %x.\n", rom_addr, bios_base);
/* check for frequncy table */
/* check for frequency table */
bios_ptr = (u8*)bios_base;
rom_table_offset = (u16)(bios_ptr[0x48] | (bios_ptr[0x49] << 8));
freq_table_offset = bios_ptr[rom_table_offset + 16] | (bios_ptr[rom_table_offset + 17] << 8);

2
drivers/video/fbdev/aty/mach64_cursor.c
View File

@ -43,7 +43,7 @@
*
*
* The Screen position of the top left corner of the displayed
* cursor is specificed by CURS_HORZ_VERT_POSN. Care must be taken
* cursor is specified by CURS_HORZ_VERT_POSN. Care must be taken
* when the cursor hot spot is not the top left corner and the
* physical cursor position becomes negative. It will be displayed
* if either the horizontal or vertical cursor position is negative

4
drivers/video/fbdev/aty/radeon_base.c
View File

@ -779,7 +779,7 @@ static void radeon_get_pllinfo(struct radeonfb_info *rinfo)
#endif /* CONFIG_PPC || CONFIG_SPARC */
/*
* Check out if we have an X86 which gave us some PLL informations
* Check out if we have an X86 which gave us some PLL information
* and if yes, retrieve them
*/
if (!force_measure_pll && rinfo->bios_seg) {
@ -2407,7 +2407,7 @@ static int radeonfb_pci_register(struct pci_dev *pdev,
if (rinfo->bios_seg == NULL && rinfo->is_mobility)
radeon_map_ROM(rinfo, pdev);
/* Get informations about the board's PLL */
/* Get information about the board's PLL */
radeon_get_pllinfo(rinfo);
#ifdef CONFIG_FB_RADEON_I2C

4
drivers/video/fbdev/aty/radeon_monitor.c
View File

@ -58,7 +58,7 @@ static char *radeon_get_mon_name(int type)
#if defined(CONFIG_PPC) || defined(CONFIG_SPARC)
/*
* Try to find monitor informations & EDID data out of the Open Firmware
* Try to find monitor information & EDID data out of the Open Firmware
* device-tree. This also contains some "hacks" to work around a few machine
* models with broken OF probing by hard-coding known EDIDs for some Mac
* laptops internal LVDS panel. (XXX: not done yet)
@ -248,7 +248,7 @@ static int radeon_get_panel_info_BIOS(struct radeonfb_info *rinfo)
return 0;
}
/* Try to extract the connector informations from the BIOS. This
/* Try to extract the connector information from the BIOS. This
* doesn't quite work yet, but it's output is still useful for
* debugging
*/

2
drivers/video/fbdev/aty/radeonfb.h
View File

@ -148,7 +148,7 @@ struct pll_info {
* This structure contains the various registers manipulated by this
* driver for setting or restoring a mode. It's mostly copied from
* XFree's RADEONSaveRec structure. A few chip settings might still be
* tweaked without beeing reflected or saved in these registers though
* tweaked without being reflected or saved in these registers though
*/
struct radeon_regs {
/* Common registers */

20
drivers/video/fbdev/au1100fb.c
View File

@ -424,15 +424,15 @@ static int au1100fb_fb_blank(int blank_mode, struct fb_info *fbi)
switch (blank_mode) {
case VESA_NO_BLANKING:
case FB_BLANK_UNBLANK:
/* Turn on panel */
fbdev->regs->lcd_control |= LCD_CONTROL_GO;
wmb(); /* drain writebuffer */
break;
case VESA_VSYNC_SUSPEND:
case VESA_HSYNC_SUSPEND:
case VESA_POWERDOWN:
case FB_BLANK_NORMAL:
case FB_BLANK_VSYNC_SUSPEND:
case FB_BLANK_HSYNC_SUSPEND:
case FB_BLANK_POWERDOWN:
/* Turn off panel */
fbdev->regs->lcd_control &= ~LCD_CONTROL_GO;
wmb(); /* drain writebuffer */
@ -528,7 +528,7 @@ static int au1100fb_setmode(struct au1100fb_device *fbdev)
if (!info->var.rotate || (info->var.rotate == 180)) {
words *= info->var.yres_virtual;
if (info->var.rotate /* 180 */) {
words -= (words % 8); /* should be divisable by 8 */
words -= (words % 8); /* should be divisible by 8 */
}
}
fbdev->regs->lcd_words = LCD_WRD_WRDS_N(words);
@ -539,7 +539,7 @@ static int au1100fb_setmode(struct au1100fb_device *fbdev)
/* Resume controller */
fbdev->regs->lcd_control |= LCD_CONTROL_GO;
mdelay(10);
au1100fb_fb_blank(VESA_NO_BLANKING, info);
au1100fb_fb_blank(FB_BLANK_UNBLANK, info);
return 0;
}
@ -856,7 +856,7 @@ static void au1100fb_drv_remove(struct platform_device *dev)
fbdev = platform_get_drvdata(dev);
#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
au1100fb_fb_blank(VESA_POWERDOWN, &fbdev->info);
au1100fb_fb_blank(FB_BLANK_POWERDOWN, &fbdev->info);
#endif
fbdev->regs->lcd_control &= ~LCD_CONTROL_GO;
@ -880,7 +880,7 @@ static int au1100fb_drv_suspend(struct platform_device *dev, pm_message_t state)
return 0;
/* Blank the LCD */
au1100fb_fb_blank(VESA_POWERDOWN, &fbdev->info);
au1100fb_fb_blank(FB_BLANK_POWERDOWN, &fbdev->info);
clk_disable(fbdev->lcdclk);
@ -904,7 +904,7 @@ static int au1100fb_drv_resume(struct platform_device *dev)
return ret;
/* Unblank the LCD */
au1100fb_fb_blank(VESA_NO_BLANKING, &fbdev->info);
au1100fb_fb_blank(FB_BLANK_UNBLANK, &fbdev->info);
return 0;
}

6
drivers/video/fbdev/core/Kconfig
View File

@ -155,12 +155,6 @@ config FB_IOMEM_HELPERS
select FB_CFB_IMAGEBLIT
select FB_IOMEM_FOPS
config FB_IOMEM_HELPERS_DEFERRED
bool
depends on FB_CORE
select FB_DEFERRED_IO
select FB_IOMEM_HELPERS
config FB_SYSMEM_HELPERS
bool
depends on FB_CORE

10
drivers/video/fbdev/core/bitblit.c
View File

@ -18,6 +18,7 @@
#include <linux/console.h>
#include <asm/types.h>
#include "fbcon.h"
#include "fbcon_rotate.h"
/*
* Accelerated handlers.
@ -150,7 +151,9 @@ static void bit_putcs(struct vc_data *vc, struct fb_info *info,
const unsigned short *s, int count, int yy, int xx,
int fg, int bg)
{
struct fbcon_par *par = info->fbcon_par;
struct fb_image image;
u32 vyres = GETVYRES(par->p, info);
u32 width = DIV_ROUND_UP(vc->vc_font.width, 8);
u32 cellsize = width * vc->vc_font.height;
u32 maxcnt = info->pixmap.size/cellsize;
@ -167,10 +170,10 @@ static void bit_putcs(struct vc_data *vc, struct fb_info *info,
image.height = vc->vc_font.height;
image.depth = 1;
if (image.dy >= info->var.yres)
if (image.dy >= vyres)
return;
image.height = min(image.height, info->var.yres - image.dy);
image.height = min(image.height, vyres - image.dy);
if (attribute) {
buf = kmalloc(cellsize, GFP_ATOMIC);
@ -334,11 +337,10 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, bool enable,
vc->vc_cursor_type != par->p->cursor_shape ||
par->cursor_state.mask == NULL ||
par->cursor_reset) {
unsigned char *mask = kmalloc_array(vc->vc_font.height, w, GFP_ATOMIC);
unsigned char *mask = fbcon_cursor_glyph(&vc->vc_font, vc->vc_cursor_type);
if (!mask)
return;
fbcon_fill_cursor_mask(par, vc, mask);
kfree(par->cursor_state.mask);
par->cursor_state.mask = (const char *)mask;

1
drivers/video/fbdev/core/fb_info.c
View File

@ -43,6 +43,7 @@ struct fb_info *framebuffer_alloc(size_t size, struct device *dev)
info->device = dev;
info->fbcon_rotate_hint = -1;
info->blank = FB_BLANK_UNBLANK;
INIT_LIST_HEAD(&info->modelist);
#if IS_ENABLED(CONFIG_FB_BACKLIGHT)
mutex_init(&info->bl_curve_mutex);

91
drivers/video/fbdev/core/fbcon.c
View File

@ -444,44 +444,21 @@ static void fbcon_del_cursor_work(struct fb_info *info)
cancel_delayed_work_sync(&par->cursor_work);
}
void fbcon_fill_cursor_mask(struct fbcon_par *par, struct vc_data *vc, unsigned char *mask)
unsigned char *fbcon_cursor_glyph(const struct vc_font *font, unsigned int cursor_type)
{
static const unsigned int pattern = 0xffffffff;
unsigned int pitch = vc_font_pitch(&vc->vc_font);
unsigned int cur_height, size;
unsigned int height = font->height;
unsigned int cursor_size = vc_cursor_valid_size(CUR_SIZE(cursor_type));
unsigned char *glyph;
switch (CUR_SIZE(vc->vc_cursor_type)) {
case CUR_NONE:
cur_height = 0;
break;
case CUR_UNDERLINE:
if (vc->vc_font.height < 10)
cur_height = 1;
else
cur_height = 2;
break;
case CUR_LOWER_THIRD:
cur_height = vc->vc_font.height / 3;
break;
case CUR_LOWER_HALF:
cur_height = vc->vc_font.height / 2;
break;
case CUR_TWO_THIRDS:
cur_height = (vc->vc_font.height * 2) / 3;
break;
case CUR_BLOCK:
default:
cur_height = vc->vc_font.height;
break;
}
glyph = kmalloc_array(height, vc_font_pitch(font), GFP_ATOMIC);
if (!glyph)
return NULL;
size = (vc->vc_font.height - cur_height) * pitch;
while (size--)
*mask++ = (unsigned char)~pattern;
font_glyph_cursor(font->width, height,
vc_cursor_start(height, cursor_size),
vc_cursor_end(height, cursor_size), glyph);
size = cur_height * pitch;
while (size--)
*mask++ = (unsigned char)pattern;
return glyph;
}
#ifndef MODULE
@ -2413,6 +2390,10 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h, int charcount,
font_data_t *old_fontdata = p->fontdata;
const u8 *old_data = vc->vc_font.data;
unsigned short old_hi_font_mask = vc->vc_hi_font_mask;
#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
struct fbcon_rotated saved_rotated = { };
bool rotated_saved = false;
#endif
font_data_get(data);
@ -2431,6 +2412,27 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h, int charcount,
else if (!vc->vc_hi_font_mask && charcount == 512)
set_vc_hi_font(vc, true);
/*
* Select the console's blitting state and update par->rotated to
* match the new font, so that the rendering below does not use a
* cache that was built for the old font. Clear the cached state so
* the rebuild allocates a fresh buffer; the old state is kept until
* the font change can no longer fail.
*/
if (con_is_visible(vc)) {
set_blitting_type(vc, info);
if (par->bitops->rotate_font) {
#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
saved_rotated = par->rotated;
memset(&par->rotated, 0, sizeof(par->rotated));
rotated_saved = true;
#endif
ret = par->bitops->rotate_font(info, vc);
if (ret)
goto err_out;
}
}
if (resize) {
int cols, rows;
@ -2447,12 +2449,26 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h, int charcount,
update_screen(vc);
}
#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
if (rotated_saved)
kfree(saved_rotated.buf);
#endif
if (old_fontdata)
font_data_put(old_fontdata);
return 0;
err_out:
#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
/*
* Drop the buffer built for the new font and restore the saved
* state.
*/
if (rotated_saved) {
kfree(par->rotated.buf);
par->rotated = saved_rotated;
}
#endif
p->fontdata = old_fontdata;
vc->vc_font.data = old_data;
vc->vc_font.width = old_width;
@ -2465,6 +2481,13 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h, int charcount,
else if (!old_hi_font_mask && vc->vc_hi_font_mask)
set_vc_hi_font(vc, false);
/*
* Re-select the blitting type, which re-uploads the font map on
* tile-blitting hardware.
*/
if (con_is_visible(vc))
set_blitting_type(vc, info);
font_data_put(data);
return ret;

21
drivers/video/fbdev/core/fbcon.h
View File

@ -72,6 +72,18 @@ struct fbcon_bitops {
int (*rotate_font)(struct fb_info *info, struct vc_data *vc);
};
#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
struct fbcon_rotated {
font_data_t *fontdata; /* source font */
u8 *buf; /* rotated glyphs */
size_t bufsize;
int buf_rotate; /* rotation of buf */
unsigned int buf_width; /* geometry of source font */
unsigned int buf_height;
unsigned int buf_charcount;
};
#endif
struct fbcon_par {
struct fb_var_screeninfo var; /* copy of the current fb_var_screeninfo */
struct delayed_work cursor_work; /* Cursor timer */
@ -88,12 +100,7 @@ struct fbcon_par {
int rotate;
char *cursor_data;
#ifdef CONFIG_FRAMEBUFFER_CONSOLE_ROTATION
struct {
font_data_t *fontdata; /* source font */
u8 *buf; /* rotated glyphs */
size_t bufsize;
int buf_rotate; /* rotation of buf */
} rotated;
struct fbcon_rotated rotated;
#endif
u8 *cursor_src;
u32 cursor_size;
@ -202,7 +209,7 @@ extern void fbcon_set_tileops(struct vc_data *vc, struct fb_info *info);
extern void fbcon_set_bitops_ur(struct fbcon_par *par);
extern int soft_cursor(struct fb_info *info, struct fb_cursor *cursor);
void fbcon_fill_cursor_mask(struct fbcon_par *par, struct vc_data *vc, unsigned char *mask);
unsigned char *fbcon_cursor_glyph(const struct vc_font *font, unsigned int cursor_type);
#define FBCON_ATTRIBUTE_UNDERLINE 1
#define FBCON_ATTRIBUTE_REVERSE 2

3
drivers/video/fbdev/core/fbcon_ccw.c
View File

@ -298,10 +298,9 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, bool enable,
par->cursor_reset) {
unsigned char *tmp, *mask;
tmp = kmalloc_array(vc->vc_font.height, vc_font_pitch(&vc->vc_font), GFP_ATOMIC);
tmp = fbcon_cursor_glyph(&vc->vc_font, vc->vc_cursor_type);
if (!tmp)
return;
fbcon_fill_cursor_mask(par, vc, tmp);
mask = kmalloc_array(vc->vc_font.width, w, GFP_ATOMIC);
if (!mask) {

3
drivers/video/fbdev/core/fbcon_cw.c
View File

@ -281,10 +281,9 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, bool enable,
par->cursor_reset) {
unsigned char *tmp, *mask;
tmp = kmalloc_array(vc->vc_font.height, vc_font_pitch(&vc->vc_font), GFP_ATOMIC);
tmp = fbcon_cursor_glyph(&vc->vc_font, vc->vc_cursor_type);
if (!tmp)
return;
fbcon_fill_cursor_mask(par, vc, tmp);
mask = kmalloc_array(vc->vc_font.width, w, GFP_ATOMIC);
if (!mask) {

10
drivers/video/fbdev/core/fbcon_rotate.c
View File

@ -21,11 +21,19 @@ int fbcon_rotate_font(struct fb_info *info, struct vc_data *vc)
unsigned char *buf;
int ret;
if (par->p->fontdata == par->rotated.fontdata && par->rotate == par->rotated.buf_rotate)
if (par->p->fontdata == par->rotated.fontdata &&
par->rotate == par->rotated.buf_rotate &&
vc->vc_font.width == par->rotated.buf_width &&
vc->vc_font.height == par->rotated.buf_height &&
vc->vc_font.charcount == par->rotated.buf_charcount &&
par->rotated.buf)
return 0;
par->rotated.fontdata = par->p->fontdata;
par->rotated.buf_rotate = par->rotate;
par->rotated.buf_width = vc->vc_font.width;
par->rotated.buf_height = vc->vc_font.height;
par->rotated.buf_charcount = vc->vc_font.charcount;
if (info->fbops->fb_sync)
info->fbops->fb_sync(info);

3
drivers/video/fbdev/core/fbcon_ud.c
View File

@ -328,10 +328,9 @@ static void ud_cursor(struct vc_data *vc, struct fb_info *info, bool enable,
par->cursor_reset) {
unsigned char *tmp, *mask;
tmp = kmalloc_array(vc->vc_font.height, w, GFP_ATOMIC);
tmp = fbcon_cursor_glyph(&vc->vc_font, vc->vc_cursor_type);
if (!tmp)
return;
fbcon_fill_cursor_mask(par, vc, tmp);
mask = kmalloc_array(vc->vc_font.height, w, GFP_ATOMIC);
if (!mask) {

4
drivers/video/fbdev/efifb.c
View File

@ -97,7 +97,7 @@ static int efifb_setcolreg(unsigned regno, unsigned red, unsigned green,
}
/*
* If fbcon deffered console takeover is configured, the intent is for the
* If fbcon deferred console takeover is configured, the intent is for the
* framebuffer to show the boot graphics (e.g. vendor logo) until there is some
* (error) message to display. But the boot graphics may have been destroyed by
* e.g. option ROM output, detect this and restore the boot graphics.
@ -421,7 +421,7 @@ static int efifb_probe(struct platform_device *dev)
size_vmode = efifb_defined.yres * efifb_fix.line_length;
/* size_total -- all video memory we have. Used for
* entries, ressource allocation and bounds
* entries, resource allocation and bounds
* checking. */
size_total = si->lfb_size;
if (size_total < size_vmode)

2
drivers/video/fbdev/grvga.c
View File

@ -432,7 +432,7 @@ static int grvga_probe(struct platform_device *dev)
retval = -ENOMEM;
goto dealloc_cmap;
}
} else { /* Allocate frambuffer memory */
} else { /* Allocate framebuffer memory */
unsigned long page;

1
drivers/video/fbdev/gxt4500.c
View File

@ -719,6 +719,7 @@ static int gxt4500_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
err_free_cmap:
fb_dealloc_cmap(&info->cmap);
err_unmap_all:
arch_phys_wc_del(par->wc_cookie);
iounmap(info->screen_base);
err_unmap_regs:
iounmap(par->regs);

2
drivers/video/fbdev/i810/i810_main.c
View File

@ -1623,7 +1623,7 @@ static int i810fb_resume(struct pci_dev *dev)
par->cursor_heap.offset);
i810fb_set_par(info);
fb_set_suspend (info, 0);
info->fbops->fb_blank(VESA_NO_BLANKING, info);
info->fbops->fb_blank(FB_BLANK_UNBLANK, info);
fail:
console_unlock();
return 0;

2
drivers/video/fbdev/kyro/STG4000OverlayDevice.c
View File

@ -60,7 +60,7 @@ typedef struct _OVRL_SRC_DEST {
u32 ulDstX2;
u32 ulDstY2;
/*clipped pixel pos of source data within buffer thses need to be 128 bit word aligned */
/* clipped pixel pos of source data within buffer these need to be 128 bit word aligned */
u32 ulSrcX1;
u32 ulSrcY1;
u32 ulSrcX2;

4
drivers/video/fbdev/kyro/fbdev.c
View File

@ -765,7 +765,7 @@ static int kyrofb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
fb_memset_io(info->screen_base, 0, size);
if (register_framebuffer(info) < 0)
goto out_free_fb;
goto out_free_wc;
fb_info(info, "%s frame buffer device, at %dx%d@%d using %ldk/%ldk of VRAM\n",
info->fix.id,
@ -776,6 +776,8 @@ static int kyrofb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
return 0;
out_free_wc:
arch_phys_wc_del(currentpar->wc_cookie);
out_free_fb:
framebuffer_release(info);

2
drivers/video/fbdev/maxinefb.c
View File

@ -98,7 +98,7 @@ static int maxinefb_setcolreg(unsigned regno, unsigned red, unsigned green,
return 1;
red >>= 8; /* The cmap fields are 16 bits */
green >>= 8; /* wide, but the harware colormap */
green >>= 8; /* wide, but the hardware colormap */
blue >>= 8; /* registers are only 8 bits wide */
hw_colorvalue = (blue << 16) + (green << 8) + (red);

2
drivers/video/fbdev/mmp/core.c
View File

@ -65,7 +65,7 @@ static DEFINE_MUTEX(disp_lock);
* @p: panel to be registered
*
* this function provides interface for panel drivers to register panel
* to panel_list and connect to path which matchs panel->plat_path_name.
* to panel_list and connect to path which matches panel->plat_path_name.
* no error returns when no matching path is found as path register after
* panel register is permitted.
*/

4
drivers/video/fbdev/mmp/hw/mmp_ctrl.c
View File

@ -325,7 +325,7 @@ static void ctrl_set_default(struct mmphw_ctrl *ctrl)
u32 tmp, irq_mask;
/*
* LCD Global control(LCD_TOP_CTRL) should be configed before
* LCD Global control(LCD_TOP_CTRL) should be configured before
* any other LCD registers read/write, or there maybe issues.
*/
tmp = readl_relaxed(ctrl->reg_base + LCD_TOP_CTRL);
@ -521,7 +521,7 @@ static int mmphw_probe(struct platform_device *pdev)
/* init global regs */
ctrl_set_default(ctrl);
/* init pathes from machine info and register them */
/* init paths from machine info and register them */
for (i = 0; i < ctrl->path_num; i++) {
/* get from config and machine info */
path_plat = &ctrl->path_plats[i];

4
drivers/video/fbdev/mmp/hw/mmp_ctrl.h
View File

@ -1404,7 +1404,7 @@ struct mmphw_ctrl {
int status;
struct mutex access_ok;
/*pathes*/
/* paths */
int path_num;
struct mmphw_path_plat path_plats[] __counted_by(path_num);
};
@ -1434,7 +1434,7 @@ static inline void __iomem *ctrl_regs(struct mmp_path *path)
return path_to_ctrl(path)->reg_base;
}
/* path regs, for regs symmetrical for both pathes */
/* path regs, for regs symmetrical for both paths */
static inline struct lcd_regs *path_regs(struct mmp_path *path)
{
if (path->id == PATH_PN)

2
drivers/video/fbdev/mmp/hw/mmp_spi.c
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
/*
* linux/drivers/video/mmp/hw/mmp_spi.c
* using the spi in LCD controler for commands send
* using the spi in LCD controller for commands send
*
* Copyright (C) 2012 Marvell Technology Group Ltd.
* Authors: Guoqing Li <ligq@marvell.com>

1
drivers/video/fbdev/nvidia/nvidia.c
View File

@ -1423,6 +1423,7 @@ static int nvidiafb_probe(struct pci_dev *pd, const struct pci_device_id *ent)
return 0;
err_out_iounmap_fb:
arch_phys_wc_del(par->wc_cookie);
fb_destroy_modelist(&info->modelist);
err_out_free_base1:
fb_destroy_modedb(info->monspecs.modedb);

2
drivers/video/fbdev/ocfb.c
View File

@ -115,7 +115,7 @@ static int ocfb_setupfb(struct ocfb_dev *fbdev)
fbdev->little_endian = 0;
ocfb_writereg(fbdev, OCFB_VBARA, fbdev->fb_phys);
/* Detect endianess */
/* Detect endianness */
if (ocfb_readreg(fbdev, OCFB_VBARA) != fbdev->fb_phys) {
fbdev->little_endian = 1;
ocfb_writereg(fbdev, OCFB_VBARA, fbdev->fb_phys);

4
drivers/video/fbdev/omap2/omapfb/dss/dispc.c
View File

@ -2119,7 +2119,7 @@ static int check_horiz_timing_omap3(unsigned long pclk, unsigned long lclk,
/*
* Pixel data should be prepared before visible display point starts.
* So, atleast DS-2 lines must have already been fetched by DISPC
* So, at least DS-2 lines must have already been fetched by DISPC
* during nonactive - pos_x period.
*/
val = div_u64((u64)(nonactive - pos_x) * lclk, pclk);
@ -2130,7 +2130,7 @@ static int check_horiz_timing_omap3(unsigned long pclk, unsigned long lclk,
/*
* All lines need to be refilled during the nonactive period of which
* only one line can be loaded during the active period. So, atleast
* only one line can be loaded during the active period. So, at least
* DS - 1 lines should be loaded during nonactive period.
*/
val = div_u64((u64)nonactive * lclk, pclk);

8
drivers/video/fbdev/platinumfb.c
View File

@ -167,10 +167,12 @@ static int platinumfb_blank(int blank, struct fb_info *fb)
ctrl = le32_to_cpup(&info->platinum_regs->ctrl.r) | 0x33;
if (blank)
--blank_mode;
if (blank & VESA_VSYNC_SUSPEND)
ctrl &= ~3;
if (blank & VESA_HSYNC_SUSPEND)
if (blank == FB_BLANK_VSYNC_SUSPEND)
ctrl &= ~0x03;
else if (blank == FB_BLANK_HSYNC_SUSPEND)
ctrl &= ~0x30;
else if (blank == FB_BLANK_POWERDOWN)
ctrl &= ~0x33;
out_le32(&info->platinum_regs->ctrl.r, ctrl);
*/
/* TODO: Figure out how the heck to powerdown this thing! */

2
drivers/video/fbdev/pm2fb.c
View File

@ -428,7 +428,7 @@ static void set_aperture(struct pm2fb_par *p, u32 depth)
}
#endif
/* We don't use aperture two, so this may be superflous */
/* We don't use aperture two, so this may be superfluous */
pm2_WR(p, PM2R_APERTURE_TWO, PM2F_APERTURE_STANDARD);
}

6
drivers/video/fbdev/s1d13xxxfb.c
View File

@ -400,7 +400,7 @@ s1d13xxxfb_pan_display(struct fb_var_screeninfo *var, struct fb_info *info)
/**
* bltbit_wait_bitclear - waits for change in register value
* @info : frambuffer structure
* @info : framebuffer structure
* @bit : value currently in register
* @timeout : ...
*
@ -426,7 +426,7 @@ bltbit_wait_bitclear(struct fb_info *info, u8 bit, int timeout)
* @info : framebuffer structure
* @area : fb_copyarea structure
*
* supports (atleast) S1D13506
* supports (at least) S1D13506
*
*/
static void
@ -516,7 +516,7 @@ s1d13xxxfb_bitblt_copyarea(struct fb_info *info, const struct fb_copyarea *area)
* @info : framebuffer structure
* @rect : fb_fillrect structure
*
* supports (atleast 13506)
* supports (at least 13506)
*
**/
static void

29
drivers/video/fbdev/sa1100fb.c
View File

@ -491,35 +491,6 @@ sa1100fb_set_cmap(struct fb_cmap *cmap, int kspc, int con,
}
#endif
/*
* Formal definition of the VESA spec:
* On
* This refers to the state of the display when it is in full operation
* Stand-By
* This defines an optional operating state of minimal power reduction with
* the shortest recovery time
* Suspend
* This refers to a level of power management in which substantial power
* reduction is achieved by the display. The display can have a longer
* recovery time from this state than from the Stand-by state
* Off
* This indicates that the display is consuming the lowest level of power
* and is non-operational. Recovery from this state may optionally require
* the user to manually power on the monitor
*
* Now, the fbdev driver adds an additional state, (blank), where they
* turn off the video (maybe by colormap tricks), but don't mess with the
* video itself: think of it semantically between on and Stand-By.
*
* So here's what we should do in our fbdev blank routine:
*
* VESA_NO_BLANKING (mode 0) Video on, front/back light on
* VESA_VSYNC_SUSPEND (mode 1) Video on, front/back light off
* VESA_HSYNC_SUSPEND (mode 2) Video on, front/back light off
* VESA_POWERDOWN (mode 3) Video off, front/back light off
*
* This will match the matrox implementation.
*/
/*
* sa1100fb_blank():
* Blank the display by setting all palette values to zero. Note, the

43
drivers/video/fbdev/sh_mobile_lcdcfb.c
View File

@ -1042,7 +1042,11 @@ static int sh_mobile_lcdc_start(struct sh_mobile_lcdc_priv *priv)
ch->defio.deferred_io = sh_mobile_lcdc_deferred_io;
ch->defio.delay = msecs_to_jiffies(tmp);
ch->info->fbdefio = &ch->defio;
fb_deferred_io_init(ch->info);
ret = fb_deferred_io_init(ch->info);
if (ret) {
ch->info->fbdefio = NULL;
return ret;
}
}
sh_mobile_lcdc_display_on(ch);
@ -1337,22 +1341,24 @@ overlay_rop3_store(struct device *dev, struct device_attribute *attr,
return count;
}
static DEVICE_ATTR_RW(overlay_alpha);
static DEVICE_ATTR_RW(overlay_mode);
static DEVICE_ATTR_RW(overlay_position);
static DEVICE_ATTR_RW(overlay_rop3);
static struct device_attribute dev_attr_ovl_alpha =
__ATTR(ovl_alpha, 0644, overlay_alpha_show, overlay_alpha_store);
static struct device_attribute dev_attr_ovl_mode =
__ATTR(ovl_mode, 0644, overlay_mode_show, overlay_mode_store);
static struct device_attribute dev_attr_ovl_position =
__ATTR(ovl_position, 0644, overlay_position_show, overlay_position_store);
static struct device_attribute dev_attr_ovl_rop3 =
__ATTR(ovl_rop3, 0644, overlay_rop3_show, overlay_rop3_store);
static struct attribute *overlay_sysfs_attrs[] __maybe_unused = {
&dev_attr_overlay_alpha.attr,
&dev_attr_overlay_mode.attr,
&dev_attr_overlay_position.attr,
&dev_attr_overlay_rop3.attr,
static struct attribute *overlay_sysfs_attrs[] = {
&dev_attr_ovl_alpha.attr,
&dev_attr_ovl_mode.attr,
&dev_attr_ovl_position.attr,
&dev_attr_ovl_rop3.attr,
NULL,
};
#ifdef CONFIG_FB_DEVICE
ATTRIBUTE_GROUPS(overlay_sysfs);
#endif
static const struct fb_fix_screeninfo sh_mobile_lcdc_overlay_fix = {
.id = "SH Mobile LCDC",
@ -1510,9 +1516,10 @@ sh_mobile_lcdc_overlay_fb_unregister(struct sh_mobile_lcdc_overlay *ovl)
{
struct fb_info *info = ovl->info;
if (info == NULL || info->dev == NULL)
if (!info || !dev_of_fbinfo(info))
return;
device_remove_groups(dev_of_fbinfo(info), overlay_sysfs_groups);
unregister_framebuffer(ovl->info);
}
@ -1530,6 +1537,15 @@ sh_mobile_lcdc_overlay_fb_register(struct sh_mobile_lcdc_overlay *ovl)
if (ret < 0)
return ret;
/* The framebuffer device is optional, see fb_device_create(). */
if (dev_of_fbinfo(info)) {
ret = device_add_groups(dev_of_fbinfo(info), overlay_sysfs_groups);
if (ret < 0) {
unregister_framebuffer(info);
return ret;
}
}
dev_info(lcdc->dev, "registered %s/overlay %u as %dx%d %dbpp.\n",
dev_name(lcdc->dev), ovl->index, info->var.xres,
info->var.yres, info->var.bits_per_pixel);
@ -2637,7 +2653,6 @@ static int sh_mobile_lcdc_probe(struct platform_device *pdev)
static struct platform_driver sh_mobile_lcdc_driver = {
.driver = {
.name = "sh_mobile_lcdc_fb",
.dev_groups = overlay_sysfs_groups,
.pm = &sh_mobile_lcdc_dev_pm_ops,
},
.probe = sh_mobile_lcdc_probe,

6
drivers/video/fbdev/skeletonfb.c
View File

@ -478,7 +478,7 @@ static int xxxfb_blank(int blank_mode, struct fb_info *info)
/**
* xxxfb_fillrect - REQUIRED function. Can use generic routines if
* non acclerated hardware and packed pixel based.
* non accelerated hardware and packed pixel based.
* Draws a rectangle on the screen.
*
* @info: frame buffer structure that represents a single frame buffer
@ -505,7 +505,7 @@ void xxxfb_fillrect(struct fb_info *p, const struct fb_fillrect *region)
/**
* xxxfb_copyarea - REQUIRED function. Can use generic routines if
* non acclerated hardware and packed pixel based.
* non accelerated hardware and packed pixel based.
* Copies one area of the screen to another area.
*
* @info: frame buffer structure that represents a single frame buffer
@ -530,7 +530,7 @@ void xxxfb_copyarea(struct fb_info *p, const struct fb_copyarea *area)
/**
* xxxfb_imageblit - REQUIRED function. Can use generic routines if
* non acclerated hardware and packed pixel based.
* non accelerated hardware and packed pixel based.
* Copies a image from system memory to the screen.
*
* @info: frame buffer structure that represents a single frame buffer

9
drivers/video/fbdev/smscufx.c
View File

@ -1041,10 +1041,13 @@ static int ufx_ops_open(struct fb_info *info, int user)
if (fbdefio) {
fbdefio->delay = UFX_DEFIO_WRITE_DELAY;
fbdefio->deferred_io = ufx_dpy_deferred_io;
}
info->fbdefio = fbdefio;
fb_deferred_io_init(info);
info->fbdefio = fbdefio;
if (fb_deferred_io_init(info)) {
kfree(fbdefio);
info->fbdefio = NULL;
}
}
}
pr_debug("open /dev/fb%d user=%d fb_info=%p count=%d",

6
drivers/video/fbdev/ssd1307fb.c
View File

@ -767,7 +767,11 @@ static int ssd1307fb_probe(struct i2c_client *client)
info->fix.smem_start = __pa(vmem);
info->fix.smem_len = vmem_size;
fb_deferred_io_init(info);
ret = fb_deferred_io_init(info);
if (ret) {
dev_err(dev, "failed to init fb deferred io: %d\n", ret);
goto fb_defio_error;
}
i2c_set_clientdata(client, info);

5
drivers/video/fbdev/sstfb.c
View File

@ -15,7 +15,7 @@
* 09/2002 Helge Deller <deller@gmx.de>
* (enable driver on big-endian machines (hppa), ioctl fixes)
* 12/2002 Helge Deller <deller@gmx.de>
* (port driver to new frambuffer infrastructure)
* (port driver to new framebuffer infrastructure)
* 01/2003 Helge Deller <deller@gmx.de>
* (initial work on fb hardware acceleration for voodoo2)
* 08/2006 Alan Cox <alan@redhat.com>
@ -1332,7 +1332,8 @@ static int sstfb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
return err;
/* Enable device in PCI config. */
if ((err=pci_enable_device(pdev))) {
err = pcim_enable_device(pdev);
if (err) {
printk(KERN_ERR "cannot enable device\n");
return err;
}

6
drivers/video/fbdev/tgafb.c
View File

@ -884,7 +884,7 @@ tgafb_clut_imageblit(struct fb_info *info, const struct fb_image *image)
/**
* tgafb_imageblit - REQUIRED function. Can use generic routines if
* non acclerated hardware and packed pixel based.
* non accelerated hardware and packed pixel based.
* Copies a image from system memory to the screen.
*
* @info: frame buffer structure that represents a single frame buffer
@ -921,7 +921,7 @@ tgafb_imageblit(struct fb_info *info, const struct fb_image *image)
/**
* tgafb_fillrect - REQUIRED function. Can use generic routines if
* non acclerated hardware and packed pixel based.
* non accelerated hardware and packed pixel based.
* Draws a rectangle on the screen.
*
* @info: frame buffer structure that represents a single frame buffer
@ -1047,7 +1047,7 @@ tgafb_fillrect(struct fb_info *info, const struct fb_fillrect *rect)
/*
* tgafb_copyarea - REQUIRED function. Can use generic routines if
* non acclerated hardware and packed pixel based.
* non accelerated hardware and packed pixel based.
* Copies on area of the screen to another area.
*
* @info: frame buffer structure that represents a single frame buffer

2
drivers/video/fbdev/tridentfb.c
View File

@ -58,7 +58,7 @@ static struct fb_fix_screeninfo tridentfb_fix = {
.accel = FB_ACCEL_NONE,
};
/* defaults which are normally overriden by user values */
/* defaults which are normally overridden by user values */
/* video mode */
static char *mode_option;

14
drivers/video/fbdev/udlfb.c
View File

@ -947,10 +947,13 @@ static int dlfb_ops_open(struct fb_info *info, int user)
fbdefio->delay = DL_DEFIO_WRITE_DELAY;
fbdefio->sort_pagereflist = true;
fbdefio->deferred_io = dlfb_dpy_deferred_io;
}
info->fbdefio = fbdefio;
fb_deferred_io_init(info);
info->fbdefio = fbdefio;
if (fb_deferred_io_init(info)) {
kfree(fbdefio);
info->fbdefio = NULL;
}
}
}
dev_dbg(info->dev, "open, user=%d fb_info=%p count=%d\n",
@ -1293,6 +1296,11 @@ static int dlfb_setup_modes(struct dlfb_data *dlfb,
goto error;
}
if (dlfb->fb_count) {
result = -EINVAL;
goto error;
}
fb_destroy_modelist(&info->modelist);
memset(&info->monspecs, 0, sizeof(info->monspecs));

6
drivers/video/fbdev/via/dvi.c
View File

@ -399,7 +399,7 @@ void viafb_dvi_enable(void)
tmds_register_write(0x88, 0x3b);
else
/*clear CR91[5] to direct on display period
in the secondary diplay path */
in the secondary display path */
via_write_reg_mask(VIACR, 0x91, 0x00, 0x20);
break;
@ -407,12 +407,12 @@ void viafb_dvi_enable(void)
if (viaparinfo->chip_info->gfx_chip_name == UNICHROME_CLE266)
viafb_write_reg_mask(CR93, VIACR, 0x21, BIT0 + BIT5);
/*fix dvi cann't be enabled with MB VT5718C4 - Al Zhang */
/* fix dvi can't be enabled with MB VT5718C4 - Al Zhang */
if (viaparinfo->chip_info->gfx_chip_name == UNICHROME_CLE266)
tmds_register_write(0x88, 0x3b);
else
/*clear CR91[5] to direct on display period
in the secondary diplay path */
in the secondary display path */
via_write_reg_mask(VIACR, 0x91, 0x00, 0x20);
/*fix DVI cannot enable on EPIA-M board */

2
drivers/video/fbdev/via/hw.c
View File

@ -1542,7 +1542,7 @@ static void init_gfx_chip_info(int chip_type)
else
viaparinfo->chip_info->gfx_chip_revision =
CLE266_REVISION_CX;
/* restore orignal CR4F value */
/* restore original CR4F value */
viafb_write_reg(CR4F, VIACR, tmp);
}

4
drivers/video/fbdev/via/viafbdev.c
View File

@ -190,7 +190,7 @@ static int viafb_check_var(struct fb_var_screeninfo *var,
DEBUG_MSG(KERN_INFO "viafb_check_var!\n");
/* Sanity check */
/* HW neither support interlacte nor double-scaned mode */
/* HW neither support interlacte nor double-scanned mode */
if (var->vmode & FB_VMODE_INTERLACED || var->vmode & FB_VMODE_DOUBLE)
return -EINVAL;
@ -765,7 +765,7 @@ static int viafb_cursor(struct fb_info *info, struct fb_cursor *cursor)
if (info->flags & FBINFO_HWACCEL_DISABLED || info != viafbinfo)
return -ENODEV;
/* LCD ouput does not support hw cursors (at least on VN896) */
/* LCD output does not support hw cursors (at least on VN896) */
if ((chip_name == UNICHROME_CLE266 && viapar->iga_path == IGA2) ||
viafb_LCD_ON)
return -ENODEV;

7
drivers/video/fbdev/xen-fbfront.c
View File

@ -443,7 +443,11 @@ static int xenfb_probe(struct xenbus_device *dev,
}
fb_info->fbdefio = &xenfb_defio;
fb_deferred_io_init(fb_info);
ret = fb_deferred_io_init(fb_info);
if (ret < 0) {
xenbus_dev_fatal(dev, ret, "fb_deferred_io_init");
goto error_cmap;
}
xenfb_init_shared_page(info, fb_info);
@ -465,6 +469,7 @@ static int xenfb_probe(struct xenbus_device *dev,
error_fb:
fb_deferred_io_cleanup(fb_info);
error_cmap:
fb_dealloc_cmap(&fb_info->cmap);
framebuffer_release(fb_info);
error_nomem:

2
drivers/video/fbdev/xilinxfb.c
View File

@ -376,7 +376,7 @@ static void xilinxfb_release(struct device *dev)
struct xilinxfb_drvdata *drvdata = dev_get_drvdata(dev);
#if !defined(CONFIG_FRAMEBUFFER_CONSOLE) && defined(CONFIG_LOGO)
xilinx_fb_blank(VESA_POWERDOWN, &drvdata->info);
xilinx_fb_blank(FB_BLANK_POWERDOWN, &drvdata->info);
#endif
unregister_framebuffer(&drvdata->info);

2
drivers/video/sticore.c
View File

@ -389,7 +389,7 @@ static int sti_font_setup(char *str)
* - sti_font=<number> (<number> = 1,2,3,...)
* most STI ROMs have built-in HP specific fonts, which can be selected
* by giving the desired number to the sticon driver.
* NOTE: This number is machine and STI ROM dependend.
* NOTE: This number is machine and STI ROM dependent.
* - sti_font=<height>x<width> (e.g. sti_font=16x8)
* <height> and <width> gives hints to the height and width of the
* font which the user wants. The sticon driver will try to use

8
include/linux/console_struct.h
View File

@ -204,6 +204,10 @@ struct vc {
extern struct vc vc_cons [MAX_NR_CONSOLES];
extern void vc_SAK(struct work_struct *work);
/*
* Cursors
*/
#define CUR_MAKE(size, change, set) ((size) | ((change) << 8) | \
((set) << 16))
#define CUR_SIZE(c) ((c) & 0x00000f)
@ -222,6 +226,10 @@ extern void vc_SAK(struct work_struct *work);
#define CUR_CHANGE(c) ((c) & 0x00ff00)
#define CUR_SET(c) (((c) & 0xff0000) >> 8)
unsigned int vc_cursor_valid_size(unsigned int cursor_size);
unsigned int vc_cursor_start(unsigned int cell_height, unsigned int cursor_size);
unsigned int vc_cursor_end(unsigned int cell_height, unsigned int cursor_size);
bool con_is_visible(const struct vc_data *vc);
#endif /* _LINUX_CONSOLE_STRUCT_H */

4
include/linux/font.h
View File

@ -109,6 +109,10 @@ const unsigned char *font_data_glyph_buf(font_data_t *fd,
bool font_data_is_equal(font_data_t *lhs, font_data_t *rhs);
int font_data_export(font_data_t *fd, struct console_font *font, unsigned int vpitch);
/* font_cursor.c */
void font_glyph_cursor(unsigned int width, unsigned int height,
unsigned int from, unsigned int to, unsigned char *out);
/* font_rotate.c */
void font_glyph_rotate_90(const unsigned char *glyph, unsigned int width, unsigned int height,
unsigned char *out);

6
include/video/mmp_disp.h
View File

@ -172,7 +172,7 @@ struct mmp_panel {
/* use node to register to list */
struct list_head node;
const char *name;
/* path name used to connect to proper path configed */
/* path name used to connect to proper path configured */
const char *plat_path_name;
struct device *dev;
int panel_type;
@ -291,7 +291,7 @@ static inline int mmp_overlay_set_addr(struct mmp_overlay *overlay,
* it defined a common interface that plat driver need to implement
*/
struct mmp_path_info {
/* driver data, set when registed*/
/* driver data, set when registered */
const char *name;
struct device *dev;
int id;
@ -309,7 +309,7 @@ extern void mmp_unregister_path(struct mmp_path *path);
extern void mmp_register_panel(struct mmp_panel *panel);
extern void mmp_unregister_panel(struct mmp_panel *panel);
/* defintions for platform data */
/* definitions for platform data */
/* interface for buffer driver */
struct mmp_buffer_driver_mach_info {
const char *name;

3
lib/fonts/Makefile
View File

@ -1,7 +1,8 @@
# SPDX-License-Identifier: GPL-2.0
# Font handling
font-y := fonts.o
font-y := fonts.o \
font_cursor.o
font-$(CONFIG_FRAMEBUFFER_CONSOLE_ROTATION) += font_rotate.o
# Built-in fonts; sorted by Family-Size in ascending order

56
lib/fonts/font_cursor.c Normal file
View File

@ -0,0 +1,56 @@
// SPDX-License-Identifier: GPL-2.0-only
#include <linux/bug.h>
#include <linux/export.h>
#include <linux/string.h>
#include "font.h"
/**
* font_glyph_cursor - Create a cursor glyph
* @width: The glyph width in bits per scanline
* @height: The number of scanlines in the glyph
* @start: The first scanline of the cursor block
* @end: The first scanline after the cursor block
* @out: The cursor-glyph bitmap
*
* The parameters @width and @height refer to the glyph size. The caller
* has to provide the output buffer @out of sufficient size to hold the
* cursor glyph. The arguments in @start and @end describe the number of
* scanlines occupied by the cursor block; counting from the top of the
* glyph. The helper fills these scanlines with a pattern and clears the
* remaining scanlines.
*/
void font_glyph_cursor(unsigned int width, unsigned int height,
unsigned int start, unsigned int end, unsigned char *out)
{
unsigned int pitch = font_glyph_pitch(width);
const unsigned char *out_end = out + height * pitch;
unsigned int size;
if (WARN_ON_ONCE(start > height))
start = height;
if (WARN_ON_ONCE(end > height))
end = height;
if (end < start)
end = start;
/* clear scanlines before cursor block */
size = start * pitch;
memset(out, 0x00, size);
out += size;
/* set cursor block */
size = (end - start) * pitch;
memset(out, 0xff, size);
out += size;
/* clear scanlines below cursor block */
size = (height - end) * pitch;
memset(out, 0x00, size);
out += size;
WARN_ON_ONCE(out != out_end);
}
EXPORT_SYMBOL_GPL(font_glyph_cursor);