mirror of
https://github.com/u-boot/u-boot.git
synced 2024-11-24 04:34:22 +08:00
video: Drop common LCD implementation
This code is no-longer used. Drop it. Signed-off-by: Simon Glass <sjg@chromium.org>
This commit is contained in:
Simon Glass
Anatolij Gustschin
parent
70cc7b614f
commit
b0c5353c7c
@ -1466,8 +1466,6 @@ M: Anatolij Gustschin <agust@denx.de>
|
||||
S: Maintained
|
||||
T: git https://source.denx.de/u-boot/custodians/u-boot-video.git
|
||||
F: drivers/video/
|
||||
F: common/lcd*.c
|
||||
F: include/lcd*.h
|
||||
F: include/video*.h
|
||||
|
||||
VirtIO
|
||||
|
||||
@ -35,9 +35,6 @@ obj-$(CONFIG_I2C_EDID) += edid.o
|
||||
obj-$(CONFIG_KALLSYMS) += kallsyms.o
|
||||
obj-y += splash.o
|
||||
obj-$(CONFIG_SPLASH_SOURCE) += splash_source.o
|
||||
ifndef CONFIG_DM_VIDEO
|
||||
obj-$(CONFIG_LCD) += lcd.o lcd_console.o
|
||||
endif
|
||||
obj-$(CONFIG_MENU) += menu.o
|
||||
obj-$(CONFIG_UPDATE_COMMON) += update.o
|
||||
obj-$(CONFIG_USB_KEYBOARD) += usb_kbd.o
|
||||
|
||||
495
common/lcd.c
495
common/lcd.c
@ -1,495 +0,0 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* Common LCD routines
|
||||
*
|
||||
* (C) Copyright 2001-2002
|
||||
* Wolfgang Denk, DENX Software Engineering -- wd@denx.de
|
||||
*/
|
||||
|
||||
/* #define DEBUG */
|
||||
#include <config.h>
|
||||
#include <common.h>
|
||||
#include <command.h>
|
||||
#include <cpu_func.h>
|
||||
#include <env_callback.h>
|
||||
#include <log.h>
|
||||
#include <asm/cache.h>
|
||||
#include <init.h>
|
||||
#include <asm/global_data.h>
|
||||
#include <linux/types.h>
|
||||
#include <stdio_dev.h>
|
||||
#include <lcd.h>
|
||||
#include <mapmem.h>
|
||||
#include <watchdog.h>
|
||||
#include <asm/unaligned.h>
|
||||
#include <splash.h>
|
||||
#include <asm/io.h>
|
||||
#include <asm/unaligned.h>
|
||||
#include <video_font.h>
|
||||
|
||||
#if (LCD_BPP != LCD_COLOR8) && (LCD_BPP != LCD_COLOR16) && \
|
||||
(LCD_BPP != LCD_COLOR32)
|
||||
#error Unsupported LCD BPP.
|
||||
#endif
|
||||
|
||||
DECLARE_GLOBAL_DATA_PTR;
|
||||
|
||||
static int lcd_init(void *lcdbase);
|
||||
static void lcd_logo(void);
|
||||
static void lcd_setfgcolor(int color);
|
||||
static void lcd_setbgcolor(int color);
|
||||
|
||||
static int lcd_color_fg;
|
||||
static int lcd_color_bg;
|
||||
int lcd_line_length;
|
||||
char lcd_is_enabled = 0;
|
||||
static void *lcd_base; /* Start of framebuffer memory */
|
||||
static char lcd_flush_dcache; /* 1 to flush dcache after each lcd update */
|
||||
|
||||
/* Flush LCD activity to the caches */
|
||||
void lcd_sync(void)
|
||||
{
|
||||
/*
|
||||
* flush_dcache_range() is declared in common.h but it seems that some
|
||||
* architectures do not actually implement it. Is there a way to find
|
||||
* out whether it exists? For now, ARM is safe.
|
||||
*/
|
||||
#if defined(CONFIG_ARM) && !CONFIG_IS_ENABLED(SYS_DCACHE_OFF)
|
||||
int line_length;
|
||||
|
||||
if (lcd_flush_dcache)
|
||||
flush_dcache_range((ulong)lcd_base,
|
||||
(ulong)(lcd_base + lcd_get_size(&line_length)));
|
||||
#endif
|
||||
}
|
||||
|
||||
void lcd_set_flush_dcache(int flush)
|
||||
{
|
||||
lcd_flush_dcache = (flush != 0);
|
||||
}
|
||||
|
||||
static void lcd_stub_putc(struct stdio_dev *dev, const char c)
|
||||
{
|
||||
lcd_putc(c);
|
||||
}
|
||||
|
||||
static void lcd_stub_puts(struct stdio_dev *dev, const char *s)
|
||||
{
|
||||
lcd_puts(s);
|
||||
}
|
||||
|
||||
/*
|
||||
* With most lcd drivers the line length is set up
|
||||
* by calculating it from panel_info parameters. Some
|
||||
* drivers need to calculate the line length differently,
|
||||
* so make the function weak to allow overriding it.
|
||||
*/
|
||||
__weak int lcd_get_size(int *line_length)
|
||||
{
|
||||
*line_length = (panel_info.vl_col * NBITS(panel_info.vl_bpix)) / 8;
|
||||
return *line_length * panel_info.vl_row;
|
||||
}
|
||||
|
||||
int drv_lcd_init(void)
|
||||
{
|
||||
struct stdio_dev lcddev;
|
||||
int rc;
|
||||
|
||||
lcd_base = map_sysmem(gd->fb_base, 0);
|
||||
|
||||
lcd_init(lcd_base);
|
||||
|
||||
/* Device initialization */
|
||||
memset(&lcddev, 0, sizeof(lcddev));
|
||||
|
||||
strcpy(lcddev.name, "lcd");
|
||||
lcddev.ext = 0; /* No extensions */
|
||||
lcddev.flags = DEV_FLAGS_OUTPUT; /* Output only */
|
||||
lcddev.putc = lcd_stub_putc; /* 'putc' function */
|
||||
lcddev.puts = lcd_stub_puts; /* 'puts' function */
|
||||
|
||||
rc = stdio_register(&lcddev);
|
||||
|
||||
return (rc == 0) ? 1 : rc;
|
||||
}
|
||||
|
||||
void lcd_clear(void)
|
||||
{
|
||||
int bg_color;
|
||||
__maybe_unused ulong addr;
|
||||
static int do_splash = 1;
|
||||
#if LCD_BPP == LCD_COLOR8
|
||||
/* Setting the palette */
|
||||
lcd_setcolreg(CONSOLE_COLOR_BLACK, 0, 0, 0);
|
||||
lcd_setcolreg(CONSOLE_COLOR_RED, 0xFF, 0, 0);
|
||||
lcd_setcolreg(CONSOLE_COLOR_GREEN, 0, 0xFF, 0);
|
||||
lcd_setcolreg(CONSOLE_COLOR_YELLOW, 0xFF, 0xFF, 0);
|
||||
lcd_setcolreg(CONSOLE_COLOR_BLUE, 0, 0, 0xFF);
|
||||
lcd_setcolreg(CONSOLE_COLOR_MAGENTA, 0xFF, 0, 0xFF);
|
||||
lcd_setcolreg(CONSOLE_COLOR_CYAN, 0, 0xFF, 0xFF);
|
||||
lcd_setcolreg(CONSOLE_COLOR_GREY, 0xAA, 0xAA, 0xAA);
|
||||
lcd_setcolreg(CONSOLE_COLOR_WHITE, 0xFF, 0xFF, 0xFF);
|
||||
#endif
|
||||
|
||||
#ifndef CONFIG_SYS_WHITE_ON_BLACK
|
||||
lcd_setfgcolor(CONSOLE_COLOR_BLACK);
|
||||
lcd_setbgcolor(CONSOLE_COLOR_WHITE);
|
||||
bg_color = CONSOLE_COLOR_WHITE;
|
||||
#else
|
||||
lcd_setfgcolor(CONSOLE_COLOR_WHITE);
|
||||
lcd_setbgcolor(CONSOLE_COLOR_BLACK);
|
||||
bg_color = CONSOLE_COLOR_BLACK;
|
||||
#endif /* CONFIG_SYS_WHITE_ON_BLACK */
|
||||
|
||||
/* set framebuffer to background color */
|
||||
#if (LCD_BPP != LCD_COLOR32)
|
||||
memset((char *)lcd_base, bg_color, lcd_line_length * panel_info.vl_row);
|
||||
#else
|
||||
u32 *ppix = lcd_base;
|
||||
u32 i;
|
||||
for (i = 0;
|
||||
i < (lcd_line_length * panel_info.vl_row)/NBYTES(panel_info.vl_bpix);
|
||||
i++) {
|
||||
*ppix++ = bg_color;
|
||||
}
|
||||
#endif
|
||||
/* setup text-console */
|
||||
debug("[LCD] setting up console...\n");
|
||||
lcd_init_console(lcd_base,
|
||||
panel_info.vl_col,
|
||||
panel_info.vl_row,
|
||||
panel_info.vl_rot);
|
||||
/* Paint the logo and retrieve LCD base address */
|
||||
debug("[LCD] Drawing the logo...\n");
|
||||
if (do_splash) {
|
||||
if (splash_display() == 0) {
|
||||
do_splash = 0;
|
||||
lcd_sync();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
lcd_logo();
|
||||
lcd_sync();
|
||||
}
|
||||
|
||||
static int lcd_init(void *lcdbase)
|
||||
{
|
||||
debug("[LCD] Initializing LCD frambuffer at %p\n", lcdbase);
|
||||
lcd_ctrl_init(lcdbase);
|
||||
|
||||
/*
|
||||
* lcd_ctrl_init() of some drivers (i.e. bcm2835 on rpi) ignores
|
||||
* the 'lcdbase' argument and uses custom lcd base address
|
||||
* by setting up gd->fb_base. Check for this condition and fixup
|
||||
* 'lcd_base' address.
|
||||
*/
|
||||
if (map_to_sysmem(lcdbase) != gd->fb_base)
|
||||
lcd_base = map_sysmem(gd->fb_base, 0);
|
||||
|
||||
debug("[LCD] Using LCD frambuffer at %p\n", lcd_base);
|
||||
|
||||
lcd_get_size(&lcd_line_length);
|
||||
lcd_is_enabled = 1;
|
||||
lcd_clear();
|
||||
lcd_enable();
|
||||
|
||||
/* Initialize the console */
|
||||
lcd_set_col(0);
|
||||
lcd_set_row(1); /* leave 1 blank line below logo */
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* This is called early in the system initialization to grab memory
|
||||
* for the LCD controller.
|
||||
* Returns new address for monitor, after reserving LCD buffer memory
|
||||
*
|
||||
* Note that this is running from ROM, so no write access to global data.
|
||||
*/
|
||||
ulong lcd_setmem(ulong addr)
|
||||
{
|
||||
ulong size;
|
||||
int line_length;
|
||||
|
||||
debug("LCD panel info: %d x %d, %d bit/pix\n", panel_info.vl_col,
|
||||
panel_info.vl_row, NBITS(panel_info.vl_bpix));
|
||||
|
||||
size = lcd_get_size(&line_length);
|
||||
|
||||
/* Allocate pages for the frame buffer. */
|
||||
addr -= size;
|
||||
|
||||
debug("Reserving %ldk for LCD Framebuffer at: %08lx\n",
|
||||
size >> 10, addr);
|
||||
|
||||
return addr;
|
||||
}
|
||||
|
||||
static void lcd_setfgcolor(int color)
|
||||
{
|
||||
lcd_color_fg = color;
|
||||
}
|
||||
|
||||
int lcd_getfgcolor(void)
|
||||
{
|
||||
return lcd_color_fg;
|
||||
}
|
||||
|
||||
static void lcd_setbgcolor(int color)
|
||||
{
|
||||
lcd_color_bg = color;
|
||||
}
|
||||
|
||||
int lcd_getbgcolor(void)
|
||||
{
|
||||
return lcd_color_bg;
|
||||
}
|
||||
|
||||
static inline void lcd_logo_plot(int x, int y) {}
|
||||
|
||||
#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
|
||||
#ifdef CONFIG_SPLASH_SCREEN_ALIGN
|
||||
|
||||
static void splash_align_axis(int *axis, unsigned long panel_size,
|
||||
unsigned long picture_size)
|
||||
{
|
||||
unsigned long panel_picture_delta = panel_size - picture_size;
|
||||
unsigned long axis_alignment;
|
||||
|
||||
if (*axis == BMP_ALIGN_CENTER)
|
||||
axis_alignment = panel_picture_delta / 2;
|
||||
else if (*axis < 0)
|
||||
axis_alignment = panel_picture_delta + *axis + 1;
|
||||
else
|
||||
return;
|
||||
|
||||
*axis = max(0, (int)axis_alignment);
|
||||
}
|
||||
#endif
|
||||
|
||||
__weak void fb_put_byte(uchar **fb, uchar **from)
|
||||
{
|
||||
*(*fb)++ = *(*from)++;
|
||||
}
|
||||
|
||||
#if defined(CONFIG_BMP_16BPP)
|
||||
__weak void fb_put_word(uchar **fb, uchar **from)
|
||||
{
|
||||
*(*fb)++ = *(*from)++;
|
||||
*(*fb)++ = *(*from)++;
|
||||
}
|
||||
#endif /* CONFIG_BMP_16BPP */
|
||||
|
||||
__weak void lcd_set_cmap(struct bmp_image *bmp, unsigned colors)
|
||||
{
|
||||
int i;
|
||||
struct bmp_color_table_entry cte;
|
||||
ushort *cmap = configuration_get_cmap();
|
||||
|
||||
for (i = 0; i < colors; ++i) {
|
||||
cte = bmp->color_table[i];
|
||||
*cmap = (((cte.red) << 8) & 0xf800) |
|
||||
(((cte.green) << 3) & 0x07e0) |
|
||||
(((cte.blue) >> 3) & 0x001f);
|
||||
cmap++;
|
||||
}
|
||||
}
|
||||
|
||||
int lcd_display_bitmap(ulong bmp_image, int x, int y)
|
||||
{
|
||||
ushort *cmap_base = NULL;
|
||||
ushort i, j;
|
||||
uchar *fb;
|
||||
struct bmp_image *bmp = (struct bmp_image *)map_sysmem(bmp_image, 0);
|
||||
uchar *bmap;
|
||||
ushort padded_width;
|
||||
unsigned long width, height, byte_width;
|
||||
unsigned long pwidth = panel_info.vl_col;
|
||||
unsigned colors, bpix, bmp_bpix;
|
||||
int hdr_size;
|
||||
struct bmp_color_table_entry *palette;
|
||||
|
||||
if (!bmp || !(bmp->header.signature[0] == 'B' &&
|
||||
bmp->header.signature[1] == 'M')) {
|
||||
printf("Error: no valid bmp image at %lx\n", bmp_image);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
palette = bmp->color_table;
|
||||
width = get_unaligned_le32(&bmp->header.width);
|
||||
height = get_unaligned_le32(&bmp->header.height);
|
||||
bmp_bpix = get_unaligned_le16(&bmp->header.bit_count);
|
||||
hdr_size = get_unaligned_le16(&bmp->header.size);
|
||||
debug("hdr_size=%d, bmp_bpix=%d\n", hdr_size, bmp_bpix);
|
||||
|
||||
colors = 1 << bmp_bpix;
|
||||
|
||||
bpix = NBITS(panel_info.vl_bpix);
|
||||
|
||||
if (bpix != 1 && bpix != 8 && bpix != 16 && bpix != 32) {
|
||||
printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
|
||||
bpix, bmp_bpix);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* We support displaying 8bpp BMPs on 16bpp LCDs
|
||||
* and displaying 24bpp BMPs on 32bpp LCDs
|
||||
* */
|
||||
if (bpix != bmp_bpix &&
|
||||
!(bmp_bpix == 8 && bpix == 16) &&
|
||||
!(bmp_bpix == 24 && bpix == 32)) {
|
||||
printf ("Error: %d bit/pixel mode, but BMP has %d bit/pixel\n",
|
||||
bpix, get_unaligned_le16(&bmp->header.bit_count));
|
||||
return 1;
|
||||
}
|
||||
|
||||
debug("Display-bmp: %d x %d with %d colors, display %d\n",
|
||||
(int)width, (int)height, (int)colors, 1 << bpix);
|
||||
|
||||
if (bmp_bpix == 8)
|
||||
lcd_set_cmap(bmp, colors);
|
||||
|
||||
padded_width = (width & 0x3 ? (width & ~0x3) + 4 : width);
|
||||
|
||||
#ifdef CONFIG_SPLASH_SCREEN_ALIGN
|
||||
splash_align_axis(&x, pwidth, width);
|
||||
splash_align_axis(&y, panel_info.vl_row, height);
|
||||
#endif /* CONFIG_SPLASH_SCREEN_ALIGN */
|
||||
|
||||
if ((x + width) > pwidth)
|
||||
width = pwidth - x;
|
||||
if ((y + height) > panel_info.vl_row)
|
||||
height = panel_info.vl_row - y;
|
||||
|
||||
bmap = (uchar *)bmp + get_unaligned_le32(&bmp->header.data_offset);
|
||||
fb = (uchar *)(lcd_base +
|
||||
(y + height - 1) * lcd_line_length + x * bpix / 8);
|
||||
|
||||
switch (bmp_bpix) {
|
||||
case 1:
|
||||
case 8: {
|
||||
cmap_base = configuration_get_cmap();
|
||||
|
||||
if (bpix != 16)
|
||||
byte_width = width;
|
||||
else
|
||||
byte_width = width * 2;
|
||||
|
||||
for (i = 0; i < height; ++i) {
|
||||
schedule();
|
||||
for (j = 0; j < width; j++) {
|
||||
if (bpix != 16) {
|
||||
fb_put_byte(&fb, &bmap);
|
||||
} else {
|
||||
struct bmp_color_table_entry *entry;
|
||||
uint val;
|
||||
|
||||
if (cmap_base) {
|
||||
val = cmap_base[*bmap];
|
||||
} else {
|
||||
entry = &palette[*bmap];
|
||||
val = entry->blue >> 3 |
|
||||
entry->green >> 2 << 5 |
|
||||
entry->red >> 3 << 11;
|
||||
}
|
||||
*(uint16_t *)fb = val;
|
||||
bmap++;
|
||||
fb += sizeof(uint16_t) / sizeof(*fb);
|
||||
}
|
||||
}
|
||||
bmap += (padded_width - width);
|
||||
fb -= byte_width + lcd_line_length;
|
||||
}
|
||||
break;
|
||||
}
|
||||
#if defined(CONFIG_BMP_16BPP)
|
||||
case 16:
|
||||
for (i = 0; i < height; ++i) {
|
||||
schedule();
|
||||
for (j = 0; j < width; j++)
|
||||
fb_put_word(&fb, &bmap);
|
||||
|
||||
bmap += (padded_width - width) * 2;
|
||||
fb -= width * 2 + lcd_line_length;
|
||||
}
|
||||
break;
|
||||
#endif /* CONFIG_BMP_16BPP */
|
||||
#if defined(CONFIG_BMP_24BPP)
|
||||
case 24:
|
||||
for (i = 0; i < height; ++i) {
|
||||
for (j = 0; j < width; j++) {
|
||||
*(fb++) = *(bmap++);
|
||||
*(fb++) = *(bmap++);
|
||||
*(fb++) = *(bmap++);
|
||||
*(fb++) = 0;
|
||||
}
|
||||
fb -= lcd_line_length + width * (bpix / 8);
|
||||
}
|
||||
break;
|
||||
#endif /* CONFIG_BMP_24BPP */
|
||||
#if defined(CONFIG_BMP_32BPP)
|
||||
case 32:
|
||||
for (i = 0; i < height; ++i) {
|
||||
for (j = 0; j < width; j++) {
|
||||
*(fb++) = *(bmap++);
|
||||
*(fb++) = *(bmap++);
|
||||
*(fb++) = *(bmap++);
|
||||
*(fb++) = *(bmap++);
|
||||
}
|
||||
fb -= lcd_line_length + width * (bpix / 8);
|
||||
}
|
||||
break;
|
||||
#endif /* CONFIG_BMP_32BPP */
|
||||
default:
|
||||
break;
|
||||
};
|
||||
|
||||
lcd_sync();
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
static void lcd_logo(void)
|
||||
{
|
||||
lcd_logo_plot(0, 0);
|
||||
|
||||
}
|
||||
|
||||
#ifdef CONFIG_SPLASHIMAGE_GUARD
|
||||
static int on_splashimage(const char *name, const char *value, enum env_op op,
|
||||
int flags)
|
||||
{
|
||||
ulong addr;
|
||||
int aligned;
|
||||
|
||||
if (op == env_op_delete)
|
||||
return 0;
|
||||
|
||||
addr = hextoul(value, NULL);
|
||||
/* See README.displaying-bmps */
|
||||
aligned = (addr % 4 == 2);
|
||||
if (!aligned) {
|
||||
printf("Invalid splashimage value. Value must be 16 bit aligned, but not 32 bit aligned\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
U_BOOT_ENV_CALLBACK(splashimage, on_splashimage);
|
||||
#endif
|
||||
|
||||
int lcd_get_pixel_width(void)
|
||||
{
|
||||
return panel_info.vl_col;
|
||||
}
|
||||
|
||||
int lcd_get_pixel_height(void)
|
||||
{
|
||||
return panel_info.vl_row;
|
||||
}
|
||||
@ -1,252 +0,0 @@
|
||||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* (C) Copyright 2001-2015
|
||||
* DENX Software Engineering -- wd@denx.de
|
||||
* Compulab Ltd - http://compulab.co.il/
|
||||
* Bernecker & Rainer Industrieelektronik GmbH - http://www.br-automation.com
|
||||
*/
|
||||
|
||||
#include <common.h>
|
||||
#include <command.h>
|
||||
#include <lcd.h>
|
||||
#include <log.h>
|
||||
#include <serial.h>
|
||||
#include <video_font.h> /* Get font data, width and height */
|
||||
|
||||
static struct console_t cons;
|
||||
|
||||
void lcd_set_col(short col)
|
||||
{
|
||||
cons.curr_col = col;
|
||||
}
|
||||
|
||||
void lcd_set_row(short row)
|
||||
{
|
||||
cons.curr_row = row;
|
||||
}
|
||||
|
||||
void lcd_position_cursor(unsigned col, unsigned row)
|
||||
{
|
||||
cons.curr_col = min_t(short, col, cons.cols - 1);
|
||||
cons.curr_row = min_t(short, row, cons.rows - 1);
|
||||
}
|
||||
|
||||
int lcd_get_screen_rows(void)
|
||||
{
|
||||
return cons.rows;
|
||||
}
|
||||
|
||||
int lcd_get_screen_columns(void)
|
||||
{
|
||||
return cons.cols;
|
||||
}
|
||||
|
||||
static void lcd_putc_xy0(struct console_t *pcons, ushort x, ushort y, char c)
|
||||
{
|
||||
int fg_color = lcd_getfgcolor();
|
||||
int bg_color = lcd_getbgcolor();
|
||||
int i, row;
|
||||
fbptr_t *dst = (fbptr_t *)pcons->fbbase +
|
||||
y * pcons->lcdsizex +
|
||||
x;
|
||||
|
||||
for (row = 0; row < VIDEO_FONT_HEIGHT; row++) {
|
||||
uchar bits = video_fontdata[c * VIDEO_FONT_HEIGHT + row];
|
||||
for (i = 0; i < VIDEO_FONT_WIDTH; ++i) {
|
||||
*dst++ = (bits & 0x80) ? fg_color : bg_color;
|
||||
bits <<= 1;
|
||||
}
|
||||
dst += (pcons->lcdsizex - VIDEO_FONT_WIDTH);
|
||||
}
|
||||
}
|
||||
|
||||
static inline void console_setrow0(struct console_t *pcons, u32 row, int clr)
|
||||
{
|
||||
int i;
|
||||
fbptr_t *dst = (fbptr_t *)pcons->fbbase +
|
||||
row * VIDEO_FONT_HEIGHT *
|
||||
pcons->lcdsizex;
|
||||
|
||||
for (i = 0; i < (VIDEO_FONT_HEIGHT * pcons->lcdsizex); i++)
|
||||
*dst++ = clr;
|
||||
}
|
||||
|
||||
static inline void console_moverow0(struct console_t *pcons,
|
||||
u32 rowdst, u32 rowsrc)
|
||||
{
|
||||
int i;
|
||||
fbptr_t *dst = (fbptr_t *)pcons->fbbase +
|
||||
rowdst * VIDEO_FONT_HEIGHT *
|
||||
pcons->lcdsizex;
|
||||
|
||||
fbptr_t *src = (fbptr_t *)pcons->fbbase +
|
||||
rowsrc * VIDEO_FONT_HEIGHT *
|
||||
pcons->lcdsizex;
|
||||
|
||||
for (i = 0; i < (VIDEO_FONT_HEIGHT * pcons->lcdsizex); i++)
|
||||
*dst++ = *src++;
|
||||
}
|
||||
|
||||
static inline void console_back(void)
|
||||
{
|
||||
if (--cons.curr_col < 0) {
|
||||
cons.curr_col = cons.cols - 1;
|
||||
if (--cons.curr_row < 0)
|
||||
cons.curr_row = 0;
|
||||
}
|
||||
|
||||
cons.fp_putc_xy(&cons,
|
||||
cons.curr_col * VIDEO_FONT_WIDTH,
|
||||
cons.curr_row * VIDEO_FONT_HEIGHT, ' ');
|
||||
}
|
||||
|
||||
static inline void console_newline(void)
|
||||
{
|
||||
const int rows = CONFIG_CONSOLE_SCROLL_LINES;
|
||||
int bg_color = lcd_getbgcolor();
|
||||
int i;
|
||||
|
||||
cons.curr_col = 0;
|
||||
|
||||
/* Check if we need to scroll the terminal */
|
||||
if (++cons.curr_row >= cons.rows) {
|
||||
for (i = 0; i < cons.rows-rows; i++)
|
||||
cons.fp_console_moverow(&cons, i, i+rows);
|
||||
for (i = 0; i < rows; i++)
|
||||
cons.fp_console_setrow(&cons, cons.rows-i-1, bg_color);
|
||||
cons.curr_row -= rows;
|
||||
}
|
||||
lcd_sync();
|
||||
}
|
||||
|
||||
void console_calc_rowcol(struct console_t *pcons, u32 sizex, u32 sizey)
|
||||
{
|
||||
pcons->cols = sizex / VIDEO_FONT_WIDTH;
|
||||
pcons->rows = sizey / VIDEO_FONT_HEIGHT;
|
||||
}
|
||||
|
||||
void __weak lcd_init_console_rot(struct console_t *pcons)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void lcd_init_console(void *address, int vl_cols, int vl_rows, int vl_rot)
|
||||
{
|
||||
memset(&cons, 0, sizeof(cons));
|
||||
cons.fbbase = address;
|
||||
|
||||
cons.lcdsizex = vl_cols;
|
||||
cons.lcdsizey = vl_rows;
|
||||
cons.lcdrot = vl_rot;
|
||||
|
||||
cons.fp_putc_xy = &lcd_putc_xy0;
|
||||
cons.fp_console_moverow = &console_moverow0;
|
||||
cons.fp_console_setrow = &console_setrow0;
|
||||
console_calc_rowcol(&cons, cons.lcdsizex, cons.lcdsizey);
|
||||
|
||||
lcd_init_console_rot(&cons);
|
||||
|
||||
debug("lcd_console: have %d/%d col/rws on scr %dx%d (%d deg rotated)\n",
|
||||
cons.cols, cons.rows, cons.lcdsizex, cons.lcdsizey, vl_rot);
|
||||
}
|
||||
|
||||
void lcd_putc(const char c)
|
||||
{
|
||||
if (!lcd_is_enabled) {
|
||||
serial_putc(c);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
switch (c) {
|
||||
case '\r':
|
||||
cons.curr_col = 0;
|
||||
return;
|
||||
case '\n':
|
||||
console_newline();
|
||||
|
||||
return;
|
||||
case '\t': /* Tab (8 chars alignment) */
|
||||
cons.curr_col += 8;
|
||||
cons.curr_col &= ~7;
|
||||
|
||||
if (cons.curr_col >= cons.cols)
|
||||
console_newline();
|
||||
|
||||
return;
|
||||
case '\b':
|
||||
console_back();
|
||||
|
||||
return;
|
||||
default:
|
||||
cons.fp_putc_xy(&cons,
|
||||
cons.curr_col * VIDEO_FONT_WIDTH,
|
||||
cons.curr_row * VIDEO_FONT_HEIGHT, c);
|
||||
if (++cons.curr_col >= cons.cols)
|
||||
console_newline();
|
||||
}
|
||||
}
|
||||
|
||||
void lcd_puts(const char *s)
|
||||
{
|
||||
if (!lcd_is_enabled) {
|
||||
serial_puts(s);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
while (*s)
|
||||
lcd_putc(*s++);
|
||||
|
||||
lcd_sync();
|
||||
}
|
||||
|
||||
void lcd_printf(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
char buf[CONFIG_SYS_PBSIZE];
|
||||
|
||||
va_start(args, fmt);
|
||||
vsprintf(buf, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
lcd_puts(buf);
|
||||
}
|
||||
|
||||
static int do_lcd_setcursor(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
unsigned int col, row;
|
||||
|
||||
if (argc != 3)
|
||||
return CMD_RET_USAGE;
|
||||
|
||||
col = dectoul(argv[1], NULL);
|
||||
row = dectoul(argv[2], NULL);
|
||||
lcd_position_cursor(col, row);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_lcd_puts(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
if (argc != 2)
|
||||
return CMD_RET_USAGE;
|
||||
|
||||
lcd_puts(argv[1]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
U_BOOT_CMD(
|
||||
setcurs, 3, 1, do_lcd_setcursor,
|
||||
"set cursor position within screen",
|
||||
" <col> <row> in character"
|
||||
);
|
||||
|
||||
U_BOOT_CMD(
|
||||
lcdputs, 2, 1, do_lcd_puts,
|
||||
"print string on lcd-framebuffer",
|
||||
" <string>"
|
||||
);
|
||||
207
include/lcd.h
207
include/lcd.h
@ -1,207 +0,0 @@
|
||||
/* SPDX-License-Identifier: GPL-2.0+ */
|
||||
/*
|
||||
* MPC823 and PXA LCD Controller
|
||||
*
|
||||
* Modeled after video interface by Paolo Scaffardi
|
||||
*
|
||||
*
|
||||
* (C) Copyright 2001
|
||||
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
|
||||
*/
|
||||
|
||||
#ifndef _LCD_H_
|
||||
#define _LCD_H_
|
||||
#include <lcd_console.h>
|
||||
#if defined(CONFIG_CMD_BMP) || defined(CONFIG_SPLASH_SCREEN)
|
||||
#include <bmp_layout.h>
|
||||
#include <asm/byteorder.h>
|
||||
#endif
|
||||
|
||||
int bmp_display(ulong addr, int x, int y);
|
||||
struct bmp_image *gunzip_bmp(unsigned long addr, unsigned long *lenp,
|
||||
void **alloc_addr);
|
||||
|
||||
#ifndef CONFIG_DM_VIDEO
|
||||
|
||||
extern char lcd_is_enabled;
|
||||
extern int lcd_line_length;
|
||||
extern struct vidinfo panel_info;
|
||||
|
||||
void lcd_ctrl_init(void *lcdbase);
|
||||
void lcd_enable(void);
|
||||
void lcd_setcolreg(ushort regno, ushort red, ushort green, ushort blue);
|
||||
ulong lcd_setmem(ulong addr);
|
||||
|
||||
/**
|
||||
* Set whether we need to flush the dcache when changing the LCD image. This
|
||||
* defaults to off.
|
||||
*
|
||||
* @param flush non-zero to flush cache after update, 0 to skip
|
||||
*/
|
||||
void lcd_set_flush_dcache(int flush);
|
||||
|
||||
#if defined(CONFIG_ATMEL_LCD) || defined(CONFIG_ATMEL_HLCD)
|
||||
#include <atmel_lcd.h>
|
||||
#elif defined(CONFIG_EXYNOS_FB)
|
||||
#include <exynos_lcd.h>
|
||||
#else
|
||||
typedef struct vidinfo {
|
||||
ushort vl_col; /* Number of columns (i.e. 160) */
|
||||
ushort vl_row; /* Number of rows (i.e. 100) */
|
||||
ushort vl_rot; /* Rotation of Display (0, 1, 2, 3) */
|
||||
u_char vl_bpix; /* Bits per pixel, 0 = 1 */
|
||||
ushort *cmap; /* Pointer to the colormap */
|
||||
void *priv; /* Pointer to driver-specific data */
|
||||
} vidinfo_t;
|
||||
|
||||
static __maybe_unused ushort *configuration_get_cmap(void)
|
||||
{
|
||||
return panel_info.cmap;
|
||||
}
|
||||
#endif
|
||||
|
||||
ushort *configuration_get_cmap(void);
|
||||
|
||||
extern vidinfo_t panel_info;
|
||||
|
||||
void lcd_putc(const char c);
|
||||
void lcd_puts(const char *s);
|
||||
void lcd_printf(const char *fmt, ...);
|
||||
void lcd_clear(void);
|
||||
int lcd_display_bitmap(ulong bmp_image, int x, int y);
|
||||
|
||||
/**
|
||||
* Get the width of the LCD in pixels
|
||||
*
|
||||
* Return: width of LCD in pixels
|
||||
*/
|
||||
int lcd_get_pixel_width(void);
|
||||
|
||||
/**
|
||||
* Get the height of the LCD in pixels
|
||||
*
|
||||
* Return: height of LCD in pixels
|
||||
*/
|
||||
int lcd_get_pixel_height(void);
|
||||
|
||||
/**
|
||||
* Get the number of text lines/rows on the LCD
|
||||
*
|
||||
* Return: number of rows
|
||||
*/
|
||||
int lcd_get_screen_rows(void);
|
||||
|
||||
/**
|
||||
* Get the number of text columns on the LCD
|
||||
*
|
||||
* Return: number of columns
|
||||
*/
|
||||
int lcd_get_screen_columns(void);
|
||||
|
||||
/**
|
||||
* Get the background color of the LCD
|
||||
*
|
||||
* Return: background color value
|
||||
*/
|
||||
int lcd_getbgcolor(void);
|
||||
|
||||
/**
|
||||
* Get the foreground color of the LCD
|
||||
*
|
||||
* Return: foreground color value
|
||||
*/
|
||||
int lcd_getfgcolor(void);
|
||||
|
||||
/**
|
||||
* Set the position of the text cursor
|
||||
*
|
||||
* @param col Column to place cursor (0 = left side)
|
||||
* @param row Row to place cursor (0 = top line)
|
||||
*/
|
||||
void lcd_position_cursor(unsigned col, unsigned row);
|
||||
|
||||
/* Allow boards to customize the information displayed */
|
||||
void lcd_show_board_info(void);
|
||||
|
||||
/* Return the size of the LCD frame buffer, and the line length */
|
||||
int lcd_get_size(int *line_length);
|
||||
|
||||
/* Update the LCD / flush the cache */
|
||||
void lcd_sync(void);
|
||||
|
||||
/*
|
||||
* Information about displays we are using. This is for configuring
|
||||
* the LCD controller and memory allocation. Someone has to know what
|
||||
* is connected, as we can't autodetect anything.
|
||||
*/
|
||||
#define CONFIG_SYS_HIGH 0 /* Pins are active high */
|
||||
#define CONFIG_SYS_LOW 1 /* Pins are active low */
|
||||
|
||||
#define LCD_MONOCHROME 0
|
||||
#define LCD_COLOR2 1
|
||||
#define LCD_COLOR4 2
|
||||
#define LCD_COLOR8 3
|
||||
#define LCD_COLOR16 4
|
||||
#define LCD_COLOR32 5
|
||||
|
||||
/* Default to 8bpp if bit depth not specified */
|
||||
#ifndef LCD_BPP
|
||||
#define LCD_BPP LCD_COLOR8
|
||||
#endif
|
||||
|
||||
#ifndef LCD_DF
|
||||
#define LCD_DF 1
|
||||
#endif
|
||||
|
||||
/* Calculate nr. of bits per pixel and nr. of colors */
|
||||
#define NBITS(bit_code) (1 << (bit_code))
|
||||
#define NCOLORS(bit_code) (1 << NBITS(bit_code))
|
||||
|
||||
#if LCD_BPP == LCD_COLOR8
|
||||
# define CONSOLE_COLOR_BLACK 0
|
||||
# define CONSOLE_COLOR_RED 1
|
||||
# define CONSOLE_COLOR_GREEN 2
|
||||
# define CONSOLE_COLOR_YELLOW 3
|
||||
# define CONSOLE_COLOR_BLUE 4
|
||||
# define CONSOLE_COLOR_MAGENTA 5
|
||||
# define CONSOLE_COLOR_CYAN 6
|
||||
# define CONSOLE_COLOR_GREY 14
|
||||
# define CONSOLE_COLOR_WHITE 15 /* Must remain last / highest */
|
||||
#elif LCD_BPP == LCD_COLOR32
|
||||
#define CONSOLE_COLOR_RED 0x00ff0000
|
||||
#define CONSOLE_COLOR_GREEN 0x0000ff00
|
||||
#define CONSOLE_COLOR_YELLOW 0x00ffff00
|
||||
#define CONSOLE_COLOR_BLUE 0x000000ff
|
||||
#define CONSOLE_COLOR_MAGENTA 0x00ff00ff
|
||||
#define CONSOLE_COLOR_CYAN 0x0000ffff
|
||||
#define CONSOLE_COLOR_GREY 0x00aaaaaa
|
||||
#define CONSOLE_COLOR_BLACK 0x00000000
|
||||
#define CONSOLE_COLOR_WHITE 0x00ffffff /* Must remain last / highest */
|
||||
#define NBYTES(bit_code) (NBITS(bit_code) >> 3)
|
||||
#else /* 16bpp color definitions */
|
||||
# define CONSOLE_COLOR_BLACK 0x0000
|
||||
# define CONSOLE_COLOR_RED 0xF800
|
||||
# define CONSOLE_COLOR_GREEN 0x07E0
|
||||
# define CONSOLE_COLOR_YELLOW 0xFFE0
|
||||
# define CONSOLE_COLOR_BLUE 0x001F
|
||||
# define CONSOLE_COLOR_MAGENTA 0xF81F
|
||||
# define CONSOLE_COLOR_CYAN 0x07FF
|
||||
# define CONSOLE_COLOR_GREY 0xC618
|
||||
# define CONSOLE_COLOR_WHITE 0xffff /* Must remain last / highest */
|
||||
#endif /* color definitions */
|
||||
|
||||
#if LCD_BPP == LCD_COLOR16
|
||||
#define fbptr_t ushort
|
||||
#elif LCD_BPP == LCD_COLOR32
|
||||
#define fbptr_t u32
|
||||
#else
|
||||
#define fbptr_t uchar
|
||||
#endif
|
||||
|
||||
#ifndef PAGE_SIZE
|
||||
#define PAGE_SIZE 4096
|
||||
#endif
|
||||
|
||||
#endif /* !CONFIG_DM_VIDEO */
|
||||
|
||||
#endif /* _LCD_H_ */
|
||||
Loading…
Reference in New Issue
Block a user