Commit | Line | Data |
---|---|---|
867e359b CM |
1 | /* |
2 | * Copyright 2010 Tilera Corporation. All Rights Reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public License | |
6 | * as published by the Free Software Foundation, version 2. | |
7 | * | |
8 | * This program is distributed in the hope that it will be useful, but | |
9 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
10 | * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE, GOOD TITLE or | |
11 | * NON INFRINGEMENT. See the GNU General Public License for | |
12 | * more details. | |
13 | * | |
14 | * 32-bit SMP spinlocks. | |
15 | */ | |
16 | ||
17 | #ifndef _ASM_TILE_SPINLOCK_32_H | |
18 | #define _ASM_TILE_SPINLOCK_32_H | |
19 | ||
60063497 | 20 | #include <linux/atomic.h> |
867e359b CM |
21 | #include <asm/page.h> |
22 | #include <asm/system.h> | |
23 | #include <linux/compiler.h> | |
24 | ||
25 | /* | |
26 | * We only use even ticket numbers so the '1' inserted by a tns is | |
27 | * an unambiguous "ticket is busy" flag. | |
28 | */ | |
29 | #define TICKET_QUANTUM 2 | |
30 | ||
31 | ||
32 | /* | |
33 | * SMP ticket spinlocks, allowing only a single CPU anywhere | |
34 | * | |
35 | * (the type definitions are in asm/spinlock_types.h) | |
36 | */ | |
37 | static inline int arch_spin_is_locked(arch_spinlock_t *lock) | |
38 | { | |
39 | /* | |
40 | * Note that even if a new ticket is in the process of being | |
41 | * acquired, so lock->next_ticket is 1, it's still reasonable | |
42 | * to claim the lock is held, since it will be momentarily | |
43 | * if not already. There's no need to wait for a "valid" | |
44 | * lock->next_ticket to become available. | |
45 | */ | |
46 | return lock->next_ticket != lock->current_ticket; | |
47 | } | |
48 | ||
49 | void arch_spin_lock(arch_spinlock_t *lock); | |
50 | ||
51 | /* We cannot take an interrupt after getting a ticket, so don't enable them. */ | |
52 | #define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock) | |
53 | ||
54 | int arch_spin_trylock(arch_spinlock_t *lock); | |
55 | ||
56 | static inline void arch_spin_unlock(arch_spinlock_t *lock) | |
57 | { | |
58 | /* For efficiency, overlap fetching the old ticket with the wmb(). */ | |
59 | int old_ticket = lock->current_ticket; | |
60 | wmb(); /* guarantee anything modified under the lock is visible */ | |
61 | lock->current_ticket = old_ticket + TICKET_QUANTUM; | |
62 | } | |
63 | ||
64 | void arch_spin_unlock_wait(arch_spinlock_t *lock); | |
65 | ||
66 | /* | |
67 | * Read-write spinlocks, allowing multiple readers | |
68 | * but only one writer. | |
69 | * | |
70 | * We use a "tns/store-back" technique on a single word to manage | |
71 | * the lock state, looping around to retry if the tns returns 1. | |
72 | */ | |
73 | ||
74 | /* Internal layout of the word; do not use. */ | |
75 | #define _WR_NEXT_SHIFT 8 | |
76 | #define _WR_CURR_SHIFT 16 | |
77 | #define _WR_WIDTH 8 | |
78 | #define _RD_COUNT_SHIFT 24 | |
79 | #define _RD_COUNT_WIDTH 8 | |
80 | ||
867e359b CM |
81 | /** |
82 | * arch_read_can_lock() - would read_trylock() succeed? | |
83 | */ | |
84 | static inline int arch_read_can_lock(arch_rwlock_t *rwlock) | |
85 | { | |
86 | return (rwlock->lock << _RD_COUNT_WIDTH) == 0; | |
87 | } | |
88 | ||
89 | /** | |
90 | * arch_write_can_lock() - would write_trylock() succeed? | |
91 | */ | |
92 | static inline int arch_write_can_lock(arch_rwlock_t *rwlock) | |
93 | { | |
94 | return rwlock->lock == 0; | |
95 | } | |
96 | ||
97 | /** | |
98 | * arch_read_lock() - acquire a read lock. | |
99 | */ | |
3c5ead52 | 100 | void arch_read_lock(arch_rwlock_t *rwlock); |
867e359b CM |
101 | |
102 | /** | |
3c5ead52 | 103 | * arch_write_lock() - acquire a write lock. |
867e359b | 104 | */ |
3c5ead52 | 105 | void arch_write_lock(arch_rwlock_t *rwlock); |
867e359b CM |
106 | |
107 | /** | |
108 | * arch_read_trylock() - try to acquire a read lock. | |
109 | */ | |
3c5ead52 | 110 | int arch_read_trylock(arch_rwlock_t *rwlock); |
867e359b CM |
111 | |
112 | /** | |
113 | * arch_write_trylock() - try to acquire a write lock. | |
114 | */ | |
3c5ead52 | 115 | int arch_write_trylock(arch_rwlock_t *rwlock); |
867e359b CM |
116 | |
117 | /** | |
118 | * arch_read_unlock() - release a read lock. | |
119 | */ | |
3c5ead52 | 120 | void arch_read_unlock(arch_rwlock_t *rwlock); |
867e359b CM |
121 | |
122 | /** | |
123 | * arch_write_unlock() - release a write lock. | |
124 | */ | |
3c5ead52 | 125 | void arch_write_unlock(arch_rwlock_t *rwlock); |
867e359b CM |
126 | |
127 | #define arch_read_lock_flags(lock, flags) arch_read_lock(lock) | |
128 | #define arch_write_lock_flags(lock, flags) arch_write_lock(lock) | |
129 | ||
130 | #endif /* _ASM_TILE_SPINLOCK_32_H */ |