board/amcc/luan/luan.c

   1 /*
   2  * (C) Copyright 2005
   3  * John Otken, jotken@softadvances.com
   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 <command.h>
  26 #include <ppc4xx.h>
  27 #include <asm/processor.h>
  28 #include <spd_sdram.h>
  29 #include "epld.h"
  30
  31 DECLARE_GLOBAL_DATA_PTR;
  32
  33 extern flash_info_t flash_info[CFG_MAX_FLASH_BANKS]; /* info for FLASH chips */
  34
  35
  36 /*************************************************************************
  37  *  int board_early_init_f()
  38  *
  39  ************************************************************************/
  40 int board_early_init_f(void)
  41 {
  42         volatile epld_t *x = (epld_t *) CFG_EPLD_BASE;
  43
  44         mtebc( pb0ap,  0x03800000 );    /* set chip selects */
  45         mtebc( pb0cr,  0xffc58000 );    /* ebc0_b0cr, 4MB at 0xffc00000 CS0 */
  46         mtebc( pb1ap,  0x03800000 );
  47         mtebc( pb1cr,  0xff018000 );    /* ebc0_b1cr, 1MB at 0xff000000 CS1 */
  48         mtebc( pb2ap,  0x03800000 );
  49         mtebc( pb2cr,  0xff838000 );    /* ebc0_b2cr, 2MB at 0xff800000 CS2 */
  50
  51         mtdcr( uic1sr, 0xffffffff );    /* Clear all interrupts */
  52         mtdcr( uic1er, 0x00000000 );    /* disable all interrupts */
  53         mtdcr( uic1cr, 0x00000000 );    /* Set Critical / Non Critical interrupts */
  54         mtdcr( uic1pr, 0x7fff83ff );    /* Set Interrupt Polarities */
  55         mtdcr( uic1tr, 0x001f8000 );    /* Set Interrupt Trigger Levels */
  56         mtdcr( uic1vr, 0x00000001 );    /* Set Vect base=0,INT31 Highest priority */
  57         mtdcr( uic1sr, 0x00000000 );    /* clear all interrupts */
  58         mtdcr( uic1sr, 0xffffffff );
  59
  60         mtdcr( uic0sr, 0xffffffff );    /* Clear all interrupts */
  61         mtdcr( uic0er, 0x00000000 );    /* disable all interrupts excepted cascade */
  62         mtdcr( uic0cr, 0x00000001 );    /* Set Critical / Non Critical interrupts */
  63         mtdcr( uic0pr, 0xffffffff );    /* Set Interrupt Polarities */
  64         mtdcr( uic0tr, 0x01000004 );    /* Set Interrupt Trigger Levels */
  65         mtdcr( uic0vr, 0x00000001 );    /* Set Vect base=0,INT31 Highest priority */
  66         mtdcr( uic0sr, 0x00000000 );    /* clear all interrupts */
  67         mtdcr( uic0sr, 0xffffffff );
  68
  69         x->ethuart &= ~EPLD2_RESET_ETH_N; /* put Ethernet+PHY in reset */
  70
  71         return  0;
  72 }
  73
  74
  75 /*************************************************************************
  76  *  int misc_init_r()
  77  *
  78  ************************************************************************/
  79 int misc_init_r(void)
  80 {
  81         volatile epld_t *x = (epld_t *) CFG_EPLD_BASE;
  82         x->ethuart |= EPLD2_RESET_ETH_N; /* take Ethernet+PHY out of reset */
  83
  84         return  0;
  85 }
  86
  87
  88 /*************************************************************************
  89  *  int checkboard()
  90  *
  91  ************************************************************************/
  92 int checkboard(void)
  93 {
  94         char *s = getenv("serial#");
  95
  96         printf("Board: Luan - AMCC PPC440SP Evaluation Board");
  97
  98         if (s != NULL) {
  99                 puts(", serial# ");
 100                 puts(s);
 101         }
 102         putc('\n');
 103
 104         return  0;
 105 }
 106
 107
 108 /*************************************************************************
 109  *  int testdram()
 110  *
 111  ************************************************************************/
 112 #if defined(CFG_DRAM_TEST)
 113 int testdram(void)
 114 {
 115         unsigned long *mem = (unsigned long *) 0;
 116         const unsigned long kend = (1024 / sizeof(unsigned long));
 117         unsigned long k, n;
 118
 119         mtmsr(0);
 120
 121         for (k = 0; k < CFG_KBYTES_SDRAM;
 122              ++k, mem += (1024 / sizeof(unsigned long))) {
 123                 if ((k & 1023) == 0) {
 124                         printf("%3d MB\r", k / 1024);
 125                 }
 126
 127                 memset(mem, 0xaaaaaaaa, 1024);
 128                 for (n = 0; n < kend; ++n) {
 129                         if (mem[n] != 0xaaaaaaaa) {
 130                                 printf("SDRAM test fails at: %08x\n",
 131                                        (uint) & mem[n]);
 132                                 return 1;
 133                         }
 134                 }
 135
 136                 memset(mem, 0x55555555, 1024);
 137                 for (n = 0; n < kend; ++n) {
 138                         if (mem[n] != 0x55555555) {
 139                                 printf("SDRAM test fails at: %08x\n",
 140                                        (uint) & mem[n]);
 141                                 return 1;
 142                         }
 143                 }
 144         }
 145         printf("SDRAM test passes\n");
 146
 147         return  0;
 148 }
 149 #endif
 150
 151
 152 /*************************************************************************
 153  *  pci_pre_init
 154  *
 155  *  This routine is called just prior to registering the hose and gives
 156  *  the board the opportunity to check things. Returning a value of zero
 157  *  indicates that things are bad & PCI initialization should be aborted.
 158  *
 159  *      Different boards may wish to customize the pci controller structure
 160  *      (add regions, override default access routines, etc) or perform
 161  *      certain pre-initialization actions.
 162  *
 163  ************************************************************************/
 164 #if defined(CONFIG_PCI)
 165 int pci_pre_init( struct pci_controller *hose )
 166 {
 167         unsigned long strap;
 168
 169         /*--------------------------------------------------------------------------+
 170          *      The luan board is always configured as the host & requires the
 171          *      PCI arbiter to be enabled.
 172          *--------------------------------------------------------------------------*/
 173         mfsdr(sdr_sdstp1, strap);
 174         if( (strap & SDR0_SDSTP1_PAE_MASK) == 0 ) {
 175                 printf("PCI: SDR0_STRP1[%08lX] - PCI Arbiter disabled.\n",strap);
 176
 177                 return  0;
 178         }
 179
 180         return  1;
 181 }
 182 #endif /* defined(CONFIG_PCI) */
 183
 184
 185 /*************************************************************************
 186  *  pci_target_init
 187  *
 188  *      The bootstrap configuration provides default settings for the pci
 189  *      inbound map (PIM). But the bootstrap config choices are limited and
 190  *      may not be sufficient for a given board.
 191  *
 192  ************************************************************************/
 193 #if defined(CONFIG_PCI) && defined(CFG_PCI_TARGET_INIT)
 194 void pci_target_init(struct pci_controller *hose)
 195 {
 196         /*--------------------------------------------------------------------------+
 197          * Disable everything
 198          *--------------------------------------------------------------------------*/
 199         out32r( PCIX0_PIM0SA, 0 ); /* disable */
 200         out32r( PCIX0_PIM1SA, 0 ); /* disable */
 201         out32r( PCIX0_PIM2SA, 0 ); /* disable */
 202         out32r( PCIX0_EROMBA, 0 ); /* disable expansion rom */
 203
 204         /*--------------------------------------------------------------------------+
 205          * Map all of SDRAM to PCI address 0x0000_0000. Note that the 440 strapping
 206          * options to not support sizes such as 128/256 MB.
 207          *--------------------------------------------------------------------------*/
 208         out32r( PCIX0_PIM0LAL, CFG_SDRAM_BASE );
 209         out32r( PCIX0_PIM0LAH, 0 );
 210         out32r( PCIX0_PIM0SA, ~(gd->ram_size - 1) | 1 );
 211
 212         out32r( PCIX0_BAR0, 0 );
 213
 214         /*--------------------------------------------------------------------------+
 215          * Program the board's subsystem id/vendor id
 216          *--------------------------------------------------------------------------*/
 217         out16r( PCIX0_SBSYSVID, CFG_PCI_SUBSYS_VENDORID );
 218         out16r( PCIX0_SBSYSID, CFG_PCI_SUBSYS_DEVICEID );
 219
 220         out16r( PCIX0_CMD, in16r(PCIX0_CMD) | PCI_COMMAND_MEMORY );
 221 }
 222 #endif /* defined(CONFIG_PCI) && defined(CFG_PCI_TARGET_INIT) */
 223
 224
 225 /*************************************************************************
 226  *  is_pci_host
 227  *
 228  *      This routine is called to determine if a pci scan should be
 229  *      performed. With various hardware environments (especially cPCI and
 230  *      PPMC) it's insufficient to depend on the state of the arbiter enable
 231  *      bit in the strap register, or generic host/adapter assumptions.
 232  *
 233  *      Rather than hard-code a bad assumption in the general 440 code, the
 234  *      440 pci code requires the board to decide at runtime.
 235  *
 236  *      Return 0 for adapter mode, non-zero for host (monarch) mode.
 237  *
 238  *
 239  ************************************************************************/
 240 #if defined(CONFIG_PCI)
 241 int is_pci_host(struct pci_controller *hose)
 242 {
 243         return  1;
 244 }
 245 #endif                          /* defined(CONFIG_PCI) */
 246
 247
 248 /*************************************************************************
 249  *  hw_watchdog_reset
 250  *
 251  *      This routine is called to reset (keep alive) the watchdog timer
 252  *
 253  ************************************************************************/
 254 #if defined(CONFIG_HW_WATCHDOG)
 255 void hw_watchdog_reset(void)
 256 {
 257 }
 258 #endif
 259
 260
 261 /*************************************************************************
 262  *  int on_off()
 263  *
 264  ************************************************************************/
 265 static int on_off( const char *s )
 266 {
 267         if (strcmp(s, "on") == 0) {
 268                 return  1;
 269         } else if (strcmp(s, "off") == 0) {
 270                 return  0;
 271         }
 272         return  -1;
 273 }
 274
 275
 276 /*************************************************************************
 277  *  void l2cache_disable()
 278  *
 279  ************************************************************************/
 280 static void l2cache_disable(void)
 281 {
 282         mtdcr( l2_cache_cfg, 0 );
 283 }
 284
 285
 286 /*************************************************************************
 287  *  void l2cache_enable()
 288  *
 289  ************************************************************************/
 290 static void l2cache_enable(void)        /* see p258 7.4.1 Enabling L2 Cache */
 291 {
 292         mtdcr( l2_cache_cfg, 0x80000000 );      /* enable L2_MODE L2_CFG[L2M] */
 293
 294         mtdcr( l2_cache_addr, 0 );              /* set L2_ADDR with all zeros */
 295
 296         mtdcr( l2_cache_cmd, 0x80000000 );      /* issue HCLEAR command via L2_CMD */
 297
 298         while (!(mfdcr( l2_cache_stat ) & 0x80000000 ))  ;; /* poll L2_SR for completion */
 299
 300         mtdcr( l2_cache_cmd, 0x10000000 );      /* clear cache errors L2_CMD[CCP] */
 301
 302         mtdcr( l2_cache_cmd, 0x08000000 );      /* clear tag errors L2_CMD[CTE] */
 303
 304         mtdcr( l2_cache_snp0, 0 );              /* snoop registers */
 305         mtdcr( l2_cache_snp1, 0 );
 306
 307         __asm__ volatile ("sync");              /* msync */
 308
 309         mtdcr( l2_cache_cfg, 0xe0000000 );      /* inst and data use L2 */
 310
 311         __asm__ volatile ("sync");
 312 }
 313
 314
 315 /*************************************************************************
 316  *  int l2cache_status()
 317  *
 318  ************************************************************************/
 319 static int l2cache_status(void)
 320 {
 321         return  (mfdcr( l2_cache_cfg ) & 0x60000000) != 0;
 322 }
 323
 324
 325 /*************************************************************************
 326  *  int do_l2cache()
 327  *
 328  ************************************************************************/
 329 int do_l2cache( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[] )
 330 {
 331         switch (argc) {
 332         case 2:                 /* on / off     */
 333                 switch (on_off(argv[1])) {
 334                 case 0: l2cache_disable();
 335                         break;
 336                 case 1: l2cache_enable();
 337                         break;
 338                 }
 339                 /* FALL TROUGH */
 340         case 1:                 /* get status */
 341                 printf ("L2 Cache is %s\n",
 342                         l2cache_status() ? "ON" : "OFF");
 343                 return 0;
 344         default:
 345                 printf ("Usage:\n%s\n", cmdtp->usage);
 346                 return 1;
 347         }
 348
 349         return  0;
 350 }
 351
 352
 353 U_BOOT_CMD(
 354         l2cache,   2,   1,     do_l2cache,
 355         "l2cache  - enable or disable L2 cache\n",
 356         "[on, off]\n"
 357         "    - enable or disable L2 cache\n"
 358         );