VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/x11include/XFree86-4.3/Xserver/compiler.h@ 97956

最後變更 在這個檔案從97956是 69098,由 vboxsync 提交於 7 年 前

Clean up XFree86 driver header files.
bugref:3810: X11 Guest Additions maintenance
Over the years we have cleaned up the layout in the tree of the X.Org
header files we use to build drivers. The XFree86 ones were still in their
original, rather sub-optimal layout. This change fixes that.
  • 屬性 svn:eol-style 設為 native
檔案大小: 48.6 KB
行 
1/* $XFree86: xc/programs/Xserver/hw/xfree86/common/compiler.h,v 3.99 2003/01/29 15:23:20 tsi Exp $ */
2/*
3 * Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
4 *
5 * Permission to use, copy, modify, distribute, and sell this software and its
6 * documentation for any purpose is hereby granted without fee, provided that
7 * the above copyright notice appear in all copies and that both that
8 * copyright notice and this permission notice appear in supporting
9 * documentation, and that the name of Thomas Roell not be used in
10 * advertising or publicity pertaining to distribution of the software without
11 * specific, written prior permission. Thomas Roell makes no representations
12 * about the suitability of this software for any purpose. It is provided
13 * "as is" without express or implied warranty.
14 *
15 * THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
16 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
17 * EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
18 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
19 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
20 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
21 * PERFORMANCE OF THIS SOFTWARE.
22 *
23 */
24/* $XConsortium: compiler.h /main/16 1996/10/25 15:38:34 kaleb $ */
25
26#ifndef _COMPILER_H
27
28# if !defined(_XF86_ANSIC_H) && defined(XFree86Module)
29# error missing #include "xf86_ansic.h" before #include "compiler.h"
30# endif
31
32# define _COMPILER_H
33
34/* Allow drivers to use the GCC-supported __inline__ and/or __inline. */
35# ifndef __inline__
36# if defined(__GNUC__)
37 /* gcc has __inline__ */
38# elif defined(__HIGHC__)
39# define __inline__ _Inline
40# else
41# define __inline__ /**/
42# endif
43# endif /* __inline__ */
44# ifndef __inline
45# if defined(__GNUC__)
46 /* gcc has __inline */
47# elif defined(__HIGHC__)
48# define __inline _Inline
49# else
50# define __inline /**/
51# endif
52# endif /* __inline */
53
54# if defined(IODEBUG) && defined(__GNUC__)
55# define outb RealOutb
56# define outw RealOutw
57# define outl RealOutl
58# define inb RealInb
59# define inw RealInw
60# define inl RealInl
61# endif
62
63# if defined(QNX4) /* Do this for now to keep Watcom happy */
64# define outb outp
65# define outw outpw
66# define outl outpd
67# define inb inp
68# define inw inpw
69# define inl inpd
70
71/* Define the ffs function for inlining */
72extern int ffs(unsigned long);
73# pragma aux ffs_ = \
74 "bsf edx, eax" \
75 "jnz bits_set" \
76 "xor eax, eax" \
77 "jmp exit1" \
78 "bits_set:" \
79 "mov eax, edx" \
80 "inc eax" \
81 "exit1:" \
82 __parm [eax] \
83 __modify [eax edx] \
84 __value [eax] \
85 ;
86# endif
87
88# if defined(NO_INLINE) || defined(DO_PROTOTYPES)
89
90# if !defined(__sparc__) && !defined(__arm32__) \
91 && !(defined(__alpha__) && defined(linux))
92
93extern void outb(unsigned short, unsigned char);
94extern void outw(unsigned short, unsigned short);
95extern void outl(unsigned short, unsigned int);
96extern unsigned int inb(unsigned short);
97extern unsigned int inw(unsigned short);
98extern unsigned int inl(unsigned short);
99
100# else /* __sparc__, __arm32__, __alpha__*/
101
102extern void outb(unsigned long, unsigned char);
103extern void outw(unsigned long, unsigned short);
104extern void outl(unsigned long, unsigned int);
105extern unsigned int inb(unsigned long);
106extern unsigned int inw(unsigned long);
107extern unsigned int inl(unsigned long);
108
109# endif /* __sparc__, __arm32__, __alpha__ */
110
111extern unsigned long ldq_u(unsigned long *);
112extern unsigned long ldl_u(unsigned int *);
113extern unsigned long ldw_u(unsigned short *);
114extern void stq_u(unsigned long, unsigned long *);
115extern void stl_u(unsigned long, unsigned int *);
116extern void stw_u(unsigned long, unsigned short *);
117extern void mem_barrier(void);
118extern void write_mem_barrier(void);
119extern void stl_brx(unsigned long, volatile unsigned char *, int);
120extern void stw_brx(unsigned short, volatile unsigned char *, int);
121extern unsigned long ldl_brx(volatile unsigned char *, int);
122extern unsigned short ldw_brx(volatile unsigned char *, int);
123
124# endif
125
126# ifndef NO_INLINE
127# ifdef __GNUC__
128# if (defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)) && defined(__alpha__)
129
130# ifdef linux
131/* for Linux on Alpha, we use the LIBC _inx/_outx routines */
132/* note that the appropriate setup via "ioperm" needs to be done */
133/* *before* any inx/outx is done. */
134
135extern void (*_alpha_outb)(char val, unsigned long port);
136static __inline__ void
137outb(unsigned long port, unsigned char val)
138{
139 _alpha_outb(val, port);
140}
141
142extern void (*_alpha_outw)(short val, unsigned long port);
143static __inline__ void
144outw(unsigned long port, unsigned short val)
145{
146 _alpha_outw(val, port);
147}
148
149extern void (*_alpha_outl)(int val, unsigned long port);
150static __inline__ void
151outl(unsigned long port, unsigned int val)
152{
153 _alpha_outl(val, port);
154}
155
156extern unsigned int (*_alpha_inb)(unsigned long port);
157static __inline__ unsigned int
158inb(unsigned long port)
159{
160 return _alpha_inb(port);
161}
162
163extern unsigned int (*_alpha_inw)(unsigned long port);
164static __inline__ unsigned int
165inw(unsigned long port)
166{
167 return _alpha_inw(port);
168}
169
170extern unsigned int (*_alpha_inl)(unsigned long port);
171static __inline__ unsigned int
172inl(unsigned long port)
173{
174 return _alpha_inl(port);
175}
176
177# endif /* linux */
178
179# if (defined(__FreeBSD__) || defined(__OpenBSD__)) \
180 && !defined(DO_PROTOTYPES)
181
182/* for FreeBSD and OpenBSD on Alpha, we use the libio (resp. libalpha) */
183/* inx/outx routines */
184/* note that the appropriate setup via "ioperm" needs to be done */
185/* *before* any inx/outx is done. */
186
187extern void outb(unsigned int port, unsigned char val);
188extern void outw(unsigned int port, unsigned short val);
189extern void outl(unsigned int port, unsigned int val);
190extern unsigned char inb(unsigned int port);
191extern unsigned short inw(unsigned int port);
192extern unsigned int inl(unsigned int port);
193
194# endif /* (__FreeBSD__ || __OpenBSD__ ) && !DO_PROTOTYPES */
195
196
197#if defined(__NetBSD__)
198#include <machine/pio.h>
199#endif /* __NetBSD__ */
200
201/*
202 * inline functions to do unaligned accesses
203 * from linux/include/asm-alpha/unaligned.h
204 */
205
206/*
207 * EGCS 1.1 knows about arbitrary unaligned loads. Define some
208 * packed structures to talk about such things with.
209 */
210
211struct __una_u64 { unsigned long x __attribute__((packed)); };
212struct __una_u32 { unsigned int x __attribute__((packed)); };
213struct __una_u16 { unsigned short x __attribute__((packed)); };
214
215/*
216 * Elemental unaligned loads
217 */
218/* let's try making these things static */
219
220static __inline__ unsigned long ldq_u(unsigned long * r11)
221{
222# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
223 const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
224 return ptr->x;
225# else
226 unsigned long r1,r2;
227 __asm__("ldq_u %0,%3\n\t"
228 "ldq_u %1,%4\n\t"
229 "extql %0,%2,%0\n\t"
230 "extqh %1,%2,%1"
231 :"=&r" (r1), "=&r" (r2)
232 :"r" (r11),
233 "m" (*r11),
234 "m" (*(const unsigned long *)(7+(char *) r11)));
235 return r1 | r2;
236# endif
237}
238
239static __inline__ unsigned long ldl_u(unsigned int * r11)
240{
241# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
242 const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
243 return ptr->x;
244# else
245 unsigned long r1,r2;
246 __asm__("ldq_u %0,%3\n\t"
247 "ldq_u %1,%4\n\t"
248 "extll %0,%2,%0\n\t"
249 "extlh %1,%2,%1"
250 :"=&r" (r1), "=&r" (r2)
251 :"r" (r11),
252 "m" (*r11),
253 "m" (*(const unsigned long *)(3+(char *) r11)));
254 return r1 | r2;
255# endif
256}
257
258static __inline__ unsigned long ldw_u(unsigned short * r11)
259{
260# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
261 const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
262 return ptr->x;
263# else
264 unsigned long r1,r2;
265 __asm__("ldq_u %0,%3\n\t"
266 "ldq_u %1,%4\n\t"
267 "extwl %0,%2,%0\n\t"
268 "extwh %1,%2,%1"
269 :"=&r" (r1), "=&r" (r2)
270 :"r" (r11),
271 "m" (*r11),
272 "m" (*(const unsigned long *)(1+(char *) r11)));
273 return r1 | r2;
274# endif
275}
276
277/*
278 * Elemental unaligned stores
279 */
280
281static __inline__ void stq_u(unsigned long r5, unsigned long * r11)
282{
283# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
284 struct __una_u64 *ptr = (struct __una_u64 *) r11;
285 ptr->x = r5;
286# else
287 unsigned long r1,r2,r3,r4;
288
289 __asm__("ldq_u %3,%1\n\t"
290 "ldq_u %2,%0\n\t"
291 "insqh %6,%7,%5\n\t"
292 "insql %6,%7,%4\n\t"
293 "mskqh %3,%7,%3\n\t"
294 "mskql %2,%7,%2\n\t"
295 "bis %3,%5,%3\n\t"
296 "bis %2,%4,%2\n\t"
297 "stq_u %3,%1\n\t"
298 "stq_u %2,%0"
299 :"=m" (*r11),
300 "=m" (*(unsigned long *)(7+(char *) r11)),
301 "=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
302 :"r" (r5), "r" (r11));
303# endif
304}
305
306static __inline__ void stl_u(unsigned long r5, unsigned int * r11)
307{
308# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
309 struct __una_u32 *ptr = (struct __una_u32 *) r11;
310 ptr->x = r5;
311# else
312 unsigned long r1,r2,r3,r4;
313
314 __asm__("ldq_u %3,%1\n\t"
315 "ldq_u %2,%0\n\t"
316 "inslh %6,%7,%5\n\t"
317 "insll %6,%7,%4\n\t"
318 "msklh %3,%7,%3\n\t"
319 "mskll %2,%7,%2\n\t"
320 "bis %3,%5,%3\n\t"
321 "bis %2,%4,%2\n\t"
322 "stq_u %3,%1\n\t"
323 "stq_u %2,%0"
324 :"=m" (*r11),
325 "=m" (*(unsigned long *)(3+(char *) r11)),
326 "=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
327 :"r" (r5), "r" (r11));
328# endif
329}
330
331static __inline__ void stw_u(unsigned long r5, unsigned short * r11)
332{
333# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
334 struct __una_u16 *ptr = (struct __una_u16 *) r11;
335 ptr->x = r5;
336# else
337 unsigned long r1,r2,r3,r4;
338
339 __asm__("ldq_u %3,%1\n\t"
340 "ldq_u %2,%0\n\t"
341 "inswh %6,%7,%5\n\t"
342 "inswl %6,%7,%4\n\t"
343 "mskwh %3,%7,%3\n\t"
344 "mskwl %2,%7,%2\n\t"
345 "bis %3,%5,%3\n\t"
346 "bis %2,%4,%2\n\t"
347 "stq_u %3,%1\n\t"
348 "stq_u %2,%0"
349 :"=m" (*r11),
350 "=m" (*(unsigned long *)(1+(char *) r11)),
351 "=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
352 :"r" (r5), "r" (r11));
353# endif
354}
355
356/* to flush the I-cache before jumping to code which just got loaded */
357# define PAL_imb 134
358# define istream_mem_barrier() \
359 __asm__ __volatile__("call_pal %0 #imb" : : "i" (PAL_imb) : "memory")
360# define mem_barrier() __asm__ __volatile__("mb" : : : "memory")
361# ifdef __ELF__
362# define write_mem_barrier() __asm__ __volatile__("wmb" : : : "memory")
363# else /* ECOFF gas 2.6 doesn't know "wmb" :-( */
364# define write_mem_barrier() mem_barrier()
365# endif
366
367
368# elif defined(linux) && defined(__ia64__)
369
370# include <inttypes.h>
371
372# include <sys/io.h>
373
374struct __una_u64 { uint64_t x __attribute__((packed)); };
375struct __una_u32 { uint32_t x __attribute__((packed)); };
376struct __una_u16 { uint16_t x __attribute__((packed)); };
377
378static __inline__ unsigned long
379__uldq (const unsigned long * r11)
380{
381 const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
382 return ptr->x;
383}
384
385static __inline__ unsigned long
386__uldl (const unsigned int * r11)
387{
388 const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
389 return ptr->x;
390}
391
392static __inline__ unsigned long
393__uldw (const unsigned short * r11)
394{
395 const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
396 return ptr->x;
397}
398
399static __inline__ void
400__ustq (unsigned long r5, unsigned long * r11)
401{
402 struct __una_u64 *ptr = (struct __una_u64 *) r11;
403 ptr->x = r5;
404}
405
406static __inline__ void
407__ustl (unsigned long r5, unsigned int * r11)
408{
409 struct __una_u32 *ptr = (struct __una_u32 *) r11;
410 ptr->x = r5;
411}
412
413static __inline__ void
414__ustw (unsigned long r5, unsigned short * r11)
415{
416 struct __una_u16 *ptr = (struct __una_u16 *) r11;
417 ptr->x = r5;
418}
419
420# define ldq_u(p) __uldq(p)
421# define ldl_u(p) __uldl(p)
422# define ldw_u(p) __uldw(p)
423# define stq_u(v,p) __ustq(v,p)
424# define stl_u(v,p) __ustl(v,p)
425# define stw_u(v,p) __ustw(v,p)
426
427# define mem_barrier() __asm__ __volatile__ ("mf" ::: "memory")
428# define write_mem_barrier() __asm__ __volatile__ ("mf" ::: "memory")
429
430/*
431 * This is overkill, but for different reasons depending on where it is used.
432 * This is thus general enough to be used everywhere cache flushes are needed.
433 * It doesn't handle memory access serialisation by other processors, though.
434 */
435# define ia64_flush_cache(Addr) \
436 __asm__ __volatile__ ( \
437 "fc %0;;;" \
438 "sync.i;;;" \
439 "mf;;;" \
440 "srlz.i;;;" \
441 :: "r"(Addr) : "memory")
442
443# undef outb
444# undef outw
445# undef outl
446
447# define outb(a,b) _outb(b,a)
448# define outw(a,b) _outw(b,a)
449# define outl(a,b) _outl(b,a)
450
451# elif defined(linux) && defined(__x86_64__)
452
453# include <inttypes.h>
454
455# define ldq_u(p) (*((unsigned long *)(p)))
456# define ldl_u(p) (*((unsigned int *)(p)))
457# define ldw_u(p) (*((unsigned short *)(p)))
458# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
459# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
460# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
461
462# define mem_barrier() \
463 __asm__ __volatile__ ("lock; addl $0,0(%%rsp)": : :"memory")
464# define write_mem_barrier() \
465 __asm__ __volatile__ ("": : :"memory")
466
467
468static __inline__ void
469outb(unsigned short port, unsigned char val)
470{
471 __asm__ __volatile__("outb %0,%1" : :"a" (val), "d" (port));
472}
473
474
475static __inline__ void
476outw(unsigned short port, unsigned short val)
477{
478 __asm__ __volatile__("outw %0,%1" : :"a" (val), "d" (port));
479}
480
481static __inline__ void
482outl(unsigned short port, unsigned int val)
483{
484 __asm__ __volatile__("outl %0,%1" : :"a" (val), "d" (port));
485}
486
487static __inline__ unsigned int
488inb(unsigned short port)
489{
490 unsigned char ret;
491 __asm__ __volatile__("inb %1,%0" :
492 "=a" (ret) :
493 "d" (port));
494 return ret;
495}
496
497static __inline__ unsigned int
498inw(unsigned short port)
499{
500 unsigned short ret;
501 __asm__ __volatile__("inw %1,%0" :
502 "=a" (ret) :
503 "d" (port));
504 return ret;
505}
506
507static __inline__ unsigned int
508inl(unsigned short port)
509{
510 unsigned int ret;
511 __asm__ __volatile__("inl %1,%0" :
512 "=a" (ret) :
513 "d" (port));
514 return ret;
515}
516
517# elif (defined(linux) || defined(Lynx) || defined(sun) || defined(__OpenBSD__)) && defined(__sparc__)
518
519# if !defined(Lynx)
520# ifndef ASI_PL
521# define ASI_PL 0x88
522# endif
523
524# define barrier() __asm__ __volatile__(".word 0x8143e00a": : :"memory")
525
526static __inline__ void
527outb(unsigned long port, unsigned char val)
528{
529 __asm__ __volatile__("stba %0, [%1] %2"
530 : /* No outputs */
531 : "r" (val), "r" (port), "i" (ASI_PL));
532 barrier();
533}
534
535static __inline__ void
536outw(unsigned long port, unsigned short val)
537{
538 __asm__ __volatile__("stha %0, [%1] %2"
539 : /* No outputs */
540 : "r" (val), "r" (port), "i" (ASI_PL));
541 barrier();
542}
543
544static __inline__ void
545outl(unsigned long port, unsigned int val)
546{
547 __asm__ __volatile__("sta %0, [%1] %2"
548 : /* No outputs */
549 : "r" (val), "r" (port), "i" (ASI_PL));
550 barrier();
551}
552
553static __inline__ unsigned int
554inb(unsigned long port)
555{
556 unsigned int ret;
557 __asm__ __volatile__("lduba [%1] %2, %0"
558 : "=r" (ret)
559 : "r" (port), "i" (ASI_PL));
560 return ret;
561}
562
563static __inline__ unsigned int
564inw(unsigned long port)
565{
566 unsigned int ret;
567 __asm__ __volatile__("lduha [%1] %2, %0"
568 : "=r" (ret)
569 : "r" (port), "i" (ASI_PL));
570 return ret;
571}
572
573static __inline__ unsigned int
574inl(unsigned long port)
575{
576 unsigned int ret;
577 __asm__ __volatile__("lda [%1] %2, %0"
578 : "=r" (ret)
579 : "r" (port), "i" (ASI_PL));
580 return ret;
581}
582
583static __inline__ unsigned char
584xf86ReadMmio8(__volatile__ void *base, const unsigned long offset)
585{
586 unsigned long addr = ((unsigned long)base) + offset;
587 unsigned char ret;
588
589 __asm__ __volatile__("lduba [%1] %2, %0"
590 : "=r" (ret)
591 : "r" (addr), "i" (ASI_PL));
592 return ret;
593}
594
595static __inline__ unsigned short
596xf86ReadMmio16Be(__volatile__ void *base, const unsigned long offset)
597{
598 unsigned long addr = ((unsigned long)base) + offset;
599 unsigned short ret;
600
601 __asm__ __volatile__("lduh [%1], %0"
602 : "=r" (ret)
603 : "r" (addr));
604 return ret;
605}
606
607static __inline__ unsigned short
608xf86ReadMmio16Le(__volatile__ void *base, const unsigned long offset)
609{
610 unsigned long addr = ((unsigned long)base) + offset;
611 unsigned short ret;
612
613 __asm__ __volatile__("lduha [%1] %2, %0"
614 : "=r" (ret)
615 : "r" (addr), "i" (ASI_PL));
616 return ret;
617}
618
619static __inline__ unsigned int
620xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset)
621{
622 unsigned long addr = ((unsigned long)base) + offset;
623 unsigned int ret;
624
625 __asm__ __volatile__("ld [%1], %0"
626 : "=r" (ret)
627 : "r" (addr));
628 return ret;
629}
630
631static __inline__ unsigned int
632xf86ReadMmio32Le(__volatile__ void *base, const unsigned long offset)
633{
634 unsigned long addr = ((unsigned long)base) + offset;
635 unsigned int ret;
636
637 __asm__ __volatile__("lda [%1] %2, %0"
638 : "=r" (ret)
639 : "r" (addr), "i" (ASI_PL));
640 return ret;
641}
642
643static __inline__ void
644xf86WriteMmio8(__volatile__ void *base, const unsigned long offset,
645 const unsigned int val)
646{
647 unsigned long addr = ((unsigned long)base) + offset;
648
649 __asm__ __volatile__("stba %0, [%1] %2"
650 : /* No outputs */
651 : "r" (val), "r" (addr), "i" (ASI_PL));
652 barrier();
653}
654
655static __inline__ void
656xf86WriteMmio16Be(__volatile__ void *base, const unsigned long offset,
657 const unsigned int val)
658{
659 unsigned long addr = ((unsigned long)base) + offset;
660
661 __asm__ __volatile__("sth %0, [%1]"
662 : /* No outputs */
663 : "r" (val), "r" (addr));
664 barrier();
665}
666
667static __inline__ void
668xf86WriteMmio16Le(__volatile__ void *base, const unsigned long offset,
669 const unsigned int val)
670{
671 unsigned long addr = ((unsigned long)base) + offset;
672
673 __asm__ __volatile__("stha %0, [%1] %2"
674 : /* No outputs */
675 : "r" (val), "r" (addr), "i" (ASI_PL));
676 barrier();
677}
678
679static __inline__ void
680xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset,
681 const unsigned int val)
682{
683 unsigned long addr = ((unsigned long)base) + offset;
684
685 __asm__ __volatile__("st %0, [%1]"
686 : /* No outputs */
687 : "r" (val), "r" (addr));
688 barrier();
689}
690
691static __inline__ void
692xf86WriteMmio32Le(__volatile__ void *base, const unsigned long offset,
693 const unsigned int val)
694{
695 unsigned long addr = ((unsigned long)base) + offset;
696
697 __asm__ __volatile__("sta %0, [%1] %2"
698 : /* No outputs */
699 : "r" (val), "r" (addr), "i" (ASI_PL));
700 barrier();
701}
702
703static __inline__ void
704xf86WriteMmio8NB(__volatile__ void *base, const unsigned long offset,
705 const unsigned int val)
706{
707 unsigned long addr = ((unsigned long)base) + offset;
708
709 __asm__ __volatile__("stba %0, [%1] %2"
710 : /* No outputs */
711 : "r" (val), "r" (addr), "i" (ASI_PL));
712}
713
714static __inline__ void
715xf86WriteMmio16BeNB(__volatile__ void *base, const unsigned long offset,
716 const unsigned int val)
717{
718 unsigned long addr = ((unsigned long)base) + offset;
719
720 __asm__ __volatile__("sth %0, [%1]"
721 : /* No outputs */
722 : "r" (val), "r" (addr));
723}
724
725static __inline__ void
726xf86WriteMmio16LeNB(__volatile__ void *base, const unsigned long offset,
727 const unsigned int val)
728{
729 unsigned long addr = ((unsigned long)base) + offset;
730
731 __asm__ __volatile__("stha %0, [%1] %2"
732 : /* No outputs */
733 : "r" (val), "r" (addr), "i" (ASI_PL));
734}
735
736static __inline__ void
737xf86WriteMmio32BeNB(__volatile__ void *base, const unsigned long offset,
738 const unsigned int val)
739{
740 unsigned long addr = ((unsigned long)base) + offset;
741
742 __asm__ __volatile__("st %0, [%1]"
743 : /* No outputs */
744 : "r" (val), "r" (addr));
745}
746
747static __inline__ void
748xf86WriteMmio32LeNB(__volatile__ void *base, const unsigned long offset,
749 const unsigned int val)
750{
751 unsigned long addr = ((unsigned long)base) + offset;
752
753 __asm__ __volatile__("sta %0, [%1] %2"
754 : /* No outputs */
755 : "r" (val), "r" (addr), "i" (ASI_PL));
756}
757
758# endif /* !Lynx */
759
760/*
761 * EGCS 1.1 knows about arbitrary unaligned loads. Define some
762 * packed structures to talk about such things with.
763 */
764
765# if defined(__arch64__) || defined(__sparcv9)
766struct __una_u64 { unsigned long x __attribute__((packed)); };
767# endif
768struct __una_u32 { unsigned int x __attribute__((packed)); };
769struct __una_u16 { unsigned short x __attribute__((packed)); };
770
771static __inline__ unsigned long ldq_u(unsigned long *p)
772{
773# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
774# if defined(__arch64__) || defined(__sparcv9)
775 const struct __una_u64 *ptr = (const struct __una_u64 *) p;
776# else
777 const struct __una_u32 *ptr = (const struct __una_u32 *) p;
778# endif
779 return ptr->x;
780# else
781 unsigned long ret;
782 memmove(&ret, p, sizeof(*p));
783 return ret;
784# endif
785}
786
787static __inline__ unsigned long ldl_u(unsigned int *p)
788{
789# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
790 const struct __una_u32 *ptr = (const struct __una_u32 *) p;
791 return ptr->x;
792# else
793 unsigned int ret;
794 memmove(&ret, p, sizeof(*p));
795 return ret;
796# endif
797}
798
799static __inline__ unsigned long ldw_u(unsigned short *p)
800{
801# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
802 const struct __una_u16 *ptr = (const struct __una_u16 *) p;
803 return ptr->x;
804# else
805 unsigned short ret;
806 memmove(&ret, p, sizeof(*p));
807 return ret;
808# endif
809}
810
811static __inline__ void stq_u(unsigned long val, unsigned long *p)
812{
813# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
814# if defined(__arch64__) || defined(__sparcv9)
815 struct __una_u64 *ptr = (struct __una_u64 *) p;
816# else
817 struct __una_u32 *ptr = (struct __una_u32 *) p;
818# endif
819 ptr->x = val;
820# else
821 unsigned long tmp = val;
822 memmove(p, &tmp, sizeof(*p));
823# endif
824}
825
826static __inline__ void stl_u(unsigned long val, unsigned int *p)
827{
828# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
829 struct __una_u32 *ptr = (struct __una_u32 *) p;
830 ptr->x = val;
831# else
832 unsigned int tmp = val;
833 memmove(p, &tmp, sizeof(*p));
834# endif
835}
836
837static __inline__ void stw_u(unsigned long val, unsigned short *p)
838{
839# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
840 struct __una_u16 *ptr = (struct __una_u16 *) p;
841 ptr->x = val;
842# else
843 unsigned short tmp = val;
844 memmove(p, &tmp, sizeof(*p));
845# endif
846}
847
848# define mem_barrier() /* XXX: nop for now */
849# define write_mem_barrier() /* XXX: nop for now */
850
851# elif defined(__mips__) || defined(__arm32__)
852#ifdef __arm32__
853#define PORT_SIZE long
854#else
855#define PORT_SIZE short
856#endif
857
858unsigned int IOPortBase; /* Memory mapped I/O port area */
859
860static __inline__ void
861outb(unsigned PORT_SIZE port, unsigned char val)
862{
863 *(volatile unsigned char*)(((unsigned PORT_SIZE)(port))+IOPortBase) = val;
864}
865
866static __inline__ void
867outw(unsigned PORT_SIZE port, unsigned short val)
868{
869 *(volatile unsigned short*)(((unsigned PORT_SIZE)(port))+IOPortBase) = val;
870}
871
872static __inline__ void
873outl(unsigned PORT_SIZE port, unsigned int val)
874{
875 *(volatile unsigned int*)(((unsigned PORT_SIZE)(port))+IOPortBase) = val;
876}
877
878static __inline__ unsigned int
879inb(unsigned PORT_SIZE port)
880{
881 return *(volatile unsigned char*)(((unsigned PORT_SIZE)(port))+IOPortBase);
882}
883
884static __inline__ unsigned int
885inw(unsigned PORT_SIZE port)
886{
887 return *(volatile unsigned short*)(((unsigned PORT_SIZE)(port))+IOPortBase);
888}
889
890static __inline__ unsigned int
891inl(unsigned PORT_SIZE port)
892{
893 return *(volatile unsigned int*)(((unsigned PORT_SIZE)(port))+IOPortBase);
894}
895
896
897# if defined(__mips__)
898static __inline__ unsigned long ldq_u(unsigned long * r11)
899{
900 unsigned long r1;
901 __asm__("lwr %0,%2\n\t"
902 "lwl %0,%3\n\t"
903 :"=&r" (r1)
904 :"r" (r11),
905 "m" (*r11),
906 "m" (*(unsigned long *)(3+(char *) r11)));
907 return r1;
908}
909
910static __inline__ unsigned long ldl_u(unsigned int * r11)
911{
912 unsigned long r1;
913 __asm__("lwr %0,%2\n\t"
914 "lwl %0,%3\n\t"
915 :"=&r" (r1)
916 :"r" (r11),
917 "m" (*r11),
918 "m" (*(unsigned long *)(3+(char *) r11)));
919 return r1;
920}
921
922static __inline__ unsigned long ldw_u(unsigned short * r11)
923{
924 unsigned long r1;
925 __asm__("lwr %0,%2\n\t"
926 "lwl %0,%3\n\t"
927 :"=&r" (r1)
928 :"r" (r11),
929 "m" (*r11),
930 "m" (*(unsigned long *)(1+(char *) r11)));
931 return r1;
932}
933
934# ifdef linux /* don't mess with other OSs */
935
936/*
937 * EGCS 1.1 knows about arbitrary unaligned loads (and we don't support older
938 * versions anyway. Define some packed structures to talk about such things
939 * with.
940 */
941
942struct __una_u32 { unsigned int x __attribute__((packed)); };
943struct __una_u16 { unsigned short x __attribute__((packed)); };
944
945static __inline__ void stw_u(unsigned long val, unsigned short *p)
946{
947 struct __una_u16 *ptr = (struct __una_u16 *) p;
948 ptr->x = val;
949}
950
951static __inline__ void stl_u(unsigned long val, unsigned int *p)
952{
953 struct __una_u32 *ptr = (struct __una_u32 *) p;
954 ptr->x = val;
955}
956
957# if X_BYTE_ORDER == X_BIG_ENDIAN
958static __inline__ unsigned int
959xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset)
960{
961 unsigned long addr = ((unsigned long)base) + offset;
962 unsigned int ret;
963
964 __asm__ __volatile__("lw %0, 0(%1)"
965 : "=r" (ret)
966 : "r" (addr));
967 return ret;
968}
969
970static __inline__ void
971xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset,
972 const unsigned int val)
973{
974 unsigned long addr = ((unsigned long)base) + offset;
975
976 __asm__ __volatile__("sw %0, 0(%1)"
977 : /* No outputs */
978 : "r" (val), "r" (addr));
979}
980# endif
981
982# define mem_barrier() \
983 __asm__ __volatile__( \
984 "# prevent instructions being moved around\n\t" \
985 ".set\tnoreorder\n\t" \
986 "# 8 nops to fool the R4400 pipeline\n\t" \
987 "nop;nop;nop;nop;nop;nop;nop;nop\n\t" \
988 ".set\treorder" \
989 : /* no output */ \
990 : /* no input */ \
991 : "memory")
992# define write_mem_barrier() mem_barrier()
993
994# else /* !linux */
995
996# define stq_u(v,p) stl_u(v,p)
997# define stl_u(v,p) (*(unsigned char *)(p)) = (v); \
998 (*(unsigned char *)(p)+1) = ((v) >> 8); \
999 (*(unsigned char *)(p)+2) = ((v) >> 16); \
1000 (*(unsigned char *)(p)+3) = ((v) >> 24)
1001
1002# define stw_u(v,p) (*(unsigned char *)(p)) = (v); \
1003 (*(unsigned char *)(p)+1) = ((v) >> 8)
1004
1005# define mem_barrier() /* NOP */
1006# endif /* !linux */
1007# endif /* __mips__ */
1008
1009# if defined(__arm32__)
1010# define ldq_u(p) (*((unsigned long *)(p)))
1011# define ldl_u(p) (*((unsigned int *)(p)))
1012# define ldw_u(p) (*((unsigned short *)(p)))
1013# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
1014# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
1015# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
1016# define mem_barrier() /* NOP */
1017# define write_mem_barrier() /* NOP */
1018# endif /* __arm32__ */
1019
1020# elif (defined(Lynx) || defined(linux) || defined(__OpenBSD__) || defined(__NetBSD__)) && defined(__powerpc__)
1021
1022# ifndef MAP_FAILED
1023# define MAP_FAILED ((void *)-1)
1024# endif
1025
1026extern volatile unsigned char *ioBase;
1027
1028# define eieio() __asm__ __volatile__ ("eieio" ::: "memory")
1029
1030static __inline__ unsigned char
1031xf86ReadMmio8(__volatile__ void *base, const unsigned long offset)
1032{
1033 register unsigned char val;
1034 __asm__ __volatile__(
1035 "lbzx %0,%1,%2\n\t"
1036 "eieio"
1037 : "=r" (val)
1038 : "b" (base), "r" (offset),
1039 "m" (*((volatile unsigned char *)base+offset)));
1040 return val;
1041}
1042
1043static __inline__ unsigned short
1044xf86ReadMmio16Be(__volatile__ void *base, const unsigned long offset)
1045{
1046 register unsigned short val;
1047 __asm__ __volatile__(
1048 "lhzx %0,%1,%2\n\t"
1049 "eieio"
1050 : "=r" (val)
1051 : "b" (base), "r" (offset),
1052 "m" (*((volatile unsigned char *)base+offset)));
1053 return val;
1054}
1055
1056static __inline__ unsigned short
1057xf86ReadMmio16Le(__volatile__ void *base, const unsigned long offset)
1058{
1059 register unsigned short val;
1060 __asm__ __volatile__(
1061 "lhbrx %0,%1,%2\n\t"
1062 "eieio"
1063 : "=r" (val)
1064 : "b" (base), "r" (offset),
1065 "m" (*((volatile unsigned char *)base+offset)));
1066 return val;
1067}
1068
1069static __inline__ unsigned int
1070xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset)
1071{
1072 register unsigned int val;
1073 __asm__ __volatile__(
1074 "lwzx %0,%1,%2\n\t"
1075 "eieio"
1076 : "=r" (val)
1077 : "b" (base), "r" (offset),
1078 "m" (*((volatile unsigned char *)base+offset)));
1079 return val;
1080}
1081
1082static __inline__ unsigned int
1083xf86ReadMmio32Le(__volatile__ void *base, const unsigned long offset)
1084{
1085 register unsigned int val;
1086 __asm__ __volatile__(
1087 "lwbrx %0,%1,%2\n\t"
1088 "eieio"
1089 : "=r" (val)
1090 : "b" (base), "r" (offset),
1091 "m" (*((volatile unsigned char *)base+offset)));
1092 return val;
1093}
1094
1095static __inline__ void
1096xf86WriteMmioNB8(__volatile__ void *base, const unsigned long offset,
1097 const unsigned char val)
1098{
1099 __asm__ __volatile__(
1100 "stbx %1,%2,%3\n\t"
1101 : "=m" (*((volatile unsigned char *)base+offset))
1102 : "r" (val), "b" (base), "r" (offset));
1103}
1104
1105static __inline__ void
1106xf86WriteMmioNB16Le(__volatile__ void *base, const unsigned long offset,
1107 const unsigned short val)
1108{
1109 __asm__ __volatile__(
1110 "sthbrx %1,%2,%3\n\t"
1111 : "=m" (*((volatile unsigned char *)base+offset))
1112 : "r" (val), "b" (base), "r" (offset));
1113}
1114
1115static __inline__ void
1116xf86WriteMmioNB16Be(__volatile__ void *base, const unsigned long offset,
1117 const unsigned short val)
1118{
1119 __asm__ __volatile__(
1120 "sthx %1,%2,%3\n\t"
1121 : "=m" (*((volatile unsigned char *)base+offset))
1122 : "r" (val), "b" (base), "r" (offset));
1123}
1124
1125static __inline__ void
1126xf86WriteMmioNB32Le(__volatile__ void *base, const unsigned long offset,
1127 const unsigned int val)
1128{
1129 __asm__ __volatile__(
1130 "stwbrx %1,%2,%3\n\t"
1131 : "=m" (*((volatile unsigned char *)base+offset))
1132 : "r" (val), "b" (base), "r" (offset));
1133}
1134
1135static __inline__ void
1136xf86WriteMmioNB32Be(__volatile__ void *base, const unsigned long offset,
1137 const unsigned int val)
1138{
1139 __asm__ __volatile__(
1140 "stwx %1,%2,%3\n\t"
1141 : "=m" (*((volatile unsigned char *)base+offset))
1142 : "r" (val), "b" (base), "r" (offset));
1143}
1144
1145static __inline__ void
1146xf86WriteMmio8(__volatile__ void *base, const unsigned long offset,
1147 const unsigned char val)
1148{
1149 xf86WriteMmioNB8(base, offset, val);
1150 eieio();
1151}
1152
1153static __inline__ void
1154xf86WriteMmio16Le(__volatile__ void *base, const unsigned long offset,
1155 const unsigned short val)
1156{
1157 xf86WriteMmioNB16Le(base, offset, val);
1158 eieio();
1159}
1160
1161static __inline__ void
1162xf86WriteMmio16Be(__volatile__ void *base, const unsigned long offset,
1163 const unsigned short val)
1164{
1165 xf86WriteMmioNB16Be(base, offset, val);
1166 eieio();
1167}
1168
1169static __inline__ void
1170xf86WriteMmio32Le(__volatile__ void *base, const unsigned long offset,
1171 const unsigned int val)
1172{
1173 xf86WriteMmioNB32Le(base, offset, val);
1174 eieio();
1175}
1176
1177static __inline__ void
1178xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset,
1179 const unsigned int val)
1180{
1181 xf86WriteMmioNB32Be(base, offset, val);
1182 eieio();
1183}
1184
1185
1186static __inline__ void
1187outb(unsigned short port, unsigned char value)
1188{
1189 if(ioBase == MAP_FAILED) return;
1190 xf86WriteMmio8((void *)ioBase, port, value);
1191}
1192
1193static __inline__ void
1194outw(unsigned short port, unsigned short value)
1195{
1196 if(ioBase == MAP_FAILED) return;
1197 xf86WriteMmio16Le((void *)ioBase, port, value);
1198}
1199
1200static __inline__ void
1201outl(unsigned short port, unsigned int value)
1202{
1203 if(ioBase == MAP_FAILED) return;
1204 xf86WriteMmio32Le((void *)ioBase, port, value);
1205}
1206
1207static __inline__ unsigned int
1208inb(unsigned short port)
1209{
1210 if(ioBase == MAP_FAILED) return 0;
1211 return xf86ReadMmio8((void *)ioBase, port);
1212}
1213
1214static __inline__ unsigned int
1215inw(unsigned short port)
1216{
1217 if(ioBase == MAP_FAILED) return 0;
1218 return xf86ReadMmio16Le((void *)ioBase, port);
1219}
1220
1221static __inline__ unsigned int
1222inl(unsigned short port)
1223{
1224 if(ioBase == MAP_FAILED) return 0;
1225 return xf86ReadMmio32Le((void *)ioBase, port);
1226}
1227
1228# define ldq_u(p) ldl_u(p)
1229# define ldl_u(p) ((*(unsigned char *)(p)) | \
1230 (*((unsigned char *)(p)+1)<<8) | \
1231 (*((unsigned char *)(p)+2)<<16) | \
1232 (*((unsigned char *)(p)+3)<<24))
1233# define ldw_u(p) ((*(unsigned char *)(p)) | \
1234 (*((unsigned char *)(p)+1)<<8))
1235
1236# define stq_u(v,p) stl_u(v,p)
1237# define stl_u(v,p) (*(unsigned char *)(p)) = (v); \
1238 (*((unsigned char *)(p)+1)) = ((v) >> 8); \
1239 (*((unsigned char *)(p)+2)) = ((v) >> 16); \
1240 (*((unsigned char *)(p)+3)) = ((v) >> 24)
1241# define stw_u(v,p) (*(unsigned char *)(p)) = (v); \
1242 (*((unsigned char *)(p)+1)) = ((v) >> 8)
1243
1244# define mem_barrier() eieio()
1245# define write_mem_barrier() eieio()
1246
1247# else /* ix86 */
1248
1249# define ldq_u(p) (*((unsigned long *)(p)))
1250# define ldl_u(p) (*((unsigned int *)(p)))
1251# define ldw_u(p) (*((unsigned short *)(p)))
1252# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
1253# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
1254# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
1255# define mem_barrier() /* NOP */
1256# define write_mem_barrier() /* NOP */
1257
1258# if !defined(FAKEIT) && !defined(__mc68000__) && !defined(__arm__) && !defined(__sh__) && !defined(__hppa__)
1259# ifdef GCCUSESGAS
1260
1261/*
1262 * If gcc uses gas rather than the native assembler, the syntax of these
1263 * inlines has to be different. DHD
1264 */
1265
1266static __inline__ void
1267outb(unsigned short port, unsigned char val)
1268{
1269 __asm__ __volatile__("outb %0,%1" : :"a" (val), "d" (port));
1270}
1271
1272
1273static __inline__ void
1274outw(unsigned short port, unsigned short val)
1275{
1276 __asm__ __volatile__("outw %0,%1" : :"a" (val), "d" (port));
1277}
1278
1279static __inline__ void
1280outl(unsigned short port, unsigned int val)
1281{
1282 __asm__ __volatile__("outl %0,%1" : :"a" (val), "d" (port));
1283}
1284
1285static __inline__ unsigned int
1286inb(unsigned short port)
1287{
1288 unsigned char ret;
1289 __asm__ __volatile__("inb %1,%0" :
1290 "=a" (ret) :
1291 "d" (port));
1292 return ret;
1293}
1294
1295static __inline__ unsigned int
1296inw(unsigned short port)
1297{
1298 unsigned short ret;
1299 __asm__ __volatile__("inw %1,%0" :
1300 "=a" (ret) :
1301 "d" (port));
1302 return ret;
1303}
1304
1305static __inline__ unsigned int
1306inl(unsigned short port)
1307{
1308 unsigned int ret;
1309 __asm__ __volatile__("inl %1,%0" :
1310 "=a" (ret) :
1311 "d" (port));
1312 return ret;
1313}
1314
1315# else /* GCCUSESGAS */
1316
1317static __inline__ void
1318outb(unsigned short port, unsigned char val)
1319{
1320 __asm__ __volatile__("out%B0 (%1)" : :"a" (val), "d" (port));
1321}
1322
1323static __inline__ void
1324outw(unsigned short port, unsigned short val)
1325{
1326 __asm__ __volatile__("out%W0 (%1)" : :"a" (val), "d" (port));
1327}
1328
1329static __inline__ void
1330outl(unsigned short port, unsigned int val)
1331{
1332 __asm__ __volatile__("out%L0 (%1)" : :"a" (val), "d" (port));
1333}
1334
1335static __inline__ unsigned int
1336inb(unsigned short port)
1337{
1338 unsigned char ret;
1339 __asm__ __volatile__("in%B0 (%1)" :
1340 "=a" (ret) :
1341 "d" (port));
1342 return ret;
1343}
1344
1345static __inline__ unsigned int
1346inw(unsigned short port)
1347{
1348 unsigned short ret;
1349 __asm__ __volatile__("in%W0 (%1)" :
1350 "=a" (ret) :
1351 "d" (port));
1352 return ret;
1353}
1354
1355static __inline__ unsigned int
1356inl(unsigned short port)
1357{
1358 unsigned int ret;
1359 __asm__ __volatile__("in%L0 (%1)" :
1360 "=a" (ret) :
1361 "d" (port));
1362 return ret;
1363}
1364
1365# endif /* GCCUSESGAS */
1366
1367# else /* !defined(FAKEIT) && !defined(__mc68000__) && !defined(__arm__) && !defined(__sh__) && !defined(__hppa__)*/
1368
1369static __inline__ void
1370outb(unsigned short port, unsigned char val)
1371{
1372}
1373
1374static __inline__ void
1375outw(unsigned short port, unsigned short val)
1376{
1377}
1378
1379static __inline__ void
1380outl(unsigned short port, unsigned int val)
1381{
1382}
1383
1384static __inline__ unsigned int
1385inb(unsigned short port)
1386{
1387 return 0;
1388}
1389
1390static __inline__ unsigned int
1391inw(unsigned short port)
1392{
1393 return 0;
1394}
1395
1396static __inline__ unsigned int
1397inl(unsigned short port)
1398{
1399 return 0;
1400}
1401
1402# endif /* FAKEIT */
1403
1404# endif /* ix86 */
1405
1406# elif defined(__powerpc__) /* && !__GNUC__ */
1407/*
1408 * NON-GCC PowerPC - Presumed to be PowerMAX OS for now
1409 */
1410# ifndef PowerMAX_OS
1411# error - Non-gcc PowerPC and !PowerMAXOS ???
1412# endif
1413
1414# define PPCIO_DEBUG 0
1415# define PPCIO_INLINE 1
1416# define USE_ABS_MACRO 1
1417/*
1418 * Use compiler intrinsics to access certain PPC machine instructions
1419 */
1420# define eieio() __inst_eieio()
1421# define stw_brx(val,base,ndx) __inst_sthbrx(val,base,ndx)
1422# define stl_brx(val,base,ndx) __inst_stwbrx(val,base,ndx)
1423# define ldw_brx(base,ndx) __inst_lhbrx(base,ndx)
1424# define ldl_brx(base,ndx) __inst_lwbrx(base,ndx)
1425
1426# define ldq_u(p) (*((unsigned long long *)(p)))
1427# define ldl_u(p) (*((unsigned long *)(p)))
1428# define ldw_u(p) (*((unsigned short *)(p)))
1429# define stq_u(v,p) (*(unsigned long long *)(p)) = (v)
1430# define stl_u(v,p) (*(unsigned long *)(p)) = (v)
1431# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
1432# define mem_barrier() eieio()
1433# define write_mem_barrier() eieio()
1434
1435extern volatile unsigned char *ioBase;
1436
1437# if !defined(abs) && defined(USE_ABS_MACRO)
1438# define abs(x) ((x) >= 0 ? (x) : -(x))
1439# endif
1440
1441# undef inb
1442# undef inw
1443# undef inl
1444# undef outb
1445# undef outw
1446# undef outl
1447
1448# if PPCIO_DEBUG
1449
1450extern void debug_outb(unsigned int a, unsigned char b, int line, char *file);
1451extern void debug_outw(unsigned int a, unsigned short w, int line, char *file);
1452extern void debug_outl(unsigned int a, unsigned int l, int line, char *file);
1453extern unsigned char debug_inb(unsigned int a, int line, char *file);
1454extern unsigned short debug_inw(unsigned int a, int line, char *file);
1455extern unsigned int debug_inl(unsigned int a, int line, char *file);
1456
1457# define outb(a,b) debug_outb(a,b, __LINE__, __FILE__)
1458# define outw(a,w) debug_outw(a,w, __LINE__, __FILE__)
1459# define outl(a,l) debug_outl(a,l, __LINE__, __FILE__)
1460# define inb(a) debug_inb(a, __LINE__, __FILE__)
1461# define inw(a) debug_inw(a, __LINE__, __FILE__)
1462# define inl(a) debug_inl(a, __LINE__, __FILE__)
1463
1464# else /* !PPCIO_DEBUG */
1465
1466extern unsigned char inb(unsigned int a);
1467extern unsigned short inw(unsigned int a);
1468extern unsigned int inl(unsigned int a);
1469
1470# if PPCIO_INLINE
1471
1472# define outb(a,b) \
1473 (*((volatile unsigned char *)(ioBase + (a))) = (b), eieio())
1474# define outw(a,w) (stw_brx((w),ioBase,(a)), eieio())
1475# define outl(a,l) (stl_brx((l),ioBase,(a)), eieio())
1476
1477# else /* !PPCIO_INLINE */
1478
1479extern void outb(unsigned int a, unsigned char b);
1480extern void outw(unsigned int a, unsigned short w);
1481extern void outl(unsigned int a, unsigned int l);
1482
1483# endif /* PPCIO_INLINE */
1484
1485# endif /* !PPCIO_DEBUG */
1486
1487# else /* !GNUC && !PPC */
1488# if !defined(QNX4)
1489# if defined(__STDC__) && (__STDC__ == 1)
1490# ifndef asm
1491# define asm __asm
1492# endif
1493# endif
1494# ifdef SVR4
1495#if 0
1496# include <sys/types.h>
1497#endif
1498# ifndef __HIGHC__
1499# ifndef __USLC__
1500# define __USLC__
1501# endif
1502# endif
1503# endif
1504# ifndef SCO325
1505# if defined(USL)
1506# if defined(IN_MODULE)
1507# /* avoid including <sys/types.h> for <sys/inline.h> on UnixWare */
1508# define ushort unsigned short
1509# define ushort_t unsigned short
1510# define ulong unsigned long
1511# define ulong_t unsigned long
1512# define uint_t unsigned int
1513# define uchar_t unsigned char
1514# else
1515# include <sys/types.h>
1516# endif /* IN_MODULE */
1517# endif /* USL */
1518# include <sys/inline.h>
1519# else
1520# include "scoasm.h"
1521# endif
1522# if !defined(__HIGHC__) && !defined(SCO325)
1523# pragma asm partial_optimization outl
1524# pragma asm partial_optimization outw
1525# pragma asm partial_optimization outb
1526# pragma asm partial_optimization inl
1527# pragma asm partial_optimization inw
1528# pragma asm partial_optimization inb
1529# endif
1530# endif
1531# define ldq_u(p) (*((unsigned long *)(p)))
1532# define ldl_u(p) (*((unsigned int *)(p)))
1533# define ldw_u(p) (*((unsigned short *)(p)))
1534# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
1535# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
1536# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
1537# define mem_barrier() /* NOP */
1538# define write_mem_barrier() /* NOP */
1539# endif /* __GNUC__ */
1540
1541# if defined(QNX4)
1542# include <sys/types.h>
1543extern unsigned inb(unsigned port);
1544extern unsigned inw(unsigned port);
1545extern unsigned inl(unsigned port);
1546extern void outb(unsigned port, unsigned val);
1547extern void outw(unsigned port, unsigned val);
1548extern void outl(unsigned port, unsigned val);
1549# endif /* QNX4 */
1550
1551# if defined(IODEBUG) && defined(__GNUC__)
1552# undef inb
1553# undef inw
1554# undef inl
1555# undef outb
1556# undef outw
1557# undef outl
1558# define inb(a) __extension__ ({unsigned char __c=RealInb(a); ErrorF("inb(0x%03x) = 0x%02x\t@ line %4d, file %s\n", a, __c, __LINE__, __FILE__);__c;})
1559# define inw(a) __extension__ ({unsigned short __c=RealInw(a); ErrorF("inw(0x%03x) = 0x%04x\t@ line %4d, file %s\n", a, __c, __LINE__, __FILE__);__c;})
1560# define inl(a) __extension__ ({unsigned int __c=RealInl(a); ErrorF("inl(0x%03x) = 0x%08x\t@ line %4d, file %s\n", a, __c, __LINE__, __FILE__);__c;})
1561
1562# define outb(a,b) (ErrorF("outb(0x%03x, 0x%02x)\t@ line %4d, file %s\n", a, b, __LINE__, __FILE__),RealOutb(a,b))
1563# define outw(a,b) (ErrorF("outw(0x%03x, 0x%04x)\t@ line %4d, file %s\n", a, b, __LINE__, __FILE__),RealOutw(a,b))
1564# define outl(a,b) (ErrorF("outl(0x%03x, 0x%08x)\t@ line %4d, file %s\n", a, b, __LINE__, __FILE__),RealOutl(a,b))
1565# endif
1566
1567# endif /* NO_INLINE */
1568
1569# ifdef __alpha__
1570/* entry points for Mmio memory access routines */
1571extern int (*xf86ReadMmio8)(void *, unsigned long);
1572extern int (*xf86ReadMmio16)(void *, unsigned long);
1573extern int (*xf86ReadMmio32)(void *, unsigned long);
1574extern void (*xf86WriteMmio8)(int, void *, unsigned long);
1575extern void (*xf86WriteMmio16)(int, void *, unsigned long);
1576extern void (*xf86WriteMmio32)(int, void *, unsigned long);
1577extern void (*xf86WriteMmioNB8)(int, void *, unsigned long);
1578extern void (*xf86WriteMmioNB16)(int, void *, unsigned long);
1579extern void (*xf86WriteMmioNB32)(int, void *, unsigned long);
1580extern void xf86JensenMemToBus(char *, long, long, int);
1581extern void xf86JensenBusToMem(char *, char *, unsigned long, int);
1582extern void xf86SlowBCopyFromBus(unsigned char *, unsigned char *, int);
1583extern void xf86SlowBCopyToBus(unsigned char *, unsigned char *, int);
1584
1585/* Some macros to hide the system dependencies for MMIO accesses */
1586/* Changed to kill noise generated by gcc's -Wcast-align */
1587# define MMIO_IN8(base, offset) (*xf86ReadMmio8)(base, offset)
1588# define MMIO_IN16(base, offset) (*xf86ReadMmio16)(base, offset)
1589# define MMIO_IN32(base, offset) (*xf86ReadMmio32)(base, offset)
1590
1591# if defined (JENSEN_SUPPORT)
1592# define MMIO_OUT32(base, offset, val) \
1593 (*xf86WriteMmio32)((CARD32)(val), base, offset)
1594# define MMIO_ONB32(base, offset, val) \
1595 (*xf86WriteMmioNB32)((CARD32)(val), base, offset)
1596# else
1597# define MMIO_OUT32(base, offset, val) \
1598 do { \
1599 write_mem_barrier(); \
1600 *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val); \
1601 } while (0)
1602# define MMIO_ONB32(base, offset, val) \
1603 *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val)
1604# endif
1605
1606# define MMIO_OUT8(base, offset, val) \
1607 (*xf86WriteMmio8)((CARD8)(val), base, offset)
1608# define MMIO_OUT16(base, offset, val) \
1609 (*xf86WriteMmio16)((CARD16)(val), base, offset)
1610# define MMIO_ONB8(base, offset, val) \
1611 (*xf86WriteMmioNB8)((CARD8)(val), base, offset)
1612# define MMIO_ONB16(base, offset, val) \
1613 (*xf86WriteMmioNB16)((CARD16)(val), base, offset)
1614# define MMIO_MOVE32(base, offset, val) \
1615 MMIO_OUT32(base, offset, val)
1616
1617# elif defined(__powerpc__)
1618 /*
1619 * we provide byteswapping and no byteswapping functions here
1620 * with byteswapping as default,
1621 * drivers that don't need byteswapping should define PPC_MMIO_IS_BE
1622 */
1623# define MMIO_IN8(base, offset) xf86ReadMmio8(base, offset)
1624# define MMIO_OUT8(base, offset, val) \
1625 xf86WriteMmio8(base, offset, (CARD8)(val))
1626# define MMIO_ONB8(base, offset, val) \
1627 xf86WriteMmioNB8(base, offset, (CARD8)(val))
1628
1629# if defined(PPC_MMIO_IS_BE) /* No byteswapping */
1630# define MMIO_IN16(base, offset) xf86ReadMmio16Be(base, offset)
1631# define MMIO_IN32(base, offset) xf86ReadMmio32Be(base, offset)
1632# define MMIO_OUT16(base, offset, val) \
1633 xf86WriteMmio16Be(base, offset, (CARD16)(val))
1634# define MMIO_OUT32(base, offset, val) \
1635 xf86WriteMmio32Be(base, offset, (CARD32)(val))
1636# define MMIO_ONB16(base, offset, val) \
1637 xf86WriteMmioNB16Be(base, offset, (CARD16)(val))
1638# define MMIO_ONB32(base, offset, val) \
1639 xf86WriteMmioNB32Be(base, offset, (CARD32)(val))
1640# else /* byteswapping is the default */
1641# define MMIO_IN16(base, offset) xf86ReadMmio16Le(base, offset)
1642# define MMIO_IN32(base, offset) xf86ReadMmio32Le(base, offset)
1643# define MMIO_OUT16(base, offset, val) \
1644 xf86WriteMmio16Le(base, offset, (CARD16)(val))
1645# define MMIO_OUT32(base, offset, val) \
1646 xf86WriteMmio32Le(base, offset, (CARD32)(val))
1647# define MMIO_ONB16(base, offset, val) \
1648 xf86WriteMmioNB16Le(base, offset, (CARD16)(val))
1649# define MMIO_ONB32(base, offset, val) \
1650 xf86WriteMmioNB32Le(base, offset, (CARD32)(val))
1651# endif
1652
1653# define MMIO_MOVE32(base, offset, val) \
1654 xf86WriteMmio32Be(base, offset, (CARD32)(val))
1655
1656static __inline__ void ppc_flush_icache(char *addr)
1657{
1658 __asm__ volatile (
1659 "dcbf 0,%0;"
1660 "sync;"
1661 "icbi 0,%0;"
1662 "sync;"
1663 "isync;"
1664 : : "r"(addr) : "memory");
1665}
1666
1667# elif defined(__sparc__)
1668 /*
1669 * Like powerpc, we provide byteswapping and no byteswapping functions
1670 * here with byteswapping as default, drivers that don't need byteswapping
1671 * should define SPARC_MMIO_IS_BE (perhaps create a generic macro so that we
1672 * do not need to use PPC_MMIO_IS_BE and the sparc one in all the same places
1673 * of drivers?).
1674 */
1675# define MMIO_IN8(base, offset) xf86ReadMmio8(base, offset)
1676# define MMIO_OUT8(base, offset, val) \
1677 xf86WriteMmio8(base, offset, (CARD8)(val))
1678# define MMIO_ONB8(base, offset, val) \
1679 xf86WriteMmio8NB(base, offset, (CARD8)(val))
1680
1681# if defined(SPARC_MMIO_IS_BE) /* No byteswapping */
1682# define MMIO_IN16(base, offset) xf86ReadMmio16Be(base, offset)
1683# define MMIO_IN32(base, offset) xf86ReadMmio32Be(base, offset)
1684# define MMIO_OUT16(base, offset, val) \
1685 xf86WriteMmio16Be(base, offset, (CARD16)(val))
1686# define MMIO_OUT32(base, offset, val) \
1687 xf86WriteMmio32Be(base, offset, (CARD32)(val))
1688# define MMIO_ONB16(base, offset, val) \
1689 xf86WriteMmio16BeNB(base, offset, (CARD16)(val))
1690# define MMIO_ONB32(base, offset, val) \
1691 xf86WriteMmio32BeNB(base, offset, (CARD32)(val))
1692# else /* byteswapping is the default */
1693# define MMIO_IN16(base, offset) xf86ReadMmio16Le(base, offset)
1694# define MMIO_IN32(base, offset) xf86ReadMmio32Le(base, offset)
1695# define MMIO_OUT16(base, offset, val) \
1696 xf86WriteMmio16Le(base, offset, (CARD16)(val))
1697# define MMIO_OUT32(base, offset, val) \
1698 xf86WriteMmio32Le(base, offset, (CARD32)(val))
1699# define MMIO_ONB16(base, offset, val) \
1700 xf86WriteMmio16LeNB(base, offset, (CARD16)(val))
1701# define MMIO_ONB32(base, offset, val) \
1702 xf86WriteMmio32LeNB(base, offset, (CARD32)(val))
1703# endif
1704
1705# define MMIO_MOVE32(base, offset, val) \
1706 xf86WriteMmio32Be(base, offset, (CARD32)(val))
1707
1708# else /* !__alpha__ && !__powerpc__ && !__sparc__ */
1709
1710# define MMIO_IN8(base, offset) \
1711 *(volatile CARD8 *)(((CARD8*)(base)) + (offset))
1712# define MMIO_IN16(base, offset) \
1713 *(volatile CARD16 *)(void *)(((CARD8*)(base)) + (offset))
1714# define MMIO_IN32(base, offset) \
1715 *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset))
1716# define MMIO_OUT8(base, offset, val) \
1717 *(volatile CARD8 *)(((CARD8*)(base)) + (offset)) = (val)
1718# define MMIO_OUT16(base, offset, val) \
1719 *(volatile CARD16 *)(void *)(((CARD8*)(base)) + (offset)) = (val)
1720# define MMIO_OUT32(base, offset, val) \
1721 *(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val)
1722# define MMIO_ONB8(base, offset, val) MMIO_OUT8(base, offset, val)
1723# define MMIO_ONB16(base, offset, val) MMIO_OUT16(base, offset, val)
1724# define MMIO_ONB32(base, offset, val) MMIO_OUT32(base, offset, val)
1725
1726# define MMIO_MOVE32(base, offset, val) MMIO_OUT32(base, offset, val)
1727
1728# endif /* __alpha__ */
1729
1730/*
1731 * With Intel, the version in os-support/misc/SlowBcopy.s is used.
1732 * This avoids port I/O during the copy (which causes problems with
1733 * some hardware).
1734 */
1735# ifdef __alpha__
1736# define slowbcopy_tobus(src,dst,count) xf86SlowBCopyToBus(src,dst,count)
1737# define slowbcopy_frombus(src,dst,count) xf86SlowBCopyFromBus(src,dst,count)
1738# else /* __alpha__ */
1739# define slowbcopy_tobus(src,dst,count) xf86SlowBcopy(src,dst,count)
1740# define slowbcopy_frombus(src,dst,count) xf86SlowBcopy(src,dst,count)
1741# endif /* __alpha__ */
1742
1743#endif /* _COMPILER_H */
注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette