arch/mn10300/include/asm/rwlock.h

   1 /*
   2  * Helpers used by both rw spinlocks and rw semaphores.
   3  *
   4  * Based in part on code from semaphore.h and
   5  * spinlock.h Copyright 1996 Linus Torvalds.
   6  *
   7  * Copyright 1999 Red Hat, Inc.
   8  *
   9  * Written by Benjamin LaHaise.
  10  *
  11  * Modified by Matsushita Electric Industrial Co., Ltd.
  12  * Modifications:
  13  * 13-Nov-2006 MEI Temporarily delete lock functions for SMP support.
  14  *
  15  * This program is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU General Public License as published by the Free
  17  * Software Foundation; either version 2 of the License, or (at your option)
  18  * any later version.
  19  */
  20 #ifndef _ASM_RWLOCK_H
  21 #define _ASM_RWLOCK_H
  22
  23 #define RW_LOCK_BIAS             0x01000000
  24
  25 #ifndef CONFIG_SMP
  26
  27 typedef struct { unsigned long a[100]; } __dummy_lock_t;
  28 #define __dummy_lock(lock) (*(__dummy_lock_t *)(lock))
  29
  30 #define RW_LOCK_BIAS_STR        "0x01000000"
  31
  32 #define __build_read_lock_ptr(rw, helper)                               \
  33         do {                                                            \
  34                 asm volatile(                                           \
  35                         "       mov     (%0),d3                 \n"     \
  36                         "       sub     1,d3                    \n"     \
  37                         "       mov     d3,(%0)                 \n"     \
  38                         "       blt     1f                      \n"     \
  39                         "       bra     2f                      \n"     \
  40                         "1:     jmp     3f                      \n"     \
  41                         "2:                                     \n"     \
  42                         "       .section .text.lock,\"ax\"      \n"     \
  43                         "3:     call    "helper"[],0            \n"     \
  44                         "       jmp     2b                      \n"     \
  45                         "       .previous"                              \
  46                         :                                               \
  47                         : "d" (rw)                                      \
  48                         : "memory", "d3", "cc");                        \
  49         } while (0)
  50
  51 #define __build_read_lock_const(rw, helper)                             \
  52         do {                                                            \
  53                 asm volatile(                                           \
  54                         "       mov     (%0),d3                 \n"     \
  55                         "       sub     1,d3                    \n"     \
  56                         "       mov     d3,(%0)                 \n"     \
  57                         "       blt     1f                      \n"     \
  58                         "       bra     2f                      \n"     \
  59                         "1:     jmp     3f                      \n"     \
  60                         "2:                                     \n"     \
  61                         "       .section .text.lock,\"ax\"      \n"     \
  62                         "3:     call    "helper"[],0            \n"     \
  63                         "       jmp     2b                      \n"     \
  64                         "       .previous"                              \
  65                         :                                               \
  66                         : "d" (rw)                                      \
  67                         : "memory", "d3", "cc");                        \
  68         } while (0)
  69
  70 #define __build_read_lock(rw, helper) \
  71         do {                                                            \
  72                 if (__builtin_constant_p(rw))                           \
  73                         __build_read_lock_const(rw, helper);            \
  74                 else                                                    \
  75                         __build_read_lock_ptr(rw, helper);              \
  76         } while (0)
  77
  78 #define __build_write_lock_ptr(rw, helper)                              \
  79         do {                                                            \
  80                 asm volatile(                                           \
  81                         "       mov     (%0),d3                 \n"     \
  82                         "       sub     1,d3                    \n"     \
  83                         "       mov     d3,(%0)                 \n"     \
  84                         "       blt     1f                      \n"     \
  85                         "       bra     2f                      \n"     \
  86                         "1:     jmp     3f                      \n"     \
  87                         "2:                                     \n"     \
  88                         "       .section .text.lock,\"ax\"      \n"     \
  89                         "3:     call    "helper"[],0            \n"     \
  90                         "       jmp     2b                      \n"     \
  91                         "       .previous"                              \
  92                         :                                               \
  93                         : "d" (rw)                                      \
  94                         : "memory", "d3", "cc");                        \
  95         } while (0)
  96
  97 #define __build_write_lock_const(rw, helper)                            \
  98         do {                                                            \
  99                 asm volatile(                                           \
 100                         "       mov     (%0),d3                 \n"     \
 101                         "       sub     1,d3                    \n"     \
 102                         "       mov     d3,(%0)                 \n"     \
 103                         "       blt     1f                      \n"     \
 104                         "       bra     2f                      \n"     \
 105                         "1:     jmp     3f                      \n"     \
 106                         "2:                                     \n"     \
 107                         "       .section .text.lock,\"ax\"      \n"     \
 108                         "3:     call    "helper"[],0            \n"     \
 109                         "       jmp     2b                      \n"     \
 110                         "       .previous"                              \
 111                         :                                               \
 112                         : "d" (rw)                                      \
 113                         : "memory", "d3", "cc");                        \
 114         } while (0)
 115
 116 #define __build_write_lock(rw, helper)                                  \
 117         do {                                                            \
 118                 if (__builtin_constant_p(rw))                           \
 119                         __build_write_lock_const(rw, helper);           \
 120                 else                                                    \
 121                         __build_write_lock_ptr(rw, helper);             \
 122         } while (0)
 123
 124 #endif /* CONFIG_SMP */
 125 #endif /* _ASM_RWLOCK_H */