Skip to content

N
nx-libs
You need to sign in or sign up before continuing.
Commit 4aeed7ad authored by Ulrich Sibiller's avatar Ulrich Sibiller
Browse files
Options

remove hw/xfree86 altogether

This is part one of ArcticaProject/nx-libs#246
parent 6c7f9cda
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 2942 deletions
nx-X11/programs/Xserver/hw/xfree86/common/compiler.h deleted 100644 → 0
View file @ 6c7f9cda
/*
* Copyright 1990,91 by Thomas Roell, Dinkelscherben, Germany.
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the name of Thomas Roell not be used in
* advertising or publicity pertaining to distribution of the software without
* specific, written prior permission. Thomas Roell makes no representations
* about the suitability of this software for any purpose. It is provided
* "as is" without express or implied warranty.
*
* THOMAS ROELL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
* EVENT SHALL THOMAS ROELL BE LIABLE FOR ANY SPECIAL, INDIRECT OR
* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
* DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
* PERFORMANCE OF THIS SOFTWARE.
*
*/
/*
* Copyright (c) 1994-2003 by The XFree86 Project, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
/* $XConsortium: compiler.h /main/16 1996/10/25 15:38:34 kaleb $ */
#ifndef _COMPILER_H
# if !defined(_XF86_ANSIC_H) && defined(XFree86Module)
# error missing #include "xf86_ansic.h" before #include "compiler.h"
# endif
# define _COMPILER_H
#if defined(__SUNPRO_C)
# define DO_PROTOTYPES
#endif
/* Allow drivers to use the GCC-supported __inline__ and/or __inline. */
# ifndef __inline__
# if defined(__GNUC__)
/* gcc has __inline__ */
# elif defined(__HIGHC__)
# define __inline__ _Inline
# else
# define __inline__ /**/
# endif
# endif /* __inline__ */
# ifndef __inline
# if defined(__GNUC__)
/* gcc has __inline */
# elif defined(__HIGHC__)
# define __inline _Inline
# else
# define __inline /**/
# endif
# endif /* __inline */
# if defined(IODEBUG) && defined(__GNUC__)
# define outb RealOutb
# define outw RealOutw
# define outl RealOutl
# define inb RealInb
# define inw RealInw
# define inl RealInl
# endif
# if defined(QNX4) /* Do this for now to keep Watcom happy */
# define outb outp
# define outw outpw
# define outl outpd
# define inb inp
# define inw inpw
# define inl inpd
/* Define the ffs function for inlining */
extern int ffs(unsigned long);
# pragma aux ffs_ = \
"bsf edx, eax" \
"jnz bits_set" \
"xor eax, eax" \
"jmp exit1" \
"bits_set:" \
"mov eax, edx" \
"inc eax" \
"exit1:" \
__parm [eax] \
__modify [eax edx] \
__value [eax] \
;
# endif
# if defined(__SUNPRO_C)
# define DO_PROTOTYPES
# endif
# if defined(NO_INLINE) || defined(DO_PROTOTYPES)
# if !defined(__arm__)
# if !defined(__sparc__) && !defined(__arm32__) \
&& !(defined(__alpha__) && defined(linux)) \
&& !(defined(__ia64__) && defined(linux)) \
extern void outb(unsigned short, unsigned char);
extern void outw(unsigned short, unsigned short);
extern void outl(unsigned short, unsigned int);
extern unsigned int inb(unsigned short);
extern unsigned int inw(unsigned short);
extern unsigned int inl(unsigned short);
# else /* __sparc__, __arm32__, __alpha__*/
extern void outb(unsigned long, unsigned char);
extern void outw(unsigned long, unsigned short);
extern void outl(unsigned long, unsigned int);
extern unsigned int inb(unsigned long);
extern unsigned int inw(unsigned long);
extern unsigned int inl(unsigned long);
# endif /* __sparc__, __arm32__, __alpha__ */
# endif /* __arm__ */
extern unsigned long ldq_u(unsigned long *);
extern unsigned long ldl_u(unsigned int *);
extern unsigned long ldw_u(unsigned short *);
extern void stq_u(unsigned long, unsigned long *);
extern void stl_u(unsigned long, unsigned int *);
extern void stw_u(unsigned long, unsigned short *);
extern void mem_barrier(void);
extern void write_mem_barrier(void);
extern void stl_brx(unsigned long, volatile unsigned char *, int);
extern void stw_brx(unsigned short, volatile unsigned char *, int);
extern unsigned long ldl_brx(volatile unsigned char *, int);
extern unsigned short ldw_brx(volatile unsigned char *, int);
# endif
# ifndef NO_INLINE
# ifdef __GNUC__
# if (defined(linux) || defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)) && (defined(__alpha__))
# ifdef linux
/* for Linux on Alpha, we use the LIBC _inx/_outx routines */
/* note that the appropriate setup via "ioperm" needs to be done */
/* *before* any inx/outx is done. */
extern void (*_alpha_outb)(char val, unsigned long port);
static __inline__ void
outb(unsigned long port, unsigned char val)
{
_alpha_outb(val, port);
}
extern void (*_alpha_outw)(short val, unsigned long port);
static __inline__ void
outw(unsigned long port, unsigned short val)
{
_alpha_outw(val, port);
}
extern void (*_alpha_outl)(int val, unsigned long port);
static __inline__ void
outl(unsigned long port, unsigned int val)
{
_alpha_outl(val, port);
}
extern unsigned int (*_alpha_inb)(unsigned long port);
static __inline__ unsigned int
inb(unsigned long port)
{
return _alpha_inb(port);
}
extern unsigned int (*_alpha_inw)(unsigned long port);
static __inline__ unsigned int
inw(unsigned long port)
{
return _alpha_inw(port);
}
extern unsigned int (*_alpha_inl)(unsigned long port);
static __inline__ unsigned int
inl(unsigned long port)
{
return _alpha_inl(port);
}
# endif /* linux */
# if (defined(__FreeBSD__) || defined(__OpenBSD__)) \
&& !defined(DO_PROTOTYPES)
/* for FreeBSD and OpenBSD on Alpha, we use the libio (resp. libalpha) */
/* inx/outx routines */
/* note that the appropriate setup via "ioperm" needs to be done */
/* *before* any inx/outx is done. */
extern void outb(unsigned int port, unsigned char val);
extern void outw(unsigned int port, unsigned short val);
extern void outl(unsigned int port, unsigned int val);
extern unsigned char inb(unsigned int port);
extern unsigned short inw(unsigned int port);
extern unsigned int inl(unsigned int port);
# endif /* (__FreeBSD__ || __OpenBSD__ ) && !DO_PROTOTYPES */
#if defined(__NetBSD__)
#include <machine/pio.h>
#endif /* __NetBSD__ */
/*
* inline functions to do unaligned accesses
* from linux/include/asm-alpha/unaligned.h
*/
/*
* EGCS 1.1 knows about arbitrary unaligned loads. Define some
* packed structures to talk about such things with.
*/
struct __una_u64 { unsigned long x __attribute__((packed)); };
struct __una_u32 { unsigned int x __attribute__((packed)); };
struct __una_u16 { unsigned short x __attribute__((packed)); };
/*
* Elemental unaligned loads
*/
/* let's try making these things static */
static __inline__ unsigned long ldq_u(unsigned long * r11)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
return ptr->x;
# else
unsigned long r1,r2;
__asm__("ldq_u %0,%3\n\t"
"ldq_u %1,%4\n\t"
"extql %0,%2,%0\n\t"
"extqh %1,%2,%1"
:"=&r" (r1), "=&r" (r2)
:"r" (r11),
"m" (*r11),
"m" (*(const unsigned long *)(7+(char *) r11)));
return r1 | r2;
# endif
}
static __inline__ unsigned long ldl_u(unsigned int * r11)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
return ptr->x;
# else
unsigned long r1,r2;
__asm__("ldq_u %0,%3\n\t"
"ldq_u %1,%4\n\t"
"extll %0,%2,%0\n\t"
"extlh %1,%2,%1"
:"=&r" (r1), "=&r" (r2)
:"r" (r11),
"m" (*r11),
"m" (*(const unsigned long *)(3+(char *) r11)));
return r1 | r2;
# endif
}
static __inline__ unsigned long ldw_u(unsigned short * r11)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
return ptr->x;
# else
unsigned long r1,r2;
__asm__("ldq_u %0,%3\n\t"
"ldq_u %1,%4\n\t"
"extwl %0,%2,%0\n\t"
"extwh %1,%2,%1"
:"=&r" (r1), "=&r" (r2)
:"r" (r11),
"m" (*r11),
"m" (*(const unsigned long *)(1+(char *) r11)));
return r1 | r2;
# endif
}
/*
* Elemental unaligned stores
*/
static __inline__ void stq_u(unsigned long r5, unsigned long * r11)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
struct __una_u64 *ptr = (struct __una_u64 *) r11;
ptr->x = r5;
# else
unsigned long r1,r2,r3,r4;
__asm__("ldq_u %3,%1\n\t"
"ldq_u %2,%0\n\t"
"insqh %6,%7,%5\n\t"
"insql %6,%7,%4\n\t"
"mskqh %3,%7,%3\n\t"
"mskql %2,%7,%2\n\t"
"bis %3,%5,%3\n\t"
"bis %2,%4,%2\n\t"
"stq_u %3,%1\n\t"
"stq_u %2,%0"
:"=m" (*r11),
"=m" (*(unsigned long *)(7+(char *) r11)),
"=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
:"r" (r5), "r" (r11));
# endif
}
static __inline__ void stl_u(unsigned long r5, unsigned int * r11)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
struct __una_u32 *ptr = (struct __una_u32 *) r11;
ptr->x = r5;
# else
unsigned long r1,r2,r3,r4;
__asm__("ldq_u %3,%1\n\t"
"ldq_u %2,%0\n\t"
"inslh %6,%7,%5\n\t"
"insll %6,%7,%4\n\t"
"msklh %3,%7,%3\n\t"
"mskll %2,%7,%2\n\t"
"bis %3,%5,%3\n\t"
"bis %2,%4,%2\n\t"
"stq_u %3,%1\n\t"
"stq_u %2,%0"
:"=m" (*r11),
"=m" (*(unsigned long *)(3+(char *) r11)),
"=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
:"r" (r5), "r" (r11));
# endif
}
static __inline__ void stw_u(unsigned long r5, unsigned short * r11)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
struct __una_u16 *ptr = (struct __una_u16 *) r11;
ptr->x = r5;
# else
unsigned long r1,r2,r3,r4;
__asm__("ldq_u %3,%1\n\t"
"ldq_u %2,%0\n\t"
"inswh %6,%7,%5\n\t"
"inswl %6,%7,%4\n\t"
"mskwh %3,%7,%3\n\t"
"mskwl %2,%7,%2\n\t"
"bis %3,%5,%3\n\t"
"bis %2,%4,%2\n\t"
"stq_u %3,%1\n\t"
"stq_u %2,%0"
:"=m" (*r11),
"=m" (*(unsigned long *)(1+(char *) r11)),
"=&r" (r1), "=&r" (r2), "=&r" (r3), "=&r" (r4)
:"r" (r5), "r" (r11));
# endif
}
/* to flush the I-cache before jumping to code which just got loaded */
# define PAL_imb 134
# define istream_mem_barrier() \
__asm__ __volatile__("call_pal %0 #imb" : : "i" (PAL_imb) : "memory")
# define mem_barrier() __asm__ __volatile__("mb" : : : "memory")
# ifdef __ELF__
# define write_mem_barrier() __asm__ __volatile__("wmb" : : : "memory")
# else /* ECOFF gas 2.6 doesn't know "wmb" :-( */
# define write_mem_barrier() mem_barrier()
# endif
# elif defined(linux) && defined(__ia64__)
# include <inttypes.h>
# include <sys/io.h>
struct __una_u64 { uint64_t x __attribute__((packed)); };
struct __una_u32 { uint32_t x __attribute__((packed)); };
struct __una_u16 { uint16_t x __attribute__((packed)); };
static __inline__ unsigned long
__uldq (const unsigned long * r11)
{
const struct __una_u64 *ptr = (const struct __una_u64 *) r11;
return ptr->x;
}
static __inline__ unsigned long
__uldl (const unsigned int * r11)
{
const struct __una_u32 *ptr = (const struct __una_u32 *) r11;
return ptr->x;
}
static __inline__ unsigned long
__uldw (const unsigned short * r11)
{
const struct __una_u16 *ptr = (const struct __una_u16 *) r11;
return ptr->x;
}
static __inline__ void
__ustq (unsigned long r5, unsigned long * r11)
{
struct __una_u64 *ptr = (struct __una_u64 *) r11;
ptr->x = r5;
}
static __inline__ void
__ustl (unsigned long r5, unsigned int * r11)
{
struct __una_u32 *ptr = (struct __una_u32 *) r11;
ptr->x = r5;
}
static __inline__ void
__ustw (unsigned long r5, unsigned short * r11)
{
struct __una_u16 *ptr = (struct __una_u16 *) r11;
ptr->x = r5;
}
# define ldq_u(p) __uldq(p)
# define ldl_u(p) __uldl(p)
# define ldw_u(p) __uldw(p)
# define stq_u(v,p) __ustq(v,p)
# define stl_u(v,p) __ustl(v,p)
# define stw_u(v,p) __ustw(v,p)
# ifndef __INTEL_COMPILER
# define mem_barrier() __asm__ __volatile__ ("mf" ::: "memory")
# define write_mem_barrier() __asm__ __volatile__ ("mf" ::: "memory")
# else
# include "ia64intrin.h"
# define mem_barrier() __mf()
# define write_mem_barrier() __mf()
# endif
/*
* This is overkill, but for different reasons depending on where it is used.
* This is thus general enough to be used everywhere cache flushes are needed.
* It doesn't handle memory access serialisation by other processors, though.
*/
# ifndef __INTEL_COMPILER
# define ia64_flush_cache(Addr) \
__asm__ __volatile__ ( \
"fc.i %0;;;" \
"sync.i;;;" \
"mf;;;" \
"srlz.i;;;" \
:: "r"(Addr) : "memory")
# else
# define ia64_flush_cache(Addr) { \
__fc(Addr);\
__synci();\
__mf();\
__isrlz();\
}
# endif
# undef outb
# undef outw
# undef outl
# undef inb
# undef inw
# undef inl
extern void outb(unsigned long port, unsigned char val);
extern void outw(unsigned long port, unsigned short val);
extern void outl(unsigned long port, unsigned int val);
extern unsigned int inb(unsigned long port);
extern unsigned int inw(unsigned long port);
extern unsigned int inl(unsigned long port);
# elif defined(linux) && defined(__amd64__)
# include <inttypes.h>
# define ldq_u(p) (*((unsigned long *)(p)))
# define ldl_u(p) (*((unsigned int *)(p)))
# define ldw_u(p) (*((unsigned short *)(p)))
# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
# define mem_barrier() \
__asm__ __volatile__ ("lock; addl $0,0(%%rsp)": : :"memory")
# define write_mem_barrier() \
__asm__ __volatile__ ("": : :"memory")
static __inline__ void
outb(unsigned short port, unsigned char val)
{
__asm__ __volatile__("outb %0,%1" : :"a" (val), "d" (port));
}
static __inline__ void
outw(unsigned short port, unsigned short val)
{
__asm__ __volatile__("outw %0,%1" : :"a" (val), "d" (port));
}
static __inline__ void
outl(unsigned short port, unsigned int val)
{
__asm__ __volatile__("outl %0,%1" : :"a" (val), "d" (port));
}
static __inline__ unsigned int
inb(unsigned short port)
{
unsigned char ret;
__asm__ __volatile__("inb %1,%0" :
"=a" (ret) :
"d" (port));
return ret;
}
static __inline__ unsigned int
inw(unsigned short port)
{
unsigned short ret;
__asm__ __volatile__("inw %1,%0" :
"=a" (ret) :
"d" (port));
return ret;
}
static __inline__ unsigned int
inl(unsigned short port)
{
unsigned int ret;
__asm__ __volatile__("inl %1,%0" :
"=a" (ret) :
"d" (port));
return ret;
}
# elif (defined(linux) || defined(Lynx) || defined(sun) || defined(__OpenBSD__) || defined(__FreeBSD__)) && defined(__sparc__)
# if !defined(Lynx)
# ifndef ASI_PL
# define ASI_PL 0x88
# endif
# define barrier() __asm__ __volatile__(".word 0x8143e00a": : :"memory")
static __inline__ void
outb(unsigned long port, unsigned char val)
{
__asm__ __volatile__("stba %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (port), "i" (ASI_PL));
barrier();
}
static __inline__ void
outw(unsigned long port, unsigned short val)
{
__asm__ __volatile__("stha %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (port), "i" (ASI_PL));
barrier();
}
static __inline__ void
outl(unsigned long port, unsigned int val)
{
__asm__ __volatile__("sta %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (port), "i" (ASI_PL));
barrier();
}
static __inline__ unsigned int
inb(unsigned long port)
{
unsigned int ret;
__asm__ __volatile__("lduba [%1] %2, %0"
: "=r" (ret)
: "r" (port), "i" (ASI_PL));
return ret;
}
static __inline__ unsigned int
inw(unsigned long port)
{
unsigned int ret;
__asm__ __volatile__("lduha [%1] %2, %0"
: "=r" (ret)
: "r" (port), "i" (ASI_PL));
return ret;
}
static __inline__ unsigned int
inl(unsigned long port)
{
unsigned int ret;
__asm__ __volatile__("lda [%1] %2, %0"
: "=r" (ret)
: "r" (port), "i" (ASI_PL));
return ret;
}
static __inline__ unsigned char
xf86ReadMmio8(__volatile__ void *base, const unsigned long offset)
{
unsigned long addr = ((unsigned long)base) + offset;
unsigned char ret;
__asm__ __volatile__("lduba [%1] %2, %0"
: "=r" (ret)
: "r" (addr), "i" (ASI_PL));
return ret;
}
static __inline__ unsigned short
xf86ReadMmio16Be(__volatile__ void *base, const unsigned long offset)
{
unsigned long addr = ((unsigned long)base) + offset;
unsigned short ret;
__asm__ __volatile__("lduh [%1], %0"
: "=r" (ret)
: "r" (addr));
return ret;
}
static __inline__ unsigned short
xf86ReadMmio16Le(__volatile__ void *base, const unsigned long offset)
{
unsigned long addr = ((unsigned long)base) + offset;
unsigned short ret;
__asm__ __volatile__("lduha [%1] %2, %0"
: "=r" (ret)
: "r" (addr), "i" (ASI_PL));
return ret;
}
static __inline__ unsigned int
xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset)
{
unsigned long addr = ((unsigned long)base) + offset;
unsigned int ret;
__asm__ __volatile__("ld [%1], %0"
: "=r" (ret)
: "r" (addr));
return ret;
}
static __inline__ unsigned int
xf86ReadMmio32Le(__volatile__ void *base, const unsigned long offset)
{
unsigned long addr = ((unsigned long)base) + offset;
unsigned int ret;
__asm__ __volatile__("lda [%1] %2, %0"
: "=r" (ret)
: "r" (addr), "i" (ASI_PL));
return ret;
}
static __inline__ void
xf86WriteMmio8(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("stba %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (addr), "i" (ASI_PL));
barrier();
}
static __inline__ void
xf86WriteMmio16Be(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("sth %0, [%1]"
: /* No outputs */
: "r" (val), "r" (addr));
barrier();
}
static __inline__ void
xf86WriteMmio16Le(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("stha %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (addr), "i" (ASI_PL));
barrier();
}
static __inline__ void
xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("st %0, [%1]"
: /* No outputs */
: "r" (val), "r" (addr));
barrier();
}
static __inline__ void
xf86WriteMmio32Le(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("sta %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (addr), "i" (ASI_PL));
barrier();
}
static __inline__ void
xf86WriteMmio8NB(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("stba %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (addr), "i" (ASI_PL));
}
static __inline__ void
xf86WriteMmio16BeNB(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("sth %0, [%1]"
: /* No outputs */
: "r" (val), "r" (addr));
}
static __inline__ void
xf86WriteMmio16LeNB(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("stha %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (addr), "i" (ASI_PL));
}
static __inline__ void
xf86WriteMmio32BeNB(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("st %0, [%1]"
: /* No outputs */
: "r" (val), "r" (addr));
}
static __inline__ void
xf86WriteMmio32LeNB(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("sta %0, [%1] %2"
: /* No outputs */
: "r" (val), "r" (addr), "i" (ASI_PL));
}
# endif /* !Lynx */
/*
* EGCS 1.1 knows about arbitrary unaligned loads. Define some
* packed structures to talk about such things with.
*/
# if defined(__arch64__) || defined(__sparcv9)
struct __una_u64 { unsigned long x __attribute__((packed)); };
# endif
struct __una_u32 { unsigned int x __attribute__((packed)); };
struct __una_u16 { unsigned short x __attribute__((packed)); };
static __inline__ unsigned long ldq_u(unsigned long *p)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
# if defined(__arch64__) || defined(__sparcv9)
const struct __una_u64 *ptr = (const struct __una_u64 *) p;
# else
const struct __una_u32 *ptr = (const struct __una_u32 *) p;
# endif
return ptr->x;
# else
unsigned long ret;
memmove(&ret, p, sizeof(*p));
return ret;
# endif
}
static __inline__ unsigned long ldl_u(unsigned int *p)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
const struct __una_u32 *ptr = (const struct __una_u32 *) p;
return ptr->x;
# else
unsigned int ret;
memmove(&ret, p, sizeof(*p));
return ret;
# endif
}
static __inline__ unsigned long ldw_u(unsigned short *p)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
const struct __una_u16 *ptr = (const struct __una_u16 *) p;
return ptr->x;
# else
unsigned short ret;
memmove(&ret, p, sizeof(*p));
return ret;
# endif
}
static __inline__ void stq_u(unsigned long val, unsigned long *p)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
# if defined(__arch64__) || defined(__sparcv9)
struct __una_u64 *ptr = (struct __una_u64 *) p;
# else
struct __una_u32 *ptr = (struct __una_u32 *) p;
# endif
ptr->x = val;
# else
unsigned long tmp = val;
memmove(p, &tmp, sizeof(*p));
# endif
}
static __inline__ void stl_u(unsigned long val, unsigned int *p)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
struct __una_u32 *ptr = (struct __una_u32 *) p;
ptr->x = val;
# else
unsigned int tmp = val;
memmove(p, &tmp, sizeof(*p));
# endif
}
static __inline__ void stw_u(unsigned long val, unsigned short *p)
{
# if defined(__GNUC__) && ((__GNUC__ > 2) || (__GNUC_MINOR__ >= 91))
struct __una_u16 *ptr = (struct __una_u16 *) p;
ptr->x = val;
# else
unsigned short tmp = val;
memmove(p, &tmp, sizeof(*p));
# endif
}
# define mem_barrier() /* XXX: nop for now */
# define write_mem_barrier() /* XXX: nop for now */
# elif defined(__mips__) || (defined(__arm32__) && !defined(__linux__))
# ifdef __arm32__
# define PORT_SIZE long
# else
# define PORT_SIZE short
# endif
unsigned int IOPortBase; /* Memory mapped I/O port area */
static __inline__ void
outb(unsigned PORT_SIZE port, unsigned char val)
{
*(volatile unsigned char*)(((unsigned PORT_SIZE)(port))+IOPortBase) = val;
}
static __inline__ void
outw(unsigned PORT_SIZE port, unsigned short val)
{
*(volatile unsigned short*)(((unsigned PORT_SIZE)(port))+IOPortBase) = val;
}
static __inline__ void
outl(unsigned PORT_SIZE port, unsigned int val)
{
*(volatile unsigned int*)(((unsigned PORT_SIZE)(port))+IOPortBase) = val;
}
static __inline__ unsigned int
inb(unsigned PORT_SIZE port)
{
return *(volatile unsigned char*)(((unsigned PORT_SIZE)(port))+IOPortBase);
}
static __inline__ unsigned int
inw(unsigned PORT_SIZE port)
{
return *(volatile unsigned short*)(((unsigned PORT_SIZE)(port))+IOPortBase);
}
static __inline__ unsigned int
inl(unsigned PORT_SIZE port)
{
return *(volatile unsigned int*)(((unsigned PORT_SIZE)(port))+IOPortBase);
}
# if defined(__mips__)
static __inline__ unsigned long ldq_u(unsigned long * r11)
{
unsigned long r1;
__asm__("lwr %0,%2\n\t"
"lwl %0,%3\n\t"
:"=&r" (r1)
:"r" (r11),
"m" (*r11),
"m" (*(unsigned long *)(3+(char *) r11)));
return r1;
}
static __inline__ unsigned long ldl_u(unsigned int * r11)
{
unsigned long r1;
__asm__("lwr %0,%2\n\t"
"lwl %0,%3\n\t"
:"=&r" (r1)
:"r" (r11),
"m" (*r11),
"m" (*(unsigned long *)(3+(char *) r11)));
return r1;
}
static __inline__ unsigned long ldw_u(unsigned short * r11)
{
unsigned long r1;
__asm__("lwr %0,%2\n\t"
"lwl %0,%3\n\t"
:"=&r" (r1)
:"r" (r11),
"m" (*r11),
"m" (*(unsigned long *)(1+(char *) r11)));
return r1;
}
# ifdef linux /* don't mess with other OSs */
/*
* EGCS 1.1 knows about arbitrary unaligned loads (and we don't support older
* versions anyway. Define some packed structures to talk about such things
* with.
*/
struct __una_u32 { unsigned int x __attribute__((packed)); };
struct __una_u16 { unsigned short x __attribute__((packed)); };
static __inline__ void stw_u(unsigned long val, unsigned short *p)
{
struct __una_u16 *ptr = (struct __una_u16 *) p;
ptr->x = val;
}
static __inline__ void stl_u(unsigned long val, unsigned int *p)
{
struct __una_u32 *ptr = (struct __una_u32 *) p;
ptr->x = val;
}
# if X_BYTE_ORDER == X_BIG_ENDIAN
static __inline__ unsigned int
xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset)
{
unsigned long addr = ((unsigned long)base) + offset;
unsigned int ret;
__asm__ __volatile__("lw %0, 0(%1)"
: "=r" (ret)
: "r" (addr));
return ret;
}
static __inline__ void
xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
unsigned long addr = ((unsigned long)base) + offset;
__asm__ __volatile__("sw %0, 0(%1)"
: /* No outputs */
: "r" (val), "r" (addr));
}
# endif
# define mem_barrier() \
__asm__ __volatile__( \
"# prevent instructions being moved around\n\t" \
".set\tnoreorder\n\t" \
"# 8 nops to fool the R4400 pipeline\n\t" \
"nop;nop;nop;nop;nop;nop;nop;nop\n\t" \
".set\treorder" \
: /* no output */ \
: /* no input */ \
: "memory")
# define write_mem_barrier() mem_barrier()
# else /* !linux */
# define stq_u(v,p) stl_u(v,p)
# define stl_u(v,p) (*(unsigned char *)(p)) = (v); \
(*(unsigned char *)(p)+1) = ((v) >> 8); \
(*(unsigned char *)(p)+2) = ((v) >> 16); \
(*(unsigned char *)(p)+3) = ((v) >> 24)
# define stw_u(v,p) (*(unsigned char *)(p)) = (v); \
(*(unsigned char *)(p)+1) = ((v) >> 8)
# define mem_barrier() /* NOP */
# endif /* !linux */
# endif /* __mips__ */
# if defined(__arm32__)
# define ldq_u(p) (*((unsigned long *)(p)))
# define ldl_u(p) (*((unsigned int *)(p)))
# define ldw_u(p) (*((unsigned short *)(p)))
# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
# define mem_barrier() /* NOP */
# define write_mem_barrier() /* NOP */
# endif /* __arm32__ */
# elif (defined(Lynx) || defined(linux) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(__FreeBSD__)) && defined(__powerpc__)
# ifndef MAP_FAILED
# define MAP_FAILED ((void *)-1)
# endif
extern volatile unsigned char *ioBase;
#if defined(linux) && defined(__powerpc64__)
# include <asm/memory.h>
#endif /* defined(linux) && defined(__powerpc64__) */
#ifndef eieio /* We deal with arch-specific eieio() routines above... */
# define eieio() __asm__ __volatile__ ("eieio" ::: "memory")
#endif /* eieio */
static __inline__ unsigned char
xf86ReadMmio8(__volatile__ void *base, const unsigned long offset)
{
register unsigned char val;
__asm__ __volatile__(
"lbzx %0,%1,%2\n\t"
"eieio"
: "=r" (val)
: "b" (base), "r" (offset),
"m" (*((volatile unsigned char *)base+offset)));
return val;
}
static __inline__ unsigned short
xf86ReadMmio16Be(__volatile__ void *base, const unsigned long offset)
{
register unsigned short val;
__asm__ __volatile__(
"lhzx %0,%1,%2\n\t"
"eieio"
: "=r" (val)
: "b" (base), "r" (offset),
"m" (*((volatile unsigned char *)base+offset)));
return val;
}
static __inline__ unsigned short
xf86ReadMmio16Le(__volatile__ void *base, const unsigned long offset)
{
register unsigned short val;
__asm__ __volatile__(
"lhbrx %0,%1,%2\n\t"
"eieio"
: "=r" (val)
: "b" (base), "r" (offset),
"m" (*((volatile unsigned char *)base+offset)));
return val;
}
static __inline__ unsigned int
xf86ReadMmio32Be(__volatile__ void *base, const unsigned long offset)
{
register unsigned int val;
__asm__ __volatile__(
"lwzx %0,%1,%2\n\t"
"eieio"
: "=r" (val)
: "b" (base), "r" (offset),
"m" (*((volatile unsigned char *)base+offset)));
return val;
}
static __inline__ unsigned int
xf86ReadMmio32Le(__volatile__ void *base, const unsigned long offset)
{
register unsigned int val;
__asm__ __volatile__(
"lwbrx %0,%1,%2\n\t"
"eieio"
: "=r" (val)
: "b" (base), "r" (offset),
"m" (*((volatile unsigned char *)base+offset)));
return val;
}
static __inline__ void
xf86WriteMmioNB8(__volatile__ void *base, const unsigned long offset,
const unsigned char val)
{
__asm__ __volatile__(
"stbx %1,%2,%3\n\t"
: "=m" (*((volatile unsigned char *)base+offset))
: "r" (val), "b" (base), "r" (offset));
}
static __inline__ void
xf86WriteMmioNB16Le(__volatile__ void *base, const unsigned long offset,
const unsigned short val)
{
__asm__ __volatile__(
"sthbrx %1,%2,%3\n\t"
: "=m" (*((volatile unsigned char *)base+offset))
: "r" (val), "b" (base), "r" (offset));
}
static __inline__ void
xf86WriteMmioNB16Be(__volatile__ void *base, const unsigned long offset,
const unsigned short val)
{
__asm__ __volatile__(
"sthx %1,%2,%3\n\t"
: "=m" (*((volatile unsigned char *)base+offset))
: "r" (val), "b" (base), "r" (offset));
}
static __inline__ void
xf86WriteMmioNB32Le(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
__asm__ __volatile__(
"stwbrx %1,%2,%3\n\t"
: "=m" (*((volatile unsigned char *)base+offset))
: "r" (val), "b" (base), "r" (offset));
}
static __inline__ void
xf86WriteMmioNB32Be(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
__asm__ __volatile__(
"stwx %1,%2,%3\n\t"
: "=m" (*((volatile unsigned char *)base+offset))
: "r" (val), "b" (base), "r" (offset));
}
static __inline__ void
xf86WriteMmio8(__volatile__ void *base, const unsigned long offset,
const unsigned char val)
{
xf86WriteMmioNB8(base, offset, val);
eieio();
}
static __inline__ void
xf86WriteMmio16Le(__volatile__ void *base, const unsigned long offset,
const unsigned short val)
{
xf86WriteMmioNB16Le(base, offset, val);
eieio();
}
static __inline__ void
xf86WriteMmio16Be(__volatile__ void *base, const unsigned long offset,
const unsigned short val)
{
xf86WriteMmioNB16Be(base, offset, val);
eieio();
}
static __inline__ void
xf86WriteMmio32Le(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
xf86WriteMmioNB32Le(base, offset, val);
eieio();
}
static __inline__ void
xf86WriteMmio32Be(__volatile__ void *base, const unsigned long offset,
const unsigned int val)
{
xf86WriteMmioNB32Be(base, offset, val);
eieio();
}
static __inline__ void
outb(unsigned short port, unsigned char value)
{
if(ioBase == MAP_FAILED) return;
xf86WriteMmio8((void *)ioBase, port, value);
}
static __inline__ void
outw(unsigned short port, unsigned short value)
{
if(ioBase == MAP_FAILED) return;
xf86WriteMmio16Le((void *)ioBase, port, value);
}
static __inline__ void
outl(unsigned short port, unsigned int value)
{
if(ioBase == MAP_FAILED) return;
xf86WriteMmio32Le((void *)ioBase, port, value);
}
static __inline__ unsigned int
inb(unsigned short port)
{
if(ioBase == MAP_FAILED) return 0;
return xf86ReadMmio8((void *)ioBase, port);
}
static __inline__ unsigned int
inw(unsigned short port)
{
if(ioBase == MAP_FAILED) return 0;
return xf86ReadMmio16Le((void *)ioBase, port);
}
static __inline__ unsigned int
inl(unsigned short port)
{
if(ioBase == MAP_FAILED) return 0;
return xf86ReadMmio32Le((void *)ioBase, port);
}
# define ldq_u(p) ldl_u(p)
# define ldl_u(p) ((*(unsigned char *)(p)) | \
(*((unsigned char *)(p)+1)<<8) | \
(*((unsigned char *)(p)+2)<<16) | \
(*((unsigned char *)(p)+3)<<24))
# define ldw_u(p) ((*(unsigned char *)(p)) | \
(*((unsigned char *)(p)+1)<<8))
# define stq_u(v,p) stl_u(v,p)
# define stl_u(v,p) (*(unsigned char *)(p)) = (v); \
(*((unsigned char *)(p)+1)) = ((v) >> 8); \
(*((unsigned char *)(p)+2)) = ((v) >> 16); \
(*((unsigned char *)(p)+3)) = ((v) >> 24)
# define stw_u(v,p) (*(unsigned char *)(p)) = (v); \
(*((unsigned char *)(p)+1)) = ((v) >> 8)
# define mem_barrier() eieio()
# define write_mem_barrier() eieio()
#elif defined(__arm__) && defined(__linux__)
#define ldq_u(p) (*((unsigned long *)(p)))
#define ldl_u(p) (*((unsigned int *)(p)))
#define ldw_u(p) (*((unsigned short *)(p)))
#define stq_u(v,p) (*(unsigned long *)(p)) = (v)
#define stl_u(v,p) (*(unsigned int *)(p)) = (v)
#define stw_u(v,p) (*(unsigned short *)(p)) = (v)
#define mem_barrier() /* NOP */
#define write_mem_barrier() /* NOP */
/* for Linux on ARM, we use the LIBC inx/outx routines */
/* note that the appropriate setup via "ioperm" needs to be done */
/* *before* any inx/outx is done. */
#include <sys/io.h>
static __inline__ void
xf_outb(unsigned short port, unsigned char val)
{
outb(val, port);
}
static __inline__ void
xf_outw(unsigned short port, unsigned short val)
{
outw(val, port);
}
static __inline__ void
xf_outl(unsigned short port, unsigned int val)
{
outl(val, port);
}
#define outb xf_outb
#define outw xf_outw
#define outl xf_outl
#define arm_flush_cache(addr) \
do { \
register unsigned long _beg __asm ("a1") = (unsigned long) (addr); \
register unsigned long _end __asm ("a2") = (unsigned long) (addr) + 4;\
register unsigned long _flg __asm ("a3") = 0; \
__asm __volatile ("swi 0x9f0002 @ sys_cacheflush" \
: "=r" (_beg) \
: "0" (_beg), "r" (_end), "r" (_flg)); \
} while (0)
# else /* ix86 */
# define ldq_u(p) (*((unsigned long *)(p)))
# define ldl_u(p) (*((unsigned int *)(p)))
# define ldw_u(p) (*((unsigned short *)(p)))
# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
# define mem_barrier() /* NOP */
# define write_mem_barrier() /* NOP */
# if !defined(__SUNPRO_C)
# if !defined(FAKEIT) && !defined(__mc68000__) && !defined(__arm__) && !defined(__sh__) && !defined(__hppa__)
# ifdef GCCUSESGAS
/*
* If gcc uses gas rather than the native assembler, the syntax of these
* inlines has to be different. DHD
*/
static __inline__ void
outb(unsigned short port, unsigned char val)
{
__asm__ __volatile__("outb %0,%1" : :"a" (val), "d" (port));
}
static __inline__ void
outw(unsigned short port, unsigned short val)
{
__asm__ __volatile__("outw %0,%1" : :"a" (val), "d" (port));
}
static __inline__ void
outl(unsigned short port, unsigned int val)
{
__asm__ __volatile__("outl %0,%1" : :"a" (val), "d" (port));
}
static __inline__ unsigned int
inb(unsigned short port)
{
unsigned char ret;
__asm__ __volatile__("inb %1,%0" :
"=a" (ret) :
"d" (port));
return ret;
}
static __inline__ unsigned int
inw(unsigned short port)
{
unsigned short ret;
__asm__ __volatile__("inw %1,%0" :
"=a" (ret) :
"d" (port));
return ret;
}
static __inline__ unsigned int
inl(unsigned short port)
{
unsigned int ret;
__asm__ __volatile__("inl %1,%0" :
"=a" (ret) :
"d" (port));
return ret;
}
# else /* GCCUSESGAS */
static __inline__ void
outb(unsigned short port, unsigned char val)
{
__asm__ __volatile__("out%B0 (%1)" : :"a" (val), "d" (port));
}
static __inline__ void
outw(unsigned short port, unsigned short val)
{
__asm__ __volatile__("out%W0 (%1)" : :"a" (val), "d" (port));
}
static __inline__ void
outl(unsigned short port, unsigned int val)
{
__asm__ __volatile__("out%L0 (%1)" : :"a" (val), "d" (port));
}
static __inline__ unsigned int
inb(unsigned short port)
{
unsigned char ret;
__asm__ __volatile__("in%B0 (%1)" :
"=a" (ret) :
"d" (port));
return ret;
}
static __inline__ unsigned int
inw(unsigned short port)
{
unsigned short ret;
__asm__ __volatile__("in%W0 (%1)" :
"=a" (ret) :
"d" (port));
return ret;
}
static __inline__ unsigned int
inl(unsigned short port)
{
unsigned int ret;
__asm__ __volatile__("in%L0 (%1)" :
"=a" (ret) :
"d" (port));
return ret;
}
# endif /* GCCUSESGAS */
# else /* !defined(FAKEIT) && !defined(__mc68000__) && !defined(__arm__) && !defined(__sh__) && !defined(__hppa__)*/
static __inline__ void
outb(unsigned short port, unsigned char val)
{
}
static __inline__ void
outw(unsigned short port, unsigned short val)
{
}
static __inline__ void
outl(unsigned short port, unsigned int val)
{
}
static __inline__ unsigned int
inb(unsigned short port)
{
return 0;
}
static __inline__ unsigned int
inw(unsigned short port)
{
return 0;
}
static __inline__ unsigned int
inl(unsigned short port)
{
return 0;
}
# endif /* FAKEIT */
# endif /* __SUNPRO_C */
# endif /* ix86 */
# elif defined(__powerpc__) /* && !__GNUC__ */
/*
* NON-GCC PowerPC - Presumed to be PowerMAX OS for now
*/
# ifndef PowerMAX_OS
# error - Non-gcc PowerPC and !PowerMAXOS ???
# endif
# define PPCIO_DEBUG 0
# define PPCIO_INLINE 1
# define USE_ABS_MACRO 1
/*
* Use compiler intrinsics to access certain PPC machine instructions
*/
# define eieio() __inst_eieio()
# define stw_brx(val,base,ndx) __inst_sthbrx(val,base,ndx)
# define stl_brx(val,base,ndx) __inst_stwbrx(val,base,ndx)
# define ldw_brx(base,ndx) __inst_lhbrx(base,ndx)
# define ldl_brx(base,ndx) __inst_lwbrx(base,ndx)
# define ldq_u(p) (*((unsigned long long *)(p)))
# define ldl_u(p) (*((unsigned long *)(p)))
# define ldw_u(p) (*((unsigned short *)(p)))
# define stq_u(v,p) (*(unsigned long long *)(p)) = (v)
# define stl_u(v,p) (*(unsigned long *)(p)) = (v)
# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
# define mem_barrier() eieio()
# define write_mem_barrier() eieio()
extern volatile unsigned char *ioBase;
# if !defined(abs) && defined(USE_ABS_MACRO)
# define abs(x) ((x) >= 0 ? (x) : -(x))
# endif
# undef inb
# undef inw
# undef inl
# undef outb
# undef outw
# undef outl
# if PPCIO_DEBUG
extern void debug_outb(unsigned int a, unsigned char b, int line, char *file);
extern void debug_outw(unsigned int a, unsigned short w, int line, char *file);
extern void debug_outl(unsigned int a, unsigned int l, int line, char *file);
extern unsigned char debug_inb(unsigned int a, int line, char *file);
extern unsigned short debug_inw(unsigned int a, int line, char *file);
extern unsigned int debug_inl(unsigned int a, int line, char *file);
# define outb(a,b) debug_outb(a,b, __LINE__, __FILE__)
# define outw(a,w) debug_outw(a,w, __LINE__, __FILE__)
# define outl(a,l) debug_outl(a,l, __LINE__, __FILE__)
# define inb(a) debug_inb(a, __LINE__, __FILE__)
# define inw(a) debug_inw(a, __LINE__, __FILE__)
# define inl(a) debug_inl(a, __LINE__, __FILE__)
# else /* !PPCIO_DEBUG */
extern unsigned char inb(unsigned int a);
extern unsigned short inw(unsigned int a);
extern unsigned int inl(unsigned int a);
# if PPCIO_INLINE
# define outb(a,b) \
(*((volatile unsigned char *)(ioBase + (a))) = (b), eieio())
# define outw(a,w) (stw_brx((w),ioBase,(a)), eieio())
# define outl(a,l) (stl_brx((l),ioBase,(a)), eieio())
# else /* !PPCIO_INLINE */
extern void outb(unsigned int a, unsigned char b);
extern void outw(unsigned int a, unsigned short w);
extern void outl(unsigned int a, unsigned int l);
# endif /* PPCIO_INLINE */
# endif /* !PPCIO_DEBUG */
# else /* !GNUC && !PPC */
# if !defined(QNX4)
# if defined(__STDC__) && (__STDC__ == 1)
# ifndef asm
# define asm __asm
# endif
# endif
# ifndef SCO325
# if defined(__UNIXWARE__)
# if defined(IN_MODULE)
# /* avoid including <sys/types.h> for <sys/inline.h> on UnixWare */
# define ushort unsigned short
# define ushort_t unsigned short
# define ulong unsigned long
# define ulong_t unsigned long
# define uint_t unsigned int
# define uchar_t unsigned char
# else
# include <sys/types.h>
# endif /* IN_MODULE */
# endif /* __UNIXWARE__ */
# if !defined(sgi) && !defined(__SUNPRO_C)
# include <sys/inline.h>
# endif
# else
# include "scoasm.h"
# endif
# if (!defined(__HIGHC__) && !defined(sgi) && !defined(__SUNPRO_C)) || \
defined(__USLC__)
# pragma asm partial_optimization outl
# pragma asm partial_optimization outw
# pragma asm partial_optimization outb
# pragma asm partial_optimization inl
# pragma asm partial_optimization inw
# pragma asm partial_optimization inb
# endif
# endif
# define ldq_u(p) (*((unsigned long *)(p)))
# define ldl_u(p) (*((unsigned int *)(p)))
# define ldw_u(p) (*((unsigned short *)(p)))
# define stq_u(v,p) (*(unsigned long *)(p)) = (v)
# define stl_u(v,p) (*(unsigned int *)(p)) = (v)
# define stw_u(v,p) (*(unsigned short *)(p)) = (v)
# define mem_barrier() /* NOP */
# define write_mem_barrier() /* NOP */
# endif /* __GNUC__ */
# if defined(QNX4)
# include <sys/types.h>
extern unsigned inb(unsigned port);
extern unsigned inw(unsigned port);
extern unsigned inl(unsigned port);
extern void outb(unsigned port, unsigned val);
extern void outw(unsigned port, unsigned val);
extern void outl(unsigned port, unsigned val);
# endif /* QNX4 */
# if defined(IODEBUG) && defined(__GNUC__)
# undef inb
# undef inw
# undef inl
# undef outb
# undef outw
# undef outl
# 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;})
# 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;})
# 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;})
# define outb(a,b) (ErrorF("outb(0x%03x, 0x%02x)\t@ line %4d, file %s\n", a, b, __LINE__, __FILE__),RealOutb(a,b))
# define outw(a,b) (ErrorF("outw(0x%03x, 0x%04x)\t@ line %4d, file %s\n", a, b, __LINE__, __FILE__),RealOutw(a,b))
# define outl(a,b) (ErrorF("outl(0x%03x, 0x%08x)\t@ line %4d, file %s\n", a, b, __LINE__, __FILE__),RealOutl(a,b))
# endif
# endif /* NO_INLINE */
# ifdef __alpha__
/* entry points for Mmio memory access routines */
extern int (*xf86ReadMmio8)(void *, unsigned long);
extern int (*xf86ReadMmio16)(void *, unsigned long);
# ifndef STANDALONE_MMIO
extern int (*xf86ReadMmio32)(void *, unsigned long);
# else
/* Some DRI 3D drivers need MMIO_IN32. */
static __inline__ int
xf86ReadMmio32(void *Base, unsigned long Offset)
{
__asm__ __volatile__("mb" : : : "memory");
return *(volatile unsigned int*)((unsigned long)Base+(Offset));
}
# endif
extern void (*xf86WriteMmio8)(int, void *, unsigned long);
extern void (*xf86WriteMmio16)(int, void *, unsigned long);
extern void (*xf86WriteMmio32)(int, void *, unsigned long);
extern void (*xf86WriteMmioNB8)(int, void *, unsigned long);
extern void (*xf86WriteMmioNB16)(int, void *, unsigned long);
extern void (*xf86WriteMmioNB32)(int, void *, unsigned long);
extern void xf86JensenMemToBus(char *, long, long, int);
extern void xf86JensenBusToMem(char *, char *, unsigned long, int);
extern void xf86SlowBCopyFromBus(unsigned char *, unsigned char *, int);
extern void xf86SlowBCopyToBus(unsigned char *, unsigned char *, int);
/* Some macros to hide the system dependencies for MMIO accesses */
/* Changed to kill noise generated by gcc's -Wcast-align */
# define MMIO_IN8(base, offset) (*xf86ReadMmio8)(base, offset)
# define MMIO_IN16(base, offset) (*xf86ReadMmio16)(base, offset)
# ifndef STANDALONE_MMIO
# define MMIO_IN32(base, offset) (*xf86ReadMmio32)(base, offset)
# else
# define MMIO_IN32(base, offset) xf86ReadMmio32(base, offset)
# endif
# if defined (JENSEN_SUPPORT)
# define MMIO_OUT32(base, offset, val) \
(*xf86WriteMmio32)((CARD32)(val), base, offset)
# define MMIO_ONB32(base, offset, val) \
(*xf86WriteMmioNB32)((CARD32)(val), base, offset)
# else
# define MMIO_OUT32(base, offset, val) \
do { \
write_mem_barrier(); \
*(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val); \
} while (0)
# define MMIO_ONB32(base, offset, val) \
*(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val)
# endif
# define MMIO_OUT8(base, offset, val) \
(*xf86WriteMmio8)((CARD8)(val), base, offset)
# define MMIO_OUT16(base, offset, val) \
(*xf86WriteMmio16)((CARD16)(val), base, offset)
# define MMIO_ONB8(base, offset, val) \
(*xf86WriteMmioNB8)((CARD8)(val), base, offset)
# define MMIO_ONB16(base, offset, val) \
(*xf86WriteMmioNB16)((CARD16)(val), base, offset)
# define MMIO_MOVE32(base, offset, val) \
MMIO_OUT32(base, offset, val)
# elif defined(__powerpc__)
/*
* we provide byteswapping and no byteswapping functions here
* with byteswapping as default,
* drivers that don't need byteswapping should define PPC_MMIO_IS_BE
*/
# define MMIO_IN8(base, offset) xf86ReadMmio8(base, offset)
# define MMIO_OUT8(base, offset, val) \
xf86WriteMmio8(base, offset, (CARD8)(val))
# define MMIO_ONB8(base, offset, val) \
xf86WriteMmioNB8(base, offset, (CARD8)(val))
# if defined(PPC_MMIO_IS_BE) /* No byteswapping */
# define MMIO_IN16(base, offset) xf86ReadMmio16Be(base, offset)
# define MMIO_IN32(base, offset) xf86ReadMmio32Be(base, offset)
# define MMIO_OUT16(base, offset, val) \
xf86WriteMmio16Be(base, offset, (CARD16)(val))
# define MMIO_OUT32(base, offset, val) \
xf86WriteMmio32Be(base, offset, (CARD32)(val))
# define MMIO_ONB16(base, offset, val) \
xf86WriteMmioNB16Be(base, offset, (CARD16)(val))
# define MMIO_ONB32(base, offset, val) \
xf86WriteMmioNB32Be(base, offset, (CARD32)(val))
# else /* byteswapping is the default */
# define MMIO_IN16(base, offset) xf86ReadMmio16Le(base, offset)
# define MMIO_IN32(base, offset) xf86ReadMmio32Le(base, offset)
# define MMIO_OUT16(base, offset, val) \
xf86WriteMmio16Le(base, offset, (CARD16)(val))
# define MMIO_OUT32(base, offset, val) \
xf86WriteMmio32Le(base, offset, (CARD32)(val))
# define MMIO_ONB16(base, offset, val) \
xf86WriteMmioNB16Le(base, offset, (CARD16)(val))
# define MMIO_ONB32(base, offset, val) \
xf86WriteMmioNB32Le(base, offset, (CARD32)(val))
# endif
# define MMIO_MOVE32(base, offset, val) \
xf86WriteMmio32Be(base, offset, (CARD32)(val))
static __inline__ void ppc_flush_icache(char *addr)
{
__asm__ volatile (
"dcbf 0,%0;"
"sync;"
"icbi 0,%0;"
"sync;"
"isync;"
: : "r"(addr) : "memory");
}
# elif defined(__sparc__) || defined(sparc)
/*
* Like powerpc, we provide byteswapping and no byteswapping functions
* here with byteswapping as default, drivers that don't need byteswapping
* should define SPARC_MMIO_IS_BE (perhaps create a generic macro so that we
* do not need to use PPC_MMIO_IS_BE and the sparc one in all the same places
* of drivers?).
*/
# define MMIO_IN8(base, offset) xf86ReadMmio8(base, offset)
# define MMIO_OUT8(base, offset, val) \
xf86WriteMmio8(base, offset, (CARD8)(val))
# define MMIO_ONB8(base, offset, val) \
xf86WriteMmio8NB(base, offset, (CARD8)(val))
# if defined(SPARC_MMIO_IS_BE) /* No byteswapping */
# define MMIO_IN16(base, offset) xf86ReadMmio16Be(base, offset)
# define MMIO_IN32(base, offset) xf86ReadMmio32Be(base, offset)
# define MMIO_OUT16(base, offset, val) \
xf86WriteMmio16Be(base, offset, (CARD16)(val))
# define MMIO_OUT32(base, offset, val) \
xf86WriteMmio32Be(base, offset, (CARD32)(val))
# define MMIO_ONB16(base, offset, val) \
xf86WriteMmio16BeNB(base, offset, (CARD16)(val))
# define MMIO_ONB32(base, offset, val) \
xf86WriteMmio32BeNB(base, offset, (CARD32)(val))
# else /* byteswapping is the default */
# define MMIO_IN16(base, offset) xf86ReadMmio16Le(base, offset)
# define MMIO_IN32(base, offset) xf86ReadMmio32Le(base, offset)
# define MMIO_OUT16(base, offset, val) \
xf86WriteMmio16Le(base, offset, (CARD16)(val))
# define MMIO_OUT32(base, offset, val) \
xf86WriteMmio32Le(base, offset, (CARD32)(val))
# define MMIO_ONB16(base, offset, val) \
xf86WriteMmio16LeNB(base, offset, (CARD16)(val))
# define MMIO_ONB32(base, offset, val) \
xf86WriteMmio32LeNB(base, offset, (CARD32)(val))
# endif
# define MMIO_MOVE32(base, offset, val) \
xf86WriteMmio32Be(base, offset, (CARD32)(val))
# else /* !__alpha__ && !__powerpc__ && !__sparc__ */
# define MMIO_IN8(base, offset) \
*(volatile CARD8 *)(((CARD8*)(base)) + (offset))
# define MMIO_IN16(base, offset) \
*(volatile CARD16 *)(void *)(((CARD8*)(base)) + (offset))
# define MMIO_IN32(base, offset) \
*(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset))
# define MMIO_OUT8(base, offset, val) \
*(volatile CARD8 *)(((CARD8*)(base)) + (offset)) = (val)
# define MMIO_OUT16(base, offset, val) \
*(volatile CARD16 *)(void *)(((CARD8*)(base)) + (offset)) = (val)
# define MMIO_OUT32(base, offset, val) \
*(volatile CARD32 *)(void *)(((CARD8*)(base)) + (offset)) = (val)
# define MMIO_ONB8(base, offset, val) MMIO_OUT8(base, offset, val)
# define MMIO_ONB16(base, offset, val) MMIO_OUT16(base, offset, val)
# define MMIO_ONB32(base, offset, val) MMIO_OUT32(base, offset, val)
# define MMIO_MOVE32(base, offset, val) MMIO_OUT32(base, offset, val)
# endif /* __alpha__ */
/*
* With Intel, the version in os-support/misc/SlowBcopy.s is used.
* This avoids port I/O during the copy (which causes problems with
* some hardware).
*/
# ifdef __alpha__
# define slowbcopy_tobus(src,dst,count) xf86SlowBCopyToBus(src,dst,count)
# define slowbcopy_frombus(src,dst,count) xf86SlowBCopyFromBus(src,dst,count)
# else /* __alpha__ */
# define slowbcopy_tobus(src,dst,count) xf86SlowBcopy(src,dst,count)
# define slowbcopy_frombus(src,dst,count) xf86SlowBcopy(src,dst,count)
# endif /* __alpha__ */
#endif /* _COMPILER_H */
nx-X11/programs/Xserver/hw/xfree86/os-support/xf86_ansic.h deleted 100644 → 0
View file @ 6c7f9cda
/*
* Copyright 1997-2003 by The XFree86 Project, Inc
*
* Permission to use, copy, modify, distribute, and sell this software and its
* documentation for any purpose is hereby granted without fee, provided that
* the above copyright notice appear in all copies and that both that
* copyright notice and this permission notice appear in supporting
* documentation, and that the names of the above listed copyright holders
* not be used in advertising or publicity pertaining to distribution of
* the software without specific, written prior permission. The above listed
* copyright holders make no representations about the suitability of this
* software for any purpose. It is provided "as is" without express or
* implied warranty.
*
* THE ABOVE LISTED COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD
* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
* AND FITNESS, IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDERS BE
* LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY
* DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
* IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
* OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*
*/
#ifndef _XF86_ANSIC_H
#define _XF86_ANSIC_H
/* Handle <stdarg.h> */
#ifndef IN_MODULE
# include <stdarg.h>
#else /* !IN_MODULE */
# ifndef __OS2ELF__
# include <stdarg.h>
# else /* __OS2ELF__ */
/* EMX/gcc_elf under OS/2 does not have native header files */
# if !defined (_VA_LIST)
# define _VA_LIST
typedef char *va_list;
# endif
# define _VA_ROUND(t) ((sizeof (t) + 3) & -4)
# if !defined (va_start)
# define va_start(ap,v) ap = (va_list)&v + ((sizeof (v) + 3) & -4)
# define va_end(ap) (ap = 0, (void)0)
# define va_arg(ap,t) (ap += _VA_ROUND (t), *(t *)(ap - _VA_ROUND (t)))
# endif
# endif /* __OS2ELF__ */
#endif /* IN_MODULE */
/*
* The first set of definitions are required both for modules and
* libc_wrapper.c.
*/
#if defined(XFree86LOADER) || defined(NEED_XF86_TYPES)
#if !defined(SYSV) && !defined(SVR4) && !defined(Lynx) || \
defined(__SCO__) || defined(__UNIXWARE__)
#define HAVE_VSSCANF
#define HAVE_VFSCANF
#endif
#ifndef NULL
#if (defined(SVR4) || defined(SYSV)) && !defined(__GNUC__)
#define NULL 0
#else
#define NULL ((void *)0)
#endif
#endif
#ifndef EOF
#define EOF (-1)
#endif
#ifndef PATH_MAX
#define PATH_MAX 1024
#endif
/* <limits.h> stuff */
#define x_BITSPERBYTE 8
#define x_BITS(type) (x_BITSPERBYTE * (int)sizeof(type))
#define x_SHORTBITS x_BITS(short)
#define x_INTBITS x_BITS(int)
#define x_LONGBITS x_BITS(long)
#ifndef SHRT_MIN
#define SHRT_MIN ((short)(1 << (x_SHORTBITS - 1)))
#endif
#ifndef FONTMODULE
#include "misc.h"
#endif
#include "xf86_libc.h"
#ifndef SHRT_MAX
#define SHRT_MAX ((short)~SHRT_MIN)
#endif
#ifndef USHRT_MAX
#define USHRT_MAX ((unsigned short)~0)
#endif
#ifndef MINSHORT
#define MINSHORT SHRT_MIN
#endif
#ifndef MAXSHORT
#define MAXSHORT SHRT_MAX
#endif
#ifndef INT_MIN
#define INT_MIN (1 << (x_INTBITS - 1))
#endif
#ifndef INT_MAX
#define INT_MAX (~INT_MIN)
#endif
#ifndef UINT_MAX
#define UINT_MAX (~0)
#endif
#ifndef MININT
#define MININT INT_MIN
#endif
#ifndef MAXINT
#define MAXINT INT_MAX
#endif
#ifndef LONG_MIN
#define LONG_MIN ((long)(1 << (x_LONGBITS - 1)))
#endif
#ifndef LONG_MAX
#define LONG_MAX ((long)~LONG_MIN)
#endif
#ifndef ULONG_MAX
#define ULONG_MAX ((unsigned long)~0UL)
#endif
#ifndef MINLONG
#define MINLONG LONG_MIN
#endif
#ifndef MAXLONG
#define MAXLONG LONG_MAX
#endif
#endif /* XFree86LOADER || NEED_XF86_TYPES */
#if defined(XFree86LOADER) || defined(NEED_XF86_PROTOTYPES)
/*
* ANSI C compilers only.
*/
/* ANSI C emulation library */
extern void xf86abort(void);
extern int xf86abs(int);
extern double xf86acos(double);
extern double xf86asin(double);
extern double xf86atan(double);
extern double xf86atan2(double,double);
extern double xf86atof(const char*);
extern int xf86atoi(const char*);
extern long xf86atol(const char*);
extern void *xf86bsearch(const void *, const void *, xf86size_t, xf86size_t,
int (*)(const void *, const void *));
extern double xf86ceil(double);
extern void* xf86calloc(xf86size_t,xf86size_t);
extern void xf86clearerr(XF86FILE*);
extern double xf86cos(double);
extern void xf86exit(int);
extern double xf86exp(double);
extern double xf86fabs(double);
extern int xf86fclose(XF86FILE*);
extern int xf86feof(XF86FILE*);
extern int xf86ferror(XF86FILE*);
extern int xf86fflush(XF86FILE*);
extern int xf86fgetc(XF86FILE*);
extern int xf86getc(XF86FILE*);
extern int xf86fgetpos(XF86FILE*,XF86fpos_t*);
extern char* xf86fgets(char*,INT32,XF86FILE*);
extern int xf86finite(double);
extern double xf86floor(double);
extern double xf86fmod(double,double);
extern XF86FILE* xf86fopen(const char*,const char*);
extern double xf86frexp(double, int*);
extern int xf86printf(const char*,...);
extern int xf86fprintf(XF86FILE*,const char*,...);
extern int xf86fputc(int,XF86FILE*);
extern int xf86fputs(const char*,XF86FILE*);
extern xf86size_t xf86fread(void*,xf86size_t,xf86size_t,XF86FILE*);
extern void xf86free(void*);
extern XF86FILE* xf86freopen(const char*,const char*,XF86FILE*);
#if defined(HAVE_VFSCANF) || !defined(NEED_XF86_PROTOTYPES)
extern int xf86fscanf(XF86FILE*,const char*,...);
#else
extern int xf86fscanf(/*XF86FILE*,const char*,char *,char *,char *,char *,
char *,char *,char *,char *,char *,char * */);
#endif
extern int xf86fseek(XF86FILE*,long,int);
extern int xf86fsetpos(XF86FILE*,const XF86fpos_t*);
extern long xf86ftell(XF86FILE*);
extern xf86size_t xf86fwrite(const void*,xf86size_t,xf86size_t,XF86FILE*);
extern char* xf86getenv(const char*);
extern int xf86isalnum(int);
extern int xf86isalpha(int);
extern int xf86iscntrl(int);
extern int xf86isdigit(int);
extern int xf86isgraph(int);
extern int xf86islower(int);
extern int xf86isprint(int);
extern int xf86ispunct(int);
extern int xf86isspace(int);
extern int xf86isupper(int);
extern int xf86isxdigit(int);
extern long xf86labs(long);
extern double xf86ldexp(double,int);
extern double xf86log(double);
extern double xf86log10(double);
extern void* xf86malloc(xf86size_t);
extern void* xf86memchr(const void*,int,xf86size_t);
extern int xf86memcmp(const void*,const void*,xf86size_t);
extern void* xf86memcpy(void*,const void*,xf86size_t);
extern void* xf86memmove(void*,const void*,xf86size_t);
extern void* xf86memset(void*,int,xf86size_t);
extern double xf86modf(double,double*);
extern void xf86perror(const char*);
extern double xf86pow(double,double);
extern void xf86qsort(void*, xf86size_t, xf86size_t,
int(*)(const void*, const void*));
extern void* xf86realloc(void*,xf86size_t);
extern int xf86remove(const char*);
extern int xf86rename(const char*,const char*);
extern void xf86rewind(XF86FILE*);
extern int xf86setbuf(XF86FILE*,char*);
extern int xf86setvbuf(XF86FILE*,char*,int,xf86size_t);
extern double xf86sin(double);
extern int xf86sprintf(char*,const char*,...);
extern int xf86snprintf(char*,xf86size_t,const char*,...);
extern double xf86sqrt(double);
#if defined(HAVE_VSSCANF) || !defined(NEED_XF86_PROTOTYPES)
extern int xf86sscanf(char*,const char*,...);
#else
extern int xf86sscanf(/*char*,const char*,char *,char *,char *,char *,
char *,char *,char *,char *,char *,char * */);
#endif
extern char* xf86strcat(char*,const char*);
extern char* xf86strchr(const char*, int c);
extern int xf86strcmp(const char*,const char*);
extern int xf86strcasecmp(const char*,const char*);
extern char* xf86strcpy(char*,const char*);
extern xf86size_t xf86strcspn(const char*,const char*);
extern char* xf86strerror(int);
extern xf86size_t xf86strlcat(char*,const char*,xf86size_t);
extern xf86size_t xf86strlcpy(char*,const char*,xf86size_t);
extern xf86size_t xf86strlen(const char*);
extern char* xf86strncat(char *, const char *, xf86size_t);
extern int xf86strncmp(const char*,const char*,xf86size_t);
extern int xf86strncasecmp(const char*,const char*,xf86size_t);
extern char* xf86strncpy(char*,const char*,xf86size_t);
extern char* xf86strpbrk(const char*,const char*);
extern char* xf86strrchr(const char*,int);
extern xf86size_t xf86strspn(const char*,const char*);
extern char* xf86strstr(const char*,const char*);
extern double xf86strtod(const char*,char**);
extern char* xf86strtok(char*,const char*);
extern long xf86strtol(const char*,char**,int);
extern unsigned long xf86strtoul(const char*,char**,int);
extern double xf86tan(double);
extern XF86FILE* xf86tmpfile(void);
extern char* xf86tmpnam(char*);
extern int xf86tolower(int);
extern int xf86toupper(int);
extern int xf86ungetc(int,XF86FILE*);
extern int xf86vfprintf(XF86FILE*,const char*,va_list);
extern int xf86vsprintf(char*,const char*,va_list);
extern int xf86vsnprintf(char*,xf86size_t,const char*,va_list);
extern int xf86open(const char*, int,...);
extern int xf86close(int);
extern long xf86lseek(int, long, int);
extern int xf86ioctl(int, unsigned long, void *);
extern xf86ssize_t xf86read(int, void *, xf86size_t);
extern xf86ssize_t xf86write(int, const void *, xf86size_t);
extern void* xf86mmap(void*, xf86size_t, int, int, int, xf86size_t /* off_t */);
extern int xf86munmap(void*, xf86size_t);
extern int xf86stat(const char *, struct xf86stat *);
extern int xf86fstat(int, struct xf86stat *);
extern int xf86access(const char *, int);
extern int xf86errno;
extern int xf86GetErrno(void);
extern double xf86HUGE_VAL;
extern double xf86hypot(double,double);
/* non-ANSI C functions */
extern XF86DIR* xf86opendir(const char*);
extern int xf86closedir(XF86DIR*);
extern XF86DIRENT* xf86readdir(XF86DIR*);
extern void xf86rewinddir(XF86DIR*);
extern void xf86bcopy(const void*,void*,xf86size_t);
extern int xf86ffs(int);
extern char* xf86strdup(const char*);
extern void xf86bzero(void*,unsigned int);
extern int xf86execl(const char *, const char *, ...);
extern long xf86fpossize(void);
extern int xf86chmod(const char *, xf86mode_t);
extern int xf86chown(const char *, xf86uid_t, xf86gid_t);
extern xf86uid_t xf86geteuid(void);
extern xf86gid_t xf86getegid(void);
extern int xf86getpid(void);
extern int xf86mknod(const char *, xf86mode_t, xf86dev_t);
extern int xf86mkdir(const char *, xf86mode_t);
unsigned int xf86sleep(unsigned int seconds);
/* sysv IPC */
extern int xf86shmget(xf86key_t key, int size, int xf86shmflg);
extern char * xf86shmat(int id, char *addr, int xf86shmflg);
extern int xf86shmdt(char *addr);
extern int xf86shmctl(int id, int xf86cmd, void * buf);
extern int xf86setjmp(xf86jmp_buf env);
extern int xf86setjmp0(xf86jmp_buf env);
extern int xf86setjmp1(xf86jmp_buf env, int);
extern int xf86setjmp1_arg2(void);
extern int xf86setjmperror(xf86jmp_buf env);
extern int xf86getjmptype(void);
extern void xf86longjmp(xf86jmp_buf env, int val);
#define xf86setjmp_macro(env) \
(xf86getjmptype() == 0 ? xf86setjmp0((env)) : \
(xf86getjmptype() == 1 ? xf86setjmp1((env), xf86setjmp1_arg2()) : \
xf86setjmperror((env))))
#else /* XFree86LOADER || NEED_XF86_PROTOTYPES */
#include <unistd.h>
#include <stdio.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <fcntl.h>
#include <ctype.h>
#ifdef HAVE_SYSV_IPC
#include <sys/ipc.h>
#include <sys/shm.h>
#endif
#include <sys/stat.h>
#define stat_t struct stat
#endif /* XFree86LOADER || NEED_XF86_PROTOTYPES */
/*
* These things are always required by drivers (but not by libc_wrapper.c),
* even for a static server because some OSs don't provide them.
*/
extern int xf86getpagesize(void);
extern void xf86usleep(unsigned long);
extern void xf86getsecs(long *, long *);
#ifndef DONT_DEFINE_WRAPPERS
#undef getpagesize
#define getpagesize() xf86getpagesize()
#undef usleep
#define usleep(ul) xf86usleep(ul)
#undef getsecs
#define getsecs(a, b) xf86getsecs(a, b)
#endif
#endif /* _XF86_ANSIC_H */
nx-X11/programs/Xserver/hw/xfree86/os-support/xf86_libc.h deleted 100644 → 0
View file @ 6c7f9cda
/*
* Copyright (c) 1997-2003 by The XFree86 Project, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of the copyright holder(s)
* and author(s) shall not be used in advertising or otherwise to promote
* the sale, use or other dealings in this Software without prior written
* authorization from the copyright holder(s) and author(s).
*/
/*
* This file is an attempt to make developing code for the new loadable module
* architecure simpler. It tries to use macros to hide all libc wrappers so
* that all that is needed to "port" a module to this architecture is to
* include this one header file
*
* Revision history:
*
*
* 0.4 Apr 12 1997 add the ANSI defines
* 0.3 Feb 24 1997 handle getenv
* 0.2 Feb 24 1997 hide few FILE functions
* 0.1 Feb 24 1997 hide the trivial functions mem* str*
*/
#ifndef XF86_LIBC_H
#define XF86_LIBC_H 1
#include <nx-X11/Xfuncs.h>
#include <stddef.h>
/*
* The first set of definitions are required both for modules and
* libc_wrapper.c.
*/
#if defined(XFree86LOADER) || defined(NEED_XF86_TYPES)
/*
* First, the new data types
*
* note: if some pointer is declared "opaque" here, pass it between
* xf86* functions only, and don't rely on it having a whatever internal
* structure, even if some source file might reveal the existence of
* such a structure.
*/
typedef void XF86FILE; /* opaque FILE replacement */
extern XF86FILE* xf86stdin;
extern XF86FILE* xf86stdout;
extern XF86FILE* xf86stderr;
typedef void XF86fpos_t; /* opaque fpos_t replacement */
#define _XF86NAMELEN 263 /* enough for a larger filename */
/* (divisble by 8) */
typedef void XF86DIR; /* opaque DIR replacement */
/* Note: the following is POSIX! POSIX only requires the d_name member.
* Normal Unix has often a number of other members, but don't rely on that
*/
struct _xf86dirent { /* types in struct dirent/direct: */
char d_name[_XF86NAMELEN+1]; /* char [MAXNAMLEN]; might be smaller or unaligned */
};
typedef struct _xf86dirent XF86DIRENT;
typedef unsigned long xf86size_t;
typedef signed long xf86ssize_t;
typedef unsigned long xf86dev_t;
typedef unsigned int xf86mode_t;
typedef unsigned int xf86uid_t;
typedef unsigned int xf86gid_t;
struct xf86stat {
xf86dev_t st_rdev; /* This is incomplete, and makes assumptions */
};
/* sysv IPC */
typedef int xf86key_t;
/* setjmp/longjmp */
#if defined(__ia64__)
typedef int xf86jmp_buf[1024] __attribute__ ((aligned (16))); /* guarantees 128-bit alignment! */
#else
typedef int xf86jmp_buf[1024];
#endif
/* for setvbuf */
#define XF86_IONBF 1
#define XF86_IOFBF 2
#define XF86_IOLBF 3
/* for open (XXX not complete) */
#define XF86_O_RDONLY 0x0000
#define XF86_O_WRONLY 0x0001
#define XF86_O_RDWR 0x0002
#define XF86_O_CREAT 0x0200
/* for mmap */
#define XF86_PROT_EXEC 0x0001
#define XF86_PROT_READ 0x0002
#define XF86_PROT_WRITE 0x0004
#define XF86_PROT_NONE 0x0008
#define XF86_MAP_FIXED 0x0001
#define XF86_MAP_SHARED 0x0002
#define XF86_MAP_PRIVATE 0x0004
#define XF86_MAP_32BIT 0x0040
#define XF86_MAP_FAILED ((void *)-1)
/* for fseek */
#define XF86_SEEK_SET 0
#define XF86_SEEK_CUR 1
#define XF86_SEEK_END 2
/* for access */
#define XF86_R_OK 0
#define XF86_W_OK 1
#define XF86_X_OK 2
#define XF86_F_OK 3
/* for chmod */
#define XF86_S_ISUID 04000 /* set user ID on execution */
#define XF86_S_ISGID 02000 /* set group ID on execution */
#define XF86_S_ISVTX 01000 /* sticky bit */
#define XF86_S_IRUSR 00400 /* read by owner */
#define XF86_S_IWUSR 00200 /* write by owner */
#define XF86_S_IXUSR 00100 /* execute/search by owner */
#define XF86_S_IRGRP 00040 /* read by group */
#define XF86_S_IWGRP 00020 /* write by group */
#define XF86_S_IXGRP 00010 /* execute/search by group */
#define XF86_S_IROTH 00004 /* read by others */
#define XF86_S_IWOTH 00002 /* write by others */
#define XF86_S_IXOTH 00001 /* execute/search by others */
/* for mknod */
#define XF86_S_IFREG 0010000
#define XF86_S_IFCHR 0020000
#define XF86_S_IFBLK 0040000
#define XF86_S_IFIFO 0100000
/*
* errno values
* They start at 1000 just so they don't match real errnos at all
*/
#define xf86_UNKNOWN 1000
#define xf86_EACCES 1001
#define xf86_EAGAIN 1002
#define xf86_EBADF 1003
#define xf86_EEXIST 1004
#define xf86_EFAULT 1005
#define xf86_EINTR 1006
#define xf86_EINVAL 1007
#define xf86_EISDIR 1008
#define xf86_ELOOP 1009
#define xf86_EMFILE 1010
#define xf86_ENAMETOOLONG 1011
#define xf86_ENFILE 1012
#define xf86_ENOENT 1013
#define xf86_ENOMEM 1014
#define xf86_ENOSPC 1015
#define xf86_ENOTDIR 1016
#define xf86_EPIPE 1017
#define xf86_EROFS 1018
#define xf86_ETXTBSY 1019
#define xf86_ENOTTY 1020
#define xf86_ENOSYS 1021
#define xf86_EBUSY 1022
#define xf86_ENODEV 1023
#define xf86_EIO 1024
#define xf86_ESRCH 1025
#define xf86_ENXIO 1026
#define xf86_E2BIG 1027
#define xf86_ENOEXEC 1028
#define xf86_ECHILD 1029
#define xf86_ENOTBLK 1030
#define xf86_EXDEV 1031
#define xf86_EFBIG 1032
#define xf86_ESPIPE 1033
#define xf86_EMLINK 1034
#define xf86_EDOM 1035
#define xf86_ERANGE 1036
/* sysv IPV */
/* xf86shmget() */
#define XF86IPC_CREAT 01000
#define XF86IPC_EXCL 02000
#define XF86IPC_NOWAIT 04000
#define XF86SHM_R 0400
#define XF86SHM_W 0200
#define XF86IPC_PRIVATE ((xf86key_t)0)
/* xf86shmat() */
#define XF86SHM_RDONLY 010000 /* attach read-only else read-write */
#define XF86SHM_RND 020000 /* round attach address to SHMLBA */
#define XF86SHM_REMAP 040000 /* take-over region on attach */
/* xf86shmclt() */
#define XF86IPC_RMID 0
#endif /* defined(XFree86LOADER) || defined(NEED_XF86_TYPES) */
/*
* the rest of this file should only be included for code that is supposed
* to go into modules
*/
#if defined(XFree86LOADER) && !defined(DONT_DEFINE_WRAPPERS)
#undef abort
#define abort() xf86abort()
#undef abs
#define abs(i) xf86abs(i)
#undef acos
#define acos(d) xf86acos(d)
#undef asin
#define asin(d) xf86asin(d)
#undef atan
#define atan(d) xf86atan(d)
#undef atan2
#define atan2(d1,d2) xf86atan2(d1,d2)
#undef atof
#define atof(ccp) xf86atof(ccp)
#undef atoi
#define atoi(ccp) xf86atoi(ccp)
#undef atol
#define atol(ccp) xf86atol(ccp)
#undef bsearch
#define bsearch(a,b,c,d,e) xf86bsearch(a,b,c,d,e)
#undef ceil
#define ceil(d) xf86ceil(d)
#undef calloc
#define calloc(I1,I2) xf86calloc(I1,I2)
#undef clearerr
#define clearerr(FP) xf86clearerr(FP)
#undef cos
#define cos(d) xf86cos(d)
#undef exit
#define exit(i) xf86exit(i)
#undef exp
#define exp(d) xf86exp(d)
#undef fabs
#define fabs(d) xf86fabs(d)
#undef fclose
#define fclose(FP) xf86fclose(FP)
#undef feof
#define feof(FP) xf86feof(FP)
#undef ferror
#define ferror(FP) xf86ferror(FP)
#undef fflush
#define fflush(FP) xf86fflush(FP)
#undef fgetc
#define fgetc(FP) xf86fgetc(FP)
#undef getc
#define getc(FP) xf86getc(FP)
#undef fgetpos
#define fgetpos(FP,fpp) xf86fgetpos(FP,fpp)
#undef fgets
#define fgets(cp,i,FP) xf86fgets(cp,i,FP)
#undef finite
#define finite(d) xf86finite(d)
#undef floor
#define floor(d) xf86floor(d)
#undef fmod
#define fmod(d1,d2) xf86fmod(d1,d2)
#undef fopen
#define fopen(ccp1,ccp2) xf86fopen(ccp1,ccp2)
#undef printf
#define printf xf86printf
#undef fprintf
#define fprintf xf86fprintf
#undef fputc
#define fputc(i,FP) xf86fputc(i,FP)
#undef fputs
#define fputs(ccp,FP) xf86fputs(ccp,FP)
#undef fread
#define fread(vp,I1,I2,FP) xf86fread(vp,I1,I2,FP)
#undef free
#define free(vp) xf86free(vp)
#undef freopen
#define freopen(ccp1,ccp2,FP) xf86freopen(ccp1,ccp2,FP)
#undef frexp
#define frexp(x,exp) xf86frexp(x,exp)
#undef fscanf
#define fscanf xf86fscanf
#undef fseek
#define fseek(FP,l,i) xf86fseek(FP,l,i)
#undef fsetpos
#define fsetpos(FP,cfpp) xf86fsetpos(FP,cfpp)
#undef ftell
#define ftell(FP) xf86ftell(FP)
#undef fwrite
#define fwrite(cvp,I1,I2,FP) xf86fwrite(cvp,I1,I2,FP)
#undef getenv
#define getenv(ccp) xf86getenv(ccp)
#undef isalnum
#define isalnum(i) xf86isalnum(i)
#undef isalpha
#define isalpha(i) xf86isalpha(i)
#undef iscntrl
#define iscntrl(i) xf86iscntrl(i)
#undef isdigit
#define isdigit(i) xf86isdigit(i)
#undef isgraph
#define isgraph(i) xf86isgraph(i)
#undef islower
#define islower(i) xf86islower(i)
#undef isprint
#define isprint(i) xf86isprint(i)
#undef ispunct
#define ispunct(i) xf86ispunct(i)
#undef isspace
#define isspace(i) xf86isspace(i)
#undef isupper
#define isupper(i) xf86isupper(i)
#undef isxdigit
#define isxdigit(i) xf86isxdigit(i)
#undef labs
#define labs(l) xf86labs(l)
#undef ldexp
#define ldexp(x, exp) xf86ldexp(x, exp)
#undef log
#define log(d) xf86log(d)
#undef log10
#define log10(d) xf86log10(d)
#undef malloc
#define malloc(I) xf86malloc(I)
#undef memchr
#define memchr(cvp,i,I) xf86memchr(cvp,i,I)
#undef memcmp
#define memcmp(cvp1,cvp2,I) xf86memcmp(cvp1,cvp2,I)
#undef memcpy
#define memcpy(vp,cvp,I) xf86memcpy(vp,cvp,I)
#undef memmove
#define memmove(vp,cvp,I) xf86memmove(vp,cvp,I)
#undef memset
#define memset(vp,int,I) xf86memset(vp,int,I)
#undef modf
#define modf(d,dp) xf86modf(d,dp)
#undef perror
#define perror(ccp) xf86perror(ccp)
#undef pow
#define pow(d1,d2) xf86pow(d1,d2)
#undef realloc
#define realloc(vp,I) xf86realloc(vp,I)
#undef remove
#define remove(ccp) xf86remove(ccp)
#undef rename
#define rename(ccp1,ccp2) xf86rename(ccp1,ccp2)
#undef rewind
#define rewind(FP) xf86rewind(FP)
#undef setbuf
#define setbuf(FP,cp) xf86setbuf(FP,cp)
#undef setvbuf
#define setvbuf(FP,cp,i,I) xf86setvbuf(FP,cp,i,I)
#undef sin
#define sin(d) xf86sin(d)
#undef snprintf
#define snprintf xf86snprintf
#undef sprintf
#define sprintf xf86sprintf
#undef sqrt
#define sqrt(d) xf86sqrt(d)
#undef sscanf
#define sscanf xf86sscanf
#undef strcat
#define strcat(cp,ccp) xf86strcat(cp,ccp)
#undef strcmp
#define strcmp(ccp1,ccp2) xf86strcmp(ccp1,ccp2)
#undef strcasecmp
#define strcasecmp(ccp1,ccp2) xf86strcasecmp(ccp1,ccp2)
#undef strcpy
#define strcpy(cp,ccp) xf86strcpy(cp,ccp)
#undef strcspn
#define strcspn(ccp1,ccp2) xf86strcspn(ccp1,ccp2)
#undef strerror
#define strerror(i) xf86strerror(i)
#undef strlcat
#define strlcat(cp,ccp,I) xf86strlcat(cp,ccp,I)
#undef strlcpy
#define strlcpy(cp,ccp,I) xf86strlcpy(cp,ccp,I)
#undef strlen
#define strlen(ccp) xf86strlen(ccp)
#undef strncmp
#define strncmp(ccp1,ccp2,I) xf86strncmp(ccp1,ccp2,I)
#undef strncasecmp
#define strncasecmp(ccp1,ccp2,I) xf86strncasecmp(ccp1,ccp2,I)
#undef strncpy
#define strncpy(cp,ccp,I) xf86strncpy(cp,ccp,I)
#undef strpbrk
#define strpbrk(ccp1,ccp2) xf86strpbrk(ccp1,ccp2)
#undef strchr
#define strchr(ccp,i) xf86strchr(ccp,i)
#undef strrchr
#define strrchr(ccp,i) xf86strrchr(ccp,i)
#undef strspn
#define strspn(ccp1,ccp2) xf86strspn(ccp1,ccp2)
#undef strstr
#define strstr(ccp1,ccp2) xf86strstr(ccp1,ccp2)
#undef srttod
#define strtod(ccp,cpp) xf86strtod(ccp,cpp)
#undef strtok
#define strtok(cp,ccp) xf86strtok(cp,ccp)
#undef strtol
#define strtol(ccp,cpp,i) xf86strtol(ccp,cpp,i)
#undef strtoul
#define strtoul(ccp,cpp,i) xf86strtoul(ccp,cpp,i)
#undef tan
#define tan(d) xf86tan(d)
#undef tmpfile
#define tmpfile() xf86tmpfile()
#undef tolower
#define tolower(i) xf86tolower(i)
#undef toupper
#define toupper(i) xf86toupper(i)
#undef ungetc
#define ungetc(i,FP) xf86ungetc(i,FP)
#undef vfprinf
#define vfprintf(p,f,a) xf86vfprintf(p,f,a)
#undef vsnprintf
#define vsnprintf(s,n,f,a) xf86vsnprintf(s,n,f,a)
#undef vsprintf
#define vsprintf(s,f,a) xf86vsprintf(s,f,a)
/* XXX Disable assert as if NDEBUG was defined */
/* Some X headers defined this away too */
#undef assert
#define assert(a) ((void)0)
#undef HUGE_VAL
#define HUGE_VAL xf86HUGE_VAL
#undef hypot
#define hypot(x,y) xf86hypot(x,y)
#undef qsort
#define qsort(b, n, s, f) xf86qsort(b, n, s, f)
/* non-ANSI C functions */
#undef opendir
#define opendir(cp) xf86opendir(cp)
#undef closedir
#define closedir(DP) xf86closedir(DP)
#undef readdir
#define readdir(DP) xf86readdir(DP)
#undef rewinddir
#define rewinddir(DP) xf86rewinddir(DP)
#undef bcopy
#define bcopy(vp,cvp,I) xf86memmove(cvp,vp,I)
#undef ffs
#define ffs(i) xf86ffs(i)
#undef strdup
#define strdup(ccp) xf86strdup(ccp)
#undef bzero
#define bzero(vp,ui) xf86bzero(vp,ui)
#undef execl
#define execl xf86execl
#undef chmod
#define chmod(a,b) xf86chmod(a,b)
#undef chown
#define chown(a,b,c) xf86chown(a,b,c)
#undef geteuid
#define geteuid xf86geteuid
#undef getegid
#define getegid xf86getegid
#undef getpid
#define getpid xf86getpid
#undef mknod
#define mknod(a,b,c) xf86mknod(a,b,c)
#undef sleep
#define sleep(a) xf86sleep(a)
#undef mkdir
#define mkdir(a,b) xf86mkdir(a,b)
#undef getpagesize
#define getpagesize xf86getpagesize
#undef shmget
#define shmget(a,b,c) xf86shmget(a,b,c)
#undef shmat
#define shmat(a,b,c) xf86shmat(a,b,c)
#undef shmdt
#define shmdt(a) xf86shmdt(a)
#undef shmctl
#define shmctl(a,b,c) xf86shmctl(a,b,c)
#undef S_ISUID
#define S_ISUID XF86_S_ISUID
#undef S_ISGID
#define S_ISGID XF86_S_ISGID
#undef S_ISVTX
#define S_ISVTX XF86_S_ISVTX
#undef S_IRUSR
#define S_IRUSR XF86_S_IRUSR
#undef S_IWUSR
#define S_IWUSR XF86_S_IWUSR
#undef S_IXUSR
#define S_IXUSR XF86_S_IXUSR
#undef S_IRGRP
#define S_IRGRP XF86_S_IRGRP
#undef S_IWGRP
#define S_IWGRP XF86_S_IWGRP
#undef S_IXGRP
#define S_IXGRP XF86_S_IXGRP
#undef S_IROTH
#define S_IROTH XF86_S_IROTH
#undef S_IWOTH
#define S_IWOTH XF86_S_IWOTH
#undef S_IXOTH
#define S_IXOTH XF86_S_IXOTH
#undef S_IFREG
#define S_IFREG XF86_S_IFREG
#undef S_IFCHR
#define S_IFCHR XF86_S_IFCHR
#undef S_IFBLK
#define S_IFBLK XF86_S_IFBLK
#undef S_IFIFO
#define S_IFIFO XF86_S_IFIFO
/* some types */
#undef FILE
#define FILE XF86FILE
#undef fpos_t
#define fpos_t XF86fpos_t
#undef DIR
#define DIR XF86DIR
#undef DIRENT
#define DIRENT XF86DIRENT
#undef size_t
#define size_t xf86size_t
#undef ssize_t
#define ssize_t xf86ssize_t
#undef dev_t
#define dev_t xf86dev_t
#undef mode_t
#define mode_t xf86mode_t
#undef uid_t
#define uid_t xf86uid_t
#undef gid_t
#define gid_t xf86gid_t
#undef stat_t
#define stat_t struct xf86stat
#undef ulong
#define ulong unsigned long
/*
* There should be no need to #undef any of these. If they are already
* defined it is because some illegal header has been included.
*/
/* some vars */
#undef stdin
#define stdin xf86stdin
#undef stdout
#define stdout xf86stdout
#undef stderr
#define stderr xf86stderr
#undef SEEK_SET
#define SEEK_SET XF86_SEEK_SET
#undef SEEK_CUR
#define SEEK_CUR XF86_SEEK_CUR
#undef SEEK_END
#define SEEK_END XF86_SEEK_END
/*
* XXX Basic I/O functions BAD,BAD,BAD!
*/
#define open xf86open
#define close(a) xf86close(a)
#define lseek(a,b,c) xf86lseek(a,b,c)
#if !defined(__DragonFly__)
#define ioctl(a,b,c) xf86ioctl(a,b,c)
#endif
#define read(a,b,c) xf86read(a,b,c)
#define write(a,b,c) xf86write(a,b,c)
#define mmap(a,b,c,d,e,f) xf86mmap(a,b,c,d,e,f)
#define munmap(a,b) xf86munmap(a,b)
#define stat(a,b) xf86stat(a,b)
#define fstat(a,b) xf86fstat(a,b)
#define access(a,b) xf86access(a,b)
#undef O_RDONLY
#define O_RDONLY XF86_O_RDONLY
#undef O_WRONLY
#define O_WRONLY XF86_O_WRONLY
#undef O_RDWR
#define O_RDWR XF86_O_RDWR
#undef O_CREAT
#define O_CREAT XF86_O_CREAT
#undef PROT_EXEC
#define PROT_EXEC XF86_PROT_EXEC
#undef PROT_READ
#define PROT_READ XF86_PROT_READ
#undef PROT_WRITE
#define PROT_WRITE XF86_PROT_WRITE
#undef PROT_NONE
#define PROT_NONE XF86_PROT_NONE
#undef MAP_FIXED
#define MAP_FIXED XF86_MAP_FIXED
#undef MAP_SHARED
#define MAP_SHARED XF86_MAP_SHARED
#undef MAP_PRIVATE
#define MAP_PRIVATE XF86_MAP_PRIVATE
#undef MAP_FAILED
#define MAP_FAILED XF86_MAP_FAILED
#undef R_OK
#define R_OK XF86_R_OK
#undef W_OK
#define W_OK XF86_W_OK
#undef X_OK
#define X_OK XF86_X_OK
#undef F_OK
#define F_OK XF86_F_OK
#undef errno
#define errno xf86errno
#undef putchar
#define putchar(i) xf86fputc(i, xf86stdout)
#undef puts
#define puts(s) xf86fputs(s, xf86stdout)
#undef EACCES
#define EACCES xf86_EACCES
#undef EAGAIN
#define EAGAIN xf86_EAGAIN
#undef EBADF
#define EBADF xf86_EBADF
#undef EEXIST
#define EEXIST xf86_EEXIST
#undef EFAULT
#define EFAULT xf86_EFAULT
#undef EINTR
#define EINTR xf86_EINTR
#undef EINVAL
#define EINVAL xf86_EINVAL
#undef EISDIR
#define EISDIR xf86_EISDIR
#undef ELOOP
#define ELOOP xf86_ELOOP
#undef EMFILE
#define EMFILE xf86_EMFILE
#undef ENAMETOOLONG
#define ENAMETOOLONG xf86_ENAMETOOLONG
#undef ENFILE
#define ENFILE xf86_ENFILE
#undef ENOENT
#define ENOENT xf86_ENOENT
#undef ENOMEM
#define ENOMEM xf86_ENOMEM
#undef ENOSPC
#define ENOSPC xf86_ENOSPC
#undef ENOTDIR
#define ENOTDIR xf86_ENOTDIR
#undef EPIPE
#define EPIPE xf86_EPIPE
#undef EROFS
#define EROFS xf86_EROFS
#undef ETXTBSY
#define ETXTBSY xf86_ETXTBSY
#undef ENOTTY
#define ENOTTY xf86_ENOTTY
#undef ENOSYS
#define ENOSYS xf86_ENOSYS
#undef EBUSY
#define EBUSY xf86_EBUSY
#undef ENODEV
#define ENODEV xf86_ENODEV
#undef EIO
#define EIO xf86_EIO
/* IPC stuff */
#undef SHM_RDONLY
#define SHM_RDONLY XF86SHM_RDONLY
#undef SHM_RND
#define SHM_RND XF86SHM_RND
#undef SHM_REMAP
#define SHM_REMAP XF86SHM_REMAP
#undef IPC_RMID
#define IPC_RMID XF86IPC_RMID
#undef IPC_CREAT
#define IPC_CREAT XF86IPC_CREAT
#undef IPC_EXCL
#define IPC_EXCL XF86IPC_EXCL
#undef PC_NOWAIT
#define IPC_NOWAIT XF86IPC_NOWAIT
#undef SHM_R
#define SHM_R XF86SHM_R
#undef SHM_W
#define SHM_W XF86SHM_W
#undef IPC_PRIVATE
#define IPC_PRIVATE XF86IPC_PRIVATE
/* Some ANSI macros */
#undef FILENAME_MAX
#define FILENAME_MAX 1024
#if (defined(sun) && defined(__SVR4))
# define _FILEDEFED /* Already have FILE defined, don't redefine it */
#endif
#endif /* XFree86LOADER && !DONT_DEFINE_WRAPPERS */
#if defined(XFree86LOADER) && \
(!defined(DONT_DEFINE_WRAPPERS) || defined(DEFINE_SETJMP_WRAPPERS))
#undef setjmp
#define setjmp(a) xf86setjmp_macro(a)
#undef longjmp
#define longjmp(a,b) xf86longjmp(a,b)
#undef jmp_buf
#define jmp_buf xf86jmp_buf
#endif
#endif /* XF86_LIBC_H */
nx-X11/programs/Xserver/include/Imakefile
View file @ 4aeed7ad
...@@ -13,9 +13,6 @@ HEADERS = os.h misc.h ...@@ -13,9 +13,6 @@ HEADERS = os.h misc.h
LinkSourceFile(xf86Module.h,$(XF86COMSRC)) LinkSourceFile(xf86Module.h,$(XF86COMSRC))
LinkSourceFile(xf86Opt.h,$(XF86COMSRC)) LinkSourceFile(xf86Opt.h,$(XF86COMSRC))
#endif #endif
LinkSourceFile(xf86_libc.h,$(XF86OSSRC))
LinkSourceFile(xf86_ansic.h,$(XF86OSSRC))
LinkSourceFile(compiler.h,$(XF86COMSRC))
#endif #endif
LinkSourceFile(osdep.h,../os) LinkSourceFile(osdep.h,../os)
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment