arch/blackfin/cpu/start.S

   1 /*
   2  * U-boot - start.S Startup file for Blackfin u-boot
   3  *
   4  * Copyright (c) 2005-2008 Analog Devices Inc.
   5  *
   6  * This file is based on head.S
   7  * Copyright (c) 2003  Metrowerks/Motorola
   8  * Copyright (C) 1998  D. Jeff Dionne <jeff@ryeham.ee.ryerson.ca>,
   9  *                     Kenneth Albanowski <kjahds@kjahds.com>,
  10  *                     The Silver Hammer Group, Ltd.
  11  * (c) 1995, Dionne & Associates
  12  * (c) 1995, DKG Display Tech.
  13  *
  14  * See file CREDITS for list of people who contributed to this
  15  * project.
  16  *
  17  * This program is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU General Public License as
  19  * published by the Free Software Foundation; either version 2 of
  20  * the License, or (at your option) any later version.
  21  *
  22  * This program is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  25  * GNU General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU General Public License
  28  * along with this program; if not, write to the Free Software
  29  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
  30  * MA 02110-1301 USA
  31  */
  32
  33 #include <config.h>
  34 #include <asm/blackfin.h>
  35 #include <asm/mach-common/bits/watchdog.h>
  36 #include <asm/mach-common/bits/core.h>
  37 #include <asm/mach-common/bits/pll.h>
  38 #include <asm/serial.h>
  39
  40 /* It may seem odd that we make calls to functions even though we haven't
  41  * relocated ourselves yet out of {flash,ram,wherever}.  This is OK because
  42  * the "call" instruction in the Blackfin architecture is actually PC
  43  * relative.  So we can call functions all we want and not worry about them
  44  * not being relocated yet.
  45  */
  46
  47 .text
  48 ENTRY(_start)
  49
  50         /* Set our initial stack to L1 scratch space */
  51         sp.l = LO(L1_SRAM_SCRATCH_END - 20);
  52         sp.h = HI(L1_SRAM_SCRATCH_END - 20);
  53
  54         /* Optimization register tricks: keep a base value in the
  55          * reserved P registers so we use the load/store with an
  56          * offset syntax.  R0 = [P5 + <constant>];
  57          *   P4 - system MMR base
  58          *   P5 - core MMR base
  59          */
  60 #ifdef CONFIG_HW_WATCHDOG
  61         p4.l = 0;
  62         p4.h = HI(SYSMMR_BASE);
  63 #endif
  64         p5.l = 0;
  65         p5.h = HI(COREMMR_BASE);
  66
  67 #ifdef CONFIG_HW_WATCHDOG
  68         /* Program the watchdog with default timeout of ~5 seconds.
  69          * That should be long enough to bootstrap ourselves up and
  70          * then the common u-boot code can take over.
  71          */
  72         r1 = WDDIS;
  73 # ifdef __ADSPBF60x__
  74         [p4 + (WDOG_CTL - SYSMMR_BASE)] = r1;
  75 # else
  76         W[p4 + (WDOG_CTL - SYSMMR_BASE)] = r1;
  77 # endif
  78         SSYNC;
  79         r0 = 0;
  80         r0.h = HI(MSEC_TO_SCLK(CONFIG_WATCHDOG_TIMEOUT_MSECS));
  81         [p4 + (WDOG_CNT - SYSMMR_BASE)] = r0;
  82         SSYNC;
  83         r1 = WDEN;
  84         /* fire up the watchdog - R0.L above needs to be 0x0000 */
  85 # ifdef __ADSPBF60x__
  86         [p4 + (WDOG_CTL - SYSMMR_BASE)] = r1;
  87 # else
  88         W[p4 + (WDOG_CTL - SYSMMR_BASE)] = r1;
  89 # endif
  90         SSYNC;
  91 #endif
  92
  93         /* Turn on the serial for debugging the init process */
  94         serial_early_init
  95         serial_early_set_baud
  96
  97         serial_early_puts("Init Registers");
  98
  99         /* Disable self-nested interrupts and enable CYCLES for udelay() */
 100         R0 = CCEN | 0x30;
 101         SYSCFG = R0;
 102
 103         /* Zero out registers required by Blackfin ABI.
 104          * http://docs.blackfin.uclinux.org/doku.php?id=application_binary_interface
 105          */
 106         r1 = 0 (x);
 107         /* Disable circular buffers */
 108         l0 = r1;
 109         l1 = r1;
 110         l2 = r1;
 111         l3 = r1;
 112         /* Disable hardware loops in case we were started by 'go' */
 113         lc0 = r1;
 114         lc1 = r1;
 115
 116         /* Save RETX so we can pass it while booting Linux */
 117         r7 = RETX;
 118
 119 #if CONFIG_MEM_SIZE
 120         /* Figure out where we are currently executing so that we can decide
 121          * how to best reprogram and relocate things.  We'll pass below:
 122          *  R4: load address of _start
 123          *  R5: current (not load) address of _start
 124          */
 125         serial_early_puts("Find ourselves");
 126
 127         call _get_pc;
 128 .Loffset:
 129         r1.l = .Loffset;
 130         r1.h = .Loffset;
 131         r4.l = _start;
 132         r4.h = _start;
 133         r3 = r1 - r4;
 134         r5 = r0 - r3;
 135
 136         /* Inform upper layers if we had to do the relocation ourselves.
 137          * This allows us to detect whether we were loaded by 'go 0x1000'
 138          * or by the bootrom from an LDR.  "R6" is "loaded_from_ldr".
 139          */
 140         r6 = 1 (x);
 141         cc = r4 == r5;
 142         if cc jump .Lnorelocate;
 143         r6 = 0 (x);
 144
 145         /* Turn off caches as they require CPLBs and a CPLB miss requires
 146          * a software exception handler to process it.  But we're about to
 147          * clobber any previous executing software (like U-Boot that just
 148          * launched a new U-Boot via 'go'), so any handler state will be
 149          * unreliable after the memcpy below.
 150          */
 151         serial_early_puts("Kill Caches");
 152         r0 = 0;
 153         [p5 + (IMEM_CONTROL - COREMMR_BASE)] = r0;
 154         [p5 + (DMEM_CONTROL - COREMMR_BASE)] = r0;
 155         ssync;
 156
 157         /* In bypass mode, we don't have an LDR with an init block
 158          * so we need to explicitly call it ourselves.  This will
 159          * reprogram our clocks, memory, and setup our async banks.
 160          */
 161         serial_early_puts("Program Clocks");
 162
 163         /* if we're executing >=0x20000000, then we dont need to dma */
 164         r3 = 0x0;
 165         r3.h = 0x2000;
 166         cc = r5 < r3 (iu);
 167         if cc jump .Ldma_and_reprogram;
 168 #else
 169         r6 = 1 (x);     /* fake loaded_from_ldr = 1 */
 170 #endif
 171         r0 = 0 (x);     /* set bootstruct to NULL */
 172         call _initcode;
 173         jump .Lprogrammed;
 174
 175         /* we're sitting in external memory, so dma into L1 and reprogram */
 176 .Ldma_and_reprogram:
 177         r0.l = LO(L1_INST_SRAM);
 178         r0.h = HI(L1_INST_SRAM);
 179         r1.l = __initcode_lma;
 180         r1.h = __initcode_lma;
 181         r2.l = __initcode_len;
 182         r2.h = __initcode_len;
 183         r1 = r1 - r4;   /* convert r1 from load address of initcode ... */
 184         r1 = r1 + r5;   /* ... to current (not load) address of initcode */
 185         p3 = r0;
 186         call _dma_memcpy_nocache;
 187         r0 = 0 (x);     /* set bootstruct to NULL */
 188         call (p3);
 189
 190         /* Since we reprogrammed SCLK, we need to update the serial divisor */
 191 .Lprogrammed:
 192         serial_early_set_baud
 193
 194 #if CONFIG_MEM_SIZE
 195         /* Relocate from wherever we are (FLASH/RAM/etc...) to the hardcoded
 196          * monitor location in the end of RAM.  We know that memcpy() only
 197          * uses registers, so it is safe to call here.  Note that this only
 198          * copies to external memory ... we do not start executing out of
 199          * it yet (see "lower to 15" below).
 200          */
 201         serial_early_puts("Relocate");
 202         r0 = r4;
 203         r1 = r5;
 204         r2.l = LO(CONFIG_SYS_MONITOR_LEN);
 205         r2.h = HI(CONFIG_SYS_MONITOR_LEN);
 206         call _memcpy_ASM;
 207 #endif
 208
 209         /* Initialize BSS section ... we know that memset() does not
 210          * use the BSS, so it is safe to call here.  The bootrom LDR
 211          * takes care of clearing things for us.
 212          */
 213         serial_early_puts("Zero BSS");
 214         r0.l = __bss_vma;
 215         r0.h = __bss_vma;
 216         r1 = 0 (x);
 217         r2.l = __bss_len;
 218         r2.h = __bss_len;
 219         call _memset;
 220
 221 .Lnorelocate:
 222
 223         /* Setup the actual stack in external memory */
 224         sp.h = HI(CONFIG_STACKBASE);
 225         sp.l = LO(CONFIG_STACKBASE);
 226         fp = sp;
 227
 228         /* Now lower ourselves from the highest interrupt level to
 229          * the lowest.  We do this by masking all interrupts but 15,
 230          * setting the 15 handler to ".Lenable_nested", raising the 15
 231          * interrupt, and then returning from the highest interrupt
 232          * level to the dummy "jump" until the interrupt controller
 233          * services the pending 15 interrupt.  If executing out of
 234          * flash, these steps also changes the code flow from flash
 235          * to external memory.
 236          */
 237         serial_early_puts("Lower to 15");
 238         r0 = r7;
 239         r1 = r6;
 240         p1.l = .Lenable_nested;
 241         p1.h = .Lenable_nested;
 242         [p5 + (EVT15 - COREMMR_BASE)] = p1;
 243         r7 = EVT_IVG15 (z);
 244         sti r7;
 245         raise 15;
 246         p3.l = .LWAIT_HERE;
 247         p3.h = .LWAIT_HERE;
 248         reti = p3;
 249         rti;
 250
 251         /* Enable nested interrupts before continuing with cpu init */
 252 .Lenable_nested:
 253         cli r7;
 254         [--sp] = reti;
 255         jump.l _cpu_init_f;
 256
 257 .LWAIT_HERE:
 258         jump .LWAIT_HERE;
 259 ENDPROC(_start)
 260
 261 LENTRY(_get_pc)
 262         r0 = rets;
 263 #if ANOMALY_05000371
 264         NOP;
 265         NOP;
 266         NOP;
 267 #endif
 268         rts;
 269 ENDPROC(_get_pc)