xtensa: use generic spinlock/rwlock implementation (579afe86) · Commits · 戴 / test

arch/xtensa/Kconfig

+2 −0

Original line number	Diff line number	Diff line
		@@ -4,6 +4,8 @@ config XTENSA
		select ARCH_HAS_SYNC_DMA_FOR_CPU
		select ARCH_HAS_SYNC_DMA_FOR_DEVICE
		select ARCH_NO_COHERENT_DMA_MMAP if !MMU
		select ARCH_USE_QUEUED_RWLOCKS
		select ARCH_USE_QUEUED_SPINLOCKS
		select ARCH_WANT_FRAME_POINTERS
		select ARCH_WANT_IPC_PARSE_VERSION
		select BUILDTIME_EXTABLE_SORT

arch/xtensa/include/asm/Kbuild

+2 −0

Original line number	Diff line number	Diff line
		@@ -23,6 +23,8 @@ generic-y += mm-arch-hooks.h
		generic-y += param.h
		generic-y += percpu.h
		generic-y += preempt.h
		generic-y += qrwlock.h
		generic-y += qspinlock.h
		generic-y += rwsem.h
		generic-y += sections.h
		generic-y += topology.h

arch/xtensa/include/asm/spinlock.h

+3 −182

Original line number	Diff line number	Diff line
		@@ -12,188 +12,9 @@
		#define _XTENSA_SPINLOCK_H

		#include <asm/barrier.h>
		#include <asm/processor.h>
		#include <asm/qrwlock.h>
		#include <asm/qspinlock.h>

		/*
		* spinlock
		*
		* There is at most one owner of a spinlock. There are not different
		* types of spinlock owners like there are for rwlocks (see below).
		*
		* When trying to obtain a spinlock, the function "spins" forever, or busy-
		* waits, until the lock is obtained. When spinning, presumably some other
		* owner will soon give up the spinlock making it available to others. Use
		* the trylock functions to avoid spinning forever.
		*
		* possible values:
		*
		* 0 nobody owns the spinlock
		* 1 somebody owns the spinlock
		*/

		#define arch_spin_is_locked(x) ((x)->slock != 0)

		static inline void arch_spin_lock(arch_spinlock_t *lock)
		{
		unsigned long tmp;

		__asm__ __volatile__(
		" movi %0, 0\n"
		" wsr %0, scompare1\n"
		"1: movi %0, 1\n"
		" s32c1i %0, %1, 0\n"
		" bnez %0, 1b\n"
		: "=&a" (tmp)
		: "a" (&lock->slock)
		: "memory");
		}

		/* Returns 1 if the lock is obtained, 0 otherwise. */

		static inline int arch_spin_trylock(arch_spinlock_t *lock)
		{
		unsigned long tmp;

		__asm__ __volatile__(
		" movi %0, 0\n"
		" wsr %0, scompare1\n"
		" movi %0, 1\n"
		" s32c1i %0, %1, 0\n"
		: "=&a" (tmp)
		: "a" (&lock->slock)
		: "memory");

		return tmp == 0 ? 1 : 0;
		}

		static inline void arch_spin_unlock(arch_spinlock_t *lock)
		{
		unsigned long tmp;

		__asm__ __volatile__(
		" movi %0, 0\n"
		" s32ri %0, %1, 0\n"
		: "=&a" (tmp)
		: "a" (&lock->slock)
		: "memory");
		}

		/*
		* rwlock
		*
		* Read-write locks are really a more flexible spinlock. They allow
		* multiple readers but only one writer. Write ownership is exclusive
		* (i.e., all other readers and writers are blocked from ownership while
		* there is a write owner). These rwlocks are unfair to writers. Writers
		* can be starved for an indefinite time by readers.
		*
		* possible values:
		*
		* 0 nobody owns the rwlock
		* >0 one or more readers own the rwlock
		* (the positive value is the actual number of readers)
		* 0x80000000 one writer owns the rwlock, no other writers, no readers
		*/

		static inline void arch_write_lock(arch_rwlock_t *rw)
		{
		unsigned long tmp;

		__asm__ __volatile__(
		" movi %0, 0\n"
		" wsr %0, scompare1\n"
		"1: movi %0, 1\n"
		" slli %0, %0, 31\n"
		" s32c1i %0, %1, 0\n"
		" bnez %0, 1b\n"
		: "=&a" (tmp)
		: "a" (&rw->lock)
		: "memory");
		}

		/* Returns 1 if the lock is obtained, 0 otherwise. */

		static inline int arch_write_trylock(arch_rwlock_t *rw)
		{
		unsigned long tmp;

		__asm__ __volatile__(
		" movi %0, 0\n"
		" wsr %0, scompare1\n"
		" movi %0, 1\n"
		" slli %0, %0, 31\n"
		" s32c1i %0, %1, 0\n"
		: "=&a" (tmp)
		: "a" (&rw->lock)
		: "memory");

		return tmp == 0 ? 1 : 0;
		}

		static inline void arch_write_unlock(arch_rwlock_t *rw)
		{
		unsigned long tmp;

		__asm__ __volatile__(
		" movi %0, 0\n"
		" s32ri %0, %1, 0\n"
		: "=&a" (tmp)
		: "a" (&rw->lock)
		: "memory");
		}

		static inline void arch_read_lock(arch_rwlock_t *rw)
		{
		unsigned long tmp;
		unsigned long result;

		__asm__ __volatile__(
		"1: l32i %1, %2, 0\n"
		" bltz %1, 1b\n"
		" wsr %1, scompare1\n"
		" addi %0, %1, 1\n"
		" s32c1i %0, %2, 0\n"
		" bne %0, %1, 1b\n"
		: "=&a" (result), "=&a" (tmp)
		: "a" (&rw->lock)
		: "memory");
		}

		/* Returns 1 if the lock is obtained, 0 otherwise. */

		static inline int arch_read_trylock(arch_rwlock_t *rw)
		{
		unsigned long result;
		unsigned long tmp;

		__asm__ __volatile__(
		" l32i %1, %2, 0\n"
		" addi %0, %1, 1\n"
		" bltz %0, 1f\n"
		" wsr %1, scompare1\n"
		" s32c1i %0, %2, 0\n"
		" sub %0, %0, %1\n"
		"1:\n"
		: "=&a" (result), "=&a" (tmp)
		: "a" (&rw->lock)
		: "memory");

		return result == 0;
		}

		static inline void arch_read_unlock(arch_rwlock_t *rw)
		{
		unsigned long tmp1, tmp2;

		__asm__ __volatile__(
		"1: l32i %1, %2, 0\n"
		" addi %0, %1, -1\n"
		" wsr %1, scompare1\n"
		" s32c1i %0, %2, 0\n"
		" bne %0, %1, 1b\n"
		: "=&a" (tmp1), "=&a" (tmp2)
		: "a" (&rw->lock)
		: "memory");
		}
		#define smp_mb__after_spinlock() smp_mb()

		#endif /* _XTENSA_SPINLOCK_H */

arch/xtensa/include/asm/spinlock_types.h

+3 −12

Original line number	Diff line number	Diff line
		@@ -2,20 +2,11 @@
		#ifndef __ASM_SPINLOCK_TYPES_H
		#define __ASM_SPINLOCK_TYPES_H

		#ifndef __LINUX_SPINLOCK_TYPES_H
		#if !defined(__LINUX_SPINLOCK_TYPES_H) && !defined(__ASM_SPINLOCK_H)
		# error "please don't include this file directly"
		#endif

		typedef struct {
		volatile unsigned int slock;
		} arch_spinlock_t;

		#define __ARCH_SPIN_LOCK_UNLOCKED { 0 }

		typedef struct {
		volatile unsigned int lock;
		} arch_rwlock_t;

		#define __ARCH_RW_LOCK_UNLOCKED { 0 }
		#include <asm-generic/qspinlock_types.h>
		#include <asm-generic/qrwlock_types.h>

		#endif

Admin message