Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 648acc48 authored by Jeff Hugo's avatar Jeff Hugo
Browse files

msm: remote_spinlock: Remove dead code 



Remove the following dead functionality:

1. DAL remote spinlocks
	Unused on supported targets and much of the DAL framework no longer
	exists

2. SWP based software locks
	SWP instructions are deprecated on modern ARM architectures

3. Dekkers based software locks
	Dekker's algorithm assumes only two entities will compete for the
	lock.  Supported targets involve more than two entities.

4. Compile-time implementation switching
	Implementation details are determined at runtime via Device Tree

5. Misc unused included headers

Change-Id: I941e508e1688f48a9439d8ce879505ba8f555e34
Signed-off-by: default avatarJeffrey Hugo <jhugo@codeaurora.org>
parent b8624ba4

arch/arm/mach-msm/include/mach/remote_spinlock.h

+2 −10
Original line number Diff line number Diff line
@@ -24,23 +24,15 @@ 


/* Remote spinlock definitions. */



struct dek_spinlock {

	volatile uint8_t self_lock;

	volatile uint8_t other_lock;

	volatile uint8_t next_yield;

	uint8_t pad;

};



typedef union {

typedef struct {

	volatile uint32_t lock;

	struct dek_spinlock dek;

} raw_remote_spinlock_t;



typedef raw_remote_spinlock_t *_remote_spinlock_t;



#define remote_spinlock_id_t const char *



#if defined(CONFIG_MSM_SMD) || defined(CONFIG_MSM_REMOTE_SPINLOCK_SFPB)

#if defined(CONFIG_MSM_SMD)

int _remote_spin_lock_init(remote_spinlock_id_t, _remote_spinlock_t *lock);

void _remote_spin_release_all(uint32_t pid);

void _remote_spin_lock(_remote_spinlock_t *lock);

arch/arm/mach-msm/remote_spinlock.c

+23 −276
Original line number Diff line number Diff line
@@ -15,60 +15,15 @@ 
#include <linux/kernel.h>

#include <linux/string.h>

#include <linux/delay.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/of.h>

#include <linux/of_address.h>



#include <mach/msm_iomap.h>

#include <mach/remote_spinlock.h>

#include <mach/dal.h>

#include <mach/msm_smem.h>





#define SPINLOCK_PID_APPS 1



#define AUTO_MODE -1

#define DEKKERS_MODE 1

#define SWP_MODE 2

#define LDREX_MODE 3

#define SFPB_MODE 4



#if defined(CONFIG_MSM_REMOTE_SPINLOCK_DEKKERS) ||\

		defined(CONFIG_MSM_REMOTE_SPINLOCK_SWP) ||\

		defined(CONFIG_MSM_REMOTE_SPINLOCK_LDREX) ||\

		defined(CONFIG_MSM_REMOTE_SPINLOCK_SFPB)



#ifdef CONFIG_MSM_REMOTE_SPINLOCK_DEKKERS

/*

 * Use Dekker's algorithm when LDREX/STREX and SWP are unavailable for

 * shared memory

 */

#define CURRENT_MODE_INIT DEKKERS_MODE;

#endif



#ifdef CONFIG_MSM_REMOTE_SPINLOCK_SWP

/* Use SWP-based locks when LDREX/STREX are unavailable for shared memory. */

#define CURRENT_MODE_INIT SWP_MODE;

#endif



#ifdef CONFIG_MSM_REMOTE_SPINLOCK_LDREX

/* Use LDREX/STREX for shared memory locking, when available */

#define CURRENT_MODE_INIT LDREX_MODE;

#endif



#ifdef CONFIG_MSM_REMOTE_SPINLOCK_SFPB

/* Use SFPB Hardware Mutex Registers */

#define CURRENT_MODE_INIT SFPB_MODE;

#endif



#else

/* Use DT info to configure with a fallback to LDREX if DT is missing */

#define CURRENT_MODE_INIT AUTO_MODE;

#endif



static int current_mode = CURRENT_MODE_INIT;



static int is_hw_lock_type;

static DEFINE_MUTEX(ops_init_lock);
@@ -84,117 +39,6 @@ static struct spinlock_ops current_ops; 


static int remote_spinlock_init_address(int id, _remote_spinlock_t *lock);



/* dekkers implementation --------------------------------------------------- */

#define DEK_LOCK_REQUEST		1

#define DEK_LOCK_YIELD			(!DEK_LOCK_REQUEST)

#define DEK_YIELD_TURN_SELF		0

static void __raw_remote_dek_spin_lock(raw_remote_spinlock_t *lock)

{

	lock->dek.self_lock = DEK_LOCK_REQUEST;



	while (lock->dek.other_lock) {



		if (lock->dek.next_yield == DEK_YIELD_TURN_SELF)

			lock->dek.self_lock = DEK_LOCK_YIELD;



		while (lock->dek.other_lock)

			;



		lock->dek.self_lock = DEK_LOCK_REQUEST;

	}

	lock->dek.next_yield = DEK_YIELD_TURN_SELF;



	smp_mb();

}



static int __raw_remote_dek_spin_trylock(raw_remote_spinlock_t *lock)

{

	lock->dek.self_lock = DEK_LOCK_REQUEST;



	if (lock->dek.other_lock) {

		lock->dek.self_lock = DEK_LOCK_YIELD;

		return 0;

	}



	lock->dek.next_yield = DEK_YIELD_TURN_SELF;



	smp_mb();

	return 1;

}



static void __raw_remote_dek_spin_unlock(raw_remote_spinlock_t *lock)

{

	smp_mb();



	lock->dek.self_lock = DEK_LOCK_YIELD;

}



static int __raw_remote_dek_spin_release(raw_remote_spinlock_t *lock,

		uint32_t pid)

{

	return -EPERM;

}



static int __raw_remote_dek_spin_owner(raw_remote_spinlock_t *lock)

{

	return -EPERM;

}

/* end dekkers implementation ----------------------------------------------- */



#ifndef CONFIG_THUMB2_KERNEL

/* swp implementation ------------------------------------------------------- */

static void __raw_remote_swp_spin_lock(raw_remote_spinlock_t *lock)

{

	unsigned long tmp;



	__asm__ __volatile__(

"1:     swp     %0, %2, [%1]\n"

"       teq     %0, #0\n"

"       bne     1b"

	: "=&r" (tmp)

	: "r" (&lock->lock), "r" (1)

	: "cc");



	smp_mb();

}



static int __raw_remote_swp_spin_trylock(raw_remote_spinlock_t *lock)

{

	unsigned long tmp;



	__asm__ __volatile__(

"       swp     %0, %2, [%1]\n"

	: "=&r" (tmp)

	: "r" (&lock->lock), "r" (1)

	: "cc");



	if (tmp == 0) {

		smp_mb();

		return 1;

	}

	return 0;

}



static void __raw_remote_swp_spin_unlock(raw_remote_spinlock_t *lock)

{

	int lock_owner;



	smp_mb();

	lock_owner = readl_relaxed(&lock->lock);

	if (lock_owner != SPINLOCK_PID_APPS) {

		pr_err("%s: spinlock not owned by Apps (actual owner is %d)\n",

				__func__, lock_owner);

	}



	__asm__ __volatile__(

"       str     %1, [%0]"

	:

	: "r" (&lock->lock), "r" (0)

	: "cc");

}

/* end swp implementation --------------------------------------------------- */

#endif



/* ldrex implementation ----------------------------------------------------- */

static char *ldrex_compatible_string = "qcom,ipc-spinlock-ldrex";
@@ -254,12 +98,6 @@ static void __raw_remote_ex_spin_unlock(raw_remote_spinlock_t *lock) 
/* end ldrex implementation ------------------------------------------------- */



/* sfpb implementation ------------------------------------------------------ */

#define SFPB_SPINLOCK_COUNT 8

#define MSM_SFPB_MUTEX_REG_BASE 0x01200600

#define MSM_SFPB_MUTEX_REG_SIZE	(33 * 4)

#define SFPB_SPINLOCK_OFFSET 4

#define SFPB_SPINLOCK_SIZE 4



static uint32_t lock_count;

static phys_addr_t reg_base;

static uint32_t reg_size;
@@ -297,15 +135,8 @@ static void find_and_init_hw_mutex(void) 
	struct device_node *node;



	node = of_find_compatible_node(NULL, NULL, sfpb_compatible_string);

	if (node) {

	BUG_ON(node == NULL);

	init_hw_mutex(node);

	} else {

		lock_count = SFPB_SPINLOCK_COUNT;

		reg_base = MSM_SFPB_MUTEX_REG_BASE;

		reg_size = MSM_SFPB_MUTEX_REG_SIZE;

		lock_offset = SFPB_SPINLOCK_OFFSET;

		lock_size = SFPB_SPINLOCK_SIZE;

	}

	hw_mutex_reg_base = ioremap(reg_base, reg_size);

	BUG_ON(hw_mutex_reg_base == NULL);

}
@@ -422,49 +253,12 @@ static void initialize_ops(void) 
{

	struct device_node *node;



	switch (current_mode) {

	case DEKKERS_MODE:

		current_ops.lock = __raw_remote_dek_spin_lock;

		current_ops.unlock = __raw_remote_dek_spin_unlock;

		current_ops.trylock = __raw_remote_dek_spin_trylock;

		current_ops.release = __raw_remote_dek_spin_release;

		current_ops.owner = __raw_remote_dek_spin_owner;

		is_hw_lock_type = 0;

		break;

#ifndef CONFIG_THUMB2_KERNEL

	case SWP_MODE:

		current_ops.lock = __raw_remote_swp_spin_lock;

		current_ops.unlock = __raw_remote_swp_spin_unlock;

		current_ops.trylock = __raw_remote_swp_spin_trylock;

		current_ops.release = __raw_remote_gen_spin_release;

		current_ops.owner = __raw_remote_gen_spin_owner;

		is_hw_lock_type = 0;

		break;

#endif

	case LDREX_MODE:

		current_ops.lock = __raw_remote_ex_spin_lock;

		current_ops.unlock = __raw_remote_ex_spin_unlock;

		current_ops.trylock = __raw_remote_ex_spin_trylock;

		current_ops.release = __raw_remote_gen_spin_release;

		current_ops.owner = __raw_remote_gen_spin_owner;

		is_hw_lock_type = 0;

		break;

	case SFPB_MODE:

		current_ops.lock = __raw_remote_sfpb_spin_lock;

		current_ops.unlock = __raw_remote_sfpb_spin_unlock;

		current_ops.trylock = __raw_remote_sfpb_spin_trylock;

		current_ops.release = __raw_remote_gen_spin_release;

		current_ops.owner = __raw_remote_gen_spin_owner;

		is_hw_lock_type = 1;

		break;

	case AUTO_MODE:

	/*

	 * of_find_compatible_node() returns a valid pointer even if

	 * the status property is "disabled", so the validity needs

	 * to be checked

	 */

		node = of_find_compatible_node(NULL, NULL,

						sfpb_compatible_string);

	node = of_find_compatible_node(NULL, NULL, sfpb_compatible_string);

	if (node && dt_node_is_valid(node)) {

		current_ops.lock = __raw_remote_sfpb_spin_lock;

		current_ops.unlock = __raw_remote_sfpb_spin_unlock;
@@ -472,11 +266,10 @@ static void initialize_ops(void) 
		current_ops.release = __raw_remote_gen_spin_release;

		current_ops.owner = __raw_remote_gen_spin_owner;

		is_hw_lock_type = 1;

			break;

		return;

	}



		node = of_find_compatible_node(NULL, NULL,

						ldrex_compatible_string);

	node = of_find_compatible_node(NULL, NULL, ldrex_compatible_string);

	if (node && dt_node_is_valid(node)) {

		current_ops.lock = __raw_remote_ex_spin_lock;

		current_ops.unlock = __raw_remote_ex_spin_unlock;
@@ -484,7 +277,7 @@ static void initialize_ops(void) 
		current_ops.release = __raw_remote_gen_spin_release;

		current_ops.owner = __raw_remote_gen_spin_owner;

		is_hw_lock_type = 0;

			break;

		return;

	}



	current_ops.lock = __raw_remote_ex_spin_lock;
@@ -494,11 +287,6 @@ static void initialize_ops(void) 
	current_ops.owner = __raw_remote_gen_spin_owner;

	is_hw_lock_type = 0;

	pr_warn("Falling back to LDREX remote spinlock implementation");

		break;

	default:

		BUG();

		break;

	}

}



/**
@@ -525,44 +313,6 @@ void _remote_spin_release_all(uint32_t pid) 
	remote_spin_release_all_locks(pid, lock_count);

}



static int

remote_spinlock_dal_init(const char *chunk_name, _remote_spinlock_t *lock)

{

	void *dal_smem_start, *dal_smem_end;

	uint32_t dal_smem_size;

	struct dal_chunk_header *cur_header;



	if (!chunk_name)

		return -EINVAL;



	dal_smem_start = smem_get_entry(SMEM_DAL_AREA, &dal_smem_size,

							0, SMEM_ANY_HOST_FLAG);

	if (!dal_smem_start)

		return -ENXIO;



	dal_smem_end = dal_smem_start + dal_smem_size;



	/* Find first chunk header */

	cur_header = (struct dal_chunk_header *)

			(((uint32_t)dal_smem_start + (4095)) & ~4095);

	*lock = NULL;

	while (cur_header->size != 0

		&& ((uint32_t)(cur_header + 1) < (uint32_t)dal_smem_end)) {



		/* Check if chunk name matches */

		if (!strncmp(cur_header->name, chunk_name,

						DAL_CHUNK_NAME_LENGTH)) {

			*lock = (_remote_spinlock_t)&cur_header->lock;

			return 0;

		}

		cur_header = (void *)cur_header + cur_header->size;

	}



	pr_err("%s: DAL remote lock \"%s\" not found.\n", __func__,

		chunk_name);

	return -EINVAL;

}



#define SMEM_SPINLOCK_COUNT 8

#define SMEM_SPINLOCK_ARRAY_SIZE (SMEM_SPINLOCK_COUNT * sizeof(uint32_t))
@@ -613,10 +363,7 @@ int _remote_spin_lock_init(remote_spinlock_id_t id, _remote_spinlock_t *lock) 
		mutex_unlock(&ops_init_lock);

	}



	if (id[0] == 'D' && id[1] == ':') {

		/* DAL chunk name starts after "D:" */

		return remote_spinlock_dal_init(&id[2], lock);

	} else if (id[0] == 'S' && id[1] == ':') {

	if (id[0] == 'S' && id[1] == ':') {

		/* Single-digit lock ID follows "S:" */

		BUG_ON(id[3] != '\0');