Merge branch 'mpc86xx'
[platform/kernel/u-boot.git] / board / trab / vfd.c
1 /*
2  * (C) Copyright 2001
3  * Wolfgang Denk, DENX Software Engineering -- wd@denx.de
4  *
5  * See file CREDITS for list of people who contributed to this
6  * project.
7  *
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.
12  *
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.
17  *
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,
21  * MA 02111-1307 USA
22  */
23
24 /************************************************************************/
25 /* ** DEBUG SETTINGS                                                    */
26 /************************************************************************/
27
28 /* #define DEBUG        */
29
30 /************************************************************************/
31 /* ** HEADER FILES                                                      */
32 /************************************************************************/
33
34 #include <config.h>
35 #include <common.h>
36 #include <version.h>
37 #include <stdarg.h>
38 #include <linux/types.h>
39 #include <devices.h>
40 #include <s3c2400.h>
41
42 DECLARE_GLOBAL_DATA_PTR;
43
44 #ifdef CONFIG_VFD
45
46 /************************************************************************/
47 /* ** CONFIG STUFF -- should be moved to board config file              */
48 /************************************************************************/
49
50 /************************************************************************/
51
52 #ifndef PAGE_SIZE
53 #define PAGE_SIZE       4096
54 #endif
55
56 #define ROT     0x09
57 #define BLAU    0x0C
58 #define VIOLETT 0X0D
59
60 /* MAGIC */
61 #define FRAME_BUF_SIZE  ((256*4*56)/8)
62 #define frame_buf_offs 4
63
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)
69
70 /* CPLD-Register for controlling vfd-blank-signal */
71 #define VFD_DISABLE     (*(volatile uchar *)0x04038000=0x0000)
72 #define VFD_ENABLE      (*(volatile uchar *)0x04038000=0x0001)
73
74 /* Supported VFD Types */
75 #define VFD_TYPE_T119C          1       /* Noritake T119C VFD */
76 #define VFD_TYPE_MN11236        2
77
78 /*#define NEW_CPLD_CLK*/
79
80 int vfd_board_id;
81
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];
85
86 /*
87  * initialize the values for the VFD-grid-control in the framebuffer
88  */
89 void init_grid_ctrl(void)
90 {
91         ulong adr, grid_cycle;
92         unsigned int bit, display;
93         unsigned char temp, bit_nr;
94
95         /*
96          * clear frame buffer (logical clear => set to "black")
97          */
98         memset ((void *)(gd->fb_base), 0, FRAME_BUF_SIZE);
99
100         switch (gd->vfd_type) {
101         case VFD_TYPE_T119C:
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);
111                         bit_nr = bit % 8;
112                         bit_nr = (bit_nr > 3) ? bit_nr-4 : bit_nr+4;
113                         temp=(*(volatile unsigned char*)(adr));
114                         temp |=  (1<<bit_nr);
115                         (*(volatile unsigned char*)(adr))=temp;
116
117                         if(grid_cycle<55)
118                                 bit = grid_cycle*256*4+(grid_cycle+201)*4+frame_buf_offs+display;
119                         else
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);
125                         bit_nr = bit%8;
126                         bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
127                         temp=(*(volatile unsigned char*)(adr));
128                         temp |=  (1<<bit_nr);
129                         (*(volatile unsigned char*)(adr))=temp;
130                 }
131             }
132             break;
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);
143                         bit_nr = bit % 8;
144                         bit_nr = (bit_nr > 3) ? bit_nr-4 : bit_nr+4;
145                         temp=(*(volatile unsigned char*)(adr));
146                         temp |=  (1<<bit_nr);
147                         (*(volatile unsigned char*)(adr))=temp;
148
149                         if(grid_cycle<37)
150                                 bit = grid_cycle*256*4+(252-grid_cycle)*4+frame_buf_offs+display;
151
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);
156                         bit_nr = bit%8;
157                         bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
158                         temp=(*(volatile unsigned char*)(adr));
159                         temp |=  (1<<bit_nr);
160                         (*(volatile unsigned char*)(adr))=temp;
161                 }
162             }
163             break;
164         default:
165             printf ("Warning: unknown display type\n");
166             break;
167         }
168 }
169
170 /*
171  *create translation table for getting easy the right position in the
172  *physical framebuffer for some x/y-coordinates of the VFDs
173  */
174 void create_vfd_table(void)
175 {
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;
179
180         switch (gd->vfd_type) {
181         case VFD_TYPE_T119C:
182             for(y=0; y<=17; y++) {      /* Line */
183                 for(x=0; x<=111; x++) { /* Column */
184                     for(display=0; display <=3; display++) {
185
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;
194                     }
195                 }
196             }
197             break;
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++) {
202
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;
207
208                             switch (x%6) {
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 */
215                             }
216
217                             /* blue pixels */
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;
221                             /* blue pixels */
222                             if (x>1 && (x-1)%3)
223                                     vfd_table[x][y][0][display][1] = x_abcdef*4+((x-1)/3+1)*1024+y*48+display;
224
225                             /* red pixels */
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;
229                             /* red pixels */
230                             if (x>1 && (x-1)%3)
231                                     vfd_table[x][y][1][display][1] = x_abcdef*4+24+((x-1)/3+1)*1024+y*48+display;
232                     }
233                 }
234             }
235             break;
236         default:
237             /* do nothing */
238             return;
239         }
240
241         /*
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
245          */
246         for(y=0;y<18;y++) {
247             for(x=0;x<112;x++) {
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;
253
254                             pixel  = vfd_table[x][y][color][display][entry] + frame_buf_offs;
255                             /*
256                              * wrap arround if offset
257                              * (see manual S3C2400)
258                              */
259                             if (pixel>=FRAME_BUF_SIZE*8)
260                                     pixel = pixel-(FRAME_BUF_SIZE*8);
261                             adr    = gd->fb_base+(pixel/32)*4+(3-(pixel%32)/8);
262                             bit_nr = pixel%8;
263                             bit_nr = (bit_nr>3)?bit_nr-4:bit_nr+4;
264
265                             adr_vfd_table[x][y][color][display][entry] = adr;
266                             bit_vfd_table[x][y][color][display][entry] = bit_nr;
267                         }
268                     }
269                 }
270             }
271         }
272 }
273
274 /*
275  * Set/clear pixel of the VFDs
276  */
277 void set_vfd_pixel(unsigned char x, unsigned char y,
278                    unsigned char color, unsigned char display,
279                    unsigned char value)
280 {
281         ulong adr;
282         unsigned char bit_nr, temp;
283
284         if (! gd->vfd_type) {
285                 /* Unknown type. */
286                 return;
287         }
288
289         /* Pixel-Eintrag Nr. 1 */
290         adr = adr_vfd_table[x][y][color][display][0];
291         /* Pixel-Eintrag Nr. 1 */
292         bit_nr = bit_vfd_table[x][y][color][display][0];
293         temp=(*(volatile unsigned char*)(adr));
294
295         if (value)
296                 temp |=  (1<<bit_nr);
297         else
298                 temp &= ~(1<<bit_nr);
299
300         (*(volatile unsigned char*)(adr))=temp;
301 }
302
303 /*
304  * transfer image from BMP-File
305  */
306 void transfer_pic(int display, unsigned char *adr, int height, int width)
307 {
308         int x, y;
309         unsigned char temp;
310
311         for (; height > 0; height -= 18)
312         {
313                 if (height > 18)
314                         y = 18;
315                 else
316                         y = height;
317                 for (; y > 0; y--)
318                 {
319                         for (x = 0; x < width; x += 2)
320                         {
321                                 temp = *adr++;
322                                 set_vfd_pixel(x, y-1, 0, display, 0);
323                                 set_vfd_pixel(x, y-1, 1, display, 0);
324                                 if ((temp >> 4) == BLAU)
325                                         set_vfd_pixel(x, y-1, 0, display, 1);
326                                 else if ((temp >> 4) == ROT)
327                                         set_vfd_pixel(x, y-1, 1, display, 1);
328                                 else if ((temp >> 4) == VIOLETT)
329                                 {
330                                         set_vfd_pixel(x, y-1, 0, display, 1);
331                                         set_vfd_pixel(x, y-1, 1, display, 1);
332                                 }
333                                 set_vfd_pixel(x+1, y-1, 0, display, 0);
334                                 set_vfd_pixel(x+1, y-1, 1, display, 0);
335                                 if ((temp & 0x0F) == BLAU)
336                                         set_vfd_pixel(x+1, y-1, 0, display, 1);
337                                 else if ((temp & 0x0F) == ROT)
338                                         set_vfd_pixel(x+1, y-1, 1, display, 1);
339                                 else if ((temp & 0x0F) == VIOLETT)
340                                 {
341                                         set_vfd_pixel(x+1, y-1, 0, display, 1);
342                                         set_vfd_pixel(x+1, y-1, 1, display, 1);
343                                 }
344                         }
345                 }
346                 if (display > 0)
347                         display--;
348                 else
349                         display = 3;
350         }
351 }
352
353 /*
354  * This function initializes VFD clock that is needed for the CPLD that
355  * manages the keyboard.
356  */
357 int vfd_init_clocks (void)
358 {
359         int i;
360
361         S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
362         S3C24X0_TIMERS * const timers = S3C24X0_GetBase_TIMERS();
363         S3C24X0_LCD * const lcd = S3C24X0_GetBase_LCD();
364
365         /* try to determine display type from the value
366          * defined by pull-ups
367          */
368         gpio->PCUP = (gpio->PCUP & 0xFFF0);     /* activate  GPC0...GPC3 pullups */
369         gpio->PCCON = (gpio->PCCON & 0xFFFFFF00);       /* configure GPC0...GPC3 as inputs */
370         /* allow signals to settle */
371         for (i=0; i<10000; i++) /* udelay isn't working yet at this point! */
372                 __asm("NOP");
373         vfd_board_id = (~gpio->PCDAT) & 0x000F; /* read GPC0...GPC3 port pins */
374
375         VFD_DISABLE;                            /* activate blank for the vfd */
376
377 #define NEW_CPLD_CLK
378
379 #ifdef NEW_CPLD_CLK
380         if (vfd_board_id) {
381                 /* If new board revision, then use PWM 3 as cpld-clock */
382                 /* Enable 500 Hz timer for fill level sensor to operate properly */
383                 /* Configure TOUT3 as functional pin, disable pull-up */
384                 gpio->PDCON &= ~0x30000;
385                 gpio->PDCON |= 0x20000;
386                 gpio->PDUP |= (1 << 8);
387
388                 /* Configure the prescaler */
389                 timers->TCFG0 &= ~0xff00;
390                 timers->TCFG0 |= 0x0f00;
391
392                 /* Select MUX input (divider) for timer3 (1/16) */
393                 timers->TCFG1 &= ~0xf000;
394                 timers->TCFG1 |= 0x3000;
395
396                 /* Enable autoreload and set the counter and compare
397                  * registers to values for the 500 Hz clock
398                  * (for a given  prescaler (15) and divider (16)):
399                  * counter = (66000000 / 500) >> 9;
400                  */
401                 timers->ch[3].TCNTB = 0x101;
402                 timers->ch[3].TCMPB = 0x101 / 2;
403
404                 /* Start timer */
405                 timers->TCON = (timers->TCON | UPDATE3 | RELOAD3) & ~INVERT3;
406                 timers->TCON = (timers->TCON | START3) & ~UPDATE3;
407         }
408 #endif
409         /* If old board revision, then use vm-signal as cpld-clock */
410         lcd->LCDCON2 = 0x00FFC000;
411         lcd->LCDCON3 = 0x0007FF00;
412         lcd->LCDCON4 = 0x00000000;
413         lcd->LCDCON5 = 0x00000400;
414         lcd->LCDCON1 = 0x00000B75;
415         /* VM (GPD1) is used as clock for the CPLD */
416         gpio->PDCON = (gpio->PDCON & 0xFFFFFFF3) | 0x00000008;
417
418         return 0;
419 }
420
421 /*
422  * initialize LCD-Controller of the S3C2400 for using VFDs
423  *
424  * VFD detection depends on the board revision:
425  * starting from Rev. 200 a type code can be read from the data pins,
426  * driven by some pull-up resistors; all earlier systems must be
427  * manually configured. The type is set in the "vfd_type" environment
428  * variable.
429  */
430 int drv_vfd_init(void)
431 {
432         S3C24X0_LCD * const lcd = S3C24X0_GetBase_LCD();
433         S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
434         char *tmp;
435         ulong palette;
436         static int vfd_init_done = 0;
437         int vfd_inv_data = 0;
438
439         if (vfd_init_done != 0)
440                 return (0);
441         vfd_init_done = 1;
442
443         debug("Detecting Revison of WA4-VFD: ID=0x%X\n", vfd_board_id);
444
445         switch (vfd_board_id) {
446         case 0:                 /* board revision < Rev.200 */
447                 if ((tmp = getenv ("vfd_type")) == NULL) {
448                         break;
449                 }
450                 if (strcmp(tmp, "T119C") == 0) {
451                         gd->vfd_type = VFD_TYPE_T119C;
452                 } else if (strcmp(tmp, "MN11236") == 0) {
453                         gd->vfd_type = VFD_TYPE_MN11236;
454                 } else {
455                         /* cannot use printf for a warning here */
456                         gd->vfd_type = 0;       /* unknown */
457                 }
458
459                 break;
460         default:                /* default to MN11236, data inverted */
461                 gd->vfd_type = VFD_TYPE_MN11236;
462                 vfd_inv_data = 1;
463                 setenv ("vfd_type", "MN11236");
464         }
465         debug ("VFD type: %s%s\n",
466                 (gd->vfd_type == VFD_TYPE_T119C)   ? "T119C" :
467                 (gd->vfd_type == VFD_TYPE_MN11236) ? "MN11236" :
468                 "unknown",
469                 vfd_inv_data ? ", inverted data" : "");
470
471         gd->fb_base = gd->fb_base;
472         create_vfd_table();
473         init_grid_ctrl();
474
475         for (palette=0; palette < 16; palette++)
476                 (*(volatile unsigned int*)(PALETTE+(palette*4)))=palette;
477         for (palette=16; palette < 256; palette++)
478                 (*(volatile unsigned int*)(PALETTE+(palette*4)))=0x00;
479
480         /*
481          * Hinweis: Der Framebuffer ist um genau ein Nibble verschoben
482          * Das erste angezeigte Pixel wird aus dem zweiten Nibble geholt
483          * das letzte angezeigte Pixel wird aus dem ersten Nibble geholt
484          * (wrap around)
485          * see manual S3C2400
486          */
487         /* Stopp LCD-Controller */
488         lcd->LCDCON1 = 0x00000000;
489         /* frame buffer startadr */
490         lcd->LCDSADDR1 = gd->fb_base >> 1;
491         /* frame buffer endadr */
492         lcd->LCDSADDR2 = (gd->fb_base + FRAME_BUF_SIZE) >> 1;
493         lcd->LCDSADDR3 = ((256/4));
494         lcd->LCDCON2 = 0x000DC000;
495         if(gd->vfd_type == VFD_TYPE_MN11236)
496                 lcd->LCDCON2 = 37 << 14;        /* MN11236: 38 lines */
497         else
498                 lcd->LCDCON2 = 55 << 14;        /* T119C:   56 lines */
499         lcd->LCDCON3 = 0x0051000A;
500         lcd->LCDCON4 = 0x00000001;
501         if (gd->vfd_type && vfd_inv_data)
502                 lcd->LCDCON5 = 0x000004C0;
503         else
504                 lcd->LCDCON5 = 0x00000440;
505
506         /* Port pins as LCD output */
507         gpio->PCCON =   (gpio->PCCON & 0xFFFFFF00)| 0x000000AA;
508         gpio->PDCON =   (gpio->PDCON & 0xFFFFFF03)| 0x000000A8;
509
510         /* Synchronize VFD enable with LCD controller to avoid flicker  */
511         lcd->LCDCON1 = 0x00000B75;                      /* Start LCD-Controller */
512         while((lcd->LCDCON5 & 0x180000)!=0x100000);     /* Wait for end of VSYNC */
513         while((lcd->LCDCON5 & 0x060000)!=0x040000);     /* Wait for next HSYNC  */
514         while((lcd->LCDCON5 & 0x060000)==0x040000);
515         while((lcd->LCDCON5 & 0x060000)!=0x000000);
516         if(gd->vfd_type)
517                 VFD_ENABLE;
518
519         debug ("LCDSADDR1: %lX\n", lcd->LCDSADDR1);
520         debug ("LCDSADDR2: %lX\n", lcd->LCDSADDR2);
521         debug ("LCDSADDR3: %lX\n", lcd->LCDSADDR3);
522
523         return 0;
524 }
525
526 /*
527  * Disable VFD: should be run before resetting the system:
528  * disable VM, enable pull-up
529  */
530 void disable_vfd (void)
531 {
532         S3C24X0_GPIO * const gpio = S3C24X0_GetBase_GPIO();
533
534         VFD_DISABLE;
535         gpio->PDCON &= ~0xC;
536         gpio->PDUP  &= ~0x2;
537 }
538
539 /************************************************************************/
540 /* ** ROM capable initialization part - needed to reserve FB memory     */
541 /************************************************************************/
542
543 /*
544  * This is called early in the system initialization to grab memory
545  * for the VFD controller.
546  *
547  * Note that this is running from ROM, so no write access to global data.
548  */
549 ulong vfd_setmem (ulong addr)
550 {
551         ulong size;
552
553         /* Round up to nearest full page */
554         size = (FRAME_BUF_SIZE + (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
555
556         debug ("Reserving %ldk for VFD Framebuffer at: %08lx\n", size>>10, addr);
557
558         return (size);
559 }
560
561 /*
562  * Calculate fb size for VIDEOLFB_ATAG. Size returned contains fb,
563  * descriptors and palette areas.
564  */
565 ulong calc_fbsize (void)
566 {
567         return FRAME_BUF_SIZE;
568 }
569
570 #endif /* CONFIG_VFD */