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 */