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

842 lines
18 KiB
C
Raw Normal View History

/*
* (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;
}