1 /* 2 * (C) Copyright 2010 3 * Marvell Semiconductor <www.marvell.com> 4 * Written-by: Prafulla Wadaskar <prafulla@marvell.com> 5 * Contributor: Mahavir Jain <mjain@marvell.com> 6 * 7 * See file CREDITS for list of people who contributed to this 8 * project. 9 * 10 * This program is free software; you can redistribute it and/or 11 * modify it under the terms of the GNU General Public License as 12 * published by the Free Software Foundation; either version 2 of 13 * the License, or (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, 23 * MA 02110-1301 USA 24 */ 25 26 #include <common.h> 27 #include <asm/arch/armada100.h> 28 29 /* 30 * Timer registers 31 * Refer Section A.6 in Datasheet 32 */ 33 struct armd1tmr_registers { 34 u32 clk_ctrl; /* Timer clk control reg */ 35 u32 match[9]; /* Timer match registers */ 36 u32 count[3]; /* Timer count registers */ 37 u32 status[3]; 38 u32 ie[3]; 39 u32 preload[3]; /* Timer preload value */ 40 u32 preload_ctrl[3]; 41 u32 wdt_match_en; 42 u32 wdt_match_r; 43 u32 wdt_val; 44 u32 wdt_sts; 45 u32 icr[3]; 46 u32 wdt_icr; 47 u32 cer; /* Timer count enable reg */ 48 u32 cmr; 49 u32 ilr[3]; 50 u32 wcr; 51 u32 wfar; 52 u32 wsar; 53 u32 cvwr; 54 }; 55 56 #define TIMER 0 /* Use TIMER 0 */ 57 /* Each timer has 3 match registers */ 58 #define MATCH_CMP(x) ((3 * TIMER) + x) 59 #define TIMER_LOAD_VAL 0xffffffff 60 #define COUNT_RD_REQ 0x1 61 62 DECLARE_GLOBAL_DATA_PTR; 63 /* Using gd->tbu from timestamp and gd->tbl for lastdec */ 64 65 /* For preventing risk of instability in reading counter value, 66 * first set read request to register cvwr and then read same 67 * register after it captures counter value. 68 */ 69 ulong read_timer(void) 70 { 71 struct armd1tmr_registers *armd1timers = 72 (struct armd1tmr_registers *) ARMD1_TIMER_BASE; 73 volatile int loop=100; 74 75 writel(COUNT_RD_REQ, &armd1timers->cvwr); 76 while (loop--); 77 return(readl(&armd1timers->cvwr)); 78 } 79 80 ulong get_timer_masked(void) 81 { 82 ulong now = read_timer(); 83 84 if (now >= gd->tbl) { 85 /* normal mode */ 86 gd->tbu += now - gd->tbl; 87 } else { 88 /* we have an overflow ... */ 89 gd->tbu += now + TIMER_LOAD_VAL - gd->tbl; 90 } 91 gd->tbl = now; 92 93 return gd->tbu; 94 } 95 96 ulong get_timer(ulong base) 97 { 98 return ((get_timer_masked() / (CONFIG_SYS_HZ_CLOCK / 1000)) - 99 base); 100 } 101 102 void __udelay(unsigned long usec) 103 { 104 ulong delayticks; 105 ulong endtime; 106 107 delayticks = (usec * (CONFIG_SYS_HZ_CLOCK / 1000000)); 108 endtime = get_timer_masked() + delayticks; 109 110 while (get_timer_masked() < endtime); 111 } 112 113 /* 114 * init the Timer 115 */ 116 int timer_init(void) 117 { 118 struct armd1apb1_registers *apb1clkres = 119 (struct armd1apb1_registers *) ARMD1_APBC1_BASE; 120 struct armd1tmr_registers *armd1timers = 121 (struct armd1tmr_registers *) ARMD1_TIMER_BASE; 122 123 /* Enable Timer clock at 3.25 MHZ */ 124 writel(APBC_APBCLK | APBC_FNCLK | APBC_FNCLKSEL(3), &apb1clkres->timers); 125 126 /* load value into timer */ 127 writel(0x0, &armd1timers->clk_ctrl); 128 /* Use Timer 0 Match Resiger 0 */ 129 writel(TIMER_LOAD_VAL, &armd1timers->match[MATCH_CMP(0)]); 130 /* Preload value is 0 */ 131 writel(0x0, &armd1timers->preload[TIMER]); 132 /* Enable match comparator 0 for Timer 0 */ 133 writel(0x1, &armd1timers->preload_ctrl[TIMER]); 134 135 /* Enable timer 0 */ 136 writel(0x1, &armd1timers->cer); 137 /* init the gd->tbu and gd->tbl value */ 138 gd->tbl = read_timer(); 139 gd->tbu = 0; 140 141 return 0; 142 } 143 144 #define MPMU_APRR_WDTR (1<<4) 145 #define TMR_WFAR 0xbaba /* WDT Register First key */ 146 #define TMP_WSAR 0xeb10 /* WDT Register Second key */ 147 148 /* 149 * This function uses internal Watchdog Timer 150 * based reset mechanism. 151 * Steps to write watchdog registers (protected access) 152 * 1. Write key value to TMR_WFAR reg. 153 * 2. Write key value to TMP_WSAR reg. 154 * 3. Perform write operation. 155 */ 156 void reset_cpu (unsigned long ignored) 157 { 158 struct armd1mpmu_registers *mpmu = 159 (struct armd1mpmu_registers *) ARMD1_MPMU_BASE; 160 struct armd1tmr_registers *armd1timers = 161 (struct armd1tmr_registers *) ARMD1_TIMER_BASE; 162 u32 val; 163 164 /* negate hardware reset to the WDT after system reset */ 165 val = readl(&mpmu->aprr); 166 val = val | MPMU_APRR_WDTR; 167 writel(val, &mpmu->aprr); 168 169 /* reset/enable WDT clock */ 170 writel(APBC_APBCLK | APBC_FNCLK | APBC_RST, &mpmu->wdtpcr); 171 readl(&mpmu->wdtpcr); 172 writel(APBC_APBCLK | APBC_FNCLK, &mpmu->wdtpcr); 173 readl(&mpmu->wdtpcr); 174 175 /* clear previous WDT status */ 176 writel(TMR_WFAR, &armd1timers->wfar); 177 writel(TMP_WSAR, &armd1timers->wsar); 178 writel(0, &armd1timers->wdt_sts); 179 180 /* set match counter */ 181 writel(TMR_WFAR, &armd1timers->wfar); 182 writel(TMP_WSAR, &armd1timers->wsar); 183 writel(0xf, &armd1timers->wdt_match_r); 184 185 /* enable WDT reset */ 186 writel(TMR_WFAR, &armd1timers->wfar); 187 writel(TMP_WSAR, &armd1timers->wsar); 188 writel(0x3, &armd1timers->wdt_match_en); 189 190 while(1); 191 } 192