board/tqc/tqm8272/tqm8272.c

   1 /*
   2  * (C) Copyright 2006
   3  * Heiko Schocher, DENX Software Engineering, hs@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 #include <common.h>
  25 #include <ioports.h>
  26 #include <mpc8260.h>
  27
  28 #include <command.h>
  29 #include <netdev.h>
  30 #ifdef CONFIG_PCI
  31 #include <pci.h>
  32 #include <asm/m8260_pci.h>
  33 #endif
  34 #include "tqm8272.h"
  35
  36 #if 0
  37 #define deb_printf(fmt,arg...) \
  38         printf ("TQM8272 %s %s: " fmt,__FILE__, __FUNCTION__, ##arg)
  39 #else
  40 #define deb_printf(fmt,arg...) \
  41         do { } while (0)
  42 #endif
  43
  44 #if defined(CONFIG_BOARD_GET_CPU_CLK_F)
  45 unsigned long board_get_cpu_clk_f (void);
  46 #endif
  47
  48 /*
  49  * I/O Port configuration table
  50  *
  51  * if conf is 1, then that port pin will be configured at boot time
  52  * according to the five values podr/pdir/ppar/psor/pdat for that entry
  53  */
  54
  55 const iop_conf_t iop_conf_tab[4][32] = {
  56
  57     /* Port A configuration */
  58     {   /*            conf ppar psor pdir podr pdat */
  59         /* PA31 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 *ATMTXEN */
  60         /* PA30 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTCA   */
  61         /* PA29 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTSOC  */
  62         /* PA28 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 *ATMRXEN */
  63         /* PA27 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRSOC */
  64         /* PA26 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRCA */
  65         /* PA25 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[0] */
  66         /* PA24 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[1] */
  67         /* PA23 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[2] */
  68         /* PA22 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[3] */
  69         /* PA21 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[4] */
  70         /* PA20 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[5] */
  71         /* PA19 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[6] */
  72         /* PA18 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMTXD[7] */
  73         /* PA17 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[7] */
  74         /* PA16 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[6] */
  75         /* PA15 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[5] */
  76         /* PA14 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[4] */
  77         /* PA13 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[3] */
  78         /* PA12 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[2] */
  79         /* PA11 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[1] */
  80         /* PA10 */ {   0,   0,   0,   1,   0,   0   }, /* FCC1 ATMRXD[0] */
  81         /* PA9  */ {   1,   1,   0,   1,   0,   0   }, /* SMC2 TXD */
  82         /* PA8  */ {   1,   1,   0,   0,   0,   0   }, /* SMC2 RXD */
  83         /* PA7  */ {   0,   0,   0,   1,   0,   0   }, /* PA7 */
  84         /* PA6  */ {   0,   0,   0,   1,   0,   0   }, /* PA6 */
  85         /* PA5  */ {   0,   0,   0,   1,   0,   0   }, /* PA5 */
  86         /* PA4  */ {   0,   0,   0,   1,   0,   0   }, /* PA4 */
  87         /* PA3  */ {   0,   0,   0,   1,   0,   0   }, /* PA3 */
  88         /* PA2  */ {   0,   0,   0,   1,   0,   0   }, /* PA2 */
  89         /* PA1  */ {   0,   0,   0,   1,   0,   0   }, /* PA1 */
  90         /* PA0  */ {   0,   0,   0,   1,   0,   0   }  /* PA0 */
  91     },
  92
  93     /* Port B configuration */
  94     {   /*            conf ppar psor pdir podr pdat */
  95         /* PB31 */ {   1,   1,   0,   1,   0,   0   }, /* FCC2 MII TX_ER */
  96         /* PB30 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII RX_DV */
  97         /* PB29 */ {   1,   1,   1,   1,   0,   0   }, /* FCC2 MII TX_EN */
  98         /* PB28 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII RX_ER */
  99         /* PB27 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII COL */
 100         /* PB26 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII CRS */
 101         /* PB25 */ {   1,   1,   0,   1,   0,   0   }, /* FCC2 MII TxD[3] */
 102         /* PB24 */ {   1,   1,   0,   1,   0,   0   }, /* FCC2 MII TxD[2] */
 103         /* PB23 */ {   1,   1,   0,   1,   0,   0   }, /* FCC2 MII TxD[1] */
 104         /* PB22 */ {   1,   1,   0,   1,   0,   0   }, /* FCC2 MII TxD[0] */
 105         /* PB21 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII RxD[0] */
 106         /* PB20 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII RxD[1] */
 107         /* PB19 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII RxD[2] */
 108         /* PB18 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII RxD[3] */
 109         /* PB17 */ {   0,   0,   0,   0,   0,   0   }, /* PB17 */
 110         /* PB16 */ {   0,   0,   0,   0,   0,   0   }, /* PB16 */
 111         /* PB15 */ {   0,   0,   0,   0,   0,   0   }, /* PB15 */
 112         /* PB14 */ {   0,   0,   0,   0,   0,   0   }, /* PB14 */
 113         /* PB13 */ {   0,   0,   0,   0,   0,   0   }, /* PB13 */
 114         /* PB12 */ {   0,   0,   0,   0,   0,   0   }, /* PB12 */
 115         /* PB11 */ {   0,   0,   0,   0,   0,   0   }, /* PB11 */
 116         /* PB10 */ {   0,   0,   0,   0,   0,   0   }, /* PB10 */
 117         /* PB9  */ {   0,   0,   0,   0,   0,   0   }, /* PB9 */
 118         /* PB8  */ {   0,   0,   0,   0,   0,   0   }, /* PB8 */
 119         /* PB7  */ {   0,   0,   0,   0,   0,   0   }, /* PB7 */
 120         /* PB6  */ {   0,   0,   0,   0,   0,   0   }, /* PB6 */
 121         /* PB5  */ {   0,   0,   0,   0,   0,   0   }, /* PB5 */
 122         /* PB4  */ {   0,   0,   0,   0,   0,   0   }, /* PB4 */
 123         /* PB3  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 124         /* PB2  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 125         /* PB1  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 126         /* PB0  */ {   0,   0,   0,   0,   0,   0   }  /* pin doesn't exist */
 127     },
 128
 129     /* Port C */
 130     {   /*            conf ppar psor pdir podr pdat */
 131         /* PC31 */ {   0,   0,   0,   1,   0,   0   }, /* PC31 */
 132         /* PC30 */ {   0,   0,   0,   0,   0,   0   }, /* PC30 */
 133         /* PC29 */ {   1,   1,   1,   0,   0,   0   }, /* SCC1 EN *CLSN */
 134         /* PC28 */ {   0,   0,   0,   1,   0,   0   }, /* PC28 */
 135         /* PC27 */ {   0,   0,   0,   1,   0,   0   }, /* PC27 */
 136         /* PC26 */ {   0,   0,   0,   1,   0,   0   }, /* PC26 */
 137         /* PC25 */ {   0,   0,   0,   1,   0,   0   }, /* PC25 */
 138         /* PC24 */ {   0,   0,   0,   1,   0,   0   }, /* PC24 */
 139         /* PC23 */ {   0,   1,   0,   1,   0,   0   }, /* ATMTFCLK */
 140         /* PC22 */ {   0,   1,   0,   0,   0,   0   }, /* ATMRFCLK */
 141         /* PC21 */ {   1,   1,   0,   0,   0,   0   }, /* SCC1 EN RXCLK */
 142         /* PC20 */ {   1,   1,   0,   0,   0,   0   }, /* SCC1 EN TXCLK */
 143         /* PC19 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII RX_CLK */
 144         /* PC18 */ {   1,   1,   0,   0,   0,   0   }, /* FCC2 MII TX_CLK */
 145         /* PC17 */ {   1,   0,   0,   1,   0,   0   }, /* PC17 MDC */
 146         /* PC16 */ {   1,   0,   0,   0,   0,   0   }, /* PC16 MDIO*/
 147         /* PC15 */ {   0,   0,   0,   1,   0,   0   }, /* PC15 */
 148         /* PC14 */ {   1,   1,   0,   0,   0,   0   }, /* SCC1 EN *CD */
 149         /* PC13 */ {   0,   0,   0,   1,   0,   0   }, /* PC13 */
 150         /* PC12 */ {   0,   0,   0,   1,   0,   0   }, /* PC12 */
 151         /* PC11 */ {   0,   0,   0,   1,   0,   0   }, /* PC11 */
 152         /* PC10 */ {   0,   0,   0,   1,   0,   0   }, /* PC10 */
 153         /* PC9  */ {   0,   0,   0,   1,   0,   0   }, /* PC9 */
 154         /* PC8  */ {   0,   0,   0,   1,   0,   0   }, /* PC8 */
 155         /* PC7  */ {   0,   0,   0,   1,   0,   0   }, /* PC7 */
 156         /* PC6  */ {   0,   0,   0,   1,   0,   0   }, /* PC6 */
 157         /* PC5  */ {   1,   1,   0,   1,   0,   0   }, /* PC5 SMC1 TXD */
 158         /* PC4  */ {   1,   1,   0,   0,   0,   0   }, /* PC4 SMC1 RXD */
 159         /* PC3  */ {   0,   0,   0,   1,   0,   0   }, /* PC3 */
 160         /* PC2  */ {   0,   0,   0,   1,   0,   1   }, /* ENET FDE */
 161         /* PC1  */ {   0,   0,   0,   1,   0,   0   }, /* ENET DSQE */
 162         /* PC0  */ {   0,   0,   0,   1,   0,   0   }, /* ENET LBK */
 163     },
 164
 165     /* Port D */
 166     {   /*            conf ppar psor pdir podr pdat */
 167         /* PD31 */ {   1,   1,   0,   0,   0,   0   }, /* SCC1 EN RxD */
 168         /* PD30 */ {   1,   1,   1,   1,   0,   0   }, /* SCC1 EN TxD */
 169         /* PD29 */ {   1,   1,   0,   1,   0,   0   }, /* SCC1 EN TENA */
 170         /* PD28 */ {   0,   0,   0,   1,   0,   0   }, /* PD28 */
 171         /* PD27 */ {   0,   0,   0,   1,   0,   0   }, /* PD27 */
 172         /* PD26 */ {   0,   0,   0,   1,   0,   0   }, /* PD26 */
 173         /* PD25 */ {   0,   0,   0,   1,   0,   0   }, /* PD25 */
 174         /* PD24 */ {   0,   0,   0,   1,   0,   0   }, /* PD24 */
 175         /* PD23 */ {   0,   0,   0,   1,   0,   0   }, /* PD23 */
 176         /* PD22 */ {   0,   0,   0,   1,   0,   0   }, /* PD22 */
 177         /* PD21 */ {   0,   0,   0,   1,   0,   0   }, /* PD21 */
 178         /* PD20 */ {   0,   0,   0,   1,   0,   0   }, /* PD20 */
 179         /* PD19 */ {   0,   0,   0,   1,   0,   0   }, /* PD19 */
 180         /* PD18 */ {   0,   0,   0,   1,   0,   0   }, /* PD19 */
 181         /* PD17 */ {   0,   1,   0,   0,   0,   0   }, /* FCC1 ATMRXPRTY */
 182         /* PD16 */ {   0,   1,   0,   1,   0,   0   }, /* FCC1 ATMTXPRTY */
 183 #if defined(CONFIG_SOFT_I2C)
 184         /* PD15 */ {   1,   0,   0,   1,   1,   1   }, /* I2C SDA */
 185         /* PD14 */ {   1,   0,   0,   1,   1,   1   }, /* I2C SCL */
 186 #else
 187 #if defined(CONFIG_HARD_I2C)
 188         /* PD15 */ {   1,   1,   1,   0,   1,   0   }, /* I2C SDA */
 189         /* PD14 */ {   1,   1,   1,   0,   1,   0   }, /* I2C SCL */
 190 #else /* normal I/O port pins */
 191         /* PD15 */ {   0,   1,   1,   0,   1,   0   }, /* I2C SDA */
 192         /* PD14 */ {   0,   1,   1,   0,   1,   0   }, /* I2C SCL */
 193 #endif
 194 #endif
 195         /* PD13 */ {   0,   0,   0,   0,   0,   0   }, /* PD13 */
 196         /* PD12 */ {   0,   0,   0,   0,   0,   0   }, /* PD12 */
 197         /* PD11 */ {   0,   0,   0,   0,   0,   0   }, /* PD11 */
 198         /* PD10 */ {   0,   0,   0,   0,   0,   0   }, /* PD10 */
 199         /* PD9  */ {   1,   1,   0,   1,   0,   0   }, /* SMC1 TXD */
 200         /* PD8  */ {   1,   1,   0,   0,   0,   0   }, /* SMC1 RXD */
 201         /* PD7  */ {   0,   0,   0,   1,   0,   1   }, /* PD7 */
 202         /* PD6  */ {   0,   0,   0,   1,   0,   1   }, /* PD6 */
 203         /* PD5  */ {   0,   0,   0,   1,   0,   0   }, /* PD5 */
 204         /* PD4  */ {   0,   0,   0,   1,   0,   1   }, /* PD4 */
 205         /* PD3  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 206         /* PD2  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 207         /* PD1  */ {   0,   0,   0,   0,   0,   0   }, /* pin doesn't exist */
 208         /* PD0  */ {   0,   0,   0,   0,   0,   0   }  /* pin doesn't exist */
 209     }
 210 };
 211
 212 /* UPM pattern for slow init */
 213 static const uint upmTableSlow[] =
 214 {
 215     /* Offset   UPM Read Single RAM array entry */
 216     /* 0x00 */  0xffffee00, 0x00ffcc80, 0x00ffcf00, 0x00ffdc00,
 217     /* 0x04 */  0x00ffce80, 0x00ffcc00, 0x00ffee00, 0x3fffcc07,
 218
 219                 /* UPM Read Burst RAM array entry -> unused */
 220     /* 0x08 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 221     /* 0x0C */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 222
 223                 /* UPM Read Burst RAM array entry -> unused */
 224     /* 0x10 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 225     /* 0x14 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 226
 227                 /* UPM Write Single RAM array entry */
 228     /* 0x18 */  0xffffee00, 0x00ffec80, 0x00ffef00, 0x00fffc80,
 229     /* 0x1C */  0x00fffe00, 0x00ffec00, 0x0fffef00, 0x3fffec05,
 230
 231                 /* UPM Write Burst RAM array entry -> unused */
 232     /* 0x20 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 233     /* 0x24 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 234     /* 0x28 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 235     /* 0x2C */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc01,
 236
 237                 /* UPM Refresh Timer RAM array entry -> unused */
 238     /* 0x30 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 239     /* 0x34 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 240     /* 0x38 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc01,
 241
 242                 /* UPM Exception RAM array entry -> unused */
 243     /* 0x3C */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc01,
 244 };
 245
 246 /* UPM pattern for fast init */
 247 static const uint upmTableFast[] =
 248 {
 249     /* Offset   UPM Read Single RAM array entry */
 250     /* 0x00 */  0xffffee00, 0x00ffcc80, 0x00ffcd80, 0x00ffdc00,
 251     /* 0x04 */  0x00ffdc00, 0x00ffcf00, 0x00ffec00, 0x3fffcc07,
 252
 253                 /* UPM Read Burst RAM array entry -> unused */
 254     /* 0x08 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 255     /* 0x0C */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 256
 257                 /* UPM Read Burst RAM array entry -> unused */
 258     /* 0x10 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 259     /* 0x14 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 260
 261                 /* UPM Write Single RAM array entry */
 262     /* 0x18 */  0xffffee00, 0x00ffec80, 0x00ffee80, 0x00fffc00,
 263     /* 0x1C */  0x00fffc00, 0x00ffec00, 0x0fffef00, 0x3fffec05,
 264
 265                 /* UPM Write Burst RAM array entry -> unused */
 266     /* 0x20 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 267     /* 0x24 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 268     /* 0x28 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 269     /* 0x2C */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc01,
 270
 271                 /* UPM Refresh Timer RAM array entry -> unused */
 272     /* 0x30 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 273     /* 0x34 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc00,
 274     /* 0x38 */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc01,
 275
 276                 /* UPM Exception RAM array entry -> unused */
 277     /* 0x3C */  0xfffffc00, 0xfffffc00, 0xfffffc00, 0xfffffc01,
 278 };
 279
 280
 281 /* ------------------------------------------------------------------------- */
 282
 283 /* Check Board Identity:
 284  */
 285 int checkboard (void)
 286 {
 287         char *p = (char *) HWIB_INFO_START_ADDR;
 288
 289         puts ("Board: ");
 290         if (*((unsigned long *)p) == (unsigned long)CONFIG_SYS_HWINFO_MAGIC) {
 291                 puts (p);
 292         } else {
 293                 puts ("No HWIB assuming TQM8272");
 294         }
 295         putc ('\n');
 296
 297         return 0;
 298 }
 299
 300 /* ------------------------------------------------------------------------- */
 301 #if defined(CONFIG_BOARD_GET_CPU_CLK_F)
 302 static int get_cas_latency (void)
 303 {
 304         /* get it from the option -ts in CIB */
 305         /* default is 3 */
 306         int     ret = 3;
 307         int     pos = 0;
 308         char    *p = (char *) CIB_INFO_START_ADDR;
 309
 310         while ((*p != '\0') && (pos < CIB_INFO_LEN)) {
 311                 if (*p < ' ' || *p > '~') { /* ASCII strings! */
 312                         return ret;
 313                 }
 314                 if (*p == '-') {
 315                         if ((p[1] == 't') && (p[2] == 's')) {
 316                                 return (p[4] - '0');
 317                         }
 318                 }
 319                 p++;
 320                 pos++;
 321         }
 322         return ret;
 323 }
 324 #endif
 325
 326 static ulong set_sdram_timing (volatile uint *sdmr_ptr, ulong sdmr, int col)
 327 {
 328 #if defined(CONFIG_BOARD_GET_CPU_CLK_F)
 329         int     clk = board_get_cpu_clk_f ();
 330         volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
 331         int     busmode = (immr->im_siu_conf.sc_bcr & BCR_EBM ? 1 : 0);
 332         int     cas;
 333
 334         sdmr = sdmr & ~(PSDMR_RFRC_MSK | PSDMR_PRETOACT_MSK | PSDMR_WRC_MSK | \
 335                          PSDMR_BUFCMD);
 336         if (busmode) {
 337                 switch (clk) {
 338                         case 66666666:
 339                                 sdmr |= (PSDMR_RFRC_66MHZ_60X | \
 340                                         PSDMR_PRETOACT_66MHZ_60X | \
 341                                         PSDMR_WRC_66MHZ_60X | \
 342                                         PSDMR_BUFCMD_66MHZ_60X);
 343                                 break;
 344                         case 100000000:
 345                                 sdmr |= (PSDMR_RFRC_100MHZ_60X | \
 346                                         PSDMR_PRETOACT_100MHZ_60X | \
 347                                         PSDMR_WRC_100MHZ_60X | \
 348                                         PSDMR_BUFCMD_100MHZ_60X);
 349                                 break;
 350
 351                 }
 352         } else {
 353                 switch (clk) {
 354                         case 66666666:
 355                                 sdmr |= (PSDMR_RFRC_66MHZ_SINGLE | \
 356                                         PSDMR_PRETOACT_66MHZ_SINGLE | \
 357                                         PSDMR_WRC_66MHZ_SINGLE | \
 358                                         PSDMR_BUFCMD_66MHZ_SINGLE);
 359                                 break;
 360                         case 100000000:
 361                                 sdmr |= (PSDMR_RFRC_100MHZ_SINGLE | \
 362                                         PSDMR_PRETOACT_100MHZ_SINGLE | \
 363                                         PSDMR_WRC_100MHZ_SINGLE | \
 364                                         PSDMR_BUFCMD_100MHZ_SINGLE);
 365                                 break;
 366                         case 133333333:
 367                                 sdmr |= (PSDMR_RFRC_133MHZ_SINGLE | \
 368                                         PSDMR_PRETOACT_133MHZ_SINGLE | \
 369                                         PSDMR_WRC_133MHZ_SINGLE | \
 370                                         PSDMR_BUFCMD_133MHZ_SINGLE);
 371                                 break;
 372                 }
 373         }
 374         cas = get_cas_latency();
 375         sdmr &=~ (PSDMR_CL_MSK | PSDMR_LDOTOPRE_MSK);
 376         sdmr |= cas;
 377         sdmr |= ((cas - 1) << 6);
 378         return sdmr;
 379 #else
 380         return sdmr;
 381 #endif
 382 }
 383
 384 /* Try SDRAM initialization with P/LSDMR=sdmr and ORx=orx
 385  *
 386  * This routine performs standard 8260 initialization sequence
 387  * and calculates the available memory size. It may be called
 388  * several times to try different SDRAM configurations on both
 389  * 60x and local buses.
 390  */
 391 static long int try_init (volatile memctl8260_t * memctl, ulong sdmr,
 392                                                   ulong orx, volatile uchar * base, int col)
 393 {
 394         volatile uchar c = 0xff;
 395         volatile uint *sdmr_ptr;
 396         volatile uint *orx_ptr;
 397         ulong maxsize, size;
 398         int i;
 399
 400         /* We must be able to test a location outsize the maximum legal size
 401          * to find out THAT we are outside; but this address still has to be
 402          * mapped by the controller. That means, that the initial mapping has
 403          * to be (at least) twice as large as the maximum expected size.
 404          */
 405         maxsize = (1 + (~orx | 0x7fff)) / 2;
 406
 407         /* Since CONFIG_SYS_SDRAM_BASE is always 0 (??), we assume that
 408          * we are configuring CS1 if base != 0
 409          */
 410         sdmr_ptr = base ? &memctl->memc_lsdmr : &memctl->memc_psdmr;
 411         orx_ptr = base ? &memctl->memc_or2 : &memctl->memc_or1;
 412
 413         *orx_ptr = orx;
 414         sdmr = set_sdram_timing (sdmr_ptr, sdmr, col);
 415         /*
 416          * Quote from 8260 UM (10.4.2 SDRAM Power-On Initialization, 10-35):
 417          *
 418          * "At system reset, initialization software must set up the
 419          *  programmable parameters in the memory controller banks registers
 420          *  (ORx, BRx, P/LSDMR). After all memory parameters are configured,
 421          *  system software should execute the following initialization sequence
 422          *  for each SDRAM device.
 423          *
 424          *  1. Issue a PRECHARGE-ALL-BANKS command
 425          *  2. Issue eight CBR REFRESH commands
 426          *  3. Issue a MODE-SET command to initialize the mode register
 427          *
 428          *  The initial commands are executed by setting P/LSDMR[OP] and
 429          *  accessing the SDRAM with a single-byte transaction."
 430          *
 431          * The appropriate BRx/ORx registers have already been set when we
 432          * get here. The SDRAM can be accessed at the address CONFIG_SYS_SDRAM_BASE.
 433          */
 434
 435         *sdmr_ptr = sdmr | PSDMR_OP_PREA;
 436         *base = c;
 437
 438         *sdmr_ptr = sdmr | PSDMR_OP_CBRR;
 439         for (i = 0; i < 8; i++)
 440                 *base = c;
 441
 442         *sdmr_ptr = sdmr | PSDMR_OP_MRW;
 443         *(base + CONFIG_SYS_MRS_OFFS) = c;      /* setting MR on address lines */
 444
 445         *sdmr_ptr = sdmr | PSDMR_OP_NORM | PSDMR_RFEN;
 446         *base = c;
 447
 448         size = get_ram_size((long *)base, maxsize);
 449         *orx_ptr = orx | ~(size - 1);
 450
 451         return (size);
 452 }
 453
 454 phys_size_t initdram (int board_type)
 455 {
 456         volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 457         volatile memctl8260_t *memctl = &immap->im_memctl;
 458
 459 #ifndef CONFIG_SYS_RAMBOOT
 460         long size8, size9;
 461 #endif
 462         long psize, lsize;
 463
 464         psize = 16 * 1024 * 1024;
 465         lsize = 0;
 466
 467         memctl->memc_psrt = CONFIG_SYS_PSRT;
 468         memctl->memc_mptpr = CONFIG_SYS_MPTPR;
 469
 470 #ifndef CONFIG_SYS_RAMBOOT
 471         /* 60x SDRAM setup:
 472          */
 473         size8 = try_init (memctl, CONFIG_SYS_PSDMR_8COL, CONFIG_SYS_OR1_8COL,
 474                                           (uchar *) CONFIG_SYS_SDRAM_BASE, 8);
 475         size9 = try_init (memctl, CONFIG_SYS_PSDMR_9COL, CONFIG_SYS_OR1_9COL,
 476                                           (uchar *) CONFIG_SYS_SDRAM_BASE, 9);
 477
 478         if (size8 < size9) {
 479                 psize = size9;
 480                 printf ("(60x:9COL - %ld MB, ", psize >> 20);
 481         } else {
 482                 psize = try_init (memctl, CONFIG_SYS_PSDMR_8COL, CONFIG_SYS_OR1_8COL,
 483                                                   (uchar *) CONFIG_SYS_SDRAM_BASE, 8);
 484                 printf ("(60x:8COL - %ld MB, ", psize >> 20);
 485         }
 486
 487 #endif /* CONFIG_SYS_RAMBOOT */
 488
 489         icache_enable ();
 490
 491         return (psize);
 492 }
 493
 494
 495 static inline int scanChar (char *p, int len, unsigned long *number)
 496 {
 497         int     akt = 0;
 498
 499         *number = 0;
 500         while (akt < len) {
 501                 if ((*p >= '0') && (*p <= '9')) {
 502                         *number *= 10;
 503                         *number += *p - '0';
 504                         p += 1;
 505                 } else {
 506                         if (*p == '-')  return akt;
 507                         return -1;
 508                 }
 509                 akt ++;
 510         }
 511         return akt;
 512 }
 513
 514 static int dump_hwib(void)
 515 {
 516         HWIB_INFO       *hw = &hwinf;
 517         volatile immap_t *immr = (immap_t *)CONFIG_SYS_IMMR;
 518         char *s = getenv("serial#");
 519
 520         if (hw->OK) {
 521                 printf ("HWIB on %x\n", HWIB_INFO_START_ADDR);
 522                 printf ("serial : %s\n", s);
 523                 printf ("ethaddr: %s\n", hw->ethaddr);
 524                 printf ("FLASH  : %x nr:%d\n", hw->flash, hw->flash_nr);
 525                 printf ("RAM    : %x cs:%d\n", hw->ram, hw->ram_cs);
 526                 printf ("CPU    : %lu\n", hw->cpunr);
 527                 printf ("CAN    : %d\n", hw->can);
 528                 if (hw->eeprom) printf ("EEprom : %x\n", hw->eeprom);
 529                 else printf ("No EEprom\n");
 530                 if (hw->nand) {
 531                         printf ("NAND   : %x\n", hw->nand);
 532                         printf ("NAND CS: %d\n", hw->nand_cs);
 533                 } else { printf ("No NAND\n");}
 534                 printf ("Bus %s mode.\n", (hw->Bus ? "60x" : "Single PQII"));
 535                 printf ("  real : %s\n", (immr->im_siu_conf.sc_bcr & BCR_EBM ? \
 536                                  "60x" : "Single PQII"));
 537                 printf ("Option : %lx\n", hw->option);
 538                 printf ("%s Security Engine\n", (hw->SecEng ? "with" : "no"));
 539                 printf ("CPM Clk: %d\n", hw->cpmcl);
 540                 printf ("CPU Clk: %d\n", hw->cpucl);
 541                 printf ("Bus Clk: %d\n", hw->buscl);
 542                 if (hw->busclk_real_ok) {
 543                         printf ("  real Clk: %d\n", hw->busclk_real);
 544                 }
 545                 printf ("CAS    : %d\n", get_cas_latency());
 546         } else {
 547                 printf("HWIB @%x not OK\n", HWIB_INFO_START_ADDR);
 548         }
 549         return 0;
 550 }
 551
 552 static inline int search_real_busclk (int *clk)
 553 {
 554         int     part = 0, pos = 0;
 555         char *p = (char *) CIB_INFO_START_ADDR;
 556         int     ok = 0;
 557
 558         while ((*p != '\0') && (pos < CIB_INFO_LEN)) {
 559                 if (*p < ' ' || *p > '~') { /* ASCII strings! */
 560                         return 0;
 561                 }
 562                 switch (part) {
 563                 default:
 564                         if (*p == '-') {
 565                                 ++part;
 566                         }
 567                         break;
 568                 case 3:
 569                         if (*p == '-') {
 570                                 ++part;
 571                                 break;
 572                         }
 573                         if (*p == 'b') {
 574                                 ok = 1;
 575                                 p++;
 576                                 break;
 577                         }
 578                         if (ok) {
 579                                 switch (*p) {
 580                                 case '6':
 581                                         *clk = 66666666;
 582                                         return 1;
 583                                         break;
 584                                 case '1':
 585                                         if (p[1] == '3') {
 586                                                 *clk = 133333333;
 587                                         } else {
 588                                                 *clk = 100000000;
 589                                         }
 590                                         return 1;
 591                                         break;
 592                                 }
 593                         }
 594                         break;
 595                 }
 596                 p++;
 597         }
 598         return 0;
 599 }
 600
 601 int analyse_hwib (void)
 602 {
 603         char    *p = (char *) HWIB_INFO_START_ADDR;
 604         int     anz;
 605         int     part = 1, i = 0, pos = 0;
 606         HWIB_INFO       *hw = &hwinf;
 607
 608         deb_printf(" %s pointer: %p\n", __FUNCTION__, p);
 609         /* Head = TQM */
 610         if (*((unsigned long *)p) != (unsigned long)CONFIG_SYS_HWINFO_MAGIC) {
 611                 deb_printf("No HWIB\n");
 612                 return -1;
 613         }
 614         p += 3;
 615         if (scanChar (p, 4, &hw->cpunr) < 0) {
 616                 deb_printf("No CPU\n");
 617                 return -2;
 618         }
 619         p +=4;
 620
 621         hw->flash = 0x200000 << (*p - 'A');
 622         p++;
 623         hw->flash_nr = *p - '0';
 624         p++;
 625
 626         hw->ram = 0x2000000 << (*p - 'A');
 627         p++;
 628         if (*p == '2') {
 629                 hw->ram_cs = 2;
 630                 p++;
 631         }
 632
 633         if (*p == 'A') hw->can = 1;
 634         if (*p == 'B') hw->can = 2;
 635         p +=1;
 636         p +=1;  /* connector */
 637         if (*p != '0') {
 638                 hw->eeprom = 0x1000 << (*p - 'A');
 639         }
 640         p++;
 641
 642         if ((*p < '0') || (*p > '9')) {
 643                 /* NAND before z-option */
 644                 hw->nand = 0x8000000 << (*p - 'A');
 645                 p++;
 646                 hw->nand_cs = *p - '0';
 647                 p += 2;
 648         }
 649         /* z-option */
 650         anz = scanChar (p, 4, &hw->option);
 651         if (anz < 0) {
 652                 deb_printf("No option\n");
 653                 return -3;
 654         }
 655         if (hw->option & 0x8) hw->Bus = 1;
 656         p += anz;
 657         if (*p != '-') {
 658                 deb_printf("No -\n");
 659                 return -4;
 660         }
 661         p++;
 662         /* C option */
 663         if (*p == 'E') {
 664                 hw->SecEng = 1;
 665                 p++;
 666         }
 667         switch (*p) {
 668                 case 'M': hw->cpucl = 266666666;
 669                         break;
 670                 case 'P': hw->cpucl = 300000000;
 671                         break;
 672                 case 'T': hw->cpucl = 400000000;
 673                         break;
 674                 default:
 675                         deb_printf("No CPU Clk: %c\n", *p);
 676                         return -5;
 677                         break;
 678         }
 679         p++;
 680         switch (*p) {
 681                 case 'I': hw->cpmcl = 200000000;
 682                         break;
 683                 case 'M': hw->cpmcl = 300000000;
 684                         break;
 685                 default:
 686                         deb_printf("No CPM Clk\n");
 687                         return -6;
 688                         break;
 689         }
 690         p++;
 691         switch (*p) {
 692                 case 'B': hw->buscl = 66666666;
 693                         break;
 694                 case 'E': hw->buscl = 100000000;
 695                         break;
 696                 case 'F': hw->buscl = 133333333;
 697                         break;
 698                 default:
 699                         deb_printf("No BUS Clk\n");
 700                         return -7;
 701                         break;
 702         }
 703         p++;
 704
 705         hw->OK = 1;
 706         /* search MAC Address */
 707         while ((*p != '\0') && (pos < CONFIG_SYS_HWINFO_SIZE)) {
 708                 if (*p < ' ' || *p > '~') { /* ASCII strings! */
 709                         return 0;
 710                 }
 711                 switch (part) {
 712                 default:
 713                         if (*p == ' ') {
 714                                 ++part;
 715                                 i = 0;
 716                         }
 717                         break;
 718                 case 3:                 /* Copy MAC address */
 719                         if (*p == ' ') {
 720                                 ++part;
 721                                 i = 0;
 722                                 break;
 723                         }
 724                         hw->ethaddr[i++] = *p;
 725                         if ((i % 3) == 2)
 726                                 hw->ethaddr[i++] = ':';
 727                         break;
 728
 729                 }
 730                 p++;
 731         }
 732
 733         hw->busclk_real_ok = search_real_busclk (&hw->busclk_real);
 734         return 0;
 735 }
 736
 737 #if defined(CONFIG_GET_CPU_STR_F)
 738 /* !! This routine runs from Flash */
 739 char get_cpu_str_f (char *buf)
 740 {
 741         char *p = (char *) HWIB_INFO_START_ADDR;
 742         int     i = 0;
 743
 744         buf[i++] = 'M';
 745         buf[i++] = 'P';
 746         buf[i++] = 'C';
 747         if (*((unsigned long *)p) == (unsigned long)CONFIG_SYS_HWINFO_MAGIC) {
 748                 buf[i++] = *&p[3];
 749                 buf[i++] = *&p[4];
 750                 buf[i++] = *&p[5];
 751                 buf[i++] = *&p[6];
 752         } else {
 753                 buf[i++] = '8';
 754                 buf[i++] = '2';
 755                 buf[i++] = '7';
 756                 buf[i++] = 'x';
 757         }
 758         buf[i++] = 0;
 759         return 0;
 760 }
 761 #endif
 762
 763 #if defined(CONFIG_BOARD_GET_CPU_CLK_F)
 764 /* !! This routine runs from Flash */
 765 unsigned long board_get_cpu_clk_f (void)
 766 {
 767         char *p = (char *) HWIB_INFO_START_ADDR;
 768         int i = 0;
 769
 770         if (*((unsigned long *)p) == (unsigned long)CONFIG_SYS_HWINFO_MAGIC) {
 771                 if (search_real_busclk (&i))
 772                         return i;
 773         }
 774         return CONFIG_8260_CLKIN;
 775 }
 776 #endif
 777
 778 #if CONFIG_BOARD_EARLY_INIT_R
 779
 780 static int can_test (unsigned long off)
 781 {
 782         volatile unsigned char  *base   = (unsigned char *) (CONFIG_SYS_CAN_BASE + off);
 783
 784         *(base + 0x17) = 'T';
 785         *(base + 0x18) = 'Q';
 786         *(base + 0x19) = 'M';
 787         if ((*(base + 0x17) != 'T') ||
 788             (*(base + 0x18) != 'Q') ||
 789             (*(base + 0x19) != 'M')) {
 790                 return 0;
 791         }
 792         return 1;
 793 }
 794
 795 static int can_config_one (unsigned long off)
 796 {
 797         volatile unsigned char  *ctrl   = (unsigned char *) (CONFIG_SYS_CAN_BASE + off);
 798         volatile unsigned char  *cpu_if = (unsigned char *) (CONFIG_SYS_CAN_BASE + off + 0x02);
 799         volatile unsigned char  *clkout = (unsigned char *) (CONFIG_SYS_CAN_BASE + off + 0x1f);
 800         unsigned char temp;
 801
 802         *cpu_if = 0x45;
 803         temp = *ctrl;
 804         temp |= 0x40;
 805         *ctrl   = temp;
 806         *clkout = 0x20;
 807         temp = *ctrl;
 808         temp &= ~0x40;
 809         *ctrl   = temp;
 810         return 0;
 811 }
 812
 813 static int can_config (void)
 814 {
 815         int     ret = 0;
 816         can_config_one (0);
 817         if (hwinf.can == 2) {
 818                 can_config_one (0x100);
 819         }
 820         /* make Test if they really there */
 821         ret += can_test (0);
 822         ret += can_test (0x100);
 823         return ret;
 824 }
 825
 826 static int init_can (void)
 827 {
 828         volatile immap_t * immr = (immap_t *)CONFIG_SYS_IMMR;
 829         volatile memctl8260_t *memctl = &immr->im_memctl;
 830         int     count = 0;
 831
 832         if ((hwinf.OK) && (hwinf.can)) {
 833                 memctl->memc_or4 = CONFIG_SYS_CAN_OR;
 834                 memctl->memc_br4 = CONFIG_SYS_CAN_BR;
 835                 /* upm Init */
 836                 upmconfig (UPMC, (uint *) upmTableFast,
 837                            sizeof (upmTableFast) / sizeof (uint));
 838                 memctl->memc_mcmr =     (MxMR_DSx_3_CYCL |
 839                                         MxMR_GPL_x4DIS |
 840                                         MxMR_RLFx_2X |
 841                                         MxMR_WLFx_2X |
 842                                         MxMR_OP_NORM);
 843                 /* can configure */
 844                 count = can_config ();
 845                 printf ("CAN:   %d @ %x\n", count, CONFIG_SYS_CAN_BASE);
 846                 if (hwinf.can != count) printf("!!! difference to HWIB\n");
 847         } else {
 848                 printf ("CAN:   No\n");
 849         }
 850         return 0;
 851 }
 852
 853 int board_early_init_r(void)
 854 {
 855         analyse_hwib ();
 856         init_can ();
 857         return 0;
 858 }
 859 #endif
 860
 861 int do_hwib_dump (cmd_tbl_t * cmdtp, int flag, int argc, char *argv[])
 862 {
 863         dump_hwib ();
 864         return 0;
 865 }
 866
 867 U_BOOT_CMD(
 868           hwib, 1,      1,      do_hwib_dump,
 869           "dump HWIB'",
 870           ""
 871 );
 872
 873 #ifdef CONFIG_SYS_UPDATE_FLASH_SIZE
 874 static int get_flash_timing (void)
 875 {
 876         /* get it from the option -tf in CIB */
 877         /* default is 0x00000c84 */
 878         int     ret = 0x00000c84;
 879         int     pos = 0;
 880         int     nr = 0;
 881         char    *p = (char *) CIB_INFO_START_ADDR;
 882
 883         while ((*p != '\0') && (pos < CIB_INFO_LEN)) {
 884                 if (*p < ' ' || *p > '~') { /* ASCII strings! */
 885                         return ret;
 886                 }
 887                 if (*p == '-') {
 888                         if ((p[1] == 't') && (p[2] == 'f')) {
 889                                 p += 6;
 890                                 ret = 0;
 891                                 while (nr < 8) {
 892                                 if ((*p >= '0') && (*p <= '9')) {
 893                                         ret *= 0x10;
 894                                         ret += *p - '0';
 895                                         p += 1;
 896                                         nr ++;
 897                                 } else if ((*p >= 'A') && (*p <= 'F')) {
 898                                         ret *= 10;
 899                                         ret += *p - '7';
 900                                         p += 1;
 901                                         nr ++;
 902                                 } else {
 903                                         if (nr < 8) return 0x00000c84;
 904                                         return ret;
 905                                 }
 906                                 }
 907                         }
 908                 }
 909                 p++;
 910                 pos++;
 911         }
 912         return ret;
 913 }
 914
 915 /* Update the Flash_Size and the Flash Timing */
 916 int update_flash_size (int flash_size)
 917 {
 918         volatile immap_t * immr = (immap_t *)CONFIG_SYS_IMMR;
 919         volatile memctl8260_t *memctl = &immr->im_memctl;
 920         unsigned long reg;
 921         unsigned long tim;
 922
 923         /* I must use reg, otherwise the board hang */
 924         reg = memctl->memc_or0;
 925         reg &= ~ORxU_AM_MSK;
 926         reg |= MEG_TO_AM(flash_size >> 20);
 927         tim = get_flash_timing ();
 928         reg &= ~0xfff;
 929         reg |= (tim & 0xfff);
 930         memctl->memc_or0 = reg;
 931         return 0;
 932 }
 933 #endif
 934
 935 #ifdef CONFIG_PCI
 936 struct pci_controller hose;
 937
 938 int board_early_init_f (void)
 939 {
 940         volatile immap_t *immap = (immap_t *) CONFIG_SYS_IMMR;
 941
 942         immap->im_clkrst.car_sccr |= M826X_SCCR_PCI_MODE_EN;
 943         return 0;
 944 }
 945
 946 extern void pci_mpc8250_init(struct pci_controller *);
 947
 948 void pci_init_board(void)
 949 {
 950         pci_mpc8250_init(&hose);
 951 }
 952 #endif
 953
 954 int board_eth_init(bd_t *bis)
 955 {
 956         return pci_eth_init(bis);
 957 }