tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

MIPS: Get rid of atomic_lock. It was resulting in build errors for some configurations. Signed-off-by: Ralf Baechle <ralf@linux-mips.org>

authored by

Ralf Baechle and committed by
b2d28b7e 2d5e7b9f

+21 -22
unified split
+21 -22
include/asm-mips/atomic.h
··· 24 #define _ASM_ATOMIC_H 25 26 #include <asm/cpu-features.h> 27 #include <asm/war.h> 28 - 29 - extern spinlock_t atomic_lock; 30 31 typedef struct { volatile int counter; } atomic_t; 32 ··· 84 } else { 85 unsigned long flags; 86 87 - spin_lock_irqsave(&atomic_lock, flags); 88 v->counter += i; 89 - spin_unlock_irqrestore(&atomic_lock, flags); 90 } 91 } 92 ··· 126 } else { 127 unsigned long flags; 128 129 - spin_lock_irqsave(&atomic_lock, flags); 130 v->counter -= i; 131 - spin_unlock_irqrestore(&atomic_lock, flags); 132 } 133 } 134 ··· 172 } else { 173 unsigned long flags; 174 175 - spin_lock_irqsave(&atomic_lock, flags); 176 result = v->counter; 177 result += i; 178 v->counter = result; 179 - spin_unlock_irqrestore(&atomic_lock, flags); 180 } 181 182 return result; ··· 219 } else { 220 unsigned long flags; 221 222 - spin_lock_irqsave(&atomic_lock, flags); 223 result = v->counter; 224 result -= i; 225 v->counter = result; 226 - spin_unlock_irqrestore(&atomic_lock, flags); 227 } 228 229 return result; ··· 276 } else { 277 unsigned long flags; 278 279 - spin_lock_irqsave(&atomic_lock, flags); 280 result = v->counter; 281 result -= i; 282 if (result >= 0) 283 v->counter = result; 284 - spin_unlock_irqrestore(&atomic_lock, flags); 285 } 286 287 return result; ··· 432 } else { 433 unsigned long flags; 434 435 - spin_lock_irqsave(&atomic_lock, flags); 436 v->counter += i; 437 - spin_unlock_irqrestore(&atomic_lock, flags); 438 } 439 } 440 ··· 474 } else { 475 unsigned long flags; 476 477 - spin_lock_irqsave(&atomic_lock, flags); 478 v->counter -= i; 479 - spin_unlock_irqrestore(&atomic_lock, flags); 480 } 481 } 482 ··· 520 } else { 521 unsigned long flags; 522 523 - spin_lock_irqsave(&atomic_lock, flags); 524 result = v->counter; 525 result += i; 526 v->counter = result; 527 - spin_unlock_irqrestore(&atomic_lock, flags); 528 } 529 530 return result; ··· 567 } else { 568 unsigned long flags; 569 570 - spin_lock_irqsave(&atomic_lock, flags); 571 result = v->counter; 572 result -= i; 573 v->counter = result; 574 - spin_unlock_irqrestore(&atomic_lock, flags); 575 } 576 577 return result; ··· 624 } else { 625 unsigned long flags; 626 627 - spin_lock_irqsave(&atomic_lock, flags); 628 result = v->counter; 629 result -= i; 630 if (result >= 0) 631 v->counter = result; 632 - spin_unlock_irqrestore(&atomic_lock, flags); 633 } 634 635 return result;
··· 24 #define _ASM_ATOMIC_H 25 26 #include <asm/cpu-features.h> 27 + #include <asm/interrupt.h> 28 #include <asm/war.h> 29 30 typedef struct { volatile int counter; } atomic_t; 31 ··· 85 } else { 86 unsigned long flags; 87 88 + local_irq_save(flags); 89 v->counter += i; 90 + local_irq_restore(flags); 91 } 92 } 93 ··· 127 } else { 128 unsigned long flags; 129 130 + local_irq_save(flags); 131 v->counter -= i; 132 + local_irq_restore(flags); 133 } 134 } 135 ··· 173 } else { 174 unsigned long flags; 175 176 + local_irq_save(flags); 177 result = v->counter; 178 result += i; 179 v->counter = result; 180 + local_irq_restore(flags); 181 } 182 183 return result; ··· 220 } else { 221 unsigned long flags; 222 223 + local_irq_save(flags); 224 result = v->counter; 225 result -= i; 226 v->counter = result; 227 + local_irq_restore(flags); 228 } 229 230 return result; ··· 277 } else { 278 unsigned long flags; 279 280 + local_irq_save(flags); 281 result = v->counter; 282 result -= i; 283 if (result >= 0) 284 v->counter = result; 285 + local_irq_restore(flags); 286 } 287 288 return result; ··· 433 } else { 434 unsigned long flags; 435 436 + local_irq_save(flags); 437 v->counter += i; 438 + local_irq_restore(flags); 439 } 440 } 441 ··· 475 } else { 476 unsigned long flags; 477 478 + local_irq_save(flags); 479 v->counter -= i; 480 + local_irq_restore(flags); 481 } 482 } 483 ··· 521 } else { 522 unsigned long flags; 523 524 + local_irq_save(flags); 525 result = v->counter; 526 result += i; 527 v->counter = result; 528 + local_irq_restore(flags); 529 } 530 531 return result; ··· 568 } else { 569 unsigned long flags; 570 571 + local_irq_save(flags); 572 result = v->counter; 573 result -= i; 574 v->counter = result; 575 + local_irq_restore(flags); 576 } 577 578 return result; ··· 625 } else { 626 unsigned long flags; 627 628 + local_irq_save(flags); 629 result = v->counter; 630 result -= i; 631 if (result >= 0) 632 v->counter = result; 633 + local_irq_restore(flags); 634 } 635 636 return result;