upstream u-boot with additional patches for our devices/boards:
https://lists.denx.de/pipermail/u-boot/2017-March/282789.html (AXP crashes) ;
Gbit ethernet patch for some LIME2 revisions ;
with SPI flash support
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.
562 lines
16 KiB
562 lines
16 KiB
/*
|
|
* (C) Copyright 2001
|
|
* Wolfgang Denk, DENX Software Engineering -- wd@denx.de
|
|
*
|
|
* See file CREDITS for list of people who contributed to this
|
|
* project.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of
|
|
* the License, or (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*/
|
|
|
|
/************************************************************************/
|
|
/* ** DEBUG SETTINGS */
|
|
/************************************************************************/
|
|
|
|
/* #define DEBUG */
|
|
|
|
/************************************************************************/
|
|
/* ** HEADER FILES */
|
|
/************************************************************************/
|
|
|
|
#include <config.h>
|
|
#include <common.h>
|
|
#include <version.h>
|
|
#include <stdarg.h>
|
|
#include <linux/types.h>
|
|
#include <devices.h>
|
|
#include <s3c2400.h>
|
|
|
|
#ifdef CONFIG_VFD
|
|
|
|
/************************************************************************/
|
|
/* ** CONFIG STUFF -- should be moved to board config file */
|
|
/************************************************************************/
|
|
|
|
/************************************************************************/
|
|
|
|
#ifndef PAGE_SIZE
|
|
#define PAGE_SIZE 4096
|
|
#endif
|
|
|
|
#define ROT 0x09
|
|
#define BLAU 0x0C
|
|
#define VIOLETT 0X0D
|
|
|
|
/* MAGIC */
|
|
#define FRAME_BUF_SIZE ((256*4*56)/8)
|
|
#define frame_buf_offs 4
|
|
|
|
/* defines for starting Timer3 as CPLD-Clk */
|
|
#define START3 (1 << 16)
|
|
#define UPDATE3 (1 << 17)
|
|
#define INVERT3 (1 << 18)
|
|
#define RELOAD3 (1 << 19)
|
|
|
|
/* CPLD-Register for controlling vfd-blank-signal */
|
|
#define VFD_DISABLE (*(volatile uchar *)0x04038000=0x0000)
|
|
#define VFD_ENABLE (*(volatile uchar *)0x04038000=0x0001)
|
|
|
|
/* Supported VFD Types */
|
|
#define VFD_TYPE_T119C 1 /* Noritake T119C VFD */
|
|
#define VFD_TYPE_MN11236 2
|
|
|
|
/*#define NEW_CPLD_CLK*/
|
|
|
|
int vfd_board_id;
|
|
|
|
/* taken from armboot/common/vfd.c */
|
|
unsigned long adr_vfd_table[112][18][2][4][2];
|
|
unsigned char bit_vfd_table[112][18][2][4][2];
|
|
|
|
/*
|
|
* initialize the values for the VFD-grid-control in the framebuffer
|
|
*/
|
|
void init_grid_ctrl(void)
|
|
{
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
ulong adr, grid_cycle;
|
|
unsigned int bit, display;
|
|
unsigned char temp, bit_nr;
|
|
|
|
/*
|
|
* clear frame buffer (logical clear => set to "black")
|
|
*/
|
|
memset ((void *)(gd->fb_base), 0, FRAME_BUF_SIZE);
|
|
|
|
switch (gd->vfd_type) {
|
|
case VFD_TYPE_T119C:
|
|
for (display=0; display<4; display++) {
|
|
for(grid_cycle=0; grid_cycle<56; grid_cycle++) {
|
|
bit = grid_cycle * 256 * 4 +
|
|
(grid_cycle + 200) * 4 +
|
|
frame_buf_offs + display;
|
|
/* wrap arround if offset (see manual S3C2400) */
|
|
if (bit>=FRAME_BUF_SIZE*8)
|
|
bit = bit - (FRAME_BUF_SIZE * 8);
|
|
adr = gd->fb_base + (bit/32) * 4 + (3 - (bit%32) / 8);
|
|
bit_nr = bit % 8;
|
|
bit_nr = (bit_nr > 3) ? bit_nr-4 : bit_nr+4;
|
|
temp=(*(volatile unsigned char*)(adr));
|
|
temp |= (1<<bit_nr);
|
|
(*(volatile unsigned char*)(adr))=temp;
|
|
|
|
if(grid_cycle<55)
|
|
bit = grid_cycle*256*4+(grid_cycle+201)*4+frame_buf_offs+display;
|
|
else
|
|
bit = grid_cycle*256*4+200*4+frame_buf_offs+display-4; /* grid nr. 0 */
|
|
/* wrap arround if offset (see manual S3C2400) */
|
|
if (bit>=FRAME_BUF_SIZE*8)
|
|
bit = bit-(FRAME_BUF_SIZE*8);
|
|
adr = gd->fb_base+(bit/32)*4+(3-(bit%32)/8);
|
|
bit_nr = bit%8;
|
|
bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
|
|
temp=(*(volatile unsigned char*)(adr));
|
|
temp |= (1<<bit_nr);
|
|
(*(volatile unsigned char*)(adr))=temp;
|
|
}
|
|
}
|
|
break;
|
|
case VFD_TYPE_MN11236:
|
|
for (display=0; display<4; display++) {
|
|
for (grid_cycle=0; grid_cycle<38; grid_cycle++) {
|
|
bit = grid_cycle * 256 * 4 +
|
|
(253 - grid_cycle) * 4 +
|
|
frame_buf_offs + display;
|
|
/* wrap arround if offset (see manual S3C2400) */
|
|
if (bit>=FRAME_BUF_SIZE*8)
|
|
bit = bit - (FRAME_BUF_SIZE * 8);
|
|
adr = gd->fb_base + (bit/32) * 4 + (3 - (bit%32) / 8);
|
|
bit_nr = bit % 8;
|
|
bit_nr = (bit_nr > 3) ? bit_nr-4 : bit_nr+4;
|
|
temp=(*(volatile unsigned char*)(adr));
|
|
temp |= (1<<bit_nr);
|
|
(*(volatile unsigned char*)(adr))=temp;
|
|
|
|
if(grid_cycle<37)
|
|
bit = grid_cycle*256*4+(252-grid_cycle)*4+frame_buf_offs+display;
|
|
|
|
/* wrap arround if offset (see manual S3C2400) */
|
|
if (bit>=FRAME_BUF_SIZE*8)
|
|
bit = bit-(FRAME_BUF_SIZE*8);
|
|
adr = gd->fb_base+(bit/32)*4+(3-(bit%32)/8);
|
|
bit_nr = bit%8;
|
|
bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
|
|
temp=(*(volatile unsigned char*)(adr));
|
|
temp |= (1<<bit_nr);
|
|
(*(volatile unsigned char*)(adr))=temp;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
printf ("Warning: unknown display type\n");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
*create translation table for getting easy the right position in the
|
|
*physical framebuffer for some x/y-coordinates of the VFDs
|
|
*/
|
|
void create_vfd_table(void)
|
|
{
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
unsigned long vfd_table[112][18][2][4][2];
|
|
unsigned int x, y, color, display, entry, pixel;
|
|
unsigned int x_abcdef = 0;
|
|
|
|
switch (gd->vfd_type) {
|
|
case VFD_TYPE_T119C:
|
|
for(y=0; y<=17; y++) { /* Line */
|
|
for(x=0; x<=111; x++) { /* Column */
|
|
for(display=0; display <=3; display++) {
|
|
|
|
/* Display 0 blue pixels */
|
|
vfd_table[x][y][0][display][0] =
|
|
(x==0) ? y*16+display
|
|
: (x%4)*4+y*16+((x-1)/2)*1024+display;
|
|
/* Display 0 red pixels */
|
|
vfd_table[x][y][1][display][0] =
|
|
(x==0) ? y*16+512+display
|
|
: (x%4)*4+y*16+((x-1)/2)*1024+512+display;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case VFD_TYPE_MN11236:
|
|
for(y=0; y<=17; y++) { /* Line */
|
|
for(x=0; x<=111; x++) { /* Column */
|
|
for(display=0; display <=3; display++) {
|
|
|
|
vfd_table[x][y][0][display][0]=0;
|
|
vfd_table[x][y][0][display][1]=0;
|
|
vfd_table[x][y][1][display][0]=0;
|
|
vfd_table[x][y][1][display][1]=0;
|
|
|
|
switch (x%6) {
|
|
case 0: x_abcdef=0; break; /* a -> a */
|
|
case 1: x_abcdef=2; break; /* b -> c */
|
|
case 2: x_abcdef=4; break; /* c -> e */
|
|
case 3: x_abcdef=5; break; /* d -> f */
|
|
case 4: x_abcdef=3; break; /* e -> d */
|
|
case 5: x_abcdef=1; break; /* f -> b */
|
|
}
|
|
|
|
/* blue pixels */
|
|
vfd_table[x][y][0][display][0] =
|
|
(x>1) ? x_abcdef*4+((x-1)/3)*1024+y*48+display
|
|
: x_abcdef*4+ 0+y*48+display;
|
|
/* blue pixels */
|
|
if (x>1 && (x-1)%3)
|
|
vfd_table[x][y][0][display][1] = x_abcdef*4+((x-1)/3+1)*1024+y*48+display;
|
|
|
|
/* red pixels */
|
|
vfd_table[x][y][1][display][0] =
|
|
(x>1) ? x_abcdef*4+24+((x-1)/3)*1024+y*48+display
|
|
: x_abcdef*4+24+ 0+y*48+display;
|
|
/* red pixels */
|
|
if (x>1 && (x-1)%3)
|
|
vfd_table[x][y][1][display][1] = x_abcdef*4+24+((x-1)/3+1)*1024+y*48+display;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
/* do nothing */
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Create table with entries for physical byte adresses and
|
|
* bit-number within the byte
|
|
* from table with bit-numbers within the total framebuffer
|
|
*/
|
|
for(y=0;y<18;y++) {
|
|
for(x=0;x<112;x++) {
|
|
for(color=0;color<2;color++) {
|
|
for(display=0;display<4;display++) {
|
|
for(entry=0;entry<2;entry++) {
|
|
unsigned long adr = gd->fb_base;
|
|
unsigned int bit_nr = 0;
|
|
|
|
if (vfd_table[x][y][color][display][entry]) {
|
|
|
|
pixel = vfd_table[x][y][color][display][entry] + frame_buf_offs;
|
|
/*
|
|
* wrap arround if offset
|
|
* (see manual S3C2400)
|
|
*/
|
|
if (pixel>=FRAME_BUF_SIZE*8)
|
|
pixel = pixel-(FRAME_BUF_SIZE*8);
|
|
adr = gd->fb_base+(pixel/32)*4+(3-(pixel%32)/8);
|
|
bit_nr = pixel%8;
|
|
bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
|
|
}
|
|
adr_vfd_table[x][y][color][display][entry] = adr;
|
|
bit_vfd_table[x][y][color][display][entry] = bit_nr;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Set/clear pixel of the VFDs
|
|
*/
|
|
void set_vfd_pixel(unsigned char x, unsigned char y,
|
|
unsigned char color, unsigned char display,
|
|
unsigned char value)
|
|
{
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
ulong adr;
|
|
unsigned char bit_nr, temp;
|
|
|
|
if (! gd->vfd_type) {
|
|
/* Unknown type. */
|
|
return;
|
|
}
|
|
|
|
/* Pixel-Eintrag Nr. 1 */
|
|
adr = adr_vfd_table[x][y][color][display][0];
|
|
/* Pixel-Eintrag Nr. 1 */
|
|
bit_nr = bit_vfd_table[x][y][color][display][0];
|
|
temp=(*(volatile unsigned char*)(adr));
|
|
|
|
if (value)
|
|
temp |= (1<<bit_nr);
|
|
else
|
|
temp &= ~(1<<bit_nr);
|
|
|
|
(*(volatile unsigned char*)(adr))=temp;
|
|
}
|
|
|
|
/*
|
|
* transfer image from BMP-File
|
|
*/
|
|
void transfer_pic(int display, unsigned char *adr, int height, int width)
|
|
{
|
|
int x, y;
|
|
unsigned char temp;
|
|
|
|
for (; height > 0; height -= 18)
|
|
{
|
|
if (height > 18)
|
|
y = 18;
|
|
else
|
|
y = height;
|
|
for (; y > 0; y--)
|
|
{
|
|
for (x = 0; x < width; x += 2)
|
|
{
|
|
temp = *adr++;
|
|
set_vfd_pixel(x, y-1, 0, display, 0);
|
|
set_vfd_pixel(x, y-1, 1, display, 0);
|
|
if ((temp >> 4) == BLAU)
|
|
set_vfd_pixel(x, y-1, 0, display, 1);
|
|
else if ((temp >> 4) == ROT)
|
|
set_vfd_pixel(x, y-1, 1, display, 1);
|
|
else if ((temp >> 4) == VIOLETT)
|
|
{
|
|
set_vfd_pixel(x, y-1, 0, display, 1);
|
|
set_vfd_pixel(x, y-1, 1, display, 1);
|
|
}
|
|
set_vfd_pixel(x+1, y-1, 0, display, 0);
|
|
set_vfd_pixel(x+1, y-1, 1, display, 0);
|
|
if ((temp & 0x0F) == BLAU)
|
|
set_vfd_pixel(x+1, y-1, 0, display, 1);
|
|
else if ((temp & 0x0F) == ROT)
|
|
set_vfd_pixel(x+1, y-1, 1, display, 1);
|
|
else if ((temp & 0x0F) == VIOLETT)
|
|
{
|
|
set_vfd_pixel(x+1, y-1, 0, display, 1);
|
|
set_vfd_pixel(x+1, y-1, 1, display, 1);
|
|
}
|
|
}
|
|
}
|
|
if (display > 0)
|
|
display--;
|
|
else
|
|
display = 3;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* This function initializes VFD clock that is needed for the CPLD that
|
|
* manages the keyboard.
|
|
*/
|
|
int vfd_init_clocks (void)
|
|
{
|
|
S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
|
|
S3C24X0_TIMERS * const timers = S3C24X0_GetBase_TIMERS();
|
|
S3C24X0_LCD * const lcd = S3C24X0_GetBase_LCD();
|
|
|
|
/* try to determine display type from the value
|
|
* defined by pull-ups
|
|
*/
|
|
gpio->PCUP = (gpio->PCUP & 0xFFF0); /* activate GPC0...GPC3 pullups */
|
|
gpio->PCCON = (gpio->PCCON & 0xFFFFFF00); /* configure GPC0...GPC3 as inputs */
|
|
udelay (10); /* allow signals to settle */
|
|
vfd_board_id = (~gpio->PCDAT) & 0x000F; /* read GPC0...GPC3 port pins */
|
|
|
|
VFD_DISABLE; /* activate blank for the vfd */
|
|
|
|
#define NEW_CPLD_CLK
|
|
|
|
#ifdef NEW_CPLD_CLK
|
|
if (vfd_board_id) {
|
|
/* If new board revision, then use PWM 3 as cpld-clock */
|
|
/* Enable 500 Hz timer for fill level sensor to operate properly */
|
|
/* Configure TOUT3 as functional pin, disable pull-up */
|
|
gpio->PDCON &= ~0x30000;
|
|
gpio->PDCON |= 0x20000;
|
|
gpio->PDUP |= (1 << 8);
|
|
|
|
/* Configure the prescaler */
|
|
timers->TCFG0 &= ~0xff00;
|
|
timers->TCFG0 |= 0x0f00;
|
|
|
|
/* Select MUX input (divider) for timer3 (1/16) */
|
|
timers->TCFG1 &= ~0xf000;
|
|
timers->TCFG1 |= 0x3000;
|
|
|
|
/* Enable autoreload and set the counter and compare
|
|
* registers to values for the 500 Hz clock
|
|
* (for a given prescaler (15) and divider (16)):
|
|
* counter = (66000000 / 500) >> 9;
|
|
*/
|
|
timers->ch[3].TCNTB = 0x101;
|
|
timers->ch[3].TCMPB = 0x101 / 2;
|
|
|
|
/* Start timer */
|
|
timers->TCON = (timers->TCON | UPDATE3 | RELOAD3) & ~INVERT3;
|
|
timers->TCON = (timers->TCON | START3) & ~UPDATE3;
|
|
}
|
|
#endif
|
|
/* If old board revision, then use vm-signal as cpld-clock */
|
|
lcd->LCDCON2 = 0x00FFC000;
|
|
lcd->LCDCON3 = 0x0007FF00;
|
|
lcd->LCDCON4 = 0x00000000;
|
|
lcd->LCDCON5 = 0x00000400;
|
|
lcd->LCDCON1 = 0x00000B75;
|
|
/* VM (GPD1) is used as clock for the CPLD */
|
|
gpio->PDCON = (gpio->PDCON & 0xFFFFFFF3) | 0x00000008;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* initialize LCD-Controller of the S3C2400 for using VFDs
|
|
*
|
|
* VFD detection depends on the board revision:
|
|
* starting from Rev. 200 a type code can be read from the data pins,
|
|
* driven by some pull-up resistors; all earlier systems must be
|
|
* manually configured. The type is set in the "vfd_type" environment
|
|
* variable.
|
|
*/
|
|
int drv_vfd_init(void)
|
|
{
|
|
S3C24X0_LCD * const lcd = S3C24X0_GetBase_LCD();
|
|
S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
|
|
char *tmp;
|
|
ulong palette;
|
|
static int vfd_init_done = 0;
|
|
int vfd_inv_data = 0;
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
if (vfd_init_done != 0)
|
|
return (0);
|
|
vfd_init_done = 1;
|
|
|
|
debug("Detecting Revison of WA4-VFD: ID=0x%X\n", vfd_board_id);
|
|
|
|
switch (vfd_board_id) {
|
|
case 0: /* board revision < Rev.200 */
|
|
if ((tmp = getenv ("vfd_type")) == NULL) {
|
|
break;
|
|
}
|
|
if (strcmp(tmp, "T119C") == 0) {
|
|
gd->vfd_type = VFD_TYPE_T119C;
|
|
} else if (strcmp(tmp, "MN11236") == 0) {
|
|
gd->vfd_type = VFD_TYPE_MN11236;
|
|
} else {
|
|
/* cannot use printf for a warning here */
|
|
gd->vfd_type = 0; /* unknown */
|
|
}
|
|
|
|
break;
|
|
default: /* default to MN11236, data inverted */
|
|
gd->vfd_type = VFD_TYPE_MN11236;
|
|
vfd_inv_data = 1;
|
|
setenv ("vfd_type", "MN11236");
|
|
}
|
|
debug ("VFD type: %s%s\n",
|
|
(gd->vfd_type == VFD_TYPE_T119C) ? "T119C" :
|
|
(gd->vfd_type == VFD_TYPE_MN11236) ? "MN11236" :
|
|
"unknown",
|
|
vfd_inv_data ? ", inverted data" : "");
|
|
|
|
gd->fb_base = gd->fb_base;
|
|
create_vfd_table();
|
|
init_grid_ctrl();
|
|
|
|
for (palette=0; palette < 16; palette++)
|
|
(*(volatile unsigned int*)(PALETTE+(palette*4)))=palette;
|
|
for (palette=16; palette < 256; palette++)
|
|
(*(volatile unsigned int*)(PALETTE+(palette*4)))=0x00;
|
|
|
|
/*
|
|
* Hinweis: Der Framebuffer ist um genau ein Nibble verschoben
|
|
* Das erste angezeigte Pixel wird aus dem zweiten Nibble geholt
|
|
* das letzte angezeigte Pixel wird aus dem ersten Nibble geholt
|
|
* (wrap around)
|
|
* see manual S3C2400
|
|
*/
|
|
/* Stopp LCD-Controller */
|
|
lcd->LCDCON1 = 0x00000000;
|
|
/* frame buffer startadr */
|
|
lcd->LCDSADDR1 = gd->fb_base >> 1;
|
|
/* frame buffer endadr */
|
|
lcd->LCDSADDR2 = (gd->fb_base + FRAME_BUF_SIZE) >> 1;
|
|
lcd->LCDSADDR3 = ((256/4));
|
|
lcd->LCDCON2 = 0x000DC000;
|
|
if(gd->vfd_type == VFD_TYPE_MN11236)
|
|
lcd->LCDCON2 = 37 << 14; /* MN11236: 38 lines */
|
|
else
|
|
lcd->LCDCON2 = 55 << 14; /* T119C: 56 lines */
|
|
lcd->LCDCON3 = 0x0051000A;
|
|
lcd->LCDCON4 = 0x00000001;
|
|
if (gd->vfd_type && vfd_inv_data)
|
|
lcd->LCDCON5 = 0x000004C0;
|
|
else
|
|
lcd->LCDCON5 = 0x00000440;
|
|
|
|
/* Port pins as LCD output */
|
|
gpio->PCCON = (gpio->PCCON & 0xFFFFFF00)| 0x000000AA;
|
|
gpio->PDCON = (gpio->PDCON & 0xFFFFFF03)| 0x000000A8;
|
|
|
|
/* Synchronize VFD enable with LCD controller to avoid flicker */
|
|
lcd->LCDCON1 = 0x00000B75; /* Start LCD-Controller */
|
|
while((lcd->LCDCON5 & 0x180000)!=0x100000); /* Wait for end of VSYNC */
|
|
while((lcd->LCDCON5 & 0x060000)!=0x040000); /* Wait for next HSYNC */
|
|
while((lcd->LCDCON5 & 0x060000)==0x040000);
|
|
while((lcd->LCDCON5 & 0x060000)!=0x000000);
|
|
if(gd->vfd_type)
|
|
VFD_ENABLE;
|
|
|
|
debug ("LCDSADDR1: %lX\n", lcd->LCDSADDR1);
|
|
debug ("LCDSADDR2: %lX\n", lcd->LCDSADDR2);
|
|
debug ("LCDSADDR3: %lX\n", lcd->LCDSADDR3);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Disable VFD: should be run before resetting the system:
|
|
* disable VM, enable pull-up
|
|
*/
|
|
void disable_vfd (void)
|
|
{
|
|
S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
|
|
|
|
VFD_DISABLE;
|
|
gpio->PDCON &= ~0xC;
|
|
gpio->PDUP &= ~0x2;
|
|
}
|
|
|
|
/************************************************************************/
|
|
/* ** ROM capable initialization part - needed to reserve FB memory */
|
|
/************************************************************************/
|
|
|
|
/*
|
|
* This is called early in the system initialization to grab memory
|
|
* for the VFD controller.
|
|
*
|
|
* Note that this is running from ROM, so no write access to global data.
|
|
*/
|
|
ulong vfd_setmem (ulong addr)
|
|
{
|
|
ulong size;
|
|
|
|
/* Round up to nearest full page */
|
|
size = (FRAME_BUF_SIZE + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
|
|
|
|
debug ("Reserving %ldk for VFD Framebuffer at: %08lx\n", size>>10, addr);
|
|
|
|
return (size);
|
|
}
|
|
|
|
#endif /* CONFIG_VFD */
|
|
|