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