LXR linux/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
  27typedef 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 */
 126