cpu/at91rm9200/interrupts.c

   1 /*
   2  * (C) Copyright 2002
   3  * Lineo, Inc. <www.lineo.com>
   4  * Bernhard Kuhn <bkuhn@lineo.com>
   5  *
   6  * (C) Copyright 2002
   7  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   8  * Marius Groeger <mgroeger@sysgo.de>
   9  *
  10  * (C) Copyright 2002
  11  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
  12  * Alex Zuepke <azu@sysgo.de>
  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., 59 Temple Place, Suite 330, Boston,
  30  * MA 02111-1307 USA
  31  */
  32
  33 #include <common.h>
  34 #include <asm/io.h>
  35 #include <asm/arch/hardware.h>
  36 #include <asm/proc/ptrace.h>
  37
  38 extern void reset_cpu(ulong addr);
  39
  40 /* we always count down the max. */
  41 #define TIMER_LOAD_VAL 0xffff
  42
  43 /* macro to read the 16 bit timer */
  44 #define READ_TIMER (tmr->TC_CV)
  45 AT91PS_TC tmr;
  46
  47
  48
  49 void enable_interrupts (void)
  50 {
  51     return;
  52 }
  53 int disable_interrupts (void)
  54 {
  55     return 0;
  56 }
  57
  58
  59 void bad_mode(void)
  60 {
  61     panic("Resetting CPU ...\n");
  62     reset_cpu(0);
  63 }
  64
  65 void show_regs(struct pt_regs * regs)
  66 {
  67     unsigned long flags;
  68 const char *processor_modes[]=
  69 { "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" ,
  70   "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26",
  71   "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "UK6_32" , "ABT_32" ,
  72   "UK8_32" , "UK9_32" , "UK10_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32"
  73 };
  74
  75     flags = condition_codes(regs);
  76
  77     printf("pc : [<%08lx>]    lr : [<%08lx>]\n"
  78            "sp : %08lx  ip : %08lx  fp : %08lx\n",
  79            instruction_pointer(regs),
  80            regs->ARM_lr, regs->ARM_sp,
  81            regs->ARM_ip, regs->ARM_fp);
  82     printf("r10: %08lx  r9 : %08lx  r8 : %08lx\n",
  83            regs->ARM_r10, regs->ARM_r9,
  84            regs->ARM_r8);
  85     printf("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
  86            regs->ARM_r7, regs->ARM_r6,
  87            regs->ARM_r5, regs->ARM_r4);
  88     printf("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
  89            regs->ARM_r3, regs->ARM_r2,
  90            regs->ARM_r1, regs->ARM_r0);
  91     printf("Flags: %c%c%c%c",
  92            flags & CC_N_BIT ? 'N' : 'n',
  93            flags & CC_Z_BIT ? 'Z' : 'z',
  94            flags & CC_C_BIT ? 'C' : 'c',
  95            flags & CC_V_BIT ? 'V' : 'v');
  96     printf("  IRQs %s  FIQs %s  Mode %s%s\n",
  97            interrupts_enabled(regs) ? "on" : "off",
  98            fast_interrupts_enabled(regs) ? "on" : "off",
  99            processor_modes[processor_mode(regs)],
 100            thumb_mode(regs) ? " (T)" : "");
 101 }
 102
 103 void do_undefined_instruction(struct pt_regs *pt_regs)
 104 {
 105     printf("undefined instruction\n");
 106     show_regs(pt_regs);
 107     bad_mode();
 108 }
 109
 110 void do_software_interrupt(struct pt_regs *pt_regs)
 111 {
 112     printf("software interrupt\n");
 113     show_regs(pt_regs);
 114     bad_mode();
 115 }
 116
 117 void do_prefetch_abort(struct pt_regs *pt_regs)
 118 {
 119     printf("prefetch abort\n");
 120     show_regs(pt_regs);
 121     bad_mode();
 122 }
 123
 124 void do_data_abort(struct pt_regs *pt_regs)
 125 {
 126     printf("data abort\n");
 127     show_regs(pt_regs);
 128     bad_mode();
 129 }
 130
 131 void do_not_used(struct pt_regs *pt_regs)
 132 {
 133     printf("not used\n");
 134     show_regs(pt_regs);
 135     bad_mode();
 136 }
 137
 138 void do_fiq(struct pt_regs *pt_regs)
 139 {
 140     printf("fast interrupt request\n");
 141     show_regs(pt_regs);
 142     bad_mode();
 143 }
 144
 145 void do_irq(struct pt_regs *pt_regs)
 146 {
 147     printf("interrupt request\n");
 148     show_regs(pt_regs);
 149     bad_mode();
 150 }
 151
 152 static ulong timestamp;
 153 static ulong lastinc;
 154
 155 int interrupt_init (void)
 156 {
 157
 158     tmr = AT91C_BASE_TC0;
 159
 160     /* enables TC1.0 clock */
 161     *AT91C_PMC_PCER = 1 << AT91C_ID_TC0;  /* enable clock */
 162
 163     *AT91C_TCB0_BCR = 0;
 164     *AT91C_TCB0_BMR = AT91C_TCB_TC0XC0S_NONE | AT91C_TCB_TC1XC1S_NONE | AT91C_TCB_TC2XC2S_NONE;
 165     tmr->TC_CCR = AT91C_TC_CLKDIS;
 166     tmr->TC_CMR = AT91C_TC_TIMER_DIV1_CLOCK;  /* set to MCLK/2 */
 167
 168     tmr->TC_IDR = ~0ul;
 169     tmr->TC_RC = TIMER_LOAD_VAL;
 170     lastinc = TIMER_LOAD_VAL;
 171     tmr->TC_CCR = AT91C_TC_SWTRG | AT91C_TC_CLKEN;
 172     timestamp = 0;
 173     return (0);
 174 }
 175
 176 /*
 177  * timer without interrupts
 178  */
 179
 180 void reset_timer(void)
 181 {
 182     reset_timer_masked();
 183 }
 184
 185 ulong get_timer (ulong base)
 186 {
 187     return get_timer_masked() - base;
 188 }
 189
 190 void set_timer (ulong t)
 191 {
 192     timestamp = t;
 193 }
 194
 195 void udelay(unsigned long usec)
 196 {
 197     udelay_masked(usec);
 198 }
 199
 200 void reset_timer_masked(void)
 201 {
 202     /* reset time */
 203     lastinc = READ_TIMER;
 204     timestamp = 0;
 205 }
 206
 207 ulong get_timer_masked(void)
 208 {
 209     ulong now = READ_TIMER;
 210     if (now >= lastinc)
 211     {
 212         /* normal mode */
 213         timestamp += now - lastinc;
 214     } else {
 215         /* we have an overflow ... */
 216         timestamp += now + TIMER_LOAD_VAL - lastinc;
 217     }
 218     lastinc = now;
 219
 220     return timestamp;
 221 }
 222
 223 void udelay_masked(unsigned long usec)
 224 {
 225     ulong tmo;
 226
 227     tmo = usec / 1000;
 228     tmo *= CFG_HZ;
 229     tmo /= 1000;
 230
 231     reset_timer_masked();
 232
 233     while(get_timer_masked() < tmo);
 234       /*NOP*/;
 235 }
 236
 237