include/asm-sh/system.h

   1 #ifndef __ASM_SH_SYSTEM_H
   2 #define __ASM_SH_SYSTEM_H
   3
   4 /*
   5  * Copyright (C) 1999, 2000  Niibe Yutaka  &  Kaz Kojima
   6  */
   7
   8 #include <linux/config.h>
   9
  10 /*
  11  *      switch_to() should switch tasks to task nr n, first
  12  */
  13
  14 typedef struct {
  15         unsigned long seg;
  16 } mm_segment_t;
  17
  18 #ifdef CONFIG_SMP
  19 #error no SMP SuperH
  20 #else
  21 #define prepare_to_switch()     do { } while(0)
  22 #define switch_to(prev,next,last) do { \
  23  register struct task_struct *__last; \
  24  register unsigned long *__ts1 __asm__ ("r1") = &prev->thread.sp; \
  25  register unsigned long *__ts2 __asm__ ("r2") = &prev->thread.pc; \
  26  register unsigned long *__ts4 __asm__ ("r4") = (unsigned long *)prev; \
  27  register unsigned long *__ts5 __asm__ ("r5") = (unsigned long *)next; \
  28  register unsigned long *__ts6 __asm__ ("r6") = &next->thread.sp; \
  29  register unsigned long __ts7 __asm__ ("r7") = next->thread.pc; \
  30  __asm__ __volatile__ (".balign 4\n\t" \
  31                        "stc.l   $gbr, @-$r15\n\t" \
  32                        "sts.l   $pr, @-$r15\n\t" \
  33                        "mov.l   $r8, @-$r15\n\t" \
  34                        "mov.l   $r9, @-$r15\n\t" \
  35                        "mov.l   $r10, @-$r15\n\t" \
  36                        "mov.l   $r11, @-$r15\n\t" \
  37                        "mov.l   $r12, @-$r15\n\t" \
  38                        "mov.l   $r13, @-$r15\n\t" \
  39                        "mov.l   $r14, @-$r15\n\t" \
  40                        "mov.l   $r15, @$r1      ! save SP\n\t" \
  41                        "mov.l   @$r6, $r15      ! change to new stack\n\t" \
  42                        "mov.l   %0, @-$r15      ! push R0 onto new stack\n\t" \
  43                        "mova    1f, %0\n\t" \
  44                        "mov.l   %0, @$r2        ! save PC\n\t" \
  45                        "mov.l   2f, %0\n\t" \
  46                        "jmp     @%0             ! call __switch_to\n\t" \
  47                        " lds    $r7, $pr        !  with return to new PC\n\t" \
  48                        ".balign 4\n"    \
  49                        "2:\n\t" \
  50                        ".long   " "__switch_to\n" \
  51                        "1:\n\t" \
  52                        "mov.l   @$r15+, %0      ! pop R0 from new stack\n\t" \
  53                        "mov.l   @$r15+, $r14\n\t" \
  54                        "mov.l   @$r15+, $r13\n\t" \
  55                        "mov.l   @$r15+, $r12\n\t" \
  56                        "mov.l   @$r15+, $r11\n\t" \
  57                        "mov.l   @$r15+, $r10\n\t" \
  58                        "mov.l   @$r15+, $r9\n\t" \
  59                        "mov.l   @$r15+, $r8\n\t" \
  60                        "lds.l   @$r15+, $pr\n\t" \
  61                        "ldc.l   @$r15+, $gbr\n\t" \
  62                        :"=&z" (__last) \
  63                        :"0" (prev), \
  64                         "r" (__ts1), "r" (__ts2), \
  65                         "r" (__ts4), "r" (__ts5), "r" (__ts6), "r" (__ts7) \
  66                        :"r3", "t"); \
  67   last = __last; \
  68 } while (0)
  69 #endif
  70
  71 #define nop() __asm__ __volatile__ ("nop")
  72
  73
  74 #define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))
  75
  76 static __inline__ unsigned long tas(volatile int *m)
  77 { /* #define tas(ptr) (xchg((ptr),1)) */
  78         unsigned long retval;
  79
  80         __asm__ __volatile__ ("tas.b    @%1\n\t"
  81                               "movt     %0"
  82                               : "=r" (retval): "r" (m): "t", "memory");
  83         return retval;
  84 }
  85
  86 extern void __xchg_called_with_bad_pointer(void);
  87
  88 #define mb()    __asm__ __volatile__ ("": : :"memory")
  89 #define rmb()   mb()
  90 #define wmb()   __asm__ __volatile__ ("": : :"memory")
  91
  92 #ifdef CONFIG_SMP
  93 #define smp_mb()        mb()
  94 #define smp_rmb()       rmb()
  95 #define smp_wmb()       wmb()
  96 #else
  97 #define smp_mb()        barrier()
  98 #define smp_rmb()       barrier()
  99 #define smp_wmb()       barrier()
 100 #endif
 101
 102 #define set_mb(var, value) do { xchg(&var, value); } while (0)
 103 #define set_wmb(var, value) do { var = value; wmb(); } while (0)
 104
 105 /* Interrupt Control */
 106 static __inline__ void __sti(void)
 107 {
 108         unsigned long __dummy0, __dummy1;
 109
 110         __asm__ __volatile__("stc       $sr, %0\n\t"
 111                              "and       %1, %0\n\t"
 112                              "stc       $r6_bank, %1\n\t"
 113                              "or        %1, %0\n\t"
 114                              "ldc       %0, $sr"
 115                              : "=&r" (__dummy0), "=r" (__dummy1)
 116                              : "1" (~0x000000f0)
 117                              : "memory");
 118 }
 119
 120 static __inline__ void __cli(void)
 121 {
 122         unsigned long __dummy;
 123         __asm__ __volatile__("stc       $sr, %0\n\t"
 124                              "or        #0xf0, %0\n\t"
 125                              "ldc       %0, $sr"
 126                              : "=&z" (__dummy)
 127                              : /* no inputs */
 128                              : "memory");
 129 }
 130
 131 #define __save_flags(x)                         \
 132 x = (__extension__ ({   unsigned long __sr;     \
 133         __asm__ __volatile__(                   \
 134                 "stc    $sr, %0"                \
 135                 : "=&r" (__sr)                  \
 136                 : /* no inputs */               \
 137                 : "memory");                    \
 138          (__sr & 0x000000f0);}))
 139
 140 #define __save_and_cli(x)                               \
 141 x = (__extension__ ({   unsigned long __dummy,__sr;     \
 142         __asm__ __volatile__(                           \
 143                 "stc    $sr, %1\n\t"                    \
 144                 "mov    %1, %0\n\t"                     \
 145                 "or     #0xf0, %0\n\t"                  \
 146                 "ldc    %0, $sr"                        \
 147                 : "=&z" (__dummy), "=&r" (__sr)         \
 148                 : /* no inputs */                       \
 149                 : "memory"); (__sr & 0x000000f0); }))
 150
 151 #define __restore_flags(x) do {                         \
 152         if (x != 0x000000f0)    /* not CLI-ed? */               \
 153                 __sti();                                \
 154 } while (0)
 155
 156 /*
 157  * Jump to P2 area.
 158  * When handling TLB or caches, we need to do it from P2 area.
 159  */
 160 #define jump_to_P2()                    \
 161 do {                                    \
 162         unsigned long __dummy;          \
 163         __asm__ __volatile__(           \
 164                 "mov.l  1f, %0\n\t"     \
 165                 "or     %1, %0\n\t"     \
 166                 "jmp    @%0\n\t"        \
 167                 " nop\n\t"              \
 168                 ".balign 4\n"           \
 169                 "1:     .long 2f\n"     \
 170                 "2:"                    \
 171                 : "=&r" (__dummy)       \
 172                 : "r" (0x20000000));    \
 173 } while (0)
 174
 175 /*
 176  * Back to P1 area.
 177  */
 178 #define back_to_P1()                                    \
 179 do {                                                    \
 180         unsigned long __dummy;                          \
 181         __asm__ __volatile__(                           \
 182                 "nop;nop;nop;nop;nop;nop;nop\n\t"       \
 183                 "mov.l  1f, %0\n\t"                     \
 184                 "jmp    @%0\n\t"                        \
 185                 " nop\n\t"                              \
 186                 ".balign 4\n"                           \
 187                 "1:     .long 2f\n"                     \
 188                 "2:"                                    \
 189                 : "=&r" (__dummy));                     \
 190 } while (0)
 191
 192 /* For spinlocks etc */
 193 #define local_irq_save(x)       __save_and_cli(x)
 194 #define local_irq_restore(x)    __restore_flags(x)
 195 #define local_irq_disable()     __cli()
 196 #define local_irq_enable()      __sti()
 197
 198 #ifdef CONFIG_SMP
 199
 200 extern void __global_cli(void);
 201 extern void __global_sti(void);
 202 extern unsigned long __global_save_flags(void);
 203 extern void __global_restore_flags(unsigned long);
 204 #define cli() __global_cli()
 205 #define sti() __global_sti()
 206 #define save_flags(x) ((x)=__global_save_flags())
 207 #define restore_flags(x) __global_restore_flags(x)
 208
 209 #else
 210
 211 #define cli() __cli()
 212 #define sti() __sti()
 213 #define save_flags(x) __save_flags(x)
 214 #define save_and_cli(x) __save_and_cli(x)
 215 #define restore_flags(x) __restore_flags(x)
 216
 217 #endif
 218
 219 static __inline__ unsigned long xchg_u32(volatile int * m, unsigned long val)
 220 {
 221         unsigned long flags, retval;
 222
 223         save_and_cli(flags);
 224         retval = *m;
 225         *m = val;
 226         restore_flags(flags);
 227         return retval;
 228 }
 229
 230 static __inline__ unsigned long xchg_u8(volatile unsigned char * m, unsigned long val)
 231 {
 232         unsigned long flags, retval;
 233
 234         save_and_cli(flags);
 235         retval = *m;
 236         *m = val & 0xff;
 237         restore_flags(flags);
 238         return retval;
 239 }
 240
 241 static __inline__ unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
 242 {
 243         switch (size) {
 244         case 4:
 245                 return xchg_u32(ptr, x);
 246                 break;
 247         case 1:
 248                 return xchg_u8(ptr, x);
 249                 break;
 250         }
 251         __xchg_called_with_bad_pointer();
 252         return x;
 253 }
 254
 255 /* XXX
 256  * disable hlt during certain critical i/o operations
 257  */
 258 #define HAVE_DISABLE_HLT
 259 void disable_hlt(void);
 260 void enable_hlt(void);
 261
 262 #endif