3 * Wolfgang Denk, DENX Software Engineering -- wd@denx.de
5 * See file CREDITS for list of people who contributed to this
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License as
10 * published by the Free Software Foundation; either version 2 of
11 * the License, or (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
24 /************************************************************************/
25 /* ** DEBUG SETTINGS */
26 /************************************************************************/
30 /************************************************************************/
32 /************************************************************************/
38 #include <linux/types.h>
42 DECLARE_GLOBAL_DATA_PTR;
46 /************************************************************************/
47 /* ** CONFIG STUFF -- should be moved to board config file */
48 /************************************************************************/
50 /************************************************************************/
53 #define PAGE_SIZE 4096
61 #define FRAME_BUF_SIZE ((256*4*56)/8)
62 #define frame_buf_offs 4
64 /* defines for starting Timer3 as CPLD-Clk */
65 #define START3 (1 << 16)
66 #define UPDATE3 (1 << 17)
67 #define INVERT3 (1 << 18)
68 #define RELOAD3 (1 << 19)
70 /* CPLD-Register for controlling vfd-blank-signal */
71 #define VFD_DISABLE (*(volatile uchar *)0x04038000=0x0000)
72 #define VFD_ENABLE (*(volatile uchar *)0x04038000=0x0001)
74 /* Supported VFD Types */
75 #define VFD_TYPE_T119C 1 /* Noritake T119C VFD */
76 #define VFD_TYPE_MN11236 2
78 /*#define NEW_CPLD_CLK*/
82 /* taken from armboot/common/vfd.c */
83 unsigned long adr_vfd_table[112][18][2][4][2];
84 unsigned char bit_vfd_table[112][18][2][4][2];
87 * initialize the values for the VFD-grid-control in the framebuffer
89 void init_grid_ctrl(void)
91 ulong adr, grid_cycle;
92 unsigned int bit, display;
93 unsigned char temp, bit_nr;
96 * clear frame buffer (logical clear => set to "black")
98 memset ((void *)(gd->fb_base), 0, FRAME_BUF_SIZE);
100 switch (gd->vfd_type) {
102 for (display=0; display<4; display++) {
103 for(grid_cycle=0; grid_cycle<56; grid_cycle++) {
104 bit = grid_cycle * 256 * 4 +
105 (grid_cycle + 200) * 4 +
106 frame_buf_offs + display;
107 /* wrap arround if offset (see manual S3C2400) */
108 if (bit>=FRAME_BUF_SIZE*8)
109 bit = bit - (FRAME_BUF_SIZE * 8);
110 adr = gd->fb_base + (bit/32) * 4 + (3 - (bit%32) / 8);
112 bit_nr = (bit_nr > 3) ? bit_nr-4 : bit_nr+4;
113 temp=(*(volatile unsigned char*)(adr));
115 (*(volatile unsigned char*)(adr))=temp;
118 bit = grid_cycle*256*4+(grid_cycle+201)*4+frame_buf_offs+display;
120 bit = grid_cycle*256*4+200*4+frame_buf_offs+display-4; /* grid nr. 0 */
121 /* wrap arround if offset (see manual S3C2400) */
122 if (bit>=FRAME_BUF_SIZE*8)
123 bit = bit-(FRAME_BUF_SIZE*8);
124 adr = gd->fb_base+(bit/32)*4+(3-(bit%32)/8);
126 bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
127 temp=(*(volatile unsigned char*)(adr));
129 (*(volatile unsigned char*)(adr))=temp;
133 case VFD_TYPE_MN11236:
134 for (display=0; display<4; display++) {
135 for (grid_cycle=0; grid_cycle<38; grid_cycle++) {
136 bit = grid_cycle * 256 * 4 +
137 (253 - grid_cycle) * 4 +
138 frame_buf_offs + display;
139 /* wrap arround if offset (see manual S3C2400) */
140 if (bit>=FRAME_BUF_SIZE*8)
141 bit = bit - (FRAME_BUF_SIZE * 8);
142 adr = gd->fb_base + (bit/32) * 4 + (3 - (bit%32) / 8);
144 bit_nr = (bit_nr > 3) ? bit_nr-4 : bit_nr+4;
145 temp=(*(volatile unsigned char*)(adr));
147 (*(volatile unsigned char*)(adr))=temp;
150 bit = grid_cycle*256*4+(252-grid_cycle)*4+frame_buf_offs+display;
152 /* wrap arround if offset (see manual S3C2400) */
153 if (bit>=FRAME_BUF_SIZE*8)
154 bit = bit-(FRAME_BUF_SIZE*8);
155 adr = gd->fb_base+(bit/32)*4+(3-(bit%32)/8);
157 bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
158 temp=(*(volatile unsigned char*)(adr));
160 (*(volatile unsigned char*)(adr))=temp;
165 printf ("Warning: unknown display type\n");
171 *create translation table for getting easy the right position in the
172 *physical framebuffer for some x/y-coordinates of the VFDs
174 void create_vfd_table(void)
176 unsigned long vfd_table[112][18][2][4][2];
177 unsigned int x, y, color, display, entry, pixel;
178 unsigned int x_abcdef = 0;
180 switch (gd->vfd_type) {
182 for(y=0; y<=17; y++) { /* Line */
183 for(x=0; x<=111; x++) { /* Column */
184 for(display=0; display <=3; display++) {
186 /* Display 0 blue pixels */
187 vfd_table[x][y][0][display][0] =
188 (x==0) ? y*16+display
189 : (x%4)*4+y*16+((x-1)/2)*1024+display;
190 /* Display 0 red pixels */
191 vfd_table[x][y][1][display][0] =
192 (x==0) ? y*16+512+display
193 : (x%4)*4+y*16+((x-1)/2)*1024+512+display;
198 case VFD_TYPE_MN11236:
199 for(y=0; y<=17; y++) { /* Line */
200 for(x=0; x<=111; x++) { /* Column */
201 for(display=0; display <=3; display++) {
203 vfd_table[x][y][0][display][0]=0;
204 vfd_table[x][y][0][display][1]=0;
205 vfd_table[x][y][1][display][0]=0;
206 vfd_table[x][y][1][display][1]=0;
209 case 0: x_abcdef=0; break; /* a -> a */
210 case 1: x_abcdef=2; break; /* b -> c */
211 case 2: x_abcdef=4; break; /* c -> e */
212 case 3: x_abcdef=5; break; /* d -> f */
213 case 4: x_abcdef=3; break; /* e -> d */
214 case 5: x_abcdef=1; break; /* f -> b */
218 vfd_table[x][y][0][display][0] =
219 (x>1) ? x_abcdef*4+((x-1)/3)*1024+y*48+display
220 : x_abcdef*4+ 0+y*48+display;
223 vfd_table[x][y][0][display][1] = x_abcdef*4+((x-1)/3+1)*1024+y*48+display;
226 vfd_table[x][y][1][display][0] =
227 (x>1) ? x_abcdef*4+24+((x-1)/3)*1024+y*48+display
228 : x_abcdef*4+24+ 0+y*48+display;
231 vfd_table[x][y][1][display][1] = x_abcdef*4+24+((x-1)/3+1)*1024+y*48+display;
242 * Create table with entries for physical byte adresses and
243 * bit-number within the byte
244 * from table with bit-numbers within the total framebuffer
248 for(color=0;color<2;color++) {
249 for(display=0;display<4;display++) {
250 for(entry=0;entry<2;entry++) {
251 unsigned long adr = gd->fb_base;
252 unsigned int bit_nr = 0;
254 if (vfd_table[x][y][color][display][entry]) {
256 pixel = vfd_table[x][y][color][display][entry] + frame_buf_offs;
258 * wrap arround if offset
259 * (see manual S3C2400)
261 if (pixel>=FRAME_BUF_SIZE*8)
262 pixel = pixel-(FRAME_BUF_SIZE*8);
263 adr = gd->fb_base+(pixel/32)*4+(3-(pixel%32)/8);
265 bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
267 adr_vfd_table[x][y][color][display][entry] = adr;
268 bit_vfd_table[x][y][color][display][entry] = bit_nr;
277 * Set/clear pixel of the VFDs
279 void set_vfd_pixel(unsigned char x, unsigned char y,
280 unsigned char color, unsigned char display,
284 unsigned char bit_nr, temp;
286 if (! gd->vfd_type) {
291 /* Pixel-Eintrag Nr. 1 */
292 adr = adr_vfd_table[x][y][color][display][0];
293 /* Pixel-Eintrag Nr. 1 */
294 bit_nr = bit_vfd_table[x][y][color][display][0];
295 temp=(*(volatile unsigned char*)(adr));
300 temp &= ~(1<<bit_nr);
302 (*(volatile unsigned char*)(adr))=temp;
306 * transfer image from BMP-File
308 void transfer_pic(int display, unsigned char *adr, int height, int width)
313 for (; height > 0; height -= 18)
321 for (x = 0; x < width; x += 2)
324 set_vfd_pixel(x, y-1, 0, display, 0);
325 set_vfd_pixel(x, y-1, 1, display, 0);
326 if ((temp >> 4) == BLAU)
327 set_vfd_pixel(x, y-1, 0, display, 1);
328 else if ((temp >> 4) == ROT)
329 set_vfd_pixel(x, y-1, 1, display, 1);
330 else if ((temp >> 4) == VIOLETT)
332 set_vfd_pixel(x, y-1, 0, display, 1);
333 set_vfd_pixel(x, y-1, 1, display, 1);
335 set_vfd_pixel(x+1, y-1, 0, display, 0);
336 set_vfd_pixel(x+1, y-1, 1, display, 0);
337 if ((temp & 0x0F) == BLAU)
338 set_vfd_pixel(x+1, y-1, 0, display, 1);
339 else if ((temp & 0x0F) == ROT)
340 set_vfd_pixel(x+1, y-1, 1, display, 1);
341 else if ((temp & 0x0F) == VIOLETT)
343 set_vfd_pixel(x+1, y-1, 0, display, 1);
344 set_vfd_pixel(x+1, y-1, 1, display, 1);
356 * This function initializes VFD clock that is needed for the CPLD that
357 * manages the keyboard.
359 int vfd_init_clocks (void)
363 S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
364 S3C24X0_TIMERS * const timers = S3C24X0_GetBase_TIMERS();
365 S3C24X0_LCD * const lcd = S3C24X0_GetBase_LCD();
367 /* try to determine display type from the value
368 * defined by pull-ups
370 gpio->PCUP = (gpio->PCUP & 0xFFF0); /* activate GPC0...GPC3 pullups */
371 gpio->PCCON = (gpio->PCCON & 0xFFFFFF00); /* configure GPC0...GPC3 as inputs */
372 /* allow signals to settle */
373 for (i=0; i<10000; i++) /* udelay isn't working yet at this point! */
375 vfd_board_id = (~gpio->PCDAT) & 0x000F; /* read GPC0...GPC3 port pins */
377 VFD_DISABLE; /* activate blank for the vfd */
383 /* If new board revision, then use PWM 3 as cpld-clock */
384 /* Enable 500 Hz timer for fill level sensor to operate properly */
385 /* Configure TOUT3 as functional pin, disable pull-up */
386 gpio->PDCON &= ~0x30000;
387 gpio->PDCON |= 0x20000;
388 gpio->PDUP |= (1 << 8);
390 /* Configure the prescaler */
391 timers->TCFG0 &= ~0xff00;
392 timers->TCFG0 |= 0x0f00;
394 /* Select MUX input (divider) for timer3 (1/16) */
395 timers->TCFG1 &= ~0xf000;
396 timers->TCFG1 |= 0x3000;
398 /* Enable autoreload and set the counter and compare
399 * registers to values for the 500 Hz clock
400 * (for a given prescaler (15) and divider (16)):
401 * counter = (66000000 / 500) >> 9;
403 timers->ch[3].TCNTB = 0x101;
404 timers->ch[3].TCMPB = 0x101 / 2;
407 timers->TCON = (timers->TCON | UPDATE3 | RELOAD3) & ~INVERT3;
408 timers->TCON = (timers->TCON | START3) & ~UPDATE3;
411 /* If old board revision, then use vm-signal as cpld-clock */
412 lcd->LCDCON2 = 0x00FFC000;
413 lcd->LCDCON3 = 0x0007FF00;
414 lcd->LCDCON4 = 0x00000000;
415 lcd->LCDCON5 = 0x00000400;
416 lcd->LCDCON1 = 0x00000B75;
417 /* VM (GPD1) is used as clock for the CPLD */
418 gpio->PDCON = (gpio->PDCON & 0xFFFFFFF3) | 0x00000008;
424 * initialize LCD-Controller of the S3C2400 for using VFDs
426 * VFD detection depends on the board revision:
427 * starting from Rev. 200 a type code can be read from the data pins,
428 * driven by some pull-up resistors; all earlier systems must be
429 * manually configured. The type is set in the "vfd_type" environment
432 int drv_vfd_init(void)
434 S3C24X0_LCD * const lcd = S3C24X0_GetBase_LCD();
435 S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
438 static int vfd_init_done = 0;
439 int vfd_inv_data = 0;
441 if (vfd_init_done != 0)
445 debug("Detecting Revison of WA4-VFD: ID=0x%X\n", vfd_board_id);
447 switch (vfd_board_id) {
448 case 0: /* board revision < Rev.200 */
449 if ((tmp = getenv ("vfd_type")) == NULL) {
452 if (strcmp(tmp, "T119C") == 0) {
453 gd->vfd_type = VFD_TYPE_T119C;
454 } else if (strcmp(tmp, "MN11236") == 0) {
455 gd->vfd_type = VFD_TYPE_MN11236;
457 /* cannot use printf for a warning here */
458 gd->vfd_type = 0; /* unknown */
462 default: /* default to MN11236, data inverted */
463 gd->vfd_type = VFD_TYPE_MN11236;
465 setenv ("vfd_type", "MN11236");
467 debug ("VFD type: %s%s\n",
468 (gd->vfd_type == VFD_TYPE_T119C) ? "T119C" :
469 (gd->vfd_type == VFD_TYPE_MN11236) ? "MN11236" :
471 vfd_inv_data ? ", inverted data" : "");
473 gd->fb_base = gd->fb_base;
477 for (palette=0; palette < 16; palette++)
478 (*(volatile unsigned int*)(PALETTE+(palette*4)))=palette;
479 for (palette=16; palette < 256; palette++)
480 (*(volatile unsigned int*)(PALETTE+(palette*4)))=0x00;
483 * Hinweis: Der Framebuffer ist um genau ein Nibble verschoben
484 * Das erste angezeigte Pixel wird aus dem zweiten Nibble geholt
485 * das letzte angezeigte Pixel wird aus dem ersten Nibble geholt
489 /* Stopp LCD-Controller */
490 lcd->LCDCON1 = 0x00000000;
491 /* frame buffer startadr */
492 lcd->LCDSADDR1 = gd->fb_base >> 1;
493 /* frame buffer endadr */
494 lcd->LCDSADDR2 = (gd->fb_base + FRAME_BUF_SIZE) >> 1;
495 lcd->LCDSADDR3 = ((256/4));
496 lcd->LCDCON2 = 0x000DC000;
497 if(gd->vfd_type == VFD_TYPE_MN11236)
498 lcd->LCDCON2 = 37 << 14; /* MN11236: 38 lines */
500 lcd->LCDCON2 = 55 << 14; /* T119C: 56 lines */
501 lcd->LCDCON3 = 0x0051000A;
502 lcd->LCDCON4 = 0x00000001;
503 if (gd->vfd_type && vfd_inv_data)
504 lcd->LCDCON5 = 0x000004C0;
506 lcd->LCDCON5 = 0x00000440;
508 /* Port pins as LCD output */
509 gpio->PCCON = (gpio->PCCON & 0xFFFFFF00)| 0x000000AA;
510 gpio->PDCON = (gpio->PDCON & 0xFFFFFF03)| 0x000000A8;
512 /* Synchronize VFD enable with LCD controller to avoid flicker */
513 lcd->LCDCON1 = 0x00000B75; /* Start LCD-Controller */
514 while((lcd->LCDCON5 & 0x180000)!=0x100000); /* Wait for end of VSYNC */
515 while((lcd->LCDCON5 & 0x060000)!=0x040000); /* Wait for next HSYNC */
516 while((lcd->LCDCON5 & 0x060000)==0x040000);
517 while((lcd->LCDCON5 & 0x060000)!=0x000000);
521 debug ("LCDSADDR1: %lX\n", lcd->LCDSADDR1);
522 debug ("LCDSADDR2: %lX\n", lcd->LCDSADDR2);
523 debug ("LCDSADDR3: %lX\n", lcd->LCDSADDR3);
529 * Disable VFD: should be run before resetting the system:
530 * disable VM, enable pull-up
532 void disable_vfd (void)
534 S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
541 /************************************************************************/
542 /* ** ROM capable initialization part - needed to reserve FB memory */
543 /************************************************************************/
546 * This is called early in the system initialization to grab memory
547 * for the VFD controller.
549 * Note that this is running from ROM, so no write access to global data.
551 ulong vfd_setmem (ulong addr)
555 /* Round up to nearest full page */
556 size = (FRAME_BUF_SIZE + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
558 debug ("Reserving %ldk for VFD Framebuffer at: %08lx\n", size>>10, addr);
564 * Calculate fb size for VIDEOLFB_ATAG. Size returned contains fb,
565 * descriptors and palette areas.
567 ulong calc_fbsize (void)
569 return FRAME_BUF_SIZE;
572 #endif /* CONFIG_VFD */