Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[linux-2.6.git] / arch / powerpc / platforms / ps3 / hvcall.S
1 /*
2  *  PS3 hvcall interface.
3  *
4  *  Copyright (C) 2006 Sony Computer Entertainment Inc.
5  *  Copyright 2006 Sony Corp.
6  *  Copyright 2003, 2004 (c) MontaVista Software, Inc.
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; version 2 of the License.
11  *
12  *  This program is distributed in the hope that it will be useful,
13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  *  GNU General Public License for more details.
16  *
17  *  You should have received a copy of the GNU General Public License
18  *  along with this program; if not, write to the Free Software
19  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include <asm/processor.h>
23 #include <asm/ppc_asm.h>
24
25 #define lv1call .long 0x44000022; extsw r3, r3
26
27 #define LV1_N_IN_0_OUT(API_NAME, API_NUMBER)    \
28 _GLOBAL(_##API_NAME)                            \
29                                                 \
30         mflr    r0;                             \
31         std     r0, 16(r1);                     \
32                                                 \
33         li      r11, API_NUMBER;                \
34         lv1call;                                \
35                                                 \
36         ld      r0, 16(r1);                     \
37         mtlr    r0;                             \
38         blr
39
40 #define LV1_0_IN_0_OUT LV1_N_IN_0_OUT
41 #define LV1_1_IN_0_OUT LV1_N_IN_0_OUT
42 #define LV1_2_IN_0_OUT LV1_N_IN_0_OUT
43 #define LV1_3_IN_0_OUT LV1_N_IN_0_OUT
44 #define LV1_4_IN_0_OUT LV1_N_IN_0_OUT
45 #define LV1_5_IN_0_OUT LV1_N_IN_0_OUT
46 #define LV1_6_IN_0_OUT LV1_N_IN_0_OUT
47 #define LV1_7_IN_0_OUT LV1_N_IN_0_OUT
48
49 #define LV1_0_IN_1_OUT(API_NAME, API_NUMBER)    \
50 _GLOBAL(_##API_NAME)                            \
51                                                 \
52         mflr    r0;                             \
53         std     r0, 16(r1);                     \
54                                                 \
55         stdu    r3, -8(r1);                     \
56                                                 \
57         li      r11, API_NUMBER;                \
58         lv1call;                                \
59                                                 \
60         addi    r1, r1, 8;                      \
61         ld      r11, -8(r1);                    \
62         std     r4, 0(r11);                     \
63                                                 \
64         ld      r0, 16(r1);                     \
65         mtlr    r0;                             \
66         blr
67
68 #define LV1_0_IN_2_OUT(API_NAME, API_NUMBER)    \
69 _GLOBAL(_##API_NAME)                            \
70                                                 \
71         mflr    r0;                             \
72         std     r0, 16(r1);                     \
73                                                 \
74         std     r3, -8(r1);                     \
75         stdu    r4, -16(r1);                    \
76                                                 \
77         li      r11, API_NUMBER;                \
78         lv1call;                                \
79                                                 \
80         addi    r1, r1, 16;                     \
81         ld      r11, -8(r1);                    \
82         std     r4, 0(r11);                     \
83         ld      r11, -16(r1);                   \
84         std     r5, 0(r11);                     \
85                                                 \
86         ld      r0, 16(r1);                     \
87         mtlr    r0;                             \
88         blr
89
90 #define LV1_0_IN_3_OUT(API_NAME, API_NUMBER)    \
91 _GLOBAL(_##API_NAME)                            \
92                                                 \
93         mflr    r0;                             \
94         std     r0, 16(r1);                     \
95                                                 \
96         std     r3, -8(r1);                     \
97         std     r4, -16(r1);                    \
98         stdu    r5, -24(r1);                    \
99                                                 \
100         li      r11, API_NUMBER;                \
101         lv1call;                                \
102                                                 \
103         addi    r1, r1, 24;                     \
104         ld      r11, -8(r1);                    \
105         std     r4, 0(r11);                     \
106         ld      r11, -16(r1);                   \
107         std     r5, 0(r11);                     \
108         ld      r11, -24(r1);                   \
109         std     r6, 0(r11);                     \
110                                                 \
111         ld      r0, 16(r1);                     \
112         mtlr    r0;                             \
113         blr
114
115 #define LV1_0_IN_7_OUT(API_NAME, API_NUMBER)    \
116 _GLOBAL(_##API_NAME)                            \
117                                                 \
118         mflr    r0;                             \
119         std     r0, 16(r1);                     \
120                                                 \
121         std     r3, -8(r1);                     \
122         std     r4, -16(r1);                    \
123         std     r5, -24(r1);                    \
124         std     r6, -32(r1);                    \
125         std     r7, -40(r1);                    \
126         std     r8, -48(r1);                    \
127         stdu    r9, -56(r1);                    \
128                                                 \
129         li      r11, API_NUMBER;                \
130         lv1call;                                \
131                                                 \
132         addi    r1, r1, 56;                     \
133         ld      r11, -8(r1);                    \
134         std     r4, 0(r11);                     \
135         ld      r11, -16(r1);                   \
136         std     r5, 0(r11);                     \
137         ld      r11, -24(r1);                   \
138         std     r6, 0(r11);                     \
139         ld      r11, -32(r1);                   \
140         std     r7, 0(r11);                     \
141         ld      r11, -40(r1);                   \
142         std     r8, 0(r11);                     \
143         ld      r11, -48(r1);                   \
144         std     r9, 0(r11);                     \
145         ld      r11, -56(r1);                   \
146         std     r10, 0(r11);                    \
147                                                 \
148         ld      r0, 16(r1);                     \
149         mtlr    r0;                             \
150         blr
151
152 #define LV1_1_IN_1_OUT(API_NAME, API_NUMBER)    \
153 _GLOBAL(_##API_NAME)                            \
154                                                 \
155         mflr    r0;                             \
156         std     r0, 16(r1);                     \
157                                                 \
158         stdu    r4, -8(r1);                     \
159                                                 \
160         li      r11, API_NUMBER;                \
161         lv1call;                                \
162                                                 \
163         addi    r1, r1, 8;                      \
164         ld      r11, -8(r1);                    \
165         std     r4, 0(r11);                     \
166                                                 \
167         ld      r0, 16(r1);                     \
168         mtlr    r0;                             \
169         blr
170
171 #define LV1_1_IN_2_OUT(API_NAME, API_NUMBER)    \
172 _GLOBAL(_##API_NAME)                            \
173                                                 \
174         mflr    r0;                             \
175         std     r0, 16(r1);                     \
176                                                 \
177         std     r4, -8(r1);                     \
178         stdu    r5, -16(r1);                    \
179                                                 \
180         li      r11, API_NUMBER;                \
181         lv1call;                                \
182                                                 \
183         addi    r1, r1, 16;                     \
184         ld      r11, -8(r1);                    \
185         std     r4, 0(r11);                     \
186         ld      r11, -16(r1);                   \
187         std     r5, 0(r11);                     \
188                                                 \
189         ld      r0, 16(r1);                     \
190         mtlr    r0;                             \
191         blr
192
193 #define LV1_1_IN_3_OUT(API_NAME, API_NUMBER)    \
194 _GLOBAL(_##API_NAME)                            \
195                                                 \
196         mflr    r0;                             \
197         std     r0, 16(r1);                     \
198                                                 \
199         std     r4, -8(r1);                     \
200         std     r5, -16(r1);                    \
201         stdu    r6, -24(r1);                    \
202                                                 \
203         li      r11, API_NUMBER;                \
204         lv1call;                                \
205                                                 \
206         addi    r1, r1, 24;                     \
207         ld      r11, -8(r1);                    \
208         std     r4, 0(r11);                     \
209         ld      r11, -16(r1);                   \
210         std     r5, 0(r11);                     \
211         ld      r11, -24(r1);                   \
212         std     r6, 0(r11);                     \
213                                                 \
214         ld      r0, 16(r1);                     \
215         mtlr    r0;                             \
216         blr
217
218 #define LV1_1_IN_4_OUT(API_NAME, API_NUMBER)    \
219 _GLOBAL(_##API_NAME)                            \
220                                                 \
221         mflr    r0;                             \
222         std     r0, 16(r1);                     \
223                                                 \
224         std     r4, -8(r1);                     \
225         std     r5, -16(r1);                    \
226         std     r6, -24(r1);                    \
227         stdu    r7, -32(r1);                    \
228                                                 \
229         li      r11, API_NUMBER;                \
230         lv1call;                                \
231                                                 \
232         addi    r1, r1, 32;                     \
233         ld      r11, -8(r1);                    \
234         std     r4, 0(r11);                     \
235         ld      r11, -16(r1);                   \
236         std     r5, 0(r11);                     \
237         ld      r11, -24(r1);                   \
238         std     r6, 0(r11);                     \
239         ld      r11, -32(r1);                   \
240         std     r7, 0(r11);                     \
241                                                 \
242         ld      r0, 16(r1);                     \
243         mtlr    r0;                             \
244         blr
245
246 #define LV1_1_IN_5_OUT(API_NAME, API_NUMBER)    \
247 _GLOBAL(_##API_NAME)                            \
248                                                 \
249         mflr    r0;                             \
250         std     r0, 16(r1);                     \
251                                                 \
252         std     r4, -8(r1);                     \
253         std     r5, -16(r1);                    \
254         std     r6, -24(r1);                    \
255         std     r7, -32(r1);                    \
256         stdu    r8, -40(r1);                    \
257                                                 \
258         li      r11, API_NUMBER;                \
259         lv1call;                                \
260                                                 \
261         addi    r1, r1, 40;                     \
262         ld      r11, -8(r1);                    \
263         std     r4, 0(r11);                     \
264         ld      r11, -16(r1);                   \
265         std     r5, 0(r11);                     \
266         ld      r11, -24(r1);                   \
267         std     r6, 0(r11);                     \
268         ld      r11, -32(r1);                   \
269         std     r7, 0(r11);                     \
270         ld      r11, -40(r1);                   \
271         std     r8, 0(r11);                     \
272                                                 \
273         ld      r0, 16(r1);                     \
274         mtlr    r0;                             \
275         blr
276
277 #define LV1_1_IN_6_OUT(API_NAME, API_NUMBER)    \
278 _GLOBAL(_##API_NAME)                            \
279                                                 \
280         mflr    r0;                             \
281         std     r0, 16(r1);                     \
282                                                 \
283         std     r4, -8(r1);                     \
284         std     r5, -16(r1);                    \
285         std     r6, -24(r1);                    \
286         std     r7, -32(r1);                    \
287         std     r8, -40(r1);                    \
288         stdu    r9, -48(r1);                    \
289                                                 \
290         li      r11, API_NUMBER;                \
291         lv1call;                                \
292                                                 \
293         addi    r1, r1, 48;                     \
294         ld      r11, -8(r1);                    \
295         std     r4, 0(r11);                     \
296         ld      r11, -16(r1);                   \
297         std     r5, 0(r11);                     \
298         ld      r11, -24(r1);                   \
299         std     r6, 0(r11);                     \
300         ld      r11, -32(r1);                   \
301         std     r7, 0(r11);                     \
302         ld      r11, -40(r1);                   \
303         std     r8, 0(r11);                     \
304         ld      r11, -48(r1);                   \
305         std     r9, 0(r11);                     \
306                                                 \
307         ld      r0, 16(r1);                     \
308         mtlr    r0;                             \
309         blr
310
311 #define LV1_1_IN_7_OUT(API_NAME, API_NUMBER)    \
312 _GLOBAL(_##API_NAME)                            \
313                                                 \
314         mflr    r0;                             \
315         std     r0, 16(r1);                     \
316                                                 \
317         std     r4, -8(r1);                     \
318         std     r5, -16(r1);                    \
319         std     r6, -24(r1);                    \
320         std     r7, -32(r1);                    \
321         std     r8, -40(r1);                    \
322         std     r9, -48(r1);                    \
323         stdu    r10, -56(r1);                   \
324                                                 \
325         li      r11, API_NUMBER;                \
326         lv1call;                                \
327                                                 \
328         addi    r1, r1, 56;                     \
329         ld      r11, -8(r1);                    \
330         std     r4, 0(r11);                     \
331         ld      r11, -16(r1);                   \
332         std     r5, 0(r11);                     \
333         ld      r11, -24(r1);                   \
334         std     r6, 0(r11);                     \
335         ld      r11, -32(r1);                   \
336         std     r7, 0(r11);                     \
337         ld      r11, -40(r1);                   \
338         std     r8, 0(r11);                     \
339         ld      r11, -48(r1);                   \
340         std     r9, 0(r11);                     \
341         ld      r11, -56(r1);                   \
342         std     r10, 0(r11);                    \
343                                                 \
344         ld      r0, 16(r1);                     \
345         mtlr    r0;                             \
346         blr
347
348 #define LV1_2_IN_1_OUT(API_NAME, API_NUMBER)    \
349 _GLOBAL(_##API_NAME)                            \
350                                                 \
351         mflr    r0;                             \
352         std     r0, 16(r1);                     \
353                                                 \
354         stdu    r5, -8(r1);                     \
355                                                 \
356         li      r11, API_NUMBER;                \
357         lv1call;                                \
358                                                 \
359         addi    r1, r1, 8;                      \
360         ld      r11, -8(r1);                    \
361         std     r4, 0(r11);                     \
362                                                 \
363         ld      r0, 16(r1);                     \
364         mtlr    r0;                             \
365         blr
366
367 #define LV1_2_IN_2_OUT(API_NAME, API_NUMBER)    \
368 _GLOBAL(_##API_NAME)                            \
369                                                 \
370         mflr    r0;                             \
371         std     r0, 16(r1);                     \
372                                                 \
373         std     r5, -8(r1);                     \
374         stdu    r6, -16(r1);                    \
375                                                 \
376         li      r11, API_NUMBER;                \
377         lv1call;                                \
378                                                 \
379         addi    r1, r1, 16;                     \
380         ld      r11, -8(r1);                    \
381         std     r4, 0(r11);                     \
382         ld      r11, -16(r1);                   \
383         std     r5, 0(r11);                     \
384                                                 \
385         ld      r0, 16(r1);                     \
386         mtlr    r0;                             \
387         blr
388
389 #define LV1_2_IN_3_OUT(API_NAME, API_NUMBER)    \
390 _GLOBAL(_##API_NAME)                            \
391                                                 \
392         mflr    r0;                             \
393         std     r0, 16(r1);                     \
394                                                 \
395         std     r5, -8(r1);                     \
396         std     r6, -16(r1);                    \
397         stdu    r7, -24(r1);                    \
398                                                 \
399         li      r11, API_NUMBER;                \
400         lv1call;                                \
401                                                 \
402         addi    r1, r1, 24;                     \
403         ld      r11, -8(r1);                    \
404         std     r4, 0(r11);                     \
405         ld      r11, -16(r1);                   \
406         std     r5, 0(r11);                     \
407         ld      r11, -24(r1);                   \
408         std     r6, 0(r11);                     \
409                                                 \
410         ld      r0, 16(r1);                     \
411         mtlr    r0;                             \
412         blr
413
414 #define LV1_2_IN_4_OUT(API_NAME, API_NUMBER)    \
415 _GLOBAL(_##API_NAME)                            \
416                                                 \
417         mflr    r0;                             \
418         std     r0, 16(r1);                     \
419                                                 \
420         std     r5, -8(r1);                     \
421         std     r6, -16(r1);                    \
422         std     r7, -24(r1);                    \
423         stdu    r8, -32(r1);                    \
424                                                 \
425         li      r11, API_NUMBER;                \
426         lv1call;                                \
427                                                 \
428         addi    r1, r1, 32;                     \
429         ld      r11, -8(r1);                    \
430         std     r4, 0(r11);                     \
431         ld      r11, -16(r1);                   \
432         std     r5, 0(r11);                     \
433         ld      r11, -24(r1);                   \
434         std     r6, 0(r11);                     \
435         ld      r11, -32(r1);                   \
436         std     r7, 0(r11);                     \
437                                                 \
438         ld      r0, 16(r1);                     \
439         mtlr    r0;                             \
440         blr
441
442 #define LV1_2_IN_5_OUT(API_NAME, API_NUMBER)    \
443 _GLOBAL(_##API_NAME)                            \
444                                                 \
445         mflr    r0;                             \
446         std     r0, 16(r1);                     \
447                                                 \
448         std     r5, -8(r1);                     \
449         std     r6, -16(r1);                    \
450         std     r7, -24(r1);                    \
451         std     r8, -32(r1);                    \
452         stdu    r9, -40(r1);                    \
453                                                 \
454         li      r11, API_NUMBER;                \
455         lv1call;                                \
456                                                 \
457         addi    r1, r1, 40;                     \
458         ld      r11, -8(r1);                    \
459         std     r4, 0(r11);                     \
460         ld      r11, -16(r1);                   \
461         std     r5, 0(r11);                     \
462         ld      r11, -24(r1);                   \
463         std     r6, 0(r11);                     \
464         ld      r11, -32(r1);                   \
465         std     r7, 0(r11);                     \
466         ld      r11, -40(r1);                   \
467         std     r8, 0(r11);                     \
468                                                 \
469         ld      r0, 16(r1);                     \
470         mtlr    r0;                             \
471         blr
472
473 #define LV1_3_IN_1_OUT(API_NAME, API_NUMBER)    \
474 _GLOBAL(_##API_NAME)                            \
475                                                 \
476         mflr    r0;                             \
477         std     r0, 16(r1);                     \
478                                                 \
479         stdu    r6, -8(r1);                     \
480                                                 \
481         li      r11, API_NUMBER;                \
482         lv1call;                                \
483                                                 \
484         addi    r1, r1, 8;                      \
485         ld      r11, -8(r1);                    \
486         std     r4, 0(r11);                     \
487                                                 \
488         ld      r0, 16(r1);                     \
489         mtlr    r0;                             \
490         blr
491
492 #define LV1_3_IN_2_OUT(API_NAME, API_NUMBER)    \
493 _GLOBAL(_##API_NAME)                            \
494                                                 \
495         mflr    r0;                             \
496         std     r0, 16(r1);                     \
497                                                 \
498         std     r6, -8(r1);                     \
499         stdu    r7, -16(r1);                    \
500                                                 \
501         li      r11, API_NUMBER;                \
502         lv1call;                                \
503                                                 \
504         addi    r1, r1, 16;                     \
505         ld      r11, -8(r1);                    \
506         std     r4, 0(r11);                     \
507         ld      r11, -16(r1);                   \
508         std     r5, 0(r11);                     \
509                                                 \
510         ld      r0, 16(r1);                     \
511         mtlr    r0;                             \
512         blr
513
514 #define LV1_3_IN_3_OUT(API_NAME, API_NUMBER)    \
515 _GLOBAL(_##API_NAME)                            \
516                                                 \
517         mflr    r0;                             \
518         std     r0, 16(r1);                     \
519                                                 \
520         std     r6, -8(r1);                     \
521         std     r7, -16(r1);                    \
522         stdu    r8, -24(r1);                    \
523                                                 \
524         li      r11, API_NUMBER;                \
525         lv1call;                                \
526                                                 \
527         addi    r1, r1, 24;                     \
528         ld      r11, -8(r1);                    \
529         std     r4, 0(r11);                     \
530         ld      r11, -16(r1);                   \
531         std     r5, 0(r11);                     \
532         ld      r11, -24(r1);                   \
533         std     r6, 0(r11);                     \
534                                                 \
535         ld      r0, 16(r1);                     \
536         mtlr    r0;                             \
537         blr
538
539 #define LV1_4_IN_1_OUT(API_NAME, API_NUMBER)    \
540 _GLOBAL(_##API_NAME)                            \
541                                                 \
542         mflr    r0;                             \
543         std     r0, 16(r1);                     \
544                                                 \
545         stdu    r7, -8(r1);                     \
546                                                 \
547         li      r11, API_NUMBER;                \
548         lv1call;                                \
549                                                 \
550         addi    r1, r1, 8;                      \
551         ld      r11, -8(r1);                    \
552         std     r4, 0(r11);                     \
553                                                 \
554         ld      r0, 16(r1);                     \
555         mtlr    r0;                             \
556         blr
557
558 #define LV1_4_IN_2_OUT(API_NAME, API_NUMBER)    \
559 _GLOBAL(_##API_NAME)                            \
560                                                 \
561         mflr    r0;                             \
562         std     r0, 16(r1);                     \
563                                                 \
564         std     r7, -8(r1);                     \
565         stdu    r8, -16(r1);                    \
566                                                 \
567         li      r11, API_NUMBER;                \
568         lv1call;                                \
569                                                 \
570         addi    r1, r1, 16;                     \
571         ld      r11, -8(r1);                    \
572         std     r4, 0(r11);                     \
573         ld      r11, -16(r1);                   \
574         std     r5, 0(r11);                     \
575                                                 \
576         ld      r0, 16(r1);                     \
577         mtlr    r0;                             \
578         blr
579
580 #define LV1_4_IN_3_OUT(API_NAME, API_NUMBER)    \
581 _GLOBAL(_##API_NAME)                            \
582                                                 \
583         mflr    r0;                             \
584         std     r0, 16(r1);                     \
585                                                 \
586         std     r7, -8(r1);                     \
587         std     r8, -16(r1);                    \
588         stdu    r9, -24(r1);                    \
589                                                 \
590         li      r11, API_NUMBER;                \
591         lv1call;                                \
592                                                 \
593         addi    r1, r1, 24;                     \
594         ld      r11, -8(r1);                    \
595         std     r4, 0(r11);                     \
596         ld      r11, -16(r1);                   \
597         std     r5, 0(r11);                     \
598         ld      r11, -24(r1);                   \
599         std     r6, 0(r11);                     \
600                                                 \
601         ld      r0, 16(r1);                     \
602         mtlr    r0;                             \
603         blr
604
605 #define LV1_5_IN_1_OUT(API_NAME, API_NUMBER)    \
606 _GLOBAL(_##API_NAME)                            \
607                                                 \
608         mflr    r0;                             \
609         std     r0, 16(r1);                     \
610                                                 \
611         stdu    r8, -8(r1);                     \
612                                                 \
613         li      r11, API_NUMBER;                \
614         lv1call;                                \
615                                                 \
616         addi    r1, r1, 8;                      \
617         ld      r11, -8(r1);                    \
618         std     r4, 0(r11);                     \
619                                                 \
620         ld      r0, 16(r1);                     \
621         mtlr    r0;                             \
622         blr
623
624 #define LV1_5_IN_2_OUT(API_NAME, API_NUMBER)    \
625 _GLOBAL(_##API_NAME)                            \
626                                                 \
627         mflr    r0;                             \
628         std     r0, 16(r1);                     \
629                                                 \
630         std     r8, -8(r1);                     \
631         stdu    r9, -16(r1);                    \
632                                                 \
633         li      r11, API_NUMBER;                \
634         lv1call;                                \
635                                                 \
636         addi    r1, r1, 16;                     \
637         ld      r11, -8(r1);                    \
638         std     r4, 0(r11);                     \
639         ld      r11, -16(r1);                   \
640         std     r5, 0(r11);                     \
641                                                 \
642         ld      r0, 16(r1);                     \
643         mtlr    r0;                             \
644         blr
645
646 #define LV1_5_IN_3_OUT(API_NAME, API_NUMBER)    \
647 _GLOBAL(_##API_NAME)                            \
648                                                 \
649         mflr    r0;                             \
650         std     r0, 16(r1);                     \
651                                                 \
652         std     r8, -8(r1);                     \
653         std     r9, -16(r1);                    \
654         stdu    r10, -24(r1);                   \
655                                                 \
656         li      r11, API_NUMBER;                \
657         lv1call;                                \
658                                                 \
659         addi    r1, r1, 24;                     \
660         ld      r11, -8(r1);                    \
661         std     r4, 0(r11);                     \
662         ld      r11, -16(r1);                   \
663         std     r5, 0(r11);                     \
664         ld      r11, -24(r1);                   \
665         std     r6, 0(r11);                     \
666                                                 \
667         ld      r0, 16(r1);                     \
668         mtlr    r0;                             \
669         blr
670
671 #define LV1_6_IN_1_OUT(API_NAME, API_NUMBER)    \
672 _GLOBAL(_##API_NAME)                            \
673                                                 \
674         mflr    r0;                             \
675         std     r0, 16(r1);                     \
676                                                 \
677         stdu    r9, -8(r1);                     \
678                                                 \
679         li      r11, API_NUMBER;                \
680         lv1call;                                \
681                                                 \
682         addi    r1, r1, 8;                      \
683         ld      r11, -8(r1);                    \
684         std     r4, 0(r11);                     \
685                                                 \
686         ld      r0, 16(r1);                     \
687         mtlr    r0;                             \
688         blr
689
690 #define LV1_6_IN_2_OUT(API_NAME, API_NUMBER)    \
691 _GLOBAL(_##API_NAME)                            \
692                                                 \
693         mflr    r0;                             \
694         std     r0, 16(r1);                     \
695                                                 \
696         std     r9, -8(r1);                     \
697         stdu    r10, -16(r1);                   \
698                                                 \
699         li      r11, API_NUMBER;                \
700         lv1call;                                \
701                                                 \
702         addi    r1, r1, 16;                     \
703         ld      r11, -8(r1);                    \
704         std     r4, 0(r11);                     \
705         ld      r11, -16(r1);                   \
706         std     r5, 0(r11);                     \
707                                                 \
708         ld      r0, 16(r1);                     \
709         mtlr    r0;                             \
710         blr
711
712 #define LV1_6_IN_3_OUT(API_NAME, API_NUMBER)    \
713 _GLOBAL(_##API_NAME)                            \
714                                                 \
715         mflr    r0;                             \
716         std     r0, 16(r1);                     \
717                                                 \
718         std     r9, -8(r1);                     \
719         stdu    r10, -16(r1);                   \
720                                                 \
721         li      r11, API_NUMBER;                \
722         lv1call;                                \
723                                                 \
724         addi    r1, r1, 16;                     \
725         ld      r11, -8(r1);                    \
726         std     r4, 0(r11);                     \
727         ld      r11, -16(r1);                   \
728         std     r5, 0(r11);                     \
729         ld      r11, 48+8*8(r1);                \
730         std     r6, 0(r11);                     \
731                                                 \
732         ld      r0, 16(r1);                     \
733         mtlr    r0;                             \
734         blr
735
736 #define LV1_7_IN_1_OUT(API_NAME, API_NUMBER)    \
737 _GLOBAL(_##API_NAME)                            \
738                                                 \
739         mflr    r0;                             \
740         std     r0, 16(r1);                     \
741                                                 \
742         stdu    r10, -8(r1);                    \
743                                                 \
744         li      r11, API_NUMBER;                \
745         lv1call;                                \
746                                                 \
747         addi    r1, r1, 8;                      \
748         ld      r11, -8(r1);                    \
749         std     r4, 0(r11);                     \
750                                                 \
751         ld      r0, 16(r1);                     \
752         mtlr    r0;                             \
753         blr
754
755 #define LV1_7_IN_6_OUT(API_NAME, API_NUMBER)    \
756 _GLOBAL(_##API_NAME)                            \
757                                                 \
758         mflr    r0;                             \
759         std     r0, 16(r1);                     \
760                                                 \
761         std     r10, 48+8*7(r1);                \
762                                                 \
763         li      r11, API_NUMBER;                \
764         lv1call;                                \
765                                                 \
766         ld      r11, 48+8*7(r1);                \
767         std     r4, 0(r11);                     \
768         ld      r11, 48+8*8(r1);                \
769         std     r5, 0(r11);                     \
770         ld      r11, 48+8*9(r1);                \
771         std     r6, 0(r11);                     \
772         ld      r11, 48+8*10(r1);               \
773         std     r7, 0(r11);                     \
774         ld      r11, 48+8*11(r1);               \
775         std     r8, 0(r11);                     \
776         ld      r11, 48+8*12(r1);               \
777         std     r9, 0(r11);                     \
778                                                 \
779         ld      r0, 16(r1);                     \
780         mtlr    r0;                             \
781         blr
782
783 #define LV1_8_IN_1_OUT(API_NAME, API_NUMBER)    \
784 _GLOBAL(_##API_NAME)                            \
785                                                 \
786         mflr    r0;                             \
787         std     r0, 16(r1);                     \
788                                                 \
789         li      r11, API_NUMBER;                \
790         lv1call;                                \
791                                                 \
792         ld      r11, 48+8*8(r1);                \
793         std     r4, 0(r11);                     \
794                                                 \
795         ld      r0, 16(r1);                     \
796         mtlr    r0;                             \
797         blr
798
799         .text
800
801 /* the lv1 underscored call definitions expand here */
802
803 #define LV1_CALL(name, in, out, num) LV1_##in##_IN_##out##_OUT(lv1_##name, num)
804 #include <asm/lv1call.h>