diff options
author | Ishizaki Kou <kou.ishizaki@toshiba.co.jp> | 2008-04-24 05:27:32 -0400 |
---|---|---|
committer | Paul Mackerras <paulus@samba.org> | 2008-04-24 07:08:13 -0400 |
commit | 5a96dfe84b53cc05abe8c7f4d1dfd7b03a3e314a (patch) | |
tree | 7f449a38b739925d4d03fe752db8c9e55d4fc7b9 /arch/powerpc/platforms/cell/beat_wrapper.h | |
parent | 11eef455c2834e192c6ffe9f3ffd09af70fafe81 (diff) |
[POWERPC] celleb: Move files for Beat hvcall interfaces
This moves files for Beat hvcall interfaces into platforms/cell/.
All files in this patch are used by celleb-beat only.
Signed-off-by: Kou Ishizaki <kou.ishizaki@toshiba.co.jp>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Acked-by: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Signed-off-by: Paul Mackerras <paulus@samba.org>
Diffstat (limited to 'arch/powerpc/platforms/cell/beat_wrapper.h')
-rw-r--r-- | arch/powerpc/platforms/cell/beat_wrapper.h | 289 |
1 files changed, 289 insertions, 0 deletions
diff --git a/arch/powerpc/platforms/cell/beat_wrapper.h b/arch/powerpc/platforms/cell/beat_wrapper.h new file mode 100644 index 00000000000..b47dfda48d0 --- /dev/null +++ b/arch/powerpc/platforms/cell/beat_wrapper.h | |||
@@ -0,0 +1,289 @@ | |||
1 | /* | ||
2 | * Beat hypervisor call I/F | ||
3 | * | ||
4 | * (C) Copyright 2007 TOSHIBA CORPORATION | ||
5 | * | ||
6 | * This code is based on arch/powerpc/platforms/pseries/plpar_wrapper.h. | ||
7 | * | ||
8 | * This program is free software; you can redistribute it and/or modify | ||
9 | * it under the terms of the GNU General Public License as published by | ||
10 | * the Free Software Foundation; either version 2 of the License, or | ||
11 | * (at your option) any later version. | ||
12 | * | ||
13 | * This program is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | ||
16 | * GNU General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU General Public License along | ||
19 | * with this program; if not, write to the Free Software Foundation, Inc., | ||
20 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. | ||
21 | */ | ||
22 | #ifndef BEAT_HCALL | ||
23 | #include "beat_syscall.h" | ||
24 | |||
25 | /* defined in hvCall.S */ | ||
26 | extern s64 beat_hcall_norets(u64 opcode, ...); | ||
27 | extern s64 beat_hcall_norets8(u64 opcode, u64 arg1, u64 arg2, u64 arg3, | ||
28 | u64 arg4, u64 arg5, u64 arg6, u64 arg7, u64 arg8); | ||
29 | extern s64 beat_hcall1(u64 opcode, u64 retbuf[1], ...); | ||
30 | extern s64 beat_hcall2(u64 opcode, u64 retbuf[2], ...); | ||
31 | extern s64 beat_hcall3(u64 opcode, u64 retbuf[3], ...); | ||
32 | extern s64 beat_hcall4(u64 opcode, u64 retbuf[4], ...); | ||
33 | extern s64 beat_hcall5(u64 opcode, u64 retbuf[5], ...); | ||
34 | extern s64 beat_hcall6(u64 opcode, u64 retbuf[6], ...); | ||
35 | |||
36 | static inline s64 beat_downcount_of_interrupt(u64 plug_id) | ||
37 | { | ||
38 | return beat_hcall_norets(HV_downcount_of_interrupt, plug_id); | ||
39 | } | ||
40 | |||
41 | static inline s64 beat_set_interrupt_mask(u64 index, | ||
42 | u64 val0, u64 val1, u64 val2, u64 val3) | ||
43 | { | ||
44 | return beat_hcall_norets(HV_set_interrupt_mask, index, | ||
45 | val0, val1, val2, val3); | ||
46 | } | ||
47 | |||
48 | static inline s64 beat_destruct_irq_plug(u64 plug_id) | ||
49 | { | ||
50 | return beat_hcall_norets(HV_destruct_irq_plug, plug_id); | ||
51 | } | ||
52 | |||
53 | static inline s64 beat_construct_and_connect_irq_plug(u64 plug_id, | ||
54 | u64 outlet_id) | ||
55 | { | ||
56 | return beat_hcall_norets(HV_construct_and_connect_irq_plug, plug_id, | ||
57 | outlet_id); | ||
58 | } | ||
59 | |||
60 | static inline s64 beat_detect_pending_interrupts(u64 index, u64 *retbuf) | ||
61 | { | ||
62 | return beat_hcall4(HV_detect_pending_interrupts, retbuf, index); | ||
63 | } | ||
64 | |||
65 | static inline s64 beat_pause(u64 style) | ||
66 | { | ||
67 | return beat_hcall_norets(HV_pause, style); | ||
68 | } | ||
69 | |||
70 | static inline s64 beat_read_htab_entries(u64 htab_id, u64 index, u64 *retbuf) | ||
71 | { | ||
72 | return beat_hcall5(HV_read_htab_entries, retbuf, htab_id, index); | ||
73 | } | ||
74 | |||
75 | static inline s64 beat_insert_htab_entry(u64 htab_id, u64 group, | ||
76 | u64 bitmask, u64 hpte_v, u64 hpte_r, u64 *slot) | ||
77 | { | ||
78 | u64 dummy[3]; | ||
79 | s64 ret; | ||
80 | |||
81 | ret = beat_hcall3(HV_insert_htab_entry, dummy, htab_id, group, | ||
82 | bitmask, hpte_v, hpte_r); | ||
83 | *slot = dummy[0]; | ||
84 | return ret; | ||
85 | } | ||
86 | |||
87 | static inline s64 beat_write_htab_entry(u64 htab_id, u64 slot, | ||
88 | u64 hpte_v, u64 hpte_r, u64 mask_v, u64 mask_r, | ||
89 | u64 *ret_v, u64 *ret_r) | ||
90 | { | ||
91 | u64 dummy[2]; | ||
92 | s64 ret; | ||
93 | |||
94 | ret = beat_hcall2(HV_write_htab_entry, dummy, htab_id, slot, | ||
95 | hpte_v, hpte_r, mask_v, mask_r); | ||
96 | *ret_v = dummy[0]; | ||
97 | *ret_r = dummy[1]; | ||
98 | return ret; | ||
99 | } | ||
100 | |||
101 | static inline s64 beat_insert_htab_entry3(u64 htab_id, u64 group, | ||
102 | u64 hpte_v, u64 hpte_r, u64 mask_v, u64 value_v, u64 *slot) | ||
103 | { | ||
104 | u64 dummy[1]; | ||
105 | s64 ret; | ||
106 | |||
107 | ret = beat_hcall1(HV_insert_htab_entry3, dummy, htab_id, group, | ||
108 | hpte_v, hpte_r, mask_v, value_v); | ||
109 | *slot = dummy[0]; | ||
110 | return ret; | ||
111 | } | ||
112 | |||
113 | static inline s64 beat_invalidate_htab_entry3(u64 htab_id, u64 group, | ||
114 | u64 va, u64 pss) | ||
115 | { | ||
116 | return beat_hcall_norets(HV_invalidate_htab_entry3, | ||
117 | htab_id, group, va, pss); | ||
118 | } | ||
119 | |||
120 | static inline s64 beat_update_htab_permission3(u64 htab_id, u64 group, | ||
121 | u64 va, u64 pss, u64 ptel_mask, u64 ptel_value) | ||
122 | { | ||
123 | return beat_hcall_norets(HV_update_htab_permission3, | ||
124 | htab_id, group, va, pss, ptel_mask, ptel_value); | ||
125 | } | ||
126 | |||
127 | static inline s64 beat_clear_htab3(u64 htab_id) | ||
128 | { | ||
129 | return beat_hcall_norets(HV_clear_htab3, htab_id); | ||
130 | } | ||
131 | |||
132 | static inline void beat_shutdown_logical_partition(u64 code) | ||
133 | { | ||
134 | (void)beat_hcall_norets(HV_shutdown_logical_partition, code); | ||
135 | } | ||
136 | |||
137 | static inline s64 beat_rtc_write(u64 time_from_epoch) | ||
138 | { | ||
139 | return beat_hcall_norets(HV_rtc_write, time_from_epoch); | ||
140 | } | ||
141 | |||
142 | static inline s64 beat_rtc_read(u64 *time_from_epoch) | ||
143 | { | ||
144 | u64 dummy[1]; | ||
145 | s64 ret; | ||
146 | |||
147 | ret = beat_hcall1(HV_rtc_read, dummy); | ||
148 | *time_from_epoch = dummy[0]; | ||
149 | return ret; | ||
150 | } | ||
151 | |||
152 | #define BEAT_NVRW_CNT (sizeof(u64) * 6) | ||
153 | |||
154 | static inline s64 beat_eeprom_write(u64 index, u64 length, u8 *buffer) | ||
155 | { | ||
156 | u64 b[6]; | ||
157 | |||
158 | if (length > BEAT_NVRW_CNT) | ||
159 | return -1; | ||
160 | memcpy(b, buffer, sizeof(b)); | ||
161 | return beat_hcall_norets8(HV_eeprom_write, index, length, | ||
162 | b[0], b[1], b[2], b[3], b[4], b[5]); | ||
163 | } | ||
164 | |||
165 | static inline s64 beat_eeprom_read(u64 index, u64 length, u8 *buffer) | ||
166 | { | ||
167 | u64 b[6]; | ||
168 | s64 ret; | ||
169 | |||
170 | if (length > BEAT_NVRW_CNT) | ||
171 | return -1; | ||
172 | ret = beat_hcall6(HV_eeprom_read, b, index, length); | ||
173 | memcpy(buffer, b, length); | ||
174 | return ret; | ||
175 | } | ||
176 | |||
177 | static inline s64 beat_set_dabr(u64 value, u64 style) | ||
178 | { | ||
179 | return beat_hcall_norets(HV_set_dabr, value, style); | ||
180 | } | ||
181 | |||
182 | static inline s64 beat_get_characters_from_console(u64 termno, u64 *len, | ||
183 | u8 *buffer) | ||
184 | { | ||
185 | u64 dummy[3]; | ||
186 | s64 ret; | ||
187 | |||
188 | ret = beat_hcall3(HV_get_characters_from_console, dummy, termno, len); | ||
189 | *len = dummy[0]; | ||
190 | memcpy(buffer, dummy + 1, *len); | ||
191 | return ret; | ||
192 | } | ||
193 | |||
194 | static inline s64 beat_put_characters_to_console(u64 termno, u64 len, | ||
195 | u8 *buffer) | ||
196 | { | ||
197 | u64 b[2]; | ||
198 | |||
199 | memcpy(b, buffer, len); | ||
200 | return beat_hcall_norets(HV_put_characters_to_console, termno, len, | ||
201 | b[0], b[1]); | ||
202 | } | ||
203 | |||
204 | static inline s64 beat_get_spe_privileged_state_1_registers( | ||
205 | u64 id, u64 offsetof, u64 *value) | ||
206 | { | ||
207 | u64 dummy[1]; | ||
208 | s64 ret; | ||
209 | |||
210 | ret = beat_hcall1(HV_get_spe_privileged_state_1_registers, dummy, id, | ||
211 | offsetof); | ||
212 | *value = dummy[0]; | ||
213 | return ret; | ||
214 | } | ||
215 | |||
216 | static inline s64 beat_set_irq_mask_for_spe(u64 id, u64 class, u64 mask) | ||
217 | { | ||
218 | return beat_hcall_norets(HV_set_irq_mask_for_spe, id, class, mask); | ||
219 | } | ||
220 | |||
221 | static inline s64 beat_clear_interrupt_status_of_spe(u64 id, u64 class, | ||
222 | u64 mask) | ||
223 | { | ||
224 | return beat_hcall_norets(HV_clear_interrupt_status_of_spe, | ||
225 | id, class, mask); | ||
226 | } | ||
227 | |||
228 | static inline s64 beat_set_spe_privileged_state_1_registers( | ||
229 | u64 id, u64 offsetof, u64 value) | ||
230 | { | ||
231 | return beat_hcall_norets(HV_set_spe_privileged_state_1_registers, | ||
232 | id, offsetof, value); | ||
233 | } | ||
234 | |||
235 | static inline s64 beat_get_interrupt_status_of_spe(u64 id, u64 class, u64 *val) | ||
236 | { | ||
237 | u64 dummy[1]; | ||
238 | s64 ret; | ||
239 | |||
240 | ret = beat_hcall1(HV_get_interrupt_status_of_spe, dummy, id, class); | ||
241 | *val = dummy[0]; | ||
242 | return ret; | ||
243 | } | ||
244 | |||
245 | static inline s64 beat_put_iopte(u64 ioas_id, u64 io_addr, u64 real_addr, | ||
246 | u64 ioid, u64 flags) | ||
247 | { | ||
248 | return beat_hcall_norets(HV_put_iopte, ioas_id, io_addr, real_addr, | ||
249 | ioid, flags); | ||
250 | } | ||
251 | |||
252 | static inline s64 beat_construct_event_receive_port(u64 *port) | ||
253 | { | ||
254 | u64 dummy[1]; | ||
255 | s64 ret; | ||
256 | |||
257 | ret = beat_hcall1(HV_construct_event_receive_port, dummy); | ||
258 | *port = dummy[0]; | ||
259 | return ret; | ||
260 | } | ||
261 | |||
262 | static inline s64 beat_destruct_event_receive_port(u64 port) | ||
263 | { | ||
264 | s64 ret; | ||
265 | |||
266 | ret = beat_hcall_norets(HV_destruct_event_receive_port, port); | ||
267 | return ret; | ||
268 | } | ||
269 | |||
270 | static inline s64 beat_create_repository_node(u64 path[4], u64 data[2]) | ||
271 | { | ||
272 | s64 ret; | ||
273 | |||
274 | ret = beat_hcall_norets(HV_create_repository_node2, | ||
275 | path[0], path[1], path[2], path[3], data[0], data[1]); | ||
276 | return ret; | ||
277 | } | ||
278 | |||
279 | static inline s64 beat_get_repository_node_value(u64 lpid, u64 path[4], | ||
280 | u64 data[2]) | ||
281 | { | ||
282 | s64 ret; | ||
283 | |||
284 | ret = beat_hcall2(HV_get_repository_node_value2, data, | ||
285 | lpid, path[0], path[1], path[2], path[3]); | ||
286 | return ret; | ||
287 | } | ||
288 | |||
289 | #endif | ||