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"); \
  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 #define set_mb(var, value) do { xchg(&var, value); } while (0)
  92 #define set_wmb(var, value) do { var = value; wmb(); } while (0)
  93
  94 /* Interrupt Control */
  95 extern __inline__ void __sti(void)
  96 {
  97         unsigned long __dummy0, __dummy1;
  98
  99         __asm__ __volatile__("stc       $sr, %0\n\t"
 100                              "and       %1, %0\n\t"
 101                              "stc       $r6_bank, %1\n\t"
 102                              "or        %1, %0\n\t"
 103                              "ldc       %0, $sr"
 104                              : "=&r" (__dummy0), "=r" (__dummy1)
 105                              : "1" (~0x000000f0)
 106                              : "memory");
 107 }
 108
 109 extern __inline__ void __cli(void)
 110 {
 111         unsigned long __dummy;
 112         __asm__ __volatile__("stc       $sr, %0\n\t"
 113                              "or        #0xf0, %0\n\t"
 114                              "ldc       %0, $sr"
 115                              : "=&z" (__dummy)
 116                              : /* no inputs */
 117                              : "memory");
 118 }
 119
 120 #define __save_flags(x)                         \
 121 x = (__extension__ ({   unsigned long __sr;     \
 122         __asm__ __volatile__(                   \
 123                 "stc    $sr, %0"                \
 124                 : "=&r" (__sr)                  \
 125                 : /* no inputs */               \
 126                 : "memory");                    \
 127          (__sr & 0x000000f0);}))
 128
 129 #define __save_and_cli(x)                               \
 130 x = (__extension__ ({   unsigned long __dummy,__sr;     \
 131         __asm__ __volatile__(                           \
 132                 "stc    $sr, %1\n\t"                    \
 133                 "mov    %1, %0\n\t"                     \
 134                 "or     #0xf0, %0\n\t"                  \
 135                 "ldc    %0, $sr"                        \
 136                 : "=&z" (__dummy), "=&r" (__sr)         \
 137                 : /* no inputs */                       \
 138                 : "memory"); (__sr & 0x000000f0); }))
 139
 140 #define __restore_flags(x) do {                         \
 141         if (x != 0x000000f0)    /* not CLI-ed? */               \
 142                 __sti();                                \
 143 } while (0)
 144
 145 /*
 146  * Jump to P2 area.
 147  * When handling TLB or caches, we need to do it from P2 area.
 148  */
 149 #define jump_to_P2()                    \
 150 do {                                    \
 151         unsigned long __dummy;          \
 152         __asm__ __volatile__(           \
 153                 "mov.l  1f, %0\n\t"     \
 154                 "or     %1, %0\n\t"     \
 155                 "jmp    @%0\n\t"        \
 156                 " nop\n\t"              \
 157                 ".balign 4\n"           \
 158                 "1:     .long 2f\n"     \
 159                 "2:"                    \
 160                 : "=&r" (__dummy)       \
 161                 : "r" (0x20000000));    \
 162 } while (0)
 163
 164 /*
 165  * Back to P1 area.
 166  */
 167 #define back_to_P1()                                    \
 168 do {                                                    \
 169         unsigned long __dummy;                          \
 170         __asm__ __volatile__(                           \
 171                 "nop;nop;nop;nop;nop;nop;nop\n\t"       \
 172                 "mov.l  1f, %0\n\t"                     \
 173                 "jmp    @%0\n\t"                        \
 174                 " nop\n\t"                              \
 175                 ".balign 4\n"                           \
 176                 "1:     .long 2f\n"                     \
 177                 "2:"                                    \
 178                 : "=&r" (__dummy));                     \
 179 } while (0)
 180
 181 /* For spinlocks etc */
 182 #define local_irq_save(x)       __save_and_cli(x)
 183 #define local_irq_restore(x)    __restore_flags(x)
 184 #define local_irq_disable()     __cli()
 185 #define local_irq_enable()      __sti()
 186
 187 #ifdef CONFIG_SMP
 188
 189 extern void __global_cli(void);
 190 extern void __global_sti(void);
 191 extern unsigned long __global_save_flags(void);
 192 extern void __global_restore_flags(unsigned long);
 193 #define cli() __global_cli()
 194 #define sti() __global_sti()
 195 #define save_flags(x) ((x)=__global_save_flags())
 196 #define restore_flags(x) __global_restore_flags(x)
 197
 198 #else
 199
 200 #define cli() __cli()
 201 #define sti() __sti()
 202 #define save_flags(x) __save_flags(x)
 203 #define save_and_cli(x) __save_and_cli(x)
 204 #define restore_flags(x) __restore_flags(x)
 205
 206 #endif
 207
 208 extern __inline__ unsigned long xchg_u32(volatile int * m, unsigned long val)
 209 {
 210         unsigned long flags, retval;
 211
 212         save_and_cli(flags);
 213         retval = *m;
 214         *m = val;
 215         restore_flags(flags);
 216         return retval;
 217 }
 218
 219 extern __inline__ unsigned long xchg_u8(volatile unsigned char * m, unsigned long val)
 220 {
 221         unsigned long flags, retval;
 222
 223         save_and_cli(flags);
 224         retval = *m;
 225         *m = val & 0xff;
 226         restore_flags(flags);
 227         return retval;
 228 }
 229
 230 static __inline__ unsigned long __xchg(unsigned long x, volatile void * ptr, int size)
 231 {
 232         switch (size) {
 233         case 4:
 234                 return xchg_u32(ptr, x);
 235                 break;
 236         case 1:
 237                 return xchg_u8(ptr, x);
 238                 break;
 239         }
 240         __xchg_called_with_bad_pointer();
 241         return x;
 242 }
 243
 244 /* XXX
 245  * disable hlt during certain critical i/o operations
 246  */
 247 #define HAVE_DISABLE_HLT
 248 void disable_hlt(void);
 249 void enable_hlt(void);
 250
 251 #endif