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 | 21 | #include <asm/page.h> |
867e359b CM |
22 | #include <linux/compiler.h> |
23 | ||
24 | /* | |
25 | * We only use even ticket numbers so the '1' inserted by a tns is | |
26 | * an unambiguous "ticket is busy" flag. | |
27 | */ | |
28 | #define TICKET_QUANTUM 2 | |
29 | ||
30 | ||
31 | /* | |
32 | * SMP ticket spinlocks, allowing only a single CPU anywhere | |
33 | * | |
34 | * (the type definitions are in asm/spinlock_types.h) | |
35 | */ | |
36 | static inline int arch_spin_is_locked(arch_spinlock_t *lock) | |
37 | { | |
38 | /* | |
39 | * Note that even if a new ticket is in the process of being | |
40 | * acquired, so lock->next_ticket is 1, it's still reasonable | |
41 | * to claim the lock is held, since it will be momentarily | |
42 | * if not already. There's no need to wait for a "valid" | |
43 | * lock->next_ticket to become available. | |
627ae548 | 44 | * Use READ_ONCE() to ensure that calling this in a loop is OK. |
867e359b | 45 | */ |
627ae548 CM |
46 | int curr = READ_ONCE(lock->current_ticket); |
47 | int next = READ_ONCE(lock->next_ticket); | |
48 | ||
49 | return next != curr; | |
867e359b CM |
50 | } |
51 | ||
52 | void arch_spin_lock(arch_spinlock_t *lock); | |
53 | ||
54 | /* We cannot take an interrupt after getting a ticket, so don't enable them. */ | |
55 | #define arch_spin_lock_flags(lock, flags) arch_spin_lock(lock) | |
56 | ||
57 | int arch_spin_trylock(arch_spinlock_t *lock); | |
58 | ||
59 | static inline void arch_spin_unlock(arch_spinlock_t *lock) | |
60 | { | |
61 | /* For efficiency, overlap fetching the old ticket with the wmb(). */ | |
62 | int old_ticket = lock->current_ticket; | |
63 | wmb(); /* guarantee anything modified under the lock is visible */ | |
64 | lock->current_ticket = old_ticket + TICKET_QUANTUM; | |
65 | } | |
66 | ||
867e359b CM |
67 | /* |
68 | * Read-write spinlocks, allowing multiple readers | |
69 | * but only one writer. | |
70 | * | |
71 | * We use a "tns/store-back" technique on a single word to manage | |
72 | * the lock state, looping around to retry if the tns returns 1. | |
73 | */ | |
74 | ||
75 | /* Internal layout of the word; do not use. */ | |
76 | #define _WR_NEXT_SHIFT 8 | |
77 | #define _WR_CURR_SHIFT 16 | |
78 | #define _WR_WIDTH 8 | |
79 | #define _RD_COUNT_SHIFT 24 | |
80 | #define _RD_COUNT_WIDTH 8 | |
81 | ||
867e359b CM |
82 | /** |
83 | * arch_read_can_lock() - would read_trylock() succeed? | |
84 | */ | |
85 | static inline int arch_read_can_lock(arch_rwlock_t *rwlock) | |
86 | { | |
87 | return (rwlock->lock << _RD_COUNT_WIDTH) == 0; | |
88 | } | |
89 | ||
90 | /** | |
91 | * arch_write_can_lock() - would write_trylock() succeed? | |
92 | */ | |
93 | static inline int arch_write_can_lock(arch_rwlock_t *rwlock) | |
94 | { | |
95 | return rwlock->lock == 0; | |
96 | } | |
97 | ||
98 | /** | |
99 | * arch_read_lock() - acquire a read lock. | |
100 | */ | |
3c5ead52 | 101 | void arch_read_lock(arch_rwlock_t *rwlock); |
867e359b CM |
102 | |
103 | /** | |
3c5ead52 | 104 | * arch_write_lock() - acquire a write lock. |
867e359b | 105 | */ |
3c5ead52 | 106 | void arch_write_lock(arch_rwlock_t *rwlock); |
867e359b CM |
107 | |
108 | /** | |
109 | * arch_read_trylock() - try to acquire a read lock. | |
110 | */ | |
3c5ead52 | 111 | int arch_read_trylock(arch_rwlock_t *rwlock); |
867e359b CM |
112 | |
113 | /** | |
114 | * arch_write_trylock() - try to acquire a write lock. | |
115 | */ | |
3c5ead52 | 116 | int arch_write_trylock(arch_rwlock_t *rwlock); |
867e359b CM |
117 | |
118 | /** | |
119 | * arch_read_unlock() - release a read lock. | |
120 | */ | |
3c5ead52 | 121 | void arch_read_unlock(arch_rwlock_t *rwlock); |
867e359b CM |
122 | |
123 | /** | |
124 | * arch_write_unlock() - release a write lock. | |
125 | */ | |
3c5ead52 | 126 | void arch_write_unlock(arch_rwlock_t *rwlock); |
867e359b CM |
127 | |
128 | #define arch_read_lock_flags(lock, flags) arch_read_lock(lock) | |
129 | #define arch_write_lock_flags(lock, flags) arch_write_lock(lock) | |
130 | ||
131 | #endif /* _ASM_TILE_SPINLOCK_32_H */ |