Merge "msm: remote_spinlock: Remove dead code" (0a80c2ec) · Commits · e / devices / android_kernel_sony_msm8994_rework

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');