xnu-1228.3.13.tar.gz

[apple/xnu.git] / osfmk / ppc / cpu_capabilities.h

diff --git a/osfmk/ppc/cpu_capabilities.h b/osfmk/ppc/cpu_capabilities.h
index 9eb971a25029bc7352f7f440278772af25ed1b6c..268666cd25e6e3bd8662ed8633768f0efbf56bde 100644 (file)
--- a/osfmk/ppc/cpu_capabilities.h
+++ b/osfmk/ppc/cpu_capabilities.h
@@ -1,47 +1,40 @@
 /*
 /*

- * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
+ * Copyright (c) 2003-2006 Apple Computer, Inc. All rights reserved.

  *
  *

- * @APPLE_LICENSE_HEADER_START@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_START@

  * 
  * 

- * The contents of this file constitute Original Code as defined in and
- * are subject to the Apple Public Source License Version 1.1 (the
- * "License").  You may not use this file except in compliance with the
- * License.  Please obtain a copy of the License at
- * http://www.apple.com/publicsource and read it before using this file.
+ * This file contains Original Code and/or Modifications of Original Code
+ * as defined in and that are subject to the Apple Public Source License
+ * Version 2.0 (the 'License'). You may not use this file except in
+ * compliance with the License. The rights granted to you under the License
+ * may not be used to create, or enable the creation or redistribution of,
+ * unlawful or unlicensed copies of an Apple operating system, or to
+ * circumvent, violate, or enable the circumvention or violation of, any
+ * terms of an Apple operating system software license agreement.

  * 
  * 

- * This Original Code and all software distributed under the License are
- * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
+ * Please obtain a copy of the License at
+ * http://www.opensource.apple.com/apsl/ and read it before using this file.
+ * 
+ * The Original Code and all software distributed under the License are
+ * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER

  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,

- * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
- * License for the specific language governing rights and limitations
- * under the License.
+ * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
+ * Please see the License for the specific language governing rights and
+ * limitations under the License.

  * 
  * 

- * @APPLE_LICENSE_HEADER_END@
+ * @APPLE_OSREFERENCE_LICENSE_HEADER_END@

  */
  */

+#ifdef PRIVATE

 
 #ifndef _PPC_CPU_CAPABILITIES_H
 #define _PPC_CPU_CAPABILITIES_H
 
 
 #ifndef _PPC_CPU_CAPABILITIES_H
 #define _PPC_CPU_CAPABILITIES_H
 

-/* Sadly, some clients of this interface misspell __APPLE_API_PRIVATE.
- * To avoid breaking them, we accept the incorrect _APPLE_API_PRIVATE.
- */
-#ifdef _APPLE_API_PRIVATE
-#ifndef __APPLE_API_PRIVATE
-#define        __APPLE_API_PRIVATE
-#endif /* __APPLE_API_PRIVATE */
-#endif /* _APPLE_API_PRIVATE */
- 
-#ifndef __APPLE_API_PRIVATE
-#error cpu_capabilities.h is for Apple Internal use only
-#else  /* __APPLE_API_PRIVATE */
-

 /* _cpu_capabilities
  *
  * This is the authoritative way to determine from user mode what
  * implementation-specific processor features are available.
 /* _cpu_capabilities
  *
  * This is the authoritative way to determine from user mode what
  * implementation-specific processor features are available.

- * This API only supported for Apple internal use.
- * 
+ * This API is only supported for Apple internal use.

  */
 
 #ifndef        __ASSEMBLER__
  */
 
 #ifndef        __ASSEMBLER__


@@ -58,11 +51,12 @@ extern int _cpu_capabilities;
 #define        kCache64                                0x00000008
 #define        kCache128                               0x00000010
 #define        kDcbaRecommended                0x00000020      // PPC: dcba is available and recommended
 #define        kCache64                                0x00000008
 #define        kCache128                               0x00000010
 #define        kDcbaRecommended                0x00000020      // PPC: dcba is available and recommended

-#define        kDcbaAvailable                  0x00000040      // PPC: dcba is available but is not recommended
+#define        kDcbaAvailable                  0x00000040      // PPC: dcba is available (but may or may not be recommended)

 #define        kDataStreamsRecommended 0x00000080      // PPC: dst, dstt, dstst, dss, and dssall instructions available and recommended
 #define        kDataStreamsRecommended 0x00000080      // PPC: dst, dstt, dstst, dss, and dssall instructions available and recommended

-#define        kDataStreamsAvailable   0x00000100      // PPC: dst, dstt, dstst, dss, and dssall instructions available but not recommended
+#define        kDataStreamsAvailable   0x00000100      // PPC: dst, dstt, dstst, dss, and dssall instructions available (may or may not be rec'd)

 #define        kDcbtStreamsRecommended 0x00000200      // PPC: enhanced dcbt instruction available and recommended
 #define        kDcbtStreamsRecommended 0x00000200      // PPC: enhanced dcbt instruction available and recommended

-#define        kDcbtStreamsAvailable   0x00000400      // PPC: enhanced dcbt instruction available and recommended
+#define        kDcbtStreamsAvailable   0x00000400      // PPC: enhanced dcbt instruction available (but may or may not be recommended)
+#define        kFastThreadLocalStorage 0x00000800      // TLS ptr is kept in a user-mode-readable register

 
 #define        kUP                                             0x00008000      // set if (kNumCPUs == 1)
 #define        kNumCPUs                                0x00FF0000      // number of CPUs (see _NumCPUs() below)
 
 #define        kUP                                             0x00008000      // set if (kNumCPUs == 1)
 #define        kNumCPUs                                0x00FF0000      // number of CPUs (see _NumCPUs() below)


@@ -102,12 +96,57 @@ static __inline__ int _NumCPUs( void ) { return (_cpu_capabilities & kNumCPUs) >
 #define _COMM_PAGE_BASE_ADDRESS                        (-8*4096)                                               // start at page -8, ie 0xFFFF8000
 #define        _COMM_PAGE_AREA_LENGTH                  ( 7*4096)                                               // reserved length of entire comm area
 #define        _COMM_PAGE_AREA_USED                    ( 2*4096)                                               // we use two pages so far
 #define _COMM_PAGE_BASE_ADDRESS                        (-8*4096)                                               // start at page -8, ie 0xFFFF8000
 #define        _COMM_PAGE_AREA_LENGTH                  ( 7*4096)                                               // reserved length of entire comm area
 #define        _COMM_PAGE_AREA_USED                    ( 2*4096)                                               // we use two pages so far

+
+/* The following set of definitions are used in the kernel, which needs to distinguish between
+ * the 32 and 64-bit commpage addresses and lengths.  On PPC they are the same, but on Imtel
+ * they are not.
+ */
+#define _COMM_PAGE32_BASE_ADDRESS              ( _COMM_PAGE_BASE_ADDRESS )
+#define _COMM_PAGE64_BASE_ADDRESS              ( _COMM_PAGE_BASE_ADDRESS )
+#define        _COMM_PAGE32_AREA_LENGTH                ( _COMM_PAGE_AREA_LENGTH )
+#define        _COMM_PAGE64_AREA_LENGTH                ( _COMM_PAGE_AREA_LENGTH )
+#define        _COMM_PAGE32_AREA_USED                  ( _COMM_PAGE_AREA_USED )
+#define        _COMM_PAGE64_AREA_USED                  ( _COMM_PAGE_AREA_USED )
+
+/* The Objective-C runtime fixed address page to optimize message dispatch */
+#define _OBJC_PAGE_BASE_ADDRESS                        (-20*4096)                                              // start at page -20, ie 0xFFFEC000

  
  

+/*
+ * Objective-C needs an "absolute" area all the way up to the top of the
+ * address space.
+ * For a ppc32 task, that area gets allocated at runtime from user space.
+ * For a ppc64 task, that area is not within the user-accessible address range,
+ * so we pre-allocate it at exec time (see vm_map_exec()) along with the
+ * comm page.
+ * 
+ * NOTE: that means we can't "nest" the 64-bit comm page...
+ */
+#define _COMM_PAGE32_OBJC_SIZE 0ULL
+#define _COMM_PAGE32_OBJC_BASE 0ULL
+#if 0
+#define _COMM_PAGE64_OBJC_SIZE (4 * 4096)
+#define _COMM_PAGE64_OBJC_BASE (_OBJC_PAGE_BASE_ADDRESS)
+#else
+/*
+ * PPC51: ppc64 is limited to 51-bit addresses.
+ * PPC64 has a 51-bit address space limit, so we can't just go and
+ * map the Obj-C area up there.  We would have to create a nested pmap
+ * and make a special mapping that redirects the large virtual addresses to
+ * that other address space with lower addresses that fit within the 51-bit
+ * limit.
+ * VM would then have to handle this redirection when we fault one
+ * of these pages in but it doesn't do that at this point, so no
+ * Obj-C area for ppc64 for now :-(
+ */
+#define _COMM_PAGE64_OBJC_SIZE 0ULL
+#define _COMM_PAGE64_OBJC_BASE 0ULL
+#endif
+

 /* data in the comm page */
  
 #define _COMM_PAGE_SIGNATURE                   (_COMM_PAGE_BASE_ADDRESS+0x000) // first few bytes are a signature
 #define _COMM_PAGE_VERSION                             (_COMM_PAGE_BASE_ADDRESS+0x01E) // 16-bit version#
 /* data in the comm page */
  
 #define _COMM_PAGE_SIGNATURE                   (_COMM_PAGE_BASE_ADDRESS+0x000) // first few bytes are a signature
 #define _COMM_PAGE_VERSION                             (_COMM_PAGE_BASE_ADDRESS+0x01E) // 16-bit version#

-#define        _COMM_PAGE_THIS_VERSION                 1                                                               // this is version 1 of the commarea format
+#define        _COMM_PAGE_THIS_VERSION                 2                                                               // this is version 2 of the commarea format

   
 #define _COMM_PAGE_CPU_CAPABILITIES            (_COMM_PAGE_BASE_ADDRESS+0x020) // mirror of extern int _cpu_capabilities
 #define _COMM_PAGE_NCPUS                               (_COMM_PAGE_BASE_ADDRESS+0x021) // number of configured CPUs
   
 #define _COMM_PAGE_CPU_CAPABILITIES            (_COMM_PAGE_BASE_ADDRESS+0x020) // mirror of extern int _cpu_capabilities
 #define _COMM_PAGE_NCPUS                               (_COMM_PAGE_BASE_ADDRESS+0x021) // number of configured CPUs


@@ -115,22 +154,30 @@ static __inline__ int _NumCPUs( void ) { return (_cpu_capabilities & kNumCPUs) >
 #define _COMM_PAGE_64_BIT                              (_COMM_PAGE_BASE_ADDRESS+0x025) // nonzero if 64-bit processor
 #define _COMM_PAGE_CACHE_LINESIZE              (_COMM_PAGE_BASE_ADDRESS+0x026) // cache line size (16-bit field)
  
 #define _COMM_PAGE_64_BIT                              (_COMM_PAGE_BASE_ADDRESS+0x025) // nonzero if 64-bit processor
 #define _COMM_PAGE_CACHE_LINESIZE              (_COMM_PAGE_BASE_ADDRESS+0x026) // cache line size (16-bit field)
  

-#define _COMM_PAGE_UNUSED1                             (_COMM_PAGE_BASE_ADDRESS+0x030) // 16 unused bytes
+#define _COMM_PAGE_UNUSED1                             (_COMM_PAGE_BASE_ADDRESS+0x028) // 24 unused bytes

  
 #define _COMM_PAGE_2_TO_52                             (_COMM_PAGE_BASE_ADDRESS+0x040) // double float constant 2**52
 #define _COMM_PAGE_10_TO_6                             (_COMM_PAGE_BASE_ADDRESS+0x048) // double float constant 10**6
  
 #define _COMM_PAGE_2_TO_52                             (_COMM_PAGE_BASE_ADDRESS+0x040) // double float constant 2**52
 #define _COMM_PAGE_10_TO_6                             (_COMM_PAGE_BASE_ADDRESS+0x048) // double float constant 10**6

- 
-#define _COMM_PAGE_UNUSED2                             (_COMM_PAGE_BASE_ADDRESS+0x050) // 16 unused bytes
+#define _COMM_PAGE_MAGIC_FE             (_COMM_PAGE_BASE_ADDRESS+0x050) // magic constant 0xFEFEFEFEFEFEFEFF (to find 0s)
+#define _COMM_PAGE_MAGIC_80             (_COMM_PAGE_BASE_ADDRESS+0x058) // magic constant 0x8080808080808080 (to find 0s)

  
 #define _COMM_PAGE_TIMEBASE                            (_COMM_PAGE_BASE_ADDRESS+0x060) // used by gettimeofday()
 #define _COMM_PAGE_TIMESTAMP                   (_COMM_PAGE_BASE_ADDRESS+0x068) // used by gettimeofday()
 #define _COMM_PAGE_SEC_PER_TICK                        (_COMM_PAGE_BASE_ADDRESS+0x070) // used by gettimeofday()
  
  
 #define _COMM_PAGE_TIMEBASE                            (_COMM_PAGE_BASE_ADDRESS+0x060) // used by gettimeofday()
 #define _COMM_PAGE_TIMESTAMP                   (_COMM_PAGE_BASE_ADDRESS+0x068) // used by gettimeofday()
 #define _COMM_PAGE_SEC_PER_TICK                        (_COMM_PAGE_BASE_ADDRESS+0x070) // used by gettimeofday()
  

-#define _COMM_PAGE_UNUSED3                             (_COMM_PAGE_BASE_ADDRESS+0x080) // 384 unused bytes
- 

  /* jump table (bla to this address, which may be a branch to the actual code somewhere else) */
  /* When new jump table entries are added, corresponding symbols should be added below         */
  
  /* jump table (bla to this address, which may be a branch to the actual code somewhere else) */
  /* When new jump table entries are added, corresponding symbols should be added below         */
  

+#define _COMM_PAGE_COMPARE_AND_SWAP32   (_COMM_PAGE_BASE_ADDRESS+0x080) // compare-and-swap word, no barrier
+#define _COMM_PAGE_COMPARE_AND_SWAP64   (_COMM_PAGE_BASE_ADDRESS+0x0c0) // compare-and-swap doubleword, no barrier
+#define _COMM_PAGE_ENQUEUE                             (_COMM_PAGE_BASE_ADDRESS+0x100) // enqueue
+#define _COMM_PAGE_DEQUEUE                             (_COMM_PAGE_BASE_ADDRESS+0x140) // dequeue
+#define _COMM_PAGE_MEMORY_BARRIER              (_COMM_PAGE_BASE_ADDRESS+0x180) // memory barrier
+#define _COMM_PAGE_ATOMIC_ADD32                        (_COMM_PAGE_BASE_ADDRESS+0x1a0) // add atomic word
+#define _COMM_PAGE_ATOMIC_ADD64                        (_COMM_PAGE_BASE_ADDRESS+0x1c0) // add atomic doubleword
+
+#define _COMM_PAGE_UNUSED3                             (_COMM_PAGE_BASE_ADDRESS+0x1e0) // 32 unused bytes
+

 #define _COMM_PAGE_ABSOLUTE_TIME               (_COMM_PAGE_BASE_ADDRESS+0x200) // mach_absolute_time()
 #define _COMM_PAGE_SPINLOCK_TRY                        (_COMM_PAGE_BASE_ADDRESS+0x220) // spinlock_try()
 #define _COMM_PAGE_SPINLOCK_LOCK               (_COMM_PAGE_BASE_ADDRESS+0x260) // spinlock_lock()
 #define _COMM_PAGE_ABSOLUTE_TIME               (_COMM_PAGE_BASE_ADDRESS+0x200) // mach_absolute_time()
 #define _COMM_PAGE_SPINLOCK_TRY                        (_COMM_PAGE_BASE_ADDRESS+0x220) // spinlock_try()
 #define _COMM_PAGE_SPINLOCK_LOCK               (_COMM_PAGE_BASE_ADDRESS+0x260) // spinlock_lock()


@@ -140,7 +187,9 @@ static __inline__ int _NumCPUs( void ) { return (_cpu_capabilities & kNumCPUs) >
 #define _COMM_PAGE_FLUSH_DCACHE                        (_COMM_PAGE_BASE_ADDRESS+0x4e0) // sys_dcache_flush()
 #define _COMM_PAGE_FLUSH_ICACHE                        (_COMM_PAGE_BASE_ADDRESS+0x520) // sys_icache_invalidate()
 #define _COMM_PAGE_PTHREAD_SELF                        (_COMM_PAGE_BASE_ADDRESS+0x580) // pthread_self()
 #define _COMM_PAGE_FLUSH_DCACHE                        (_COMM_PAGE_BASE_ADDRESS+0x4e0) // sys_dcache_flush()
 #define _COMM_PAGE_FLUSH_ICACHE                        (_COMM_PAGE_BASE_ADDRESS+0x520) // sys_icache_invalidate()
 #define _COMM_PAGE_PTHREAD_SELF                        (_COMM_PAGE_BASE_ADDRESS+0x580) // pthread_self()

+

 #define        _COMM_PAGE_UNUSED4                              (_COMM_PAGE_BASE_ADDRESS+0x5a0) // 32 unused bytes
 #define        _COMM_PAGE_UNUSED4                              (_COMM_PAGE_BASE_ADDRESS+0x5a0) // 32 unused bytes

+

 #define        _COMM_PAGE_RELINQUISH                   (_COMM_PAGE_BASE_ADDRESS+0x5c0) // used by spinlocks
  
 #define _COMM_PAGE_UNUSED5                             (_COMM_PAGE_BASE_ADDRESS+0x5e0) // 32 unused bytes
 #define        _COMM_PAGE_RELINQUISH                   (_COMM_PAGE_BASE_ADDRESS+0x5c0) // used by spinlocks
  
 #define _COMM_PAGE_UNUSED5                             (_COMM_PAGE_BASE_ADDRESS+0x5e0) // 32 unused bytes


@@ -150,11 +199,13 @@ static __inline__ int _NumCPUs( void ) { return (_cpu_capabilities & kNumCPUs) >
 #define        _COMM_PAGE_MEMCPY                               (_COMM_PAGE_BASE_ADDRESS+0x7a0) // memcpy()
 #define        _COMM_PAGE_MEMMOVE                              (_COMM_PAGE_BASE_ADDRESS+0x7a0) // memmove()
 
 #define        _COMM_PAGE_MEMCPY                               (_COMM_PAGE_BASE_ADDRESS+0x7a0) // memcpy()
 #define        _COMM_PAGE_MEMMOVE                              (_COMM_PAGE_BASE_ADDRESS+0x7a0) // memmove()
 

-#define        _COMM_PAGE_UNUSED6                              (_COMM_PAGE_BASE_ADDRESS+0xF80) // 128 unused bytes
+#define _COMM_PAGE_COMPARE_AND_SWAP32B  (_COMM_PAGE_BASE_ADDRESS+0xf80)        // compare-and-swap word w barrier
+#define _COMM_PAGE_COMPARE_AND_SWAP64B  (_COMM_PAGE_BASE_ADDRESS+0xfc0)        // compare-and-swap doubleword w barrier

 
 

-#define        _COMM_PAGE_BIGCOPY                              (_COMM_PAGE_BASE_ADDRESS+0x1000)// very-long-operand copies
+#define        _COMM_PAGE_MEMSET_PATTERN       (_COMM_PAGE_BASE_ADDRESS+0x1000)// used by nonzero memset()
+#define        _COMM_PAGE_BIGCOPY                              (_COMM_PAGE_BASE_ADDRESS+0x1140)// very-long-operand copies

 
 

-#define _COMM_PAGE_END                                 (_COMM_PAGE_BASE_ADDRESS+0x1600)// end of common page
+#define _COMM_PAGE_END                                 (_COMM_PAGE_BASE_ADDRESS+0x1700)// end of commpage area

 
 #ifdef __ASSEMBLER__
 #ifdef __COMM_PAGE_SYMBOLS
 
 #ifdef __ASSEMBLER__
 #ifdef __COMM_PAGE_SYMBOLS


@@ -165,6 +216,13 @@ symbol_name: nop
 
        .text           // Required to make a well behaved symbol file
 
 
        .text           // Required to make a well behaved symbol file
 

+       CREATE_COMM_PAGE_SYMBOL(___compare_and_swap32, _COMM_PAGE_COMPARE_AND_SWAP32)
+       CREATE_COMM_PAGE_SYMBOL(___compare_and_swap64, _COMM_PAGE_COMPARE_AND_SWAP64)
+       CREATE_COMM_PAGE_SYMBOL(___atomic_enqueue, _COMM_PAGE_ENQUEUE)
+       CREATE_COMM_PAGE_SYMBOL(___atomic_dequeue, _COMM_PAGE_DEQUEUE)
+       CREATE_COMM_PAGE_SYMBOL(___memory_barrier, _COMM_PAGE_MEMORY_BARRIER)
+       CREATE_COMM_PAGE_SYMBOL(___atomic_add32, _COMM_PAGE_ATOMIC_ADD32)
+       CREATE_COMM_PAGE_SYMBOL(___atomic_add64, _COMM_PAGE_ATOMIC_ADD64)

        CREATE_COMM_PAGE_SYMBOL(___mach_absolute_time, _COMM_PAGE_ABSOLUTE_TIME)
        CREATE_COMM_PAGE_SYMBOL(___spin_lock_try, _COMM_PAGE_SPINLOCK_TRY)
        CREATE_COMM_PAGE_SYMBOL(___spin_lock, _COMM_PAGE_SPINLOCK_LOCK)
        CREATE_COMM_PAGE_SYMBOL(___mach_absolute_time, _COMM_PAGE_ABSOLUTE_TIME)
        CREATE_COMM_PAGE_SYMBOL(___spin_lock_try, _COMM_PAGE_SPINLOCK_TRY)
        CREATE_COMM_PAGE_SYMBOL(___spin_lock, _COMM_PAGE_SPINLOCK_LOCK)


@@ -179,7 +237,11 @@ symbol_name: nop
        CREATE_COMM_PAGE_SYMBOL(___bcopy, _COMM_PAGE_BCOPY)
        CREATE_COMM_PAGE_SYMBOL(___memcpy, _COMM_PAGE_MEMCPY)
 //     CREATE_COMM_PAGE_SYMBOL(___memmove, _COMM_PAGE_MEMMOVE)
        CREATE_COMM_PAGE_SYMBOL(___bcopy, _COMM_PAGE_BCOPY)
        CREATE_COMM_PAGE_SYMBOL(___memcpy, _COMM_PAGE_MEMCPY)
 //     CREATE_COMM_PAGE_SYMBOL(___memmove, _COMM_PAGE_MEMMOVE)

+       CREATE_COMM_PAGE_SYMBOL(___compare_and_swap32b, _COMM_PAGE_COMPARE_AND_SWAP32B)
+       CREATE_COMM_PAGE_SYMBOL(___compare_and_swap64b, _COMM_PAGE_COMPARE_AND_SWAP64B)
+    CREATE_COMM_PAGE_SYMBOL(___memset_pattern, _COMM_PAGE_MEMSET_PATTERN)

        CREATE_COMM_PAGE_SYMBOL(___bigcopy, _COMM_PAGE_BIGCOPY)
        CREATE_COMM_PAGE_SYMBOL(___bigcopy, _COMM_PAGE_BIGCOPY)

+       

        CREATE_COMM_PAGE_SYMBOL(___end_comm_page, _COMM_PAGE_END)
 
        .data           // Required to make a well behaved symbol file
        CREATE_COMM_PAGE_SYMBOL(___end_comm_page, _COMM_PAGE_END)
 
        .data           // Required to make a well behaved symbol file


@@ -188,5 +250,5 @@ symbol_name: nop
 #endif /* __COMM_PAGE_SYMBOLS */
 #endif /* __ASSEMBLER__ */
 
 #endif /* __COMM_PAGE_SYMBOLS */
 #endif /* __ASSEMBLER__ */
 

-#endif /* __APPLE_API_PRIVATE */

 #endif /* _PPC_CPU_CAPABILITIES_H */
 #endif /* _PPC_CPU_CAPABILITIES_H */

+#endif /* PRIVATE */