git.sur5r.net Git - u-boot/blob - drivers/video/bus_vcxk.c

   1 /*
   2  * (C) Copyright 2005-2009
   3  * Jens Scharsig @ BuS Elektronik GmbH & Co. KG, <esw@bus-elektronik.de>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <bmp_layout.h>
  10 #include <asm/io.h>
  11
  12 vu_char  *vcxk_bws      = ((vu_char *) (CONFIG_SYS_VCXK_BASE));
  13 vu_short *vcxk_bws_word = ((vu_short *)(CONFIG_SYS_VCXK_BASE));
  14 vu_long  *vcxk_bws_long = ((vu_long *) (CONFIG_SYS_VCXK_BASE));
  15
  16 #ifdef CONFIG_AT91RM9200
  17         #include <asm/arch/hardware.h>
  18         #include <asm/arch/at91_pio.h>
  19
  20         #ifndef VCBITMASK
  21                 #define VCBITMASK(bitno)        (0x0001 << (bitno % 16))
  22         #endif
  23 at91_pio_t *pio = (at91_pio_t *) AT91_PIO_BASE;
  24 #define VCXK_INIT_PIN(PORT, PIN, DDR, I0O1) \
  25         do { \
  26                 writel(PIN, &pio->PORT.per); \
  27                 writel(PIN, &pio->PORT.DDR); \
  28                 writel(PIN, &pio->PORT.mddr); \
  29                 if (!I0O1) \
  30                         writel(PIN, &pio->PORT.puer); \
  31         } while (0);
  32
  33 #define VCXK_SET_PIN(PORT, PIN) writel(PIN, &pio->PORT.sodr);
  34 #define VCXK_CLR_PIN(PORT, PIN) writel(PIN, &pio->PORT.codr);
  35
  36 #define VCXK_ACKNOWLEDGE        \
  37         (!(readl(&pio->CONFIG_SYS_VCXK_ACKNOWLEDGE_PORT.pdsr) & \
  38                         CONFIG_SYS_VCXK_ACKNOWLEDGE_PIN))
  39 #elif defined(CONFIG_MCF52x2)
  40         #include <asm/m5282.h>
  41         #ifndef VCBITMASK
  42                 #define VCBITMASK(bitno) (0x8000 >> (bitno % 16))
  43         #endif
  44
  45         #define VCXK_INIT_PIN(PORT, PIN, DDR, I0O1) \
  46                 if (I0O1) DDR |= PIN; else DDR &= ~PIN;
  47
  48         #define VCXK_SET_PIN(PORT, PIN) PORT |= PIN;
  49         #define VCXK_CLR_PIN(PORT, PIN) PORT &= ~PIN;
  50
  51         #define VCXK_ACKNOWLEDGE \
  52                 (!(CONFIG_SYS_VCXK_ACKNOWLEDGE_PORT &   \
  53                         CONFIG_SYS_VCXK_ACKNOWLEDGE_PIN))
  54
  55 #else
  56         #error no vcxk support for selected ARCH
  57 #endif
  58
  59 #define VCXK_DISABLE\
  60         VCXK_SET_PIN(CONFIG_SYS_VCXK_ENABLE_PORT, CONFIG_SYS_VCXK_ENABLE_PIN)
  61 #define VCXK_ENABLE\
  62         VCXK_CLR_PIN(CONFIG_SYS_VCXK_ENABLE_PORT, CONFIG_SYS_VCXK_ENABLE_PIN)
  63
  64 #ifndef CONFIG_SYS_VCXK_DOUBLEBUFFERED
  65         #define VCXK_BWS(x, data)               vcxk_bws[x] = data;
  66         #define VCXK_BWS_WORD_SET(x, mask)      vcxk_bws_word[x] |= mask;
  67         #define VCXK_BWS_WORD_CLEAR(x, mask)    vcxk_bws_word[x] &= ~mask;
  68         #define VCXK_BWS_LONG(x, data)          vcxk_bws_long[x] = data;
  69 #else
  70         u_char double_bws[16384];
  71         u_short *double_bws_word;
  72         u_long  *double_bws_long;
  73         #define VCXK_BWS(x,data)        \
  74                 double_bws[x] = data; vcxk_bws[x] = data;
  75         #define VCXK_BWS_WORD_SET(x,mask)       \
  76                 double_bws_word[x] |= mask;     \
  77                 vcxk_bws_word[x] = double_bws_word[x];
  78         #define VCXK_BWS_WORD_CLEAR(x,mask)     \
  79                 double_bws_word[x] &= ~mask;    \
  80                 vcxk_bws_word[x] = double_bws_word[x];
  81         #define VCXK_BWS_LONG(x,data) \
  82                 double_bws_long[x] = data; vcxk_bws_long[x] = data;
  83 #endif
  84
  85 #define VC4K16_Bright1  vcxk_bws_word[0x20004 / 2]
  86 #define VC4K16_Bright2  vcxk_bws_word[0x20006 / 2]
  87 #define VC2K_Bright     vcxk_bws[0x8000]
  88 #define VC8K_BrightH    vcxk_bws[0xC000]
  89 #define VC8K_BrightL    vcxk_bws[0xC001]
  90
  91 vu_char VC4K16;
  92
  93 u_long display_width;
  94 u_long display_height;
  95 u_long display_bwidth;
  96
  97 ulong search_vcxk_driver(void);
  98 void vcxk_cls(void);
  99 void vcxk_setbrightness(unsigned int side, short brightness);
 100 int vcxk_request(void);
 101 int vcxk_acknowledge_wait(void);
 102 void vcxk_clear(void);
 103
 104 /*
 105  ****f* bus_vcxk/vcxk_init
 106  * FUNCTION
 107  * initialalize Video Controller
 108  * PARAMETERS
 109  * width        visible display width in pixel
 110  * height       visible display height  in pixel
 111  ***
 112  */
 113
 114 int vcxk_init(unsigned long width, unsigned long height)
 115 {
 116 #ifdef CONFIG_SYS_VCXK_RESET_PORT
 117         VCXK_INIT_PIN(CONFIG_SYS_VCXK_RESET_PORT,
 118                 CONFIG_SYS_VCXK_RESET_PIN, CONFIG_SYS_VCXK_RESET_DDR, 1)
 119         VCXK_SET_PIN(CONFIG_SYS_VCXK_RESET_PORT, CONFIG_SYS_VCXK_RESET_PIN);
 120 #endif
 121
 122 #ifdef CONFIG_SYS_VCXK_DOUBLEBUFFERED
 123         double_bws_word  = (u_short *)double_bws;
 124         double_bws_long  = (u_long *)double_bws;
 125         debug("%px %px %px\n", double_bws, double_bws_word, double_bws_long);
 126 #endif
 127         display_width  = width;
 128         display_height = height;
 129 #if (CONFIG_SYS_VCXK_DEFAULT_LINEALIGN == 4)
 130         display_bwidth = ((width + 31) / 8) & ~0x3;
 131 #elif (CONFIG_SYS_VCXK_DEFAULT_LINEALIGN == 2)
 132         display_bwidth = ((width + 15) / 8) & ~0x1;
 133 #else
 134         #error CONFIG_SYS_VCXK_DEFAULT_LINEALIGN is invalid
 135 #endif
 136         debug("linesize ((%ld + 15) / 8 & ~0x1) = %ld\n",
 137                 display_width, display_bwidth);
 138
 139 #ifdef CONFIG_SYS_VCXK_AUTODETECT
 140         VC4K16 = 0;
 141         vcxk_bws_long[1] = 0x0;
 142         vcxk_bws_long[1] = 0x55AAAA55;
 143         vcxk_bws_long[5] = 0x0;
 144         if (vcxk_bws_long[1] == 0x55AAAA55)
 145                 VC4K16 = 1;
 146 #else
 147         VC4K16 = 1;
 148         debug("No autodetect: use vc4k\n");
 149 #endif
 150
 151         VCXK_INIT_PIN(CONFIG_SYS_VCXK_INVERT_PORT,
 152                 CONFIG_SYS_VCXK_INVERT_PIN, CONFIG_SYS_VCXK_INVERT_DDR, 1)
 153         VCXK_SET_PIN(CONFIG_SYS_VCXK_INVERT_PORT, CONFIG_SYS_VCXK_INVERT_PIN)
 154
 155         VCXK_SET_PIN(CONFIG_SYS_VCXK_REQUEST_PORT, CONFIG_SYS_VCXK_REQUEST_PIN);
 156         VCXK_INIT_PIN(CONFIG_SYS_VCXK_REQUEST_PORT,
 157                 CONFIG_SYS_VCXK_REQUEST_PIN, CONFIG_SYS_VCXK_REQUEST_DDR, 1)
 158
 159         VCXK_INIT_PIN(CONFIG_SYS_VCXK_ACKNOWLEDGE_PORT,
 160                 CONFIG_SYS_VCXK_ACKNOWLEDGE_PIN,
 161                 CONFIG_SYS_VCXK_ACKNOWLEDGE_DDR, 0)
 162
 163         VCXK_DISABLE;
 164         VCXK_INIT_PIN(CONFIG_SYS_VCXK_ENABLE_PORT,
 165                 CONFIG_SYS_VCXK_ENABLE_PIN, CONFIG_SYS_VCXK_ENABLE_DDR, 1)
 166
 167         vcxk_cls();
 168         vcxk_cls();     /* clear second/hidden page */
 169
 170         vcxk_setbrightness(3, 1000);
 171         VCXK_ENABLE;
 172         return 1;
 173 }
 174
 175 /*
 176  ****f* bus_vcxk/vcxk_setpixel
 177  * FUNCTION
 178  * set the pixel[x,y] with the given color
 179  * PARAMETER
 180  * x            pixel colum
 181  * y            pixel row
 182  * color        <0x40 off/black
 183  *                      >0x40 on
 184  ***
 185  */
 186
 187 void vcxk_setpixel(int x, int y, unsigned long color)
 188 {
 189         vu_short dataptr;
 190
 191         if ((x < display_width) && (y < display_height)) {
 192                 dataptr = ((x / 16)) + (y * (display_bwidth >> 1));
 193
 194                 color = ((color >> 16) & 0xFF) |
 195                             ((color >> 8) & 0xFF) | (color & 0xFF);
 196
 197                 if (color > 0x40) {
 198                         VCXK_BWS_WORD_SET(dataptr, VCBITMASK(x));
 199                 } else {
 200                         VCXK_BWS_WORD_CLEAR(dataptr, VCBITMASK(x));
 201                 }
 202         }
 203 }
 204
 205 /*
 206  ****f* bus_vcxk/vcxk_loadimage
 207  * FUNCTION
 208  * copies a binary image to display memory
 209  ***
 210  */
 211
 212 void vcxk_loadimage(ulong source)
 213 {
 214         int cnt;
 215         vcxk_acknowledge_wait();
 216         if (VC4K16) {
 217                 for (cnt = 0; cnt < (16384 / 4); cnt++) {
 218                         VCXK_BWS_LONG(cnt, (*(ulong *) source));
 219                         source = source + 4;
 220                 }
 221         } else {
 222                 for (cnt = 0; cnt < 16384; cnt++) {
 223                         VCXK_BWS_LONG(cnt*2, (*(vu_char *) source));
 224                         source++;
 225                 }
 226         }
 227         vcxk_request();
 228 }
 229
 230 /*
 231  ****f* bus_vcxk/vcxk_cls
 232  * FUNCTION
 233  * clear the display
 234  ***
 235  */
 236
 237 void vcxk_cls(void)
 238 {
 239         vcxk_acknowledge_wait();
 240         vcxk_clear();
 241         vcxk_request();
 242 }
 243
 244 /*
 245  ****f* bus_vcxk/vcxk_clear(void)
 246  * FUNCTION
 247  * clear the display memory
 248  ***
 249  */
 250
 251 void vcxk_clear(void)
 252 {
 253         int cnt;
 254
 255         for (cnt = 0; cnt < (16384 / 4); cnt++) {
 256                 VCXK_BWS_LONG(cnt, 0)
 257         }
 258 }
 259
 260 /*
 261  ****f* bus_vcxk/vcxk_setbrightness
 262  * FUNCTION
 263  * set the display brightness
 264  * PARAMETER
 265  * side 1       set front side brightness
 266  *              2       set back  side brightness
 267  *              3       set brightness for both sides
 268  * brightness 0..1000
 269  ***
 270  */
 271
 272 void vcxk_setbrightness(unsigned int side, short brightness)
 273 {
 274         if (VC4K16) {
 275                 if ((side == 0) || (side & 0x1))
 276                         VC4K16_Bright1 = brightness + 23;
 277                 if ((side == 0) || (side & 0x2))
 278                         VC4K16_Bright2 = brightness + 23;
 279         } else  {
 280                 VC2K_Bright = (brightness >> 4) + 2;
 281                 VC8K_BrightH = (brightness + 23) >> 8;
 282                 VC8K_BrightL = (brightness + 23) & 0xFF;
 283         }
 284 }
 285
 286 /*
 287  ****f* bus_vcxk/vcxk_request
 288  * FUNCTION
 289  * requests viewing of display memory
 290  ***
 291  */
 292
 293 int vcxk_request(void)
 294 {
 295         VCXK_CLR_PIN(CONFIG_SYS_VCXK_REQUEST_PORT,
 296                 CONFIG_SYS_VCXK_REQUEST_PIN)
 297         VCXK_SET_PIN(CONFIG_SYS_VCXK_REQUEST_PORT,
 298                 CONFIG_SYS_VCXK_REQUEST_PIN);
 299         return 1;
 300 }
 301
 302 /*
 303  ****f* bus_vcxk/vcxk_acknowledge_wait
 304  * FUNCTION
 305  * wait for acknowledge viewing requests
 306  ***
 307  */
 308
 309 int vcxk_acknowledge_wait(void)
 310 {
 311         while (VCXK_ACKNOWLEDGE)
 312                 ;
 313         return 1;
 314 }
 315
 316 /*
 317  ****f* bus_vcxk/vcxk_draw_mono
 318  * FUNCTION
 319  * copies a monochrom bitmap (BMP-Format) from given memory
 320  * PARAMETER
 321  * dataptr      pointer to bitmap
 322  * x            output bitmap @ columne
 323  * y            output bitmap @ row
 324  ***
 325  */
 326
 327 void vcxk_draw_mono(unsigned char *dataptr, unsigned long linewidth,
 328         unsigned long  cp_width, unsigned long cp_height)
 329 {
 330         unsigned char *lineptr;
 331         unsigned long xcnt, ycnt;
 332
 333         for (ycnt = cp_height; ycnt > 0; ycnt--) {
 334                 lineptr = dataptr;
 335                 for (xcnt = 0; xcnt < cp_width; xcnt++) {
 336                         if ((*lineptr << (xcnt % 8)) & 0x80)
 337                                 vcxk_setpixel(xcnt, ycnt - 1, 0xFFFFFF);
 338                         else
 339                                 vcxk_setpixel(xcnt, ycnt-1, 0);
 340
 341                         if ((xcnt % 8) == 7)
 342                                 lineptr++;
 343                 } /* endfor xcnt */
 344                 dataptr = dataptr + linewidth;
 345         } /* endfor ycnt */
 346 }
 347
 348 /*
 349  ****f* bus_vcxk/vcxk_display_bitmap
 350  * FUNCTION
 351  * copies a bitmap (BMP-Format) to the given position
 352  * PARAMETER
 353  * addr         pointer to bitmap
 354  * x            output bitmap @ columne
 355  * y            output bitmap @ row
 356  ***
 357  */
 358
 359 int vcxk_display_bitmap(ulong addr, int x, int y)
 360 {
 361         struct bmp_image *bmp;
 362         unsigned long width;
 363         unsigned long height;
 364         unsigned long bpp;
 365
 366         unsigned long lw;
 367
 368         unsigned long c_width;
 369         unsigned long c_height;
 370         unsigned char *dataptr;
 371
 372         bmp = (struct bmp_image *)addr;
 373         if ((bmp->header.signature[0] == 'B') &&
 374             (bmp->header.signature[1] == 'M')) {
 375                 width        = le32_to_cpu(bmp->header.width);
 376                 height       = le32_to_cpu(bmp->header.height);
 377                 bpp          = le16_to_cpu(bmp->header.bit_count);
 378
 379                 dataptr = (unsigned char *) bmp +
 380                                 le32_to_cpu(bmp->header.data_offset);
 381
 382                 if (display_width < (width + x))
 383                         c_width = display_width - x;
 384                 else
 385                         c_width = width;
 386                 if (display_height < (height + y))
 387                         c_height = display_height - y;
 388                 else
 389                         c_height = height;
 390
 391                 lw = (((width + 7) / 8) + 3) & ~0x3;
 392
 393                 if (c_height < height)
 394                         dataptr = dataptr + lw * (height - c_height);
 395                 switch (bpp) {
 396                 case 1:
 397                         vcxk_draw_mono(dataptr, lw, c_width, c_height);
 398                         break;
 399                 default:
 400                         printf("Error: %ld bit per pixel "
 401                                 "not supported by VCxK\n", bpp);
 402                         return 0;
 403                 }
 404         } else  {
 405                 printf("Error: no valid bmp at %lx\n", (ulong) bmp);
 406                 return 0;
 407         }
 408         return 1;
 409 }
 410
 411 /*
 412  ****f* bus_vcxk/video_display_bitmap
 413  ***
 414  */
 415
 416 int video_display_bitmap(ulong addr, int x, int y)
 417 {
 418         vcxk_acknowledge_wait();
 419         if (vcxk_display_bitmap(addr, x, y)) {
 420                 vcxk_request();
 421                 return 0;
 422         }
 423         return 1;
 424 }
 425
 426 /* EOF */