hwspinlock/core: use a mutex to protect the radix tree

     in case an unused hwspinlock isn't available. Users of this

     API will usually want to communicate the lock's id to the remote core

     before it can be used to achieve synchronization.

     Can be called from an atomic context (this function will not sleep) but

     not from within interrupt context.

     Should be called from a process context (might sleep).

  struct hwspinlock *hwspin_lock_request_specific(unsigned int id);

   - assign a specific hwspinlock id and return its address, or NULL

     if that hwspinlock is already in use. Usually board code will

     be calling this function in order to reserve specific hwspinlock

     ids for predefined purposes.

     Can be called from an atomic context (this function will not sleep) but

     not from within interrupt context.

     Should be called from a process context (might sleep).

  int hwspin_lock_free(struct hwspinlock *hwlock);

   - free a previously-assigned hwspinlock; returns 0 on success, or an

     appropriate error code on failure (e.g. -EINVAL if the hwspinlock

     is already free).

     Can be called from an atomic context (this function will not sleep) but

     not from within interrupt context.

     Should be called from a process context (might sleep).

  int hwspin_lock_timeout(struct hwspinlock *hwlock, unsigned int timeout);

   - lock a previously-assigned hwspinlock with a timeout limit (specified in

  int hwspin_lock_register(struct hwspinlock *hwlock);

   - to be called from the underlying platform-specific implementation, in

     order to register a new hwspinlock instance. Can be called from an atomic

     context (this function will not sleep) but not from within interrupt

     context. Returns 0 on success, or appropriate error code on failure.

     order to register a new hwspinlock instance. Should be called from

     a process context (this function might sleep).

     Returns 0 on success, or appropriate error code on failure.

  struct hwspinlock *hwspin_lock_unregister(unsigned int id);

   - to be called from the underlying vendor-specific implementation, in order

     to unregister an existing (and unused) hwspinlock instance.

     Can be called from an atomic context (will not sleep) but not from

     within interrupt context.

     Should be called from a process context (this function might sleep).

     Returns the address of hwspinlock on success, or NULL on error (e.g.

     if the hwspinlock is sill in use).

#include <linux/radix-tree.h>

#include <linux/hwspinlock.h>

#include <linux/pm_runtime.h>

#include <linux/mutex.h>

#include "hwspinlock_internal.h"

static RADIX_TREE(hwspinlock_tree, GFP_KERNEL);

/*

 * Synchronization of access to the tree is achieved using this spinlock,

 * Synchronization of access to the tree is achieved using this mutex,

 * as the radix-tree API requires that users provide all synchronisation.

 * A mutex is needed because we're using non-atomic radix tree allocations.

 */

static DEFINE_SPINLOCK(hwspinlock_tree_lock);

static DEFINE_MUTEX(hwspinlock_tree_lock);

/**

 * __hwspin_trylock() - attempt to lock a specific hwspinlock

 * This function should be called from the underlying platform-specific

 * implementation, to register a new hwspinlock instance.

 *

 * Can be called from an atomic context (will not sleep) but not from

 * within interrupt context.

 * Should be called from a process context (might sleep)

 *

 * Returns 0 on success, or an appropriate error code on failure

 */

	spin_lock_init(&hwlock->lock);

	spin_lock(&hwspinlock_tree_lock);

	mutex_lock(&hwspinlock_tree_lock);

	ret = radix_tree_insert(&hwspinlock_tree, hwlock->id, hwlock);

	if (ret == -EEXIST)

	WARN_ON(tmp != hwlock);

out:

	spin_unlock(&hwspinlock_tree_lock);

	mutex_unlock(&hwspinlock_tree_lock);

	return ret;

}

EXPORT_SYMBOL_GPL(hwspin_lock_register);

 * This function should be called from the underlying platform-specific

 * implementation, to unregister an existing (and unused) hwspinlock.

 *

 * Can be called from an atomic context (will not sleep) but not from

 * within interrupt context.

 * Should be called from a process context (might sleep)

 *

 * Returns the address of hwspinlock @id on success, or NULL on failure

 */

	struct hwspinlock *hwlock = NULL;

	int ret;

	spin_lock(&hwspinlock_tree_lock);

	mutex_lock(&hwspinlock_tree_lock);

	/* make sure the hwspinlock is not in use (tag is set) */

	ret = radix_tree_tag_get(&hwspinlock_tree, id, HWSPINLOCK_UNUSED);

	}

out:

	spin_unlock(&hwspinlock_tree_lock);

	mutex_unlock(&hwspinlock_tree_lock);

	return hwlock;

}

EXPORT_SYMBOL_GPL(hwspin_lock_unregister);

 * to the remote core before it can be used for synchronization (to get the

 * id of a given hwlock, use hwspin_lock_get_id()).

 *

 * Can be called from an atomic context (will not sleep) but not from

 * within interrupt context (simply because there is no use case for

 * that yet).

 * Should be called from a process context (might sleep)

 *

 * Returns the address of the assigned hwspinlock, or NULL on error

 */

	struct hwspinlock *hwlock;

	int ret;

	spin_lock(&hwspinlock_tree_lock);

	mutex_lock(&hwspinlock_tree_lock);

	/* look for an unused lock */

	ret = radix_tree_gang_lookup_tag(&hwspinlock_tree, (void **)&hwlock,

		hwlock = NULL;

out:

	spin_unlock(&hwspinlock_tree_lock);

	mutex_unlock(&hwspinlock_tree_lock);

	return hwlock;

}

EXPORT_SYMBOL_GPL(hwspin_lock_request);

 * Usually early board code will be calling this function in order to

 * reserve specific hwspinlock ids for predefined purposes.

 *

 * Can be called from an atomic context (will not sleep) but not from

 * within interrupt context (simply because there is no use case for

 * that yet).

 * Should be called from a process context (might sleep)

 *

 * Returns the address of the assigned hwspinlock, or NULL on error

 */

	struct hwspinlock *hwlock;

	int ret;

	spin_lock(&hwspinlock_tree_lock);

	mutex_lock(&hwspinlock_tree_lock);

	/* make sure this hwspinlock exists */

	hwlock = radix_tree_lookup(&hwspinlock_tree, id);

		hwlock = NULL;

out:

	spin_unlock(&hwspinlock_tree_lock);

	mutex_unlock(&hwspinlock_tree_lock);

	return hwlock;

}

EXPORT_SYMBOL_GPL(hwspin_lock_request_specific);

 * Should only be called with an @hwlock that was retrieved from

 * an earlier call to omap_hwspin_lock_request{_specific}.

 *

 * Can be called from an atomic context (will not sleep) but not from

 * within interrupt context (simply because there is no use case for

 * that yet).

 * Should be called from a process context (might sleep)

 *

 * Returns 0 on success, or an appropriate error code on failure

 */

		return -EINVAL;

	}

	spin_lock(&hwspinlock_tree_lock);

	mutex_lock(&hwspinlock_tree_lock);

	/* make sure the hwspinlock is used */

	ret = radix_tree_tag_get(&hwspinlock_tree, hwlock->id,

	module_put(hwlock->dev->driver->owner);

out:

	spin_unlock(&hwspinlock_tree_lock);

	mutex_unlock(&hwspinlock_tree_lock);

	return ret;

}

EXPORT_SYMBOL_GPL(hwspin_lock_free);