satip-axe/kernel/drivers/stm/pad.c

/*
 * (c) 2010 STMicroelectronics Limited
 *
 * Author: Pawel Moll <pawel.moll@st.com>
 *
 * 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.
 */



#include <linux/kernel.h>
#include <linux/bootmem.h>
#include <linux/bug.h>
#include <linux/debugfs.h>
#include <linux/gpio.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/seq_file.h>
#include <linux/stm/pad.h>
#include <linux/stm/sysconf.h>
#include <linux/module.h>



/* Internal memory allocation (may be used very early, when
 * no kmalloc() is possible yet...) */

#define STM_PAD_STATIC_BUFFER_SIZE 1024

static unsigned char stm_pad_static_buffer[STM_PAD_STATIC_BUFFER_SIZE];
static unsigned char *stm_pad_static_buffer_pointer = stm_pad_static_buffer;
static int stm_pad_static_buffer_avail = sizeof(stm_pad_static_buffer);

static void *stm_pad_alloc(int size)
{
	void *result = NULL;

	size = ALIGN(size, 4);

	if (stm_pad_static_buffer_avail >= size) {
		result = stm_pad_static_buffer_pointer;
		stm_pad_static_buffer_avail -= size;
		stm_pad_static_buffer_pointer += size;
	} else {
		static int notified;

		if (!notified) {
			pr_debug("stm_pad: Out of static buffer!\n");
			notified = 1;
		}

		result = kzalloc(size, GFP_KERNEL);
	}

	return result;
}

static void stm_pad_free(void *addr)
{
	if (addr >= (void *)stm_pad_static_buffer &&
			addr < (void *)(stm_pad_static_buffer +
			STM_PAD_STATIC_BUFFER_SIZE))
		return;

	kfree(addr);
}



/* Pads interface implementation */

static int stm_pad_initialized;

struct stm_pad_state {
	struct list_head list;
	const char *owner;
	struct stm_pad_config *config;
	struct sysconf_field *sysconf_fields[0]; /* To be expanded */
};
static LIST_HEAD(stm_pad_list);

static enum {
	stm_pad_gpio_unused = 0,
	stm_pad_gpio_normal_gpio,
	stm_pad_gpio_claimed,
	stm_pad_gpio_claimed_to_be_requested,
	stm_pad_gpio_claimed_requested,
} *stm_pad_gpios;
static int stm_pad_gpios_num;

static DEFINE_MUTEX(stm_pad_mutex);

static int stm_pad_gpio_function_in;
static int stm_pad_gpio_function_out;

static int (*stm_pad_gpio_config)(unsigned gpio,
		enum stm_pad_gpio_direction direction,
		int function, void *priv);



int __init stm_pad_init(int gpios_num,
			int gpio_function_in, int gpio_function_out,
			int (*gpio_config)(unsigned gpio,
			enum stm_pad_gpio_direction direction,
			int function, void *priv))
{
	BUG_ON(!gpio_config);

	stm_pad_gpios = alloc_bootmem(sizeof(*stm_pad_gpios) * gpios_num);
	stm_pad_gpios_num = gpios_num;
	stm_pad_gpio_function_in = gpio_function_in;
	stm_pad_gpio_function_out = gpio_function_out;
	stm_pad_gpio_config = gpio_config;

	stm_pad_initialized = 1;

	return 0;
}



static int __stm_pad_claim(struct stm_pad_config *config,
		struct stm_pad_state *state, const char *owner)
{
	int i;

	BUG_ON(!stm_pad_initialized);
	WARN_ON(!owner);

	mutex_lock(&stm_pad_mutex);

	state->owner = owner;
	state->config = config;

	for (i = 0; i < config->gpios_num; i++) {
		struct stm_pad_gpio *pad_gpio = &config->gpios[i];
		unsigned gpio = pad_gpio->gpio;

		if (pad_gpio->direction == stm_pad_gpio_direction_ignored)
			continue;

		BUG_ON(pad_gpio->direction != stm_pad_gpio_direction_in &&
				pad_gpio->direction !=
				stm_pad_gpio_direction_out &&
				pad_gpio->direction !=
				stm_pad_gpio_direction_bidir &&
				pad_gpio->direction !=
				stm_pad_gpio_direction_custom);

		if (stm_pad_gpios[gpio] != stm_pad_gpio_unused)
			goto error_gpios;

		stm_pad_gpios[gpio] = stm_pad_gpio_claimed;

		if (stm_pad_gpio_config(gpio, pad_gpio->direction,
				pad_gpio->function, pad_gpio->priv) != 0) {
			i++; /* Current GPIO must be released as well... */
			goto error_gpios;
		}
	}

	for (i = 0; i < config->sysconfs_num; i++) {
		struct stm_pad_sysconf *sysconf = &config->sysconfs[i];

		state->sysconf_fields[i] = sysconf_claim(sysconf->regtype,
				sysconf->regnum, sysconf->lsb, sysconf->msb,
				owner);
		if (!state->sysconf_fields[i])
			goto error_sysconfs;
		BUG_ON(sysconf->value < 0);
		sysconf_write(state->sysconf_fields[i], sysconf->value);
	}

	list_add(&state->list, &stm_pad_list);

	mutex_unlock(&stm_pad_mutex);

	if (config->custom_claim &&
			config->custom_claim(state, config->custom_priv) != 0)
		goto error_custom;

	return 0;

error_custom:
	mutex_lock(&stm_pad_mutex);

	list_del(&state->list);

error_sysconfs:
	for (i = 0; i < config->sysconfs_num; i++)
		if (state->sysconf_fields[i])
			sysconf_release(state->sysconf_fields[i]);
		else
			break;
	i = config->gpios_num;
error_gpios:
	while (i--)
		stm_pad_gpios[config->gpios[i].gpio] = stm_pad_gpio_unused;

	mutex_unlock(&stm_pad_mutex);

	return -EBUSY;
}

static int __stm_pad_release(struct stm_pad_state *state)
{
	struct stm_pad_config *config = state->config;
	int i;

	if (config->custom_release)
		config->custom_release(state, config->custom_priv);

	mutex_lock(&stm_pad_mutex);

	list_del(&state->list);

	for (i = 0; i < config->sysconfs_num; i++)
		sysconf_release(state->sysconf_fields[i]);

	for (i = 0; i < config->gpios_num; i++) {
		unsigned gpio = config->gpios[i].gpio;

		BUG_ON(stm_pad_gpios[gpio] != stm_pad_gpio_claimed);
		stm_pad_gpios[gpio] = stm_pad_gpio_unused;
	}

	mutex_unlock(&stm_pad_mutex);

	return 0;
}



struct stm_pad_state *stm_pad_claim(struct stm_pad_config *config,
		const char *owner)
{
	struct stm_pad_state *state = kzalloc(sizeof(*state) +
			sizeof(*state->sysconf_fields) * config->sysconfs_num,
			GFP_KERNEL);

	BUG_ON(!config);
	BUG_ON(!owner);

	if (state && __stm_pad_claim(config, state, owner) != 0)
		state = NULL;

	return state;
}
EXPORT_SYMBOL(stm_pad_claim);

void stm_pad_release(struct stm_pad_state *state)
{
	BUG_ON(!state);

	__stm_pad_release(state);

	stm_pad_free(state);
}
EXPORT_SYMBOL(stm_pad_release);




static void stm_pad_devres_release(struct device *dev, void *res)
{
	struct stm_pad_state *state = res;

	__stm_pad_release(state);
}

static int stm_pad_devres_match(struct device *dev, void *res, void *data)
{
	struct stm_pad_state *state = res, *match = data;

	return state == match;
}

struct stm_pad_state *devm_stm_pad_claim(struct device *dev,
	struct stm_pad_config *config, const char *owner)
{
	struct stm_pad_state *state = devres_alloc(stm_pad_devres_release,
			sizeof(*state) + sizeof(*state->sysconf_fields) *
			config->sysconfs_num, GFP_KERNEL);

	BUG_ON(!config);
	BUG_ON(!owner);

	if (state) {
		if (__stm_pad_claim(config, state, owner) == 0) {
			devres_add(dev, state);
		} else {
			devres_free(state);
			state = NULL;
		}
	}

	return state;
}
EXPORT_SYMBOL(devm_stm_pad_claim);

void devm_stm_pad_release(struct device *dev, struct stm_pad_state *state)
{
	int err;

	__stm_pad_release(state);

	err = devres_destroy(dev, stm_pad_devres_release,
			stm_pad_devres_match, state);
	WARN_ON(err);
}
EXPORT_SYMBOL(devm_stm_pad_release);



/* Private interface for GPIO driver */

int stm_pad_claim_gpio(unsigned gpio)
{
	int result = 0;

	BUG_ON(!stm_pad_initialized);
	BUG_ON(gpio > stm_pad_gpios_num);

	mutex_lock(&stm_pad_mutex);

	switch (stm_pad_gpios[gpio]) {
	case stm_pad_gpio_unused:
		stm_pad_gpios[gpio] = stm_pad_gpio_normal_gpio;
		break;
	case stm_pad_gpio_claimed_to_be_requested:
		stm_pad_gpios[gpio] = stm_pad_gpio_claimed_requested;
		break;
	case stm_pad_gpio_normal_gpio:
	case stm_pad_gpio_claimed:
	case stm_pad_gpio_claimed_requested:
		result = -EBUSY;
		break;
	default:
		result = -EINVAL;
		BUG();
		break;
	}

	mutex_unlock(&stm_pad_mutex);

	return result;
}

void stm_pad_configure_gpio(unsigned gpio, unsigned direction)
{
	switch (direction) {
	case STM_GPIO_DIRECTION_IN:
		stm_pad_gpio_config(gpio, stm_pad_gpio_direction_in,
				    stm_pad_gpio_function_in, NULL);
		break;
	case STM_GPIO_DIRECTION_OUT:
		stm_pad_gpio_config(gpio, stm_pad_gpio_direction_out,
				    stm_pad_gpio_function_out, NULL);
		break;
	default:
		BUG();
		break;
	}
}

void stm_pad_release_gpio(unsigned gpio)
{
	BUG_ON(gpio > stm_pad_gpios_num);

	mutex_lock(&stm_pad_mutex);

	switch (stm_pad_gpios[gpio]) {
	case stm_pad_gpio_normal_gpio:
		stm_pad_gpios[gpio] = stm_pad_gpio_unused;
		break;
	case stm_pad_gpio_claimed_requested:
		stm_pad_gpios[gpio] = stm_pad_gpio_claimed;
		break;
	default:
		BUG();
		break;

	}

	mutex_unlock(&stm_pad_mutex);
}

const char *stm_pad_get_gpio_owner(unsigned gpio)
{
	const char *result = NULL;
	struct stm_pad_state *state;

	BUG_ON(gpio > stm_pad_gpios_num);

	mutex_lock(&stm_pad_mutex);

	list_for_each_entry(state, &stm_pad_list, list) {
		struct stm_pad_config *config = state->config;
		int i;

		for (i = 0; i < config->gpios_num; i++) {
			if (config->gpios[i].gpio == gpio) {
				result = state->owner;
				if (!result)
					result = "?";
			}
		}

		if (result)
			break;
	}

	mutex_unlock(&stm_pad_mutex);

	return result;
}



/* GPIO interface */

static struct stm_pad_gpio *stm_pad_find_gpio(struct stm_pad_config *config,
		const char *name);

static int __stm_pad_gpio_request(struct stm_pad_gpio *pad_gpio,
		const char *owner)
{
	int result = -EBUSY;
	unsigned gpio = pad_gpio->gpio;

	BUG_ON(!stm_pad_initialized);

	mutex_lock(&stm_pad_mutex);

	if (stm_pad_gpios[gpio] == stm_pad_gpio_claimed) {
		int err;

		stm_pad_gpios[gpio] = stm_pad_gpio_claimed_to_be_requested;

		mutex_unlock(&stm_pad_mutex);

		err = gpio_request(gpio, owner);

		mutex_lock(&stm_pad_mutex);

		if (err != 0)
			stm_pad_gpios[gpio] = stm_pad_gpio_claimed;

		result = err;
	}

	mutex_unlock(&stm_pad_mutex);

	return result;
}

unsigned stm_pad_gpio_request_input(struct stm_pad_state *state,
		const char *name)
{
	unsigned result = STM_GPIO_INVALID;
	struct stm_pad_gpio *pad_gpio = stm_pad_find_gpio(state->config, name);

	if (pad_gpio && __stm_pad_gpio_request(pad_gpio, state->owner) == 0) {
		gpio_direction_input(pad_gpio->gpio);
		stm_pad_gpio_config(pad_gpio->gpio, stm_pad_gpio_direction_in,
				    stm_pad_gpio_function_in, pad_gpio->priv);

		result = pad_gpio->gpio;
	}

	return result;
}

unsigned stm_pad_gpio_request_output(struct stm_pad_state *state,
		const char *name, int value)
{
	unsigned result = STM_GPIO_INVALID;
	struct stm_pad_gpio *pad_gpio = stm_pad_find_gpio(state->config, name);

	if (pad_gpio && __stm_pad_gpio_request(pad_gpio, state->owner) == 0) {
		BUG_ON(value < 0);
		BUG_ON(value > 1);
		gpio_direction_output(pad_gpio->gpio, value);
		stm_pad_gpio_config(pad_gpio->gpio, stm_pad_gpio_direction_out,
				    stm_pad_gpio_function_out, pad_gpio->priv);

		result = pad_gpio->gpio;
	}

	return result;
}
EXPORT_SYMBOL(stm_pad_gpio_request_output);

void stm_pad_gpio_free(struct stm_pad_state *state, unsigned gpio)
{
	struct stm_pad_config *config;
	int i;

	BUG_ON(!state);
	config = state->config;

	for (i = 0; i < config->gpios_num; i++) {
		struct stm_pad_gpio *pad_gpio = &config->gpios[i];

		if (pad_gpio->gpio == gpio) {
			gpio_free(gpio);

			stm_pad_gpio_config(gpio, pad_gpio->direction,
					pad_gpio->function, pad_gpio->priv);

			return;
		}
	}

	/* Should never be here... */
	BUG();
}
EXPORT_SYMBOL(stm_pad_gpio_free);


/* debugfs view of used pads */

#ifdef CONFIG_DEBUG_FS

static void *stm_pad_seq_start(struct seq_file *s, loff_t *pos)
{
	mutex_lock(&stm_pad_mutex);

	return seq_list_start(&stm_pad_list, *pos);
}

static void *stm_pad_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
	return seq_list_next(v, &stm_pad_list, pos);
}

static void stm_pad_seq_stop(struct seq_file *s, void *v)
{
	mutex_unlock(&stm_pad_mutex);
}

static int stm_pad_seq_show(struct seq_file *s, void *v)
{
	struct stm_pad_state *state = list_entry(v, struct stm_pad_state,
			list);
	struct stm_pad_config *config = state->config;
	int i;

	seq_printf(s, "*** %s ***\n", state->owner);

	for (i = 0; i < config->gpios_num; i++) {
		struct stm_pad_gpio *pad_gpio = &config->gpios[i];
		static const char *directions[] = {
			[stm_pad_gpio_direction_in] = "input",
			[stm_pad_gpio_direction_out] = "output",
			[stm_pad_gpio_direction_bidir] = "bidirectional",
			[stm_pad_gpio_direction_custom] = "custom mode",
		};

		if (i == 0)
			seq_printf(s, "- GPIOs:\n");

		if (pad_gpio->direction == stm_pad_gpio_direction_ignored)
			continue;

		BUG_ON(pad_gpio->direction >= ARRAY_SIZE(directions));

		seq_printf(s, "  - %d: PIO%d.%d: %s, function %d",
				pad_gpio->gpio,
				stm_gpio_port(pad_gpio->gpio),
				stm_gpio_pin(pad_gpio->gpio),
				directions[pad_gpio->direction],
				pad_gpio->function);
		if (pad_gpio->name)
			seq_printf(s, ", '%s'", pad_gpio->name);
		seq_printf(s, "\n");
	}

	for (i = 0; i < config->sysconfs_num; i++) {
		struct stm_pad_sysconf *sysconf = &config->sysconfs[i];
		const char *name = sysconf_reg_name(sysconf->regtype,
				sysconf->regnum);

		if (i == 0)
			seq_printf(s, "- System Configuration values:\n");

		seq_printf(s, "  - ");
		if (name) {
			seq_printf(s, "%s", name);
		} else {
			name = sysconf_group_name(sysconf->regtype);
			if (name)
				seq_printf(s, "%s%d", name, sysconf->regnum);
			else
				seq_printf(s, "%d.%d", sysconf->regtype,
						sysconf->regnum);
		}

		if (sysconf->msb == sysconf->lsb)
			seq_printf(s, "[%d]", sysconf->lsb);
		else
			seq_printf(s, "[%d:%d]", sysconf->msb, sysconf->lsb);

		seq_printf(s, " = 0x%0*lx\n",
				(sysconf->msb - sysconf->lsb + 4) / 4,
				sysconf_read(state->sysconf_fields[i]));
	}

	if (config->custom_claim) {
		seq_printf(s, "- custom claim");
		if (!config->custom_release)
			seq_printf(s, " and release");
		seq_printf(s, "\n");
	}

	seq_printf(s, "\n");

	return 0;
}

static const struct seq_operations stm_pad_seq_ops = {
	.start = stm_pad_seq_start,
	.next = stm_pad_seq_next,
	.stop = stm_pad_seq_stop,
	.show = stm_pad_seq_show,
};

static int stm_pad_debugfs_open(struct inode *inode, struct file *file)
{
	BUG_ON(!stm_pad_initialized);

	return seq_open(file, &stm_pad_seq_ops);
}

static const struct file_operations stm_pad_debugfs_ops = {
	.owner = THIS_MODULE,
	.open = stm_pad_debugfs_open,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = seq_release,
};

static int __init stm_pad_debugfs_init(void)
{
	debugfs_create_file("pads", S_IFREG | S_IRUGO,
			NULL, NULL, &stm_pad_debugfs_ops);

	return 0;
}
subsys_initcall(stm_pad_debugfs_init);

#endif /* CONFIG_DEBUG_FS */



/* Configuration structure helpers */

static struct stm_pad_gpio *stm_pad_find_gpio(struct stm_pad_config *config,
		const char *name)
{
	struct stm_pad_gpio *result = NULL;
	int i;

	BUG_ON(!name);

	for (i = 0; i < config->gpios_num; i++) {
		struct stm_pad_gpio *pad_gpio = &config->gpios[i];

		if (pad_gpio->name && strcmp(name, pad_gpio->name) == 0) {
			result = pad_gpio;
			break;
		}
	}

	return result;
}

int __init stm_pad_set_gpio(struct stm_pad_config *config, const char *name,
		unsigned gpio)
{
	int result = -EINVAL;
	struct stm_pad_gpio *pad_gpio = stm_pad_find_gpio(config, name);

	WARN_ON(!pad_gpio);
	if (pad_gpio) {
		pad_gpio->gpio = gpio;
		result = 0;
	}

	return result;
}

int __init stm_pad_set_priv(struct stm_pad_config *config, const char *name,
		void *priv)
{
	int result = -EINVAL;
	struct stm_pad_gpio *pad_gpio = stm_pad_find_gpio(config, name);

	WARN_ON(!pad_gpio);
	if (pad_gpio) {
		pad_gpio->priv = priv;
		result = 0;
	}

	return result;
}

int __init stm_pad_set_direction_function(struct stm_pad_config *config,
		const char *name, enum stm_pad_gpio_direction direction,
		int out_value, int function)
{
	int result = -EINVAL;
	struct stm_pad_gpio *pad_gpio = stm_pad_find_gpio(config, name);

	WARN_ON(!pad_gpio);
	if (pad_gpio) {
		pad_gpio->direction = direction;
		pad_gpio->out_value = out_value;
		pad_gpio->function = function;
		result = 0;
	}

	return result;
}



/* Dynamic configuration routines */

#define to_dynamic(config) \
		container_of(config, struct stm_pad_config_dynamic, config)

#if defined(CONFIG_BUG)
#define MAGIC_FIELD enum { magic_good = 0x600df00d } magic;
#define MAGIC_SET(d) d->magic = magic_good
#define MAGIC_CHECK(d) BUG_ON(d->magic != magic_good)
#else
#define MAGIC_FIELD
#define MAGIC_SET(d)
#define MAGIC_CHECK(d)
#endif

struct stm_pad_config_dynamic {
	MAGIC_FIELD
	int sysconfs_allocated;
	int gpios_allocated;
	struct stm_pad_config config;
};

struct stm_pad_config * __init stm_pad_config_alloc(int gpios_num,
		int sysconfs_num)
{
	struct stm_pad_config *config;
	struct stm_pad_config_dynamic *dynamic;

	dynamic = stm_pad_alloc(sizeof(struct stm_pad_config_dynamic) +
			sizeof(struct stm_pad_gpio) * gpios_num +
			sizeof(struct stm_pad_sysconf) * sysconfs_num);
	if (!dynamic)
		return NULL;
	MAGIC_SET(dynamic);

	/* +------------+
	 * | dynamic    | sizeof(struct stm_pad_config_dynamic)
	 * | { config } |
	 * +------------+
	 * | gpios      | sizeof(struct stm_pad_gpio) * gpios_num
	 * +------------+
	 * | sysconfs   | sizeof(struct stm_pad_sysconf) * sysconfs_num
	 * +------------+
	 */

	config = &dynamic->config;

	dynamic->gpios_allocated = gpios_num;
	config->gpios = (void *)dynamic + sizeof(struct stm_pad_config_dynamic);

	dynamic->sysconfs_allocated = sysconfs_num;
	config->sysconfs = (void *)config->gpios +
			sizeof(struct stm_pad_gpio) * gpios_num;

	return config;
}

int __init stm_pad_config_add_sysconf(struct stm_pad_config *config,
		int regtype, int regnum, int lsb, int msb, int value)
{
	int result = -ENOMEM;
	struct stm_pad_config_dynamic *dynamic;
	struct stm_pad_sysconf *sysconf;

	BUG_ON(!config);
	dynamic = to_dynamic(config);
	MAGIC_CHECK(dynamic);

	WARN_ON(config->sysconfs_num == dynamic->sysconfs_allocated);
	if (config->sysconfs_num < dynamic->sysconfs_allocated) {
		sysconf = config->sysconfs + config->sysconfs_num++;

		sysconf->regtype = regtype;
		sysconf->regnum = regnum;
		sysconf->lsb = lsb;
		sysconf->msb = msb;
		sysconf->value = value;

		result = 0;
	}

	return result;
}

int __init stm_pad_config_add_gpio_named(struct stm_pad_config *config,
		unsigned gpio, enum stm_pad_gpio_direction direction,
		int out_value, int function, const char *name)
{
	int result = -ENOMEM;
	struct stm_pad_config_dynamic *dynamic;
	struct stm_pad_gpio *pad_gpio;

	BUG_ON(!config);
	dynamic = to_dynamic(config);
	MAGIC_CHECK(dynamic);

	WARN_ON(config->gpios_num == dynamic->gpios_allocated);
	if (config->gpios_num < dynamic->gpios_allocated) {
		pad_gpio = config->gpios + config->gpios_num++;

		pad_gpio->gpio = gpio;
		pad_gpio->direction = direction;
		pad_gpio->out_value = out_value;
		pad_gpio->function = function;
		pad_gpio->name = name;

		result = 0;
	}

	return result;
}