/*
|
* Copyright (c) 2014, Linaro Limited
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License Version 2 as
|
* published by the Free Software Foundation.
|
*
|
* This program is distributed in the hope that it will be useful,
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
* GNU General Public License for more details.
|
*/
|
#include <linux/slab.h>
|
#include "tee_mutex_wait.h"
|
|
struct tee_mutex_wait {
|
struct list_head link;
|
struct completion comp;
|
struct mutex mu;
|
u32 wait_after;
|
u32 key;
|
};
|
|
/*
|
* Compares two serial numbers using Serial Number Arithmetic
|
* (https://www.ietf.org/rfc/rfc1982.txt).
|
*/
|
#define TICK_GT(t1, t2) \
|
(((t1) < (t2) && (t2) - (t1) > 0xFFFFFFFFu) || \
|
((t1) > (t2) && (t1) - (t2) < 0xFFFFFFFFu))
|
|
static struct tee_mutex_wait *tee_mutex_wait_get(struct device *dev,
|
struct tee_mutex_wait_private *priv, u32 key)
|
{
|
struct tee_mutex_wait *w;
|
|
mutex_lock(&priv->mu);
|
|
list_for_each_entry(w, &priv->db, link)
|
if (w->key == key)
|
goto out;
|
|
w = kmalloc(sizeof(struct tee_mutex_wait), GFP_KERNEL);
|
if (!w) {
|
dev_err(dev, "kmalloc <struct tee_mutex_wait> failed\n");
|
goto out;
|
}
|
|
init_completion(&w->comp);
|
mutex_init(&w->mu);
|
w->wait_after = 0;
|
w->key = key;
|
list_add_tail(&w->link, &priv->db);
|
out:
|
mutex_unlock(&priv->mu);
|
return w;
|
}
|
|
static void tee_mutex_wait_delete_entry(struct tee_mutex_wait *w)
|
{
|
list_del(&w->link);
|
mutex_destroy(&w->mu);
|
kfree(w);
|
}
|
|
void tee_mutex_wait_delete(struct device *dev,
|
struct tee_mutex_wait_private *priv,
|
u32 key)
|
{
|
struct tee_mutex_wait *w;
|
|
mutex_lock(&priv->mu);
|
|
list_for_each_entry(w, &priv->db, link) {
|
if (w->key == key) {
|
tee_mutex_wait_delete_entry(w);
|
break;
|
}
|
}
|
|
mutex_unlock(&priv->mu);
|
}
|
EXPORT_SYMBOL(tee_mutex_wait_delete);
|
|
void tee_mutex_wait_wakeup(struct device *dev,
|
struct tee_mutex_wait_private *priv,
|
u32 key, u32 wait_after)
|
{
|
struct tee_mutex_wait *w = tee_mutex_wait_get(dev, priv, key);
|
|
if (!w)
|
return;
|
|
mutex_lock(&w->mu);
|
w->wait_after = wait_after;
|
mutex_unlock(&w->mu);
|
complete(&w->comp);
|
}
|
EXPORT_SYMBOL(tee_mutex_wait_wakeup);
|
|
void tee_mutex_wait_sleep(struct device *dev,
|
struct tee_mutex_wait_private *priv,
|
u32 key, u32 wait_tick)
|
{
|
struct tee_mutex_wait *w = tee_mutex_wait_get(dev, priv, key);
|
u32 wait_after;
|
|
if (!w)
|
return;
|
|
mutex_lock(&w->mu);
|
wait_after = w->wait_after;
|
mutex_unlock(&w->mu);
|
|
if (TICK_GT(wait_tick, wait_after))
|
wait_for_completion_timeout(&w->comp, HZ);
|
}
|
EXPORT_SYMBOL(tee_mutex_wait_sleep);
|
|
int tee_mutex_wait_init(struct tee_mutex_wait_private *priv)
|
{
|
mutex_init(&priv->mu);
|
INIT_LIST_HEAD(&priv->db);
|
return 0;
|
}
|
EXPORT_SYMBOL(tee_mutex_wait_init);
|
|
void tee_mutex_wait_exit(struct tee_mutex_wait_private *priv)
|
{
|
/*
|
* It's the callers responibility to ensure that no one is using
|
* anything inside priv.
|
*/
|
|
mutex_destroy(&priv->mu);
|
while (!list_empty(&priv->db)) {
|
struct tee_mutex_wait *w =
|
list_first_entry(&priv->db,
|
struct tee_mutex_wait,
|
link);
|
tee_mutex_wait_delete_entry(w);
|
}
|
}
|
EXPORT_SYMBOL(tee_mutex_wait_exit);
|
