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         u32 mfr;
  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         mfsdr(sdr_mfr, mfr);
  70         mfr |= SDR0_MFR_FIXD;           /* Workaround for PCI/DMA */
  71         mtsdr(sdr_mfr, mfr);
  72
  73         return  0;
  74 }
  75
  76
  77 /*************************************************************************
  78  *  int misc_init_r()
  79  *
  80  ************************************************************************/
  81 int misc_init_r(void)
  82 {
  83         volatile epld_t *x = (epld_t *) CFG_EPLD_BASE;
  84
  85         /* set modes of operation */
  86         x->ethuart |= EPLD2_ETH_MODE_10 | EPLD2_ETH_MODE_100 |
  87                 EPLD2_ETH_MODE_1000 | EPLD2_ETH_DUPLEX_MODE;
  88         /* clear ETHERNET_AUTO_NEGO bit to turn on autonegotiation */
  89         x->ethuart &= ~EPLD2_ETH_AUTO_NEGO;
  90
  91         /* put Ethernet+PHY in reset */
  92         x->ethuart &= ~EPLD2_RESET_ETH_N;
  93         udelay(10000);
  94         /* take Ethernet+PHY out of reset */
  95         x->ethuart |= EPLD2_RESET_ETH_N;
  96
  97         return  0;
  98 }
  99
 100
 101 /*************************************************************************
 102  *  int checkboard()
 103  *
 104  ************************************************************************/
 105 int checkboard(void)
 106 {
 107         char *s = getenv("serial#");
 108
 109         printf("Board: Luan - AMCC PPC440SP Evaluation Board");
 110
 111         if (s != NULL) {
 112                 puts(", serial# ");
 113                 puts(s);
 114         }
 115         putc('\n');
 116
 117         return  0;
 118 }
 119
 120 /*
 121  * Override the default functions in cpu/ppc4xx/44x_spd_ddr2.c with
 122  * board specific values.
 123  */
 124 u32 ddr_clktr(u32 default_val) {
 125         return (SDRAM_CLKTR_CLKP_180_DEG_ADV);
 126 }
 127
 128 /*************************************************************************
 129  *  int testdram()
 130  *
 131  ************************************************************************/
 132 #if defined(CFG_DRAM_TEST)
 133 int testdram(void)
 134 {
 135         unsigned long *mem = (unsigned long *) 0;
 136         const unsigned long kend = (1024 / sizeof(unsigned long));
 137         unsigned long k, n;
 138
 139         mtmsr(0);
 140
 141         for (k = 0; k < CFG_KBYTES_SDRAM;
 142              ++k, mem += (1024 / sizeof(unsigned long))) {
 143                 if ((k & 1023) == 0) {
 144                         printf("%3d MB\r", k / 1024);
 145                 }
 146
 147                 memset(mem, 0xaaaaaaaa, 1024);
 148                 for (n = 0; n < kend; ++n) {
 149                         if (mem[n] != 0xaaaaaaaa) {
 150                                 printf("SDRAM test fails at: %08x\n",
 151                                        (uint) & mem[n]);
 152                                 return 1;
 153                         }
 154                 }
 155
 156                 memset(mem, 0x55555555, 1024);
 157                 for (n = 0; n < kend; ++n) {
 158                         if (mem[n] != 0x55555555) {
 159                                 printf("SDRAM test fails at: %08x\n",
 160                                        (uint) & mem[n]);
 161                                 return 1;
 162                         }
 163                 }
 164         }
 165         printf("SDRAM test passes\n");
 166
 167         return  0;
 168 }
 169 #endif
 170
 171
 172 /*************************************************************************
 173  *  pci_pre_init
 174  *
 175  *  This routine is called just prior to registering the hose and gives
 176  *  the board the opportunity to check things. Returning a value of zero
 177  *  indicates that things are bad & PCI initialization should be aborted.
 178  *
 179  *      Different boards may wish to customize the pci controller structure
 180  *      (add regions, override default access routines, etc) or perform
 181  *      certain pre-initialization actions.
 182  *
 183  ************************************************************************/
 184 #if defined(CONFIG_PCI)
 185 int pci_pre_init( struct pci_controller *hose )
 186 {
 187         unsigned long strap;
 188
 189         /*--------------------------------------------------------------------------+
 190          *      The luan board is always configured as the host & requires the
 191          *      PCI arbiter to be enabled.
 192          *--------------------------------------------------------------------------*/
 193         mfsdr(sdr_sdstp1, strap);
 194         if( (strap & SDR0_SDSTP1_PAE_MASK) == 0 ) {
 195                 printf("PCI: SDR0_STRP1[%08lX] - PCI Arbiter disabled.\n",strap);
 196
 197                 return  0;
 198         }
 199
 200         return  1;
 201 }
 202 #endif /* defined(CONFIG_PCI) */
 203
 204
 205 /*************************************************************************
 206  *  pci_target_init
 207  *
 208  *      The bootstrap configuration provides default settings for the pci
 209  *      inbound map (PIM). But the bootstrap config choices are limited and
 210  *      may not be sufficient for a given board.
 211  *
 212  ************************************************************************/
 213 #if defined(CONFIG_PCI) && defined(CFG_PCI_TARGET_INIT)
 214 void pci_target_init(struct pci_controller *hose)
 215 {
 216         /*--------------------------------------------------------------------------+
 217          * Disable everything
 218          *--------------------------------------------------------------------------*/
 219         out32r( PCIX0_PIM0SA, 0 ); /* disable */
 220         out32r( PCIX0_PIM1SA, 0 ); /* disable */
 221         out32r( PCIX0_PIM2SA, 0 ); /* disable */
 222         out32r( PCIX0_EROMBA, 0 ); /* disable expansion rom */
 223
 224         /*--------------------------------------------------------------------------+
 225          * Map all of SDRAM to PCI address 0x0000_0000. Note that the 440 strapping
 226          * options to not support sizes such as 128/256 MB.
 227          *--------------------------------------------------------------------------*/
 228         out32r( PCIX0_PIM0LAL, CFG_SDRAM_BASE );
 229         out32r( PCIX0_PIM0LAH, 0 );
 230         out32r( PCIX0_PIM0SA, ~(gd->ram_size - 1) | 1 );
 231
 232         out32r( PCIX0_BAR0, 0 );
 233
 234         /*--------------------------------------------------------------------------+
 235          * Program the board's subsystem id/vendor id
 236          *--------------------------------------------------------------------------*/
 237         out16r( PCIX0_SBSYSVID, CFG_PCI_SUBSYS_VENDORID );
 238         out16r( PCIX0_SBSYSID, CFG_PCI_SUBSYS_DEVICEID );
 239
 240         out16r( PCIX0_CMD, in16r(PCIX0_CMD) | PCI_COMMAND_MEMORY );
 241 }
 242 #endif /* defined(CONFIG_PCI) && defined(CFG_PCI_TARGET_INIT) */
 243
 244
 245 /*************************************************************************
 246  *  is_pci_host
 247  *
 248  *      This routine is called to determine if a pci scan should be
 249  *      performed. With various hardware environments (especially cPCI and
 250  *      PPMC) it's insufficient to depend on the state of the arbiter enable
 251  *      bit in the strap register, or generic host/adapter assumptions.
 252  *
 253  *      Rather than hard-code a bad assumption in the general 440 code, the
 254  *      440 pci code requires the board to decide at runtime.
 255  *
 256  *      Return 0 for adapter mode, non-zero for host (monarch) mode.
 257  *
 258  *
 259  ************************************************************************/
 260 #if defined(CONFIG_PCI)
 261 int is_pci_host(struct pci_controller *hose)
 262 {
 263         return  1;
 264 }
 265 #endif                          /* defined(CONFIG_PCI) */
 266
 267
 268 /*************************************************************************
 269  *  hw_watchdog_reset
 270  *
 271  *      This routine is called to reset (keep alive) the watchdog timer
 272  *
 273  ************************************************************************/
 274 #if defined(CONFIG_HW_WATCHDOG)
 275 void hw_watchdog_reset(void)
 276 {
 277 }
 278 #endif
 279
 280
 281 /*************************************************************************
 282  *  int on_off()
 283  *
 284  ************************************************************************/
 285 static int on_off( const char *s )
 286 {
 287         if (strcmp(s, "on") == 0) {
 288                 return  1;
 289         } else if (strcmp(s, "off") == 0) {
 290                 return  0;
 291         }
 292         return  -1;
 293 }
 294
 295
 296 /*************************************************************************
 297  *  void l2cache_disable()
 298  *
 299  ************************************************************************/
 300 static void l2cache_disable(void)
 301 {
 302         mtdcr( l2_cache_cfg, 0 );
 303 }
 304
 305
 306 /*************************************************************************
 307  *  void l2cache_enable()
 308  *
 309  ************************************************************************/
 310 static void l2cache_enable(void)        /* see p258 7.4.1 Enabling L2 Cache */
 311 {
 312         mtdcr( l2_cache_cfg, 0x80000000 );      /* enable L2_MODE L2_CFG[L2M] */
 313
 314         mtdcr( l2_cache_addr, 0 );              /* set L2_ADDR with all zeros */
 315
 316         mtdcr( l2_cache_cmd, 0x80000000 );      /* issue HCLEAR command via L2_CMD */
 317
 318         while (!(mfdcr( l2_cache_stat ) & 0x80000000 ))  ;; /* poll L2_SR for completion */
 319
 320         mtdcr( l2_cache_cmd, 0x10000000 );      /* clear cache errors L2_CMD[CCP] */
 321
 322         mtdcr( l2_cache_cmd, 0x08000000 );      /* clear tag errors L2_CMD[CTE] */
 323
 324         mtdcr( l2_cache_snp0, 0 );              /* snoop registers */
 325         mtdcr( l2_cache_snp1, 0 );
 326
 327         __asm__ volatile ("sync");              /* msync */
 328
 329         mtdcr( l2_cache_cfg, 0xe0000000 );      /* inst and data use L2 */
 330
 331         __asm__ volatile ("sync");
 332 }
 333
 334
 335 /*************************************************************************
 336  *  int l2cache_status()
 337  *
 338  ************************************************************************/
 339 static int l2cache_status(void)
 340 {
 341         return  (mfdcr( l2_cache_cfg ) & 0x60000000) != 0;
 342 }
 343
 344
 345 /*************************************************************************
 346  *  int do_l2cache()
 347  *
 348  ************************************************************************/
 349 int do_l2cache( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[] )
 350 {
 351         switch (argc) {
 352         case 2:                 /* on / off     */
 353                 switch (on_off(argv[1])) {
 354                 case 0: l2cache_disable();
 355                         break;
 356                 case 1: l2cache_enable();
 357                         break;
 358                 }
 359                 /* FALL TROUGH */
 360         case 1:                 /* get status */
 361                 printf ("L2 Cache is %s\n",
 362                         l2cache_status() ? "ON" : "OFF");
 363                 return 0;
 364         default:
 365                 printf ("Usage:\n%s\n", cmdtp->usage);
 366                 return 1;
 367         }
 368
 369         return  0;
 370 }
 371
 372
 373 U_BOOT_CMD(
 374         l2cache,   2,   1,     do_l2cache,
 375         "l2cache  - enable or disable L2 cache\n",
 376         "[on, off]\n"
 377         "    - enable or disable L2 cache\n"
 378         );