[mirror_ubuntu-artful-kernel.git] / drivers / mfd / vexpress-config.c

/*
 * 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.
 *
 * Copyright (C) 2012 ARM Limited
 */

#define pr_fmt(fmt) "vexpress-config: " fmt

#include <linux/bitops.h>
#include <linux/completion.h>
#include <linux/export.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/slab.h>
#include <linux/string.h>
#include <linux/vexpress.h>


#define VEXPRESS_CONFIG_MAX_BRIDGES 2

struct vexpress_config_bridge {
	struct device_node *node;
	struct vexpress_config_bridge_info *info;
	struct list_head transactions;
	spinlock_t transactions_lock;
} vexpress_config_bridges[VEXPRESS_CONFIG_MAX_BRIDGES];

static DECLARE_BITMAP(vexpress_config_bridges_map,
		ARRAY_SIZE(vexpress_config_bridges));
static DEFINE_MUTEX(vexpress_config_bridges_mutex);

struct vexpress_config_bridge *vexpress_config_bridge_register(
		struct device_node *node,
		struct vexpress_config_bridge_info *info)
{
	struct vexpress_config_bridge *bridge;
	int i;

	pr_debug("Registering bridge '%s'\n", info->name);

	mutex_lock(&vexpress_config_bridges_mutex);
	i = find_first_zero_bit(vexpress_config_bridges_map,
			ARRAY_SIZE(vexpress_config_bridges));
	if (i >= ARRAY_SIZE(vexpress_config_bridges)) {
		pr_err("Can't register more bridges!\n");
		mutex_unlock(&vexpress_config_bridges_mutex);
		return NULL;
	}
	__set_bit(i, vexpress_config_bridges_map);
	bridge = &vexpress_config_bridges[i];

	bridge->node = node;
	bridge->info = info;
	INIT_LIST_HEAD(&bridge->transactions);
	spin_lock_init(&bridge->transactions_lock);

	mutex_unlock(&vexpress_config_bridges_mutex);

	return bridge;
}
EXPORT_SYMBOL(vexpress_config_bridge_register);

void vexpress_config_bridge_unregister(struct vexpress_config_bridge *bridge)
{
	struct vexpress_config_bridge __bridge = *bridge;
	int i;

	mutex_lock(&vexpress_config_bridges_mutex);
	for (i = 0; i < ARRAY_SIZE(vexpress_config_bridges); i++)
		if (&vexpress_config_bridges[i] == bridge)
			__clear_bit(i, vexpress_config_bridges_map);
	mutex_unlock(&vexpress_config_bridges_mutex);

	WARN_ON(!list_empty(&__bridge.transactions));
	while (!list_empty(&__bridge.transactions))
		cpu_relax();
}
EXPORT_SYMBOL(vexpress_config_bridge_unregister);


struct vexpress_config_func {
	struct vexpress_config_bridge *bridge;
	void *func;
};

struct vexpress_config_func *__vexpress_config_func_get(struct device *dev,
		struct device_node *node)
{
	struct device_node *bridge_node;
	struct vexpress_config_func *func;
	int i;

	if (WARN_ON(dev && node && dev->of_node != node))
		return NULL;
	if (dev && !node)
		node = dev->of_node;

	func = kzalloc(sizeof(*func), GFP_KERNEL);
	if (!func)
		return NULL;

	bridge_node = of_node_get(node);
	while (bridge_node) {
		const __be32 *prop = of_get_property(bridge_node,
				"arm,vexpress,config-bridge", NULL);

		if (prop) {
			bridge_node = of_find_node_by_phandle(
					be32_to_cpup(prop));
			break;
		}

		bridge_node = of_get_next_parent(bridge_node);
	}

	mutex_lock(&vexpress_config_bridges_mutex);
	for (i = 0; i < ARRAY_SIZE(vexpress_config_bridges); i++) {
		struct vexpress_config_bridge *bridge =
				&vexpress_config_bridges[i];

		if (test_bit(i, vexpress_config_bridges_map) &&
				bridge->node == bridge_node) {
			func->bridge = bridge;
			func->func = bridge->info->func_get(dev, node);
			break;
		}
	}
	mutex_unlock(&vexpress_config_bridges_mutex);

	if (!func->func) {
		of_node_put(node);
		kfree(func);
		return NULL;
	}

	return func;
}
EXPORT_SYMBOL(__vexpress_config_func_get);

void vexpress_config_func_put(struct vexpress_config_func *func)
{
	func->bridge->info->func_put(func->func);
	of_node_put(func->bridge->node);
	kfree(func);
}
EXPORT_SYMBOL(vexpress_config_func_put);

struct vexpress_config_trans {
	struct vexpress_config_func *func;
	int offset;
	bool write;
	u32 *data;
	int status;
	struct completion completion;
	struct list_head list;
};

static void vexpress_config_dump_trans(const char *what,
		struct vexpress_config_trans *trans)
{
	pr_debug("%s %s trans %p func 0x%p offset %d data 0x%x status %d\n",
			what, trans->write ? "write" : "read", trans,
			trans->func->func, trans->offset,
			trans->data ? *trans->data : 0, trans->status);
}

static int vexpress_config_schedule(struct vexpress_config_trans *trans)
{
	int status;
	struct vexpress_config_bridge *bridge = trans->func->bridge;
	unsigned long flags;

	init_completion(&trans->completion);
	trans->status = -EFAULT;

	spin_lock_irqsave(&bridge->transactions_lock, flags);

	if (list_empty(&bridge->transactions)) {
		vexpress_config_dump_trans("Executing", trans);
		status = bridge->info->func_exec(trans->func->func,
				trans->offset, trans->write, trans->data);
	} else {
		vexpress_config_dump_trans("Queuing", trans);
		status = VEXPRESS_CONFIG_STATUS_WAIT;
	}

	switch (status) {
	case VEXPRESS_CONFIG_STATUS_DONE:
		vexpress_config_dump_trans("Finished", trans);
		trans->status = status;
		break;
	case VEXPRESS_CONFIG_STATUS_WAIT:
		list_add_tail(&trans->list, &bridge->transactions);
		break;
	}

	spin_unlock_irqrestore(&bridge->transactions_lock, flags);

	return status;
}

void vexpress_config_complete(struct vexpress_config_bridge *bridge,
		int status)
{
	struct vexpress_config_trans *trans;
	unsigned long flags;
	const char *message = "Completed";

	spin_lock_irqsave(&bridge->transactions_lock, flags);

	trans = list_first_entry(&bridge->transactions,
			struct vexpress_config_trans, list);
	trans->status = status;

	do {
		vexpress_config_dump_trans(message, trans);
		list_del(&trans->list);
		complete(&trans->completion);

		if (list_empty(&bridge->transactions))
			break;

		trans = list_first_entry(&bridge->transactions,
				struct vexpress_config_trans, list);
		vexpress_config_dump_trans("Executing pending", trans);
		trans->status = bridge->info->func_exec(trans->func->func,
				trans->offset, trans->write, trans->data);
		message = "Finished pending";
	} while (trans->status == VEXPRESS_CONFIG_STATUS_DONE);

	spin_unlock_irqrestore(&bridge->transactions_lock, flags);
}
EXPORT_SYMBOL(vexpress_config_complete);

int vexpress_config_wait(struct vexpress_config_trans *trans)
{
	wait_for_completion(&trans->completion);

	return trans->status;
}
EXPORT_SYMBOL(vexpress_config_wait);

int vexpress_config_read(struct vexpress_config_func *func, int offset,
		u32 *data)
{
	struct vexpress_config_trans trans = {
		.func = func,
		.offset = offset,
		.write = false,
		.data = data,
		.status = 0,
	};
	int status = vexpress_config_schedule(&trans);

	if (status == VEXPRESS_CONFIG_STATUS_WAIT)
		status = vexpress_config_wait(&trans);

	return status;
}
EXPORT_SYMBOL(vexpress_config_read);

int vexpress_config_write(struct vexpress_config_func *func, int offset,
		u32 data)
{
	struct vexpress_config_trans trans = {
		.func = func,
		.offset = offset,
		.write = true,
		.data = &data,
		.status = 0,
	};
	int status = vexpress_config_schedule(&trans);

	if (status == VEXPRESS_CONFIG_STATUS_WAIT)
		status = vexpress_config_wait(&trans);

	return status;
}
EXPORT_SYMBOL(vexpress_config_write);
Commit	Line	Data
3ecbf05b PM	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License version 2 as
	4	* published by the Free Software Foundation.
	5	*
	6	* This program is distributed in the hope that it will be useful,
	7	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	8	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	9	* GNU General Public License for more details.
	10	*
	11	* Copyright (C) 2012 ARM Limited
	12	*/
	13
	14	#define pr_fmt(fmt) "vexpress-config: " fmt
	15
	16	#include <linux/bitops.h>
	17	#include <linux/completion.h>
	18	#include <linux/export.h>
	19	#include <linux/init.h>
	20	#include <linux/list.h>
	21	#include <linux/of.h>
	22	#include <linux/of_device.h>
	23	#include <linux/slab.h>
	24	#include <linux/string.h>
	25	#include <linux/vexpress.h>
	26
	27
	28	#define VEXPRESS_CONFIG_MAX_BRIDGES 2
	29
	30	struct vexpress_config_bridge {
	31	struct device_node *node;
	32	struct vexpress_config_bridge_info *info;
	33	struct list_head transactions;
	34	spinlock_t transactions_lock;
	35	} vexpress_config_bridges[VEXPRESS_CONFIG_MAX_BRIDGES];
	36
	37	static DECLARE_BITMAP(vexpress_config_bridges_map,
	38	ARRAY_SIZE(vexpress_config_bridges));
	39	static DEFINE_MUTEX(vexpress_config_bridges_mutex);
	40
	41	struct vexpress_config_bridge *vexpress_config_bridge_register(
	42	struct device_node *node,
	43	struct vexpress_config_bridge_info *info)
	44	{
	45	struct vexpress_config_bridge *bridge;
	46	int i;
	47
	48	pr_debug("Registering bridge '%s'\n", info->name);
	49
	50	mutex_lock(&vexpress_config_bridges_mutex);
	51	i = find_first_zero_bit(vexpress_config_bridges_map,
	52	ARRAY_SIZE(vexpress_config_bridges));
	53	if (i >= ARRAY_SIZE(vexpress_config_bridges)) {
	54	pr_err("Can't register more bridges!\n");
	55	mutex_unlock(&vexpress_config_bridges_mutex);
	56	return NULL;
	57	}
	58	__set_bit(i, vexpress_config_bridges_map);
	59	bridge = &vexpress_config_bridges[i];
	60
	61	bridge->node = node;
	62	bridge->info = info;
	63	INIT_LIST_HEAD(&bridge->transactions);
	64	spin_lock_init(&bridge->transactions_lock);
65
66	mutex_unlock(&vexpress_config_bridges_mutex);
67
68	return bridge;
69	}
a17155bc	70	EXPORT_SYMBOL(vexpress_config_bridge_register);
3ecbf05b PM	71
	72	void vexpress_config_bridge_unregister(struct vexpress_config_bridge *bridge)
	73	{
	74	struct vexpress_config_bridge __bridge = *bridge;
	75	int i;
	76
	77	mutex_lock(&vexpress_config_bridges_mutex);
	78	for (i = 0; i < ARRAY_SIZE(vexpress_config_bridges); i++)
	79	if (&vexpress_config_bridges[i] == bridge)
	80	__clear_bit(i, vexpress_config_bridges_map);
	81	mutex_unlock(&vexpress_config_bridges_mutex);
	82
	83	WARN_ON(!list_empty(&__bridge.transactions));
	84	while (!list_empty(&__bridge.transactions))
	85	cpu_relax();
	86	}
a17155bc	87	EXPORT_SYMBOL(vexpress_config_bridge_unregister);
3ecbf05b PM	88
	89
	90	struct vexpress_config_func {
	91	struct vexpress_config_bridge *bridge;
	92	void *func;
	93	};
	94
	95	struct vexpress_config_func __vexpress_config_func_get(struct device dev,
	96	struct device_node *node)
	97	{
	98	struct device_node *bridge_node;
	99	struct vexpress_config_func *func;
	100	int i;
	101
	102	if (WARN_ON(dev && node && dev->of_node != node))
	103	return NULL;
	104	if (dev && !node)
	105	node = dev->of_node;
	106
	107	func = kzalloc(sizeof(*func), GFP_KERNEL);
	108	if (!func)
	109	return NULL;
	110
	111	bridge_node = of_node_get(node);
	112	while (bridge_node) {
	113	const __be32 *prop = of_get_property(bridge_node,
	114	"arm,vexpress,config-bridge", NULL);
	115
	116	if (prop) {
	117	bridge_node = of_find_node_by_phandle(
	118	be32_to_cpup(prop));
	119	break;
	120	}
	121
	122	bridge_node = of_get_next_parent(bridge_node);
	123	}
	124
	125	mutex_lock(&vexpress_config_bridges_mutex);
	126	for (i = 0; i < ARRAY_SIZE(vexpress_config_bridges); i++) {
	127	struct vexpress_config_bridge *bridge =
	128	&vexpress_config_bridges[i];
	129
	130	if (test_bit(i, vexpress_config_bridges_map) &&
	131	bridge->node == bridge_node) {
	132	func->bridge = bridge;
	133	func->func = bridge->info->func_get(dev, node);
	134	break;
	135	}
	136	}
	137	mutex_unlock(&vexpress_config_bridges_mutex);
	138
	139	if (!func->func) {
	140	of_node_put(node);
	141	kfree(func);
	142	return NULL;
	143	}
	144
	145	return func;
	146	}
a17155bc	147	EXPORT_SYMBOL(__vexpress_config_func_get);
3ecbf05b PM	148
	149	void vexpress_config_func_put(struct vexpress_config_func *func)
	150	{
	151	func->bridge->info->func_put(func->func);
	152	of_node_put(func->bridge->node);
	153	kfree(func);
	154	}
a17155bc	155	EXPORT_SYMBOL(vexpress_config_func_put);
3ecbf05b PM	156
	157	struct vexpress_config_trans {
	158	struct vexpress_config_func *func;
	159	int offset;
	160	bool write;
	161	u32 *data;
	162	int status;
	163	struct completion completion;
	164	struct list_head list;
	165	};
	166
	167	static void vexpress_config_dump_trans(const char *what,
	168	struct vexpress_config_trans *trans)
	169	{
	170	pr_debug("%s %s trans %p func 0x%p offset %d data 0x%x status %d\n",
	171	what, trans->write ? "write" : "read", trans,
	172	trans->func->func, trans->offset,
	173	trans->data ? *trans->data : 0, trans->status);
	174	}
	175
	176	static int vexpress_config_schedule(struct vexpress_config_trans *trans)
	177	{
	178	int status;
	179	struct vexpress_config_bridge *bridge = trans->func->bridge;
	180	unsigned long flags;
	181
	182	init_completion(&trans->completion);
	183	trans->status = -EFAULT;
	184
	185	spin_lock_irqsave(&bridge->transactions_lock, flags);
	186
367764a4 PM	187	if (list_empty(&bridge->transactions)) {
367764a4 PM	188	vexpress_config_dump_trans("Executing", trans);
3ecbf05b PM	189	status = bridge->info->func_exec(trans->func->func,
3ecbf05b PM	190	trans->offset, trans->write, trans->data);
367764a4 PM	191	} else {
367764a4 PM	192	vexpress_config_dump_trans("Queuing", trans);
3ecbf05b	193	status = VEXPRESS_CONFIG_STATUS_WAIT;
367764a4	194	}
3ecbf05b PM	195
	196	switch (status) {
	197	case VEXPRESS_CONFIG_STATUS_DONE:
	198	vexpress_config_dump_trans("Finished", trans);
	199	trans->status = status;
	200	break;
	201	case VEXPRESS_CONFIG_STATUS_WAIT:
	202	list_add_tail(&trans->list, &bridge->transactions);
	203	break;
	204	}
	205
	206	spin_unlock_irqrestore(&bridge->transactions_lock, flags);
	207
	208	return status;
	209	}
	210
	211	void vexpress_config_complete(struct vexpress_config_bridge *bridge,
	212	int status)
	213	{
	214	struct vexpress_config_trans *trans;
	215	unsigned long flags;
367764a4	216	const char *message = "Completed";
3ecbf05b PM	217
	218	spin_lock_irqsave(&bridge->transactions_lock, flags);
	219
	220	trans = list_first_entry(&bridge->transactions,
	221	struct vexpress_config_trans, list);
3ecbf05b	222	trans->status = status;
3ecbf05b	223
367764a4 PM	224	do {
	225	vexpress_config_dump_trans(message, trans);
	226	list_del(&trans->list);
	227	complete(&trans->completion);
3ecbf05b	228
367764a4 PM	229	if (list_empty(&bridge->transactions))
	230	break;
	231
	232	trans = list_first_entry(&bridge->transactions,
	233	struct vexpress_config_trans, list);
	234	vexpress_config_dump_trans("Executing pending", trans);
	235	trans->status = bridge->info->func_exec(trans->func->func,
	236	trans->offset, trans->write, trans->data);
	237	message = "Finished pending";
	238	} while (trans->status == VEXPRESS_CONFIG_STATUS_DONE);
3ecbf05b	239
367764a4	240	spin_unlock_irqrestore(&bridge->transactions_lock, flags);
3ecbf05b	241	}
a17155bc	242	EXPORT_SYMBOL(vexpress_config_complete);
3ecbf05b PM	243
	244	int vexpress_config_wait(struct vexpress_config_trans *trans)
	245	{
	246	wait_for_completion(&trans->completion);
	247
	248	return trans->status;
	249	}
a17155bc	250	EXPORT_SYMBOL(vexpress_config_wait);
3ecbf05b PM	251
	252	int vexpress_config_read(struct vexpress_config_func *func, int offset,
	253	u32 *data)
	254	{
	255	struct vexpress_config_trans trans = {
	256	.func = func,
	257	.offset = offset,
	258	.write = false,
	259	.data = data,
	260	.status = 0,
	261	};
	262	int status = vexpress_config_schedule(&trans);
	263
	264	if (status == VEXPRESS_CONFIG_STATUS_WAIT)
	265	status = vexpress_config_wait(&trans);
	266
	267	return status;
	268	}
	269	EXPORT_SYMBOL(vexpress_config_read);
	270
	271	int vexpress_config_write(struct vexpress_config_func *func, int offset,
	272	u32 data)
	273	{
	274	struct vexpress_config_trans trans = {
	275	.func = func,
	276	.offset = offset,
	277	.write = true,
	278	.data = &data,
	279	.status = 0,
	280	};
	281	int status = vexpress_config_schedule(&trans);
	282
	283	if (status == VEXPRESS_CONFIG_STATUS_WAIT)
	284	status = vexpress_config_wait(&trans);
	285
	286	return status;
	287	}
	288	EXPORT_SYMBOL(vexpress_config_write);