Commit 579afe86 authored by Max Filippov's avatar Max Filippov
Browse files

xtensa: use generic spinlock/rwlock implementation 



Drop custom spinlock/rwlock code and use ones from asm-generic. This way
there is less code duplication (atomic primitives are reused).

Signed-off-by: default avatarMax Filippov <jcmvbkbc@gmail.com>
parent af3d890b

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