board/freescale/p1022ds/diu.c

   1 /*
   2  * Copyright 2010 Freescale Semiconductor, Inc.
   3  * Authors: Timur Tabi <timur@freescale.com>
   4  *
   5  * FSL DIU Framebuffer driver
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License as published by the Free
   9  * Software Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  */
  12
  13 #include <common.h>
  14 #include <command.h>
  15 #include <asm/io.h>
  16 #include <stdio_dev.h>
  17 #include <video_fb.h>
  18 #include "../common/ngpixis.h"
  19 #include <fsl_diu_fb.h>
  20
  21 /* The CTL register is called 'csr' in the ngpixis_t structure */
  22 #define PX_CTL_ALTACC           0x80
  23
  24 #define PX_BRDCFG0_ELBC_SPI_MASK        0xc0
  25 #define PX_BRDCFG0_ELBC_SPI_ELBC        0x00
  26 #define PX_BRDCFG0_ELBC_SPI_NULL        0xc0
  27 #define PX_BRDCFG0_ELBC_DIU             0x02
  28
  29 #define PX_BRDCFG1_DVIEN        0x80
  30 #define PX_BRDCFG1_DFPEN        0x40
  31 #define PX_BRDCFG1_BACKLIGHT    0x20
  32
  33 #define PMUXCR_ELBCDIU_MASK     0xc0000000
  34 #define PMUXCR_ELBCDIU_NOR16    0x80000000
  35
  36 /*
  37  * DIU Area Descriptor
  38  *
  39  * Note that we need to byte-swap the value before it's written to the AD
  40  * register.  So even though the registers don't look like they're in the same
  41  * bit positions as they are on the MPC8610, the same value is written to the
  42  * AD register on the MPC8610 and on the P1022.
  43  */
  44 #define AD_BYTE_F               0x10000000
  45 #define AD_ALPHA_C_SHIFT        25
  46 #define AD_BLUE_C_SHIFT         23
  47 #define AD_GREEN_C_SHIFT        21
  48 #define AD_RED_C_SHIFT          19
  49 #define AD_PIXEL_S_SHIFT        16
  50 #define AD_COMP_3_SHIFT         12
  51 #define AD_COMP_2_SHIFT         8
  52 #define AD_COMP_1_SHIFT         4
  53 #define AD_COMP_0_SHIFT         0
  54
  55 /*
  56  * Variables used by the DIU/LBC switching code.  It's safe to makes these
  57  * global, because the DIU requires DDR, so we'll only run this code after
  58  * relocation.
  59  */
  60 static u8 px_brdcfg0;
  61 static u32 pmuxcr;
  62 static void *lbc_lcs0_ba;
  63 static void *lbc_lcs1_ba;
  64
  65 void diu_set_pixel_clock(unsigned int pixclock)
  66 {
  67         ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
  68         unsigned long speed_ccb, temp;
  69         u32 pixval;
  70
  71         speed_ccb = get_bus_freq(0);
  72         temp = 1000000000 / pixclock;
  73         temp *= 1000;
  74         pixval = speed_ccb / temp;
  75         debug("DIU pixval = %lu\n", pixval);
  76
  77         /* Modify PXCLK in GUTS CLKDVDR */
  78         temp = in_be32(&gur->clkdvdr) & 0x2000FFFF;
  79         out_be32(&gur->clkdvdr, temp);                  /* turn off clock */
  80         out_be32(&gur->clkdvdr, temp | 0x80000000 | ((pixval & 0x1F) << 16));
  81 }
  82
  83 int platform_diu_init(unsigned int *xres, unsigned int *yres)
  84 {
  85         ccsr_gur_t *gur = (void *)(CONFIG_SYS_MPC85xx_GUTS_ADDR);
  86         char *monitor_port;
  87         u32 pixel_format;
  88         u8 temp;
  89
  90         /* Save the LBC LCS0 and LCS1 addresses for the DIU mux functions */
  91         lbc_lcs0_ba = (void *)(get_lbc_br(0) & get_lbc_or(0) & 0xFFFF8000);
  92         lbc_lcs1_ba = (void *)(get_lbc_br(1) & get_lbc_or(1) & 0xFFFF8000);
  93
  94         pixel_format = cpu_to_le32(AD_BYTE_F | (3 << AD_ALPHA_C_SHIFT) |
  95                 (0 << AD_BLUE_C_SHIFT) | (1 << AD_GREEN_C_SHIFT) |
  96                 (2 << AD_RED_C_SHIFT) | (8 << AD_COMP_3_SHIFT) |
  97                 (8 << AD_COMP_2_SHIFT) | (8 << AD_COMP_1_SHIFT) |
  98                 (8 << AD_COMP_0_SHIFT) | (3 << AD_PIXEL_S_SHIFT));
  99
 100         temp = in_8(&pixis->brdcfg1);
 101
 102         monitor_port = getenv("monitor");
 103         if (!strncmp(monitor_port, "1", 1)) { /* 1 - Single link LVDS */
 104                 *xres = 1024;
 105                 *yres = 768;
 106                 /* Enable the DFP port, disable the DVI and the backlight */
 107                 temp &= ~(PX_BRDCFG1_DVIEN | PX_BRDCFG1_BACKLIGHT);
 108                 temp |= PX_BRDCFG1_DFPEN;
 109         } else {        /* DVI */
 110                 *xres = 1280;
 111                 *yres = 1024;
 112                 /* Enable the DVI port, disable the DFP and the backlight */
 113                 temp &= ~(PX_BRDCFG1_DFPEN | PX_BRDCFG1_BACKLIGHT);
 114                 temp |= PX_BRDCFG1_DVIEN;
 115         }
 116
 117         out_8(&pixis->brdcfg1, temp);
 118
 119         /*
 120          * Enable PIXIS indirect access mode.  This is a hack that allows us to
 121          * access PIXIS registers even when the LBC pins have been muxed to the
 122          * DIU.
 123          */
 124         setbits_8(&pixis->csr, PX_CTL_ALTACC);
 125
 126         /*
 127          * Route the LAD pins to the DIU.  This will disable access to the eLBC,
 128          * which means we won't be able to read/write any NOR flash addresses!
 129          */
 130         out_8(lbc_lcs0_ba, offsetof(ngpixis_t, brdcfg0));
 131         px_brdcfg0 = in_8(lbc_lcs1_ba);
 132         out_8(lbc_lcs1_ba, px_brdcfg0 | PX_BRDCFG0_ELBC_DIU);
 133
 134         /* Setting PMUXCR to switch to DVI from ELBC */
 135         clrsetbits_be32(&gur->pmuxcr,
 136                 PMUXCR_ELBCDIU_MASK, PMUXCR_ELBCDIU_NOR16);
 137         pmuxcr = in_be32(&gur->pmuxcr);
 138
 139         return fsl_diu_init(*xres, pixel_format, 0);
 140 }
 141
 142 #ifdef CONFIG_CFI_FLASH_USE_WEAK_ACCESSORS
 143
 144 /*
 145  * set_mux_to_lbc - disable the DIU so that we can read/write to elbc
 146  *
 147  * On the Freescale P1022, the DIU video signal and the LBC address/data lines
 148  * share the same pins, which means that when the DIU is active (e.g. the
 149  * console is on the DVI display), NOR flash cannot be accessed.  So we use the
 150  * weak accessor feature of the CFI flash code to temporarily switch the pin
 151  * mux from DIU to LBC whenever we want to read or write flash.  This has a
 152  * significant performance penalty, but it's the only way to make it work.
 153  *
 154  * There are two muxes: one on the chip, and one on the board. The chip mux
 155  * controls whether the pins are used for the DIU or the LBC, and it is
 156  * set via PMUXCR.  The board mux controls whether those signals go to
 157  * the video connector or the NOR flash chips, and it is set via the ngPIXIS.
 158  */
 159 static int set_mux_to_lbc(void)
 160 {
 161         ccsr_gur_t *gur = (void *)CONFIG_SYS_MPC85xx_GUTS_ADDR;
 162
 163         /* Switch the muxes only if they're currently set to DIU mode */
 164         if ((in_be32(&gur->pmuxcr) & PMUXCR_ELBCDIU_MASK) ==
 165             PMUXCR_ELBCDIU_NOR16) {
 166                 /*
 167                  * In DIU mode, the PIXIS can only be accessed indirectly
 168                  * since we can't read/write the LBC directly.
 169                  */
 170
 171                 /* Set the board mux to LBC.  This will disable the display. */
 172                 out_8(lbc_lcs0_ba, offsetof(ngpixis_t, brdcfg0));
 173                 px_brdcfg0 = in_8(lbc_lcs1_ba);
 174                 out_8(lbc_lcs1_ba, (px_brdcfg0 & ~(PX_BRDCFG0_ELBC_SPI_MASK
 175                         | PX_BRDCFG0_ELBC_DIU)) | PX_BRDCFG0_ELBC_SPI_ELBC);
 176
 177                 /* Disable indirect PIXIS mode */
 178                 out_8(lbc_lcs0_ba, offsetof(ngpixis_t, csr));
 179                 clrbits_8(lbc_lcs1_ba, PX_CTL_ALTACC);
 180
 181                 /* Set the chip mux to LBC mode, so that writes go to flash. */
 182                 out_be32(&gur->pmuxcr, (pmuxcr & ~PMUXCR_ELBCDIU_MASK) |
 183                          PMUXCR_ELBCDIU_NOR16);
 184                 in_be32(&gur->pmuxcr);
 185
 186                 return 1;
 187         }
 188
 189         return 0;
 190 }
 191
 192 /*
 193  * set_mux_to_diu - re-enable the DIU muxing
 194  *
 195  * This function restores the chip and board muxing to point to the DIU.
 196  */
 197 static void set_mux_to_diu(void)
 198 {
 199         ccsr_gur_t *gur = (void *)CONFIG_SYS_MPC85xx_GUTS_ADDR;
 200
 201         /* Enable indirect PIXIS mode */
 202         setbits_8(&pixis->csr, PX_CTL_ALTACC);
 203
 204         /* Set the board mux to DIU.  This will enable the display. */
 205         out_8(lbc_lcs0_ba, offsetof(ngpixis_t, brdcfg0));
 206         out_8(lbc_lcs1_ba, px_brdcfg0);
 207         in_8(lbc_lcs1_ba);
 208
 209         /* Set the chip mux to DIU mode. */
 210         out_be32(&gur->pmuxcr, pmuxcr);
 211         in_be32(&gur->pmuxcr);
 212 }
 213
 214 void flash_write8(u8 value, void *addr)
 215 {
 216         int sw = set_mux_to_lbc();
 217
 218         __raw_writeb(value, addr);
 219         if (sw)
 220                 set_mux_to_diu();
 221 }
 222
 223 void flash_write16(u16 value, void *addr)
 224 {
 225         int sw = set_mux_to_lbc();
 226
 227         __raw_writew(value, addr);
 228         if (sw)
 229                 set_mux_to_diu();
 230 }
 231
 232 void flash_write32(u32 value, void *addr)
 233 {
 234         int sw = set_mux_to_lbc();
 235
 236         __raw_writel(value, addr);
 237         if (sw)
 238                 set_mux_to_diu();
 239 }
 240
 241 void flash_write64(u64 value, void *addr)
 242 {
 243         int sw = set_mux_to_lbc();
 244
 245         /* There is no __raw_writeq(), so do the write manually */
 246         *(volatile u64 *)addr = value;
 247         if (sw)
 248                 set_mux_to_diu();
 249 }
 250
 251 u8 flash_read8(void *addr)
 252 {
 253         u8 ret;
 254
 255         int sw = set_mux_to_lbc();
 256
 257         ret = __raw_readb(addr);
 258         if (sw)
 259                 set_mux_to_diu();
 260
 261         return ret;
 262 }
 263
 264 u16 flash_read16(void *addr)
 265 {
 266         u16 ret;
 267
 268         int sw = set_mux_to_lbc();
 269
 270         ret = __raw_readw(addr);
 271         if (sw)
 272                 set_mux_to_diu();
 273
 274         return ret;
 275 }
 276
 277 u32 flash_read32(void *addr)
 278 {
 279         u32 ret;
 280
 281         int sw = set_mux_to_lbc();
 282
 283         ret = __raw_readl(addr);
 284         if (sw)
 285                 set_mux_to_diu();
 286
 287         return ret;
 288 }
 289
 290 u64 flash_read64(void *addr)
 291 {
 292         u64 ret;
 293
 294         int sw = set_mux_to_lbc();
 295
 296         /* There is no __raw_readq(), so do the read manually */
 297         ret = *(volatile u64 *)addr;
 298         if (sw)
 299                 set_mux_to_diu();
 300
 301         return ret;
 302 }
 303
 304 #endif