cdcm/cdcmBoth.h

   1 /**
   2  * @file cdcmBoth.h
   3  *
   4  * @brief header file with helpers for both Linux and Lynx
   5  *
   6  * Copyright (c) 2006-2009 CERN
   7  * @author Yury Georgievskiy <yury.georgievskiy@cern.ch>
   8  *
   9  * Copyright (c) 2009 CERN
  10  * @author Emilio G. Cota <emilio.garcia.cota@cern.ch>
  11  *
  12  * @section license_sec License
  13  * Released under the GPL v2. (and only v2, not any later version)
  14  */
  15
  16 #ifndef _CDCM_BOTH_H_INCLUDE_
  17 #define _CDCM_BOTH_H_INCLUDE_
  18
  19 #ifdef __linux__
  20
  21 #include <linux/spinlock.h>
  22 #include <linux/mutex.h>
  23 #include <linux/fs.h>
  24
  25 #include <asm/byteorder.h>
  26
  27 #include "cdcmDrvr.h"
  28
  29
  30 /*
  31  * Endianness definitions
  32  */
  33 #if defined(__LITTLE_ENDIAN) && defined(__BIG_ENDIAN)
  34 # error CDCM: Fix asm/byteorder.h to define one endianness.
  35 #endif
  36
  37 #if !defined(__LITTLE_ENDIAN) && !defined(__BIG_ENDIAN)
  38 # error CDCM: Fix asm/byteorder.h to define one endianness.
  39 #endif
  40
  41 #if defined(__LITTLE_ENDIAN)
  42 #define CDCM_LITTLE_ENDIAN 1234
  43 #else /* __BIG_ENDIAN */
  44 #define CDCM_BIG_ENDIAN 4321
  45 #endif
  46
  47 /*
  48  * ms_to_ticks, ticks_to_ms conversion
  49  */
  50 #define cdcm_ticks_to_ms(x) ((x) * 1000 / HZ)
  51 #define cdcm_ms_to_ticks(x) ((x) * HZ / 1000)
  52
  53 /*
  54  * CDCM Spinlocks: wrap Linux' spinlocks
  55  */
  56 typedef struct {
  57         spinlock_t lock;
  58 } cdcm_spinlock_t;
  59
  60 #define cdcm_spin_lock_init(cdcm) spin_lock_init(&(cdcm)->lock)
  61
  62 #define cdcm_spin_lock_irqsave(cdcm, flags)             \
  63                 spin_lock_irqsave(&(cdcm)->lock, flags)
  64
  65 #define cdcm_spin_unlock_irqrestore(cdcm, flags)                \
  66                 spin_unlock_irqrestore(&(cdcm)->lock, flags)
  67
  68 #define __CDCM_SPINLOCK_UNLOCKED(name) {                        \
  69                 .lock = __SPIN_LOCK_UNLOCKED(name.lock), }
  70
  71 /*
  72  * Mutexes: wrap Linux' mutexes
  73  */
  74 struct cdcm_mutex {
  75         struct mutex mutex;
  76 };
  77
  78 #define __CDCM_MUTEX_INIT(name) \
  79         (struct cdcm_mutex) {   .mutex = DEFINE_MUTEX(name.mutex) }
  80 #define cdcm_mutex_init(cdcm)   mutex_init(&(cdcm)->mutex)
  81 #define cdcm_mutex_lock(cdcm)   mutex_lock(&(cdcm)->mutex)
  82 #define cdcm_mutex_unlock(cdcm) mutex_unlock(&(cdcm)->mutex)
  83 #define cdcm_mutex_lock_interruptible(cdcm) \
  84                 mutex_lock_interruptible(&(cdcm)->mutex)
  85
  86
  87
  88 #else /* LynxOS */
  89
  90
  91 #include <kernel.h>
  92 #include <conf.h>
  93
  94 /*
  95  * Endianness definitions
  96  */
  97 #if defined(__LITTLE_ENDIAN__) && defined(__BIG_ENDIAN__)
  98 # error CDCM: Conflicting endianities defined in this machine.
  99 #endif
 100
 101 #if !defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)
 102 # error CDCM: Conflicting endianities defined in this machine.
 103 #endif
 104
 105 #if defined(__LITTLE_ENDIAN__)
 106 #define CDCM_LITTLE_ENDIAN 1234
 107 #else /* __BIG_ENDIAN__ */
 108 #define CDCM_BIG_ENDIAN 4321
 109 #endif
 110
 111 /*
 112  * ms_to_ticks, ticks_to_ms conversion
 113  */
 114 #define cdcm_ticks_to_ms(x) ((x) * 1000 / TICKSPERSEC)
 115 #define cdcm_ms_to_ticks(x) ((x) * TICKSPERSEC / 1000)
 116
 117 /*
 118  * CDCM Spinlocks: mimic Linux' spinlocks
 119  * In Lynx, we just use the only available primitives (disable/restore)
 120  * We use 'int foo' in Lynx to avoid compiler warnings (i.e. unused struct)
 121  */
 122 typedef struct {
 123         /* no individual locks in LynxOS */
 124         int foo;
 125 } cdcm_spinlock_t;
 126
 127 /*
 128  * Note: foo is just used to actually do something on the struct,
 129  * but it has no logical significance. As it is now, 'foo' refers
 130  * to the lock's state: 0 (unlocked), 1 (locked), but really, there's
 131  * no code that should ever need to rely on this value. So simply ignore it.
 132  */
 133 #define _lynx_lock_init(cdcm)           \
 134         do {                            \
 135                 (cdcm)->foo = 0;        \
 136         } while (0)                     \
 137
 138 #define __CDCM_SPINLOCK_UNLOCKED(lockname) { \
 139                 .foo = 0, }
 140
 141 #define _lynx_lock(cdcm, flags) \
 142         do {                            \
 143                 disable(flags);         \
 144                 (cdcm)->foo = 1;        \
 145         } while (0)
 146
 147 #define _lynx_unlock(cdcm, flags)       \
 148         do {                            \
 149                 (cdcm)->foo = 0;        \
 150                 restore(flags);         \
 151         } while (0)
 152
 153 #define cdcm_spin_lock_init(cdcm)                 _lynx_lock_init(cdcm)
 154 #define cdcm_spin_lock_irqsave(cdcm, flags)       _lynx_lock(cdcm, flags)
 155 #define cdcm_spin_unlock_irqrestore(cdcm, flags)  _lynx_unlock(cdcm, flags)
 156
 157 /*
 158  * Mutexes: make them Linux-like, calling ssignal/swait in Lynx
 159  */
 160 struct cdcm_mutex {
 161         int sem;
 162 };
 163
 164 #define __CDCM_MUTEX_INIT(name) \
 165         (struct cdcm_mutex) {   .sem = 1 }
 166 #define cdcm_mutex_init(cdcm)           do { (cdcm)->sem = 1; } while (0)
 167 #define cdcm_mutex_lock(cdcm)           swait(&(cdcm)->sem, SEM_SIGIGNORE)
 168 #define cdcm_mutex_unlock(cdcm)         ssignal(&(cdcm)->sem)
 169 #define cdcm_mutex_lock_interruptible(cdcm) \
 170                 swait(&(cdcm)->sem, SEM_SIGABORT)
 171
 172 #endif /* !__linux__ */
 173
 174
 175
 176 /*
 177  * Common Linux and Lynx
 178  */
 179
 180 #define CDCM_DEFINE_SPINLOCK(x) \
 181                 cdcm_spinlock_t x = __CDCM_SPINLOCK_UNLOCKED(x)
 182 /* statically define a mutex */
 183 #define CDCM_MUTEX(x) struct cdcm_mutex x = __CDCM_MUTEX_INIT(x)
 184
 185 /*
 186  * The extern declaration of these functions is mainly for Lynx, since For Linux,
 187  * they need to be declared as extern before being used. For Linux,
 188  * they're declared (as non-extern) in cdcmLynxAPI.h.
 189  */
 190 extern int ksprintf(char *buf, char *format, ...);
 191 extern void usec_sleep(unsigned long usecs);
 192 extern int scount(int *semaphore);
 193
 194 /*
 195  * Common function signatures
 196  */
 197 int cdcm_copy_from_user(void *, void *, int);
 198 int cdcm_copy_to_user(void *, void *, int);
 199
 200 #ifdef __Lynx__
 201 #define CDCM_LOOP_AGAIN
 202 #endif
 203
 204 #endif /* _CDCM_BOTH_H_INCLUDE_ */