include/asm-frv/semaphore.h

   1 /* semaphore.h: semaphores for the FR-V
   2  *
   3  * Copyright (C) 2003 Red Hat, Inc. All Rights Reserved.
   4  * Written by David Howells (dhowells@redhat.com)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version
   9  * 2 of the License, or (at your option) any later version.
  10  */
  11 #ifndef _ASM_SEMAPHORE_H
  12 #define _ASM_SEMAPHORE_H
  13
  14 #define RW_LOCK_BIAS             0x01000000
  15
  16 #ifndef __ASSEMBLY__
  17
  18 #include <linux/linkage.h>
  19 #include <linux/wait.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/rwsem.h>
  22
  23 /*
  24  * the semaphore definition
  25  * - if counter is >0 then there are tokens available on the semaphore for down to collect
  26  * - if counter is <=0 then there are no spare tokens, and anyone that wants one must wait
  27  * - if wait_list is not empty, then there are processes waiting for the semaphore
  28  */
  29 struct semaphore {
  30         unsigned                counter;
  31         spinlock_t              wait_lock;
  32         struct list_head        wait_list;
  33 #ifdef CONFIG_DEBUG_SEMAPHORE
  34         unsigned                __magic;
  35 #endif
  36 };
  37
  38 #ifdef CONFIG_DEBUG_SEMAPHORE
  39 # define __SEM_DEBUG_INIT(name) , (long)&(name).__magic
  40 #else
  41 # define __SEM_DEBUG_INIT(name)
  42 #endif
  43
  44
  45 #define __SEMAPHORE_INITIALIZER(name,count) \
  46 { count, SPIN_LOCK_UNLOCKED, LIST_HEAD_INIT((name).wait_list) __SEM_DEBUG_INIT(name) }
  47
  48 #define __DECLARE_SEMAPHORE_GENERIC(name,count) \
  49         struct semaphore name = __SEMAPHORE_INITIALIZER(name,count)
  50
  51 #define DECLARE_MUTEX(name) __DECLARE_SEMAPHORE_GENERIC(name,1)
  52
  53 static inline void sema_init (struct semaphore *sem, int val)
  54 {
  55         *sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
  56 }
  57
  58 static inline void init_MUTEX (struct semaphore *sem)
  59 {
  60         sema_init(sem, 1);
  61 }
  62
  63 static inline void init_MUTEX_LOCKED (struct semaphore *sem)
  64 {
  65         sema_init(sem, 0);
  66 }
  67
  68 extern void __down(struct semaphore *sem, unsigned long flags);
  69 extern int  __down_interruptible(struct semaphore *sem, unsigned long flags);
  70 extern void __up(struct semaphore *sem);
  71
  72 static inline void down(struct semaphore *sem)
  73 {
  74         unsigned long flags;
  75
  76 #ifdef CONFIG_DEBUG_SEMAPHORE
  77         CHECK_MAGIC(sem->__magic);
  78 #endif
  79
  80         spin_lock_irqsave(&sem->wait_lock, flags);
  81         if (likely(sem->counter > 0)) {
  82                 sem->counter--;
  83                 spin_unlock_irqrestore(&sem->wait_lock, flags);
  84         }
  85         else {
  86                 __down(sem, flags);
  87         }
  88 }
  89
  90 static inline int down_interruptible(struct semaphore *sem)
  91 {
  92         unsigned long flags;
  93         int ret = 0;
  94
  95 #ifdef CONFIG_DEBUG_SEMAPHORE
  96         CHECK_MAGIC(sem->__magic);
  97 #endif
  98
  99         spin_lock_irqsave(&sem->wait_lock, flags);
 100         if (likely(sem->counter > 0)) {
 101                 sem->counter--;
 102                 spin_unlock_irqrestore(&sem->wait_lock, flags);
 103         }
 104         else {
 105                 ret = __down_interruptible(sem, flags);
 106         }
 107         return ret;
 108 }
 109
 110 /*
 111  * non-blockingly attempt to down() a semaphore.
 112  * - returns zero if we acquired it
 113  */
 114 static inline int down_trylock(struct semaphore *sem)
 115 {
 116         unsigned long flags;
 117         int success = 0;
 118
 119 #ifdef CONFIG_DEBUG_SEMAPHORE
 120         CHECK_MAGIC(sem->__magic);
 121 #endif
 122
 123         spin_lock_irqsave(&sem->wait_lock, flags);
 124         if (sem->counter > 0) {
 125                 sem->counter--;
 126                 success = 1;
 127         }
 128         spin_unlock_irqrestore(&sem->wait_lock, flags);
 129         return !success;
 130 }
 131
 132 static inline void up(struct semaphore *sem)
 133 {
 134         unsigned long flags;
 135
 136 #ifdef CONFIG_DEBUG_SEMAPHORE
 137         CHECK_MAGIC(sem->__magic);
 138 #endif
 139
 140         spin_lock_irqsave(&sem->wait_lock, flags);
 141         if (!list_empty(&sem->wait_list))
 142                 __up(sem);
 143         else
 144                 sem->counter++;
 145         spin_unlock_irqrestore(&sem->wait_lock, flags);
 146 }
 147
 148 static inline int sem_getcount(struct semaphore *sem)
 149 {
 150         return sem->counter;
 151 }
 152
 153 #endif /* __ASSEMBLY__ */
 154
 155 #endif