sys/arch/arm/include/lock.h

   1 /*      $NetBSD: lock.h,v 1.16 2008/04/27 18:58:44 matt Exp $   */
   2
   3 /*-
   4  * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Jason R. Thorpe.
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 /*
  33  * Machine-dependent spin lock operations.
  34  *
  35  * NOTE: The SWP insn used here is available only on ARM architecture
  36  * version 3 and later (as well as 2a).  What we are going to do is
  37  * expect that the kernel will trap and emulate the insn.  That will
  38  * be slow, but give us the atomicity that we need.
  39  */
  40
  41 #ifndef _ARM_LOCK_H_
  42 #define _ARM_LOCK_H_
  43
  44 static __inline int
  45 __SIMPLELOCK_LOCKED_P(__cpu_simple_lock_t *__ptr)
  46 {
  47         return *__ptr == __SIMPLELOCK_LOCKED;
  48 }
  49
  50 static __inline int
  51 __SIMPLELOCK_UNLOCKED_P(__cpu_simple_lock_t *__ptr)
  52 {
  53         return *__ptr == __SIMPLELOCK_UNLOCKED;
  54 }
  55
  56 static __inline void
  57 __cpu_simple_lock_clear(__cpu_simple_lock_t *__ptr)
  58 {
  59         *__ptr = __SIMPLELOCK_UNLOCKED;
  60 }
  61
  62 static __inline void
  63 __cpu_simple_lock_set(__cpu_simple_lock_t *__ptr)
  64 {
  65         *__ptr = __SIMPLELOCK_LOCKED;
  66 }
  67
  68 #ifdef _KERNEL
  69 #include <arm/cpufunc.h>
  70
  71 #define mb_read         drain_writebuf          /* in cpufunc.h */
  72 #define mb_write        drain_writebuf          /* in cpufunc.h */
  73 #define mb_memory       drain_writebuf          /* in cpufunc.h */
  74 #endif
  75
  76 #if defined(_KERNEL)
  77 static __inline int
  78 __swp(int __val, volatile unsigned char *__ptr)
  79 {
  80
  81         __asm volatile("swpb %0, %1, [%2]"
  82             : "=&r" (__val) : "r" (__val), "r" (__ptr) : "memory");
  83         return __val;
  84 }
  85 #else
  86 static __inline int
  87 __swp(int __val, volatile int *__ptr)
  88 {
  89
  90         __asm volatile("swp %0, %1, [%2]"
  91             : "=&r" (__val) : "r" (__val), "r" (__ptr) : "memory");
  92         return __val;
  93 }
  94 #endif /* _KERNEL */
  95
  96 static __inline void __attribute__((__unused__))
  97 __cpu_simple_lock_init(__cpu_simple_lock_t *alp)
  98 {
  99
 100         *alp = __SIMPLELOCK_UNLOCKED;
 101 }
 102
 103 static __inline void __attribute__((__unused__))
 104 __cpu_simple_lock(__cpu_simple_lock_t *alp)
 105 {
 106
 107         while (__swp(__SIMPLELOCK_LOCKED, alp) != __SIMPLELOCK_UNLOCKED)
 108                 continue;
 109 }
 110
 111 static __inline int __attribute__((__unused__))
 112 __cpu_simple_lock_try(__cpu_simple_lock_t *alp)
 113 {
 114
 115         return (__swp(__SIMPLELOCK_LOCKED, alp) == __SIMPLELOCK_UNLOCKED);
 116 }
 117
 118 static __inline void __attribute__((__unused__))
 119 __cpu_simple_unlock(__cpu_simple_lock_t *alp)
 120 {
 121
 122         *alp = __SIMPLELOCK_UNLOCKED;
 123 }
 124
 125 #endif /* _ARM_LOCK_H_ */