1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
|
#ifndef __PPC_SYSTEM_H
#define __PPC_SYSTEM_H
#include <linux/kdev_t.h>
#include <asm/processor.h>
#include <asm/atomic.h>
/*
* Memory barrier.
* The sync instruction guarantees that all memory accesses initiated
* by this processor have been performed (with respect to all other
* mechanisms that access memory).
*/
#define mb() __asm__ __volatile__ ("sync" : : : "memory")
#define rmb() __asm__ __volatile__ ("sync" : : : "memory")
#define wmb() __asm__ __volatile__ ("sync" : : : "memory")
#define __save_flags(flags) ({\
__asm__ __volatile__ ("mfmsr %0" : "=r" ((flags)) : : "memory"); })
#define __save_and_cli(flags) ({__save_flags(flags);__cli();})
extern __inline__ void dcbf(void *line)
{
asm("dcbf %0,%1\n\t"
"sync \n\t"
"isync \n\t"
:: "r" (line), "r" (0));
}
extern __inline__ void dcbi(void *line)
{
asm("dcbi %0,%1\n\t"
"sync \n\t"
"isync \n\t"
:: "r" (line), "r" (0));
}
extern __inline__ void __restore_flags(unsigned long flags)
{
extern atomic_t n_lost_interrupts;
extern void do_lost_interrupts(unsigned long);
if ((flags & MSR_EE) && atomic_read(&n_lost_interrupts) != 0) {
do_lost_interrupts(flags);
} else {
__asm__ __volatile__ ("sync; mtmsr %0; isync"
: : "r" (flags) : "memory");
}
}
extern void __sti(void);
extern void __cli(void);
extern int _disable_interrupts(void);
extern void _enable_interrupts(int);
extern void print_backtrace(unsigned long *);
extern void show_regs(struct pt_regs * regs);
extern void flush_instruction_cache(void);
extern void hard_reset_now(void);
extern void poweroff_now(void);
extern int _get_PVR(void);
extern long _get_L2CR(void);
extern void _set_L2CR(unsigned long);
extern void via_cuda_init(void);
extern void pmac_nvram_init(void);
extern void read_rtc_time(void);
extern void pmac_find_display(void);
extern void giveup_fpu(void);
extern void smp_giveup_fpu(struct task_struct *);
extern void cvt_fd(float *from, double *to, unsigned long *fpscr);
extern void cvt_df(double *from, float *to, unsigned long *fpscr);
struct device_node;
extern void note_scsi_host(struct device_node *, void *);
struct task_struct;
extern void switch_to(struct task_struct *prev, struct task_struct *next);
struct thread_struct;
extern void _switch(struct thread_struct *prev, struct thread_struct *next,
unsigned long context);
struct pt_regs;
extern void dump_regs(struct pt_regs *);
#ifndef __SMP__
#define cli() __cli()
#define sti() __sti()
#define save_flags(flags) __save_flags(flags)
#define restore_flags(flags) __restore_flags(flags)
#define save_and_cli(flags) __save_and_cli(flags)
#else /* __SMP__ */
extern void __global_cli(void);
extern void __global_sti(void);
extern unsigned long __global_save_flags(void);
extern void __global_restore_flags(unsigned long);
#define cli() __global_cli()
#define sti() __global_sti()
#define save_flags(x) ((x)=__global_save_flags())
#define restore_flags(x) __global_restore_flags(x)
#endif /* !__SMP__ */
#define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))
extern void *xchg_u64(void *ptr, unsigned long val);
extern void *xchg_u32(void *m, unsigned long val);
/*
* This function doesn't exist, so you'll get a linker error
* if something tries to do an invalid xchg().
*
* This only works if the compiler isn't horribly bad at optimizing.
* gcc-2.5.8 reportedly can't handle this, but as that doesn't work
* too well on the alpha anyway..
*/
extern void __xchg_called_with_bad_pointer(void);
#define xchg(ptr,x) ((__typeof__(*(ptr)))__xchg((unsigned long)(x),(ptr),sizeof(*(ptr))))
#define tas(ptr) (xchg((ptr),1))
static inline unsigned long __xchg(unsigned long x, void * ptr, int size)
{
switch (size) {
case 4:
return (unsigned long )xchg_u32(ptr, x);
case 8:
return (unsigned long )xchg_u64(ptr, x);
}
__xchg_called_with_bad_pointer();
return x;
}
extern inline void * xchg_ptr(void * m, void * val)
{
return (void *) xchg_u32(m, (unsigned long) val);
}
#endif
|
