satip-axe/kernel/drivers/stm/sysconf.c
2015-03-26 17:24:57 +01:00

724 lines
16 KiB
C

/*
* Copyright (C) 2007 STMicroelectronics Limited
* Author: Stuart Menefy <stuart.menefy@st.com>
*
* May be copied or modified under the terms of the GNU General Public
* License. See linux/COPYING for more information.
*/
#include <linux/kernel.h>
#include <linux/bootmem.h>
#include <linux/io.h>
#include <linux/sysdev.h>
#include <linux/list.h>
#include <linux/platform_device.h>
#include <linux/debugfs.h>
#include <linux/seq_file.h>
#include <linux/types.h>
#include <linux/stm/platform.h>
#include <linux/stm/sysconf.h>
#define DRIVER_NAME "stm-sysconf"
struct sysconf_field {
u8 group, num;
u8 lsb, msb;
void __iomem *reg;
const char *owner;
struct list_head list;
#ifdef DEBUG
enum { magic_good = 0x600df00d, magic_bad = 0xdeadbeef } magic;
#define MAGIC_SET(field) field->magic = magic_good
#define MAGIC_CLEAR(field) field->magic = magic_bad
#define MAGIC_CHECK(field) BUG_ON(field->magic != magic_good)
#else
#define MAGIC_SET(field)
#define MAGIC_CLEAR(field)
#define MAGIC_CHECK(field)
#endif
};
struct sysconf_group {
void __iomem *base;
const char *name;
const char *(*reg_name)(int num);
struct sysconf_block *block;
};
struct sysconf_block {
void __iomem *base;
unsigned long size;
struct platform_device *pdev;
#ifdef CONFIG_PM
unsigned long *snapshot;
#endif
};
static int sysconf_blocks_num;
static struct sysconf_block *sysconf_blocks;
static int sysconf_groups_num;
static struct sysconf_group *sysconf_groups;
static LIST_HEAD(sysconf_fields);
static DEFINE_SPINLOCK(sysconf_fields_lock);
static DEFINE_SPINLOCK(sysconf_registers_lock);
/* We need a small stash of allocations before kmalloc becomes available */
#define NUM_EARLY_FIELDS 128
#define EARLY_BITS_MAPS_SIZE DIV_ROUND_UP(NUM_EARLY_FIELDS, BITS_PER_LONG)
static struct sysconf_field early_fields[NUM_EARLY_FIELDS];
static unsigned long early_fields_map[EARLY_BITS_MAPS_SIZE];
static struct sysconf_field *field_alloc(void)
{
int i;
for (i = 0; i < NUM_EARLY_FIELDS; i++)
if (test_and_set_bit(i, early_fields_map) == 0)
return &early_fields[i];
return kmalloc(sizeof(struct sysconf_field), GFP_KERNEL);
}
static void field_free(struct sysconf_field *field)
{
if (field >= early_fields && field < early_fields + NUM_EARLY_FIELDS)
clear_bit(field - early_fields, early_fields_map);
else
kfree(field);
}
struct sysconf_field *sysconf_claim(int group, int num, int lsb, int msb,
const char *devname)
{
struct sysconf_field *field, *entry;
enum {
status_searching,
status_found_register,
status_add_field_here,
status_conflict,
} status = status_searching;
int bit_avail = 0;
pr_debug("%s(group=%d, num=%d, lsb=%d, msb=%d, devname='%s')\n",
__func__, group, num, lsb, msb, devname);
BUG_ON(group < 0 || group >= sysconf_groups_num);
BUG_ON(num < 0 || num > ((1 << 8) - 1));
BUG_ON(lsb < 0 || lsb > 32);
BUG_ON(msb < 0 || msb > 32);
BUG_ON(lsb > msb);
field = field_alloc();
if (!field)
return NULL;
field->group = group;
field->num = num;
field->lsb = lsb;
field->msb = msb;
field->reg = sysconf_groups[group].base + (num * 4);
BUG_ON(field->reg >= sysconf_groups[group].block->base +
sysconf_groups[group].block->size);
field->owner = devname;
MAGIC_SET(field);
spin_lock(&sysconf_fields_lock);
/* The list is always in group->num->lsb/msb order, so it's easy to
* find a place to insert a new field (and to detect conflicts) */
list_for_each_entry(entry, &sysconf_fields, list) {
if (entry->group == group && entry->num == num) {
status = status_found_register;
/* Someone already claimed a field from this
* register - let's try to find some space for
* requested bits... */
if (bit_avail <= lsb && msb < entry->lsb) {
status = status_add_field_here;
break;
}
bit_avail = entry->msb + 1;
} else if ((entry->group == group && entry->num > num) ||
entry->group > group) {
/* Ok, there is no point of looking further -
* the group and/or num values are bigger then
* the ones we are looking for */
if ((status == status_found_register &&
bit_avail <= lsb) ||
status == status_searching)
/* A remainder of the given register is not
* used or the register wasn't used at all */
status = status_add_field_here;
else
/* Apparently some bits of the claimed field
* are already in use... */
status = status_conflict;
break;
}
}
switch (status) {
case status_searching:
case status_found_register:
/* Either nothing was on the list at all or the claimed
* field should be added as the last element... */
list_add_tail(&field->list, &sysconf_fields);
break;
case status_add_field_here:
/* So we should insert the new field between current
* list entry and the previous one */
list_add(&field->list, entry->list.prev);
break;
case status_conflict:
/* Apparently there was no place in the
* register to fulfill the request... */
MAGIC_CLEAR(field);
field_free(field);
field = NULL;
pr_debug("%s(): conflict!\n", __func__);
break;
default:
BUG();
}
spin_unlock(&sysconf_fields_lock);
pr_debug("%s()=0x%p\n", __func__, field);
return field;
}
EXPORT_SYMBOL(sysconf_claim);
void sysconf_release(struct sysconf_field *field)
{
pr_debug("%s(field=0x%p)\n", __func__, field);
BUG_ON(!field);
MAGIC_CHECK(field);
spin_lock(&sysconf_fields_lock);
list_del(&field->list);
spin_unlock(&sysconf_fields_lock);
MAGIC_CLEAR(field);
field_free(field);
}
EXPORT_SYMBOL(sysconf_release);
void sysconf_write(struct sysconf_field *field, unsigned long value)
{
int field_bits;
pr_debug("%s(field=0x%p (%s %d[%d:%d]) = 0x%08lx)\n", __func__, field,
sysconf_groups[field->group].name, field->num,
field->msb, field->lsb, value);
BUG_ON(!field);
MAGIC_CHECK(field);
field_bits = field->msb - field->lsb + 1;
BUG_ON(field_bits < 1 || field_bits > 32);
if (field_bits == 32) {
/* Operating on the whole register, nice and easy */
writel(value, field->reg);
} else {
unsigned long flags;
u32 reg_mask;
u32 tmp;
reg_mask = ~(((1 << field_bits) - 1) << field->lsb);
spin_lock_irqsave(&sysconf_registers_lock, flags);
tmp = readl(field->reg);
tmp &= reg_mask;
tmp |= value << field->lsb;
writel(tmp, field->reg);
spin_unlock_irqrestore(&sysconf_registers_lock, flags);
}
}
EXPORT_SYMBOL(sysconf_write);
unsigned long sysconf_read(struct sysconf_field *field)
{
int field_bits;
u32 result;
pr_debug("%s(field=0x%p (%s %d[%d:%d]))\n", __func__, field,
sysconf_groups[field->group].name, field->num,
field->msb, field->lsb);
BUG_ON(!field);
MAGIC_CHECK(field);
field_bits = field->msb - field->lsb + 1;
BUG_ON(field_bits < 1 || field_bits > 32);
result = readl(field->reg);
if (field_bits != 32) {
result >>= field->lsb;
result &= (1 << field_bits) - 1;
}
pr_debug("%s()=0x%u\n", __func__, result);
return result;
}
EXPORT_SYMBOL(sysconf_read);
void *sysconf_address(struct sysconf_field *field)
{
pr_debug("%s(field=0x%p)\n", __func__, field);
BUG_ON(!field);
MAGIC_CHECK(field);
pr_debug("%s()=0x%p\n", __func__, field->reg);
return field->reg;
}
EXPORT_SYMBOL(sysconf_address);
unsigned long sysconf_mask(struct sysconf_field *field)
{
int field_bits;
u32 result;
pr_debug("%s(field=0x%p)\n", __func__, field);
BUG_ON(!field);
MAGIC_CHECK(field);
field_bits = field->msb - field->lsb + 1;
BUG_ON(field_bits < 1 || field_bits > 32);
if (field_bits == 32)
result = ~0UL;
else
result = ((1 << field_bits) - 1) << field->lsb;
pr_debug("%s()=0x%u\n", __func__, result);
return result;
}
EXPORT_SYMBOL(sysconf_mask);
const char *sysconf_group_name(int group)
{
BUG_ON(group < 0 || group >= sysconf_groups_num);
return sysconf_groups[group].name;
}
EXPORT_SYMBOL(sysconf_group_name);
const char *sysconf_reg_name(int group, int num)
{
BUG_ON(group < 0 || group >= sysconf_groups_num);
return sysconf_groups[group].reg_name ?
sysconf_groups[group].reg_name(num) : NULL;
}
EXPORT_SYMBOL(sysconf_reg_name);
#ifdef CONFIG_PM
static int sysconf_pm_freeze(void)
{
int result = 0;
int i;
pr_debug("%s()\n", __func__);
for (i = 0; i < sysconf_blocks_num; i++) {
struct sysconf_block *block = &sysconf_blocks[i];
int j;
block->snapshot = kmalloc(block->size, GFP_NOWAIT);
if (!block->snapshot) {
pr_err("Failed to freeze %s!\n",
dev_name(&block->pdev->dev));
result = -ENOMEM;
continue;
}
for (j = 0; j < block->size; j += sizeof(unsigned long))
block->snapshot[j / sizeof(unsigned long)] =
readl(block->base + j);
}
pr_debug("%s()=%d\n", __func__, result);
return result;
}
static int sysconf_pm_restore(void)
{
int result = 0;
int i;
pr_debug("%s()\n", __func__);
for (i = 0; i < sysconf_blocks_num; i++) {
struct sysconf_block *block = &sysconf_blocks[i];
int j;
if (!block->snapshot) {
pr_err("Failed to restore %s!\n",
dev_name(&block->pdev->dev));
result = -EINVAL;
continue;
}
for (j = 0; j < block->size; j += sizeof(unsigned long))
writel(block->snapshot[j / sizeof(unsigned long)],
block->base + j);
kfree(block->snapshot);
block->snapshot = NULL;
}
pr_debug("%s()=%d\n", __func__, result);
return result;
}
static int sysconf_sysdev_suspend(struct sys_device *dev, pm_message_t state)
{
int result = 0;
static unsigned long prev_state = PM_EVENT_ON;
pr_debug("%s()\n", __func__);
switch (state.event) {
case PM_EVENT_ON:
if (prev_state == PM_EVENT_FREEZE)
result = sysconf_pm_restore();
break;
case PM_EVENT_SUSPEND:
break;
case PM_EVENT_FREEZE:
result = sysconf_pm_freeze();
break;
}
prev_state = state.event;
pr_debug("%s()=%d\n", __func__, result);
return result;
}
static int sysconf_sysdev_resume(struct sys_device *dev)
{
return sysconf_sysdev_suspend(dev, PMSG_ON);
}
static struct sysdev_class sysconf_sysdev_class = {
.name = "sysconf",
.suspend = sysconf_sysdev_suspend,
.resume = sysconf_sysdev_resume,
};
struct sys_device sysconf_sysdev_dev = {
.id = 0,
.cls = &sysconf_sysdev_class,
};
static int __init sysconf_sysdev_init(void)
{
int ret;
ret = sysdev_class_register(&sysconf_sysdev_class);
if (ret)
return ret;
ret = sysdev_register(&sysconf_sysdev_dev);
if (ret)
return ret;
return 0;
}
module_init(sysconf_sysdev_init);
#endif
#ifdef CONFIG_DEBUG_FS
enum sysconf_seq_state { state_blocks, state_groups, state_fields, state_last };
static void *sysconf_seq_start(struct seq_file *s, loff_t *pos)
{
if (*pos >= state_last)
return NULL;
return pos;
}
static void *sysconf_seq_next(struct seq_file *s, void *v, loff_t *pos)
{
(*pos)++;
if (*pos >= state_last)
return NULL;
return pos;
}
static void sysconf_seq_stop(struct seq_file *s, void *v)
{
}
static int sysconf_seq_show_blocks(struct seq_file *s)
{
int i;
seq_printf(s, "blocks:\n");
for (i = 0; i < sysconf_blocks_num; i++) {
struct sysconf_block *block = &sysconf_blocks[i];
struct resource *mem = platform_get_resource(block->pdev,
IORESOURCE_MEM, 0);
seq_printf(s, "- %s: 0x%08x (0x%p), 0x%lxb\n",
dev_name(&block->pdev->dev), mem->start,
block->base, block->size);
}
seq_printf(s, "\n");
return 0;
}
static int sysconf_seq_show_groups(struct seq_file *s)
{
int i;
seq_printf(s, "groups:\n");
for (i = 0; i < sysconf_groups_num; i++) {
struct sysconf_group *group = &sysconf_groups[i];
seq_printf(s, "- %s: 0x%p (%s)\n",
group->name, group->base,
dev_name(&group->block->pdev->dev));
}
seq_printf(s, "\n");
return 0;
}
static int sysconf_seq_show_fields(struct seq_file *s)
{
struct sysconf_field *field;
seq_printf(s, "claimed fields:\n");
spin_lock(&sysconf_fields_lock);
list_for_each_entry(field, &sysconf_fields, list) {
struct sysconf_group *group = &sysconf_groups[field->group];
if (group->reg_name)
seq_printf(s, "- %s[", group->reg_name(field->num));
else
seq_printf(s, "- %s%d[", group->name, field->num);
if (field->msb == field->lsb)
seq_printf(s, "%d", field->msb);
else
seq_printf(s, "%d:%d", field->msb, field->lsb);
seq_printf(s, "] = 0x%0*lx (0x%p, %s)\n",
(field->msb - field->lsb + 4) / 4,
sysconf_read(field),
field->reg, field->owner);
}
spin_unlock(&sysconf_fields_lock);
seq_printf(s, "\n");
return 0;
}
static int sysconf_seq_show(struct seq_file *s, void *v)
{
enum sysconf_seq_state state = *((loff_t *)v);
switch (state) {
case state_blocks:
return sysconf_seq_show_blocks(s);
case state_groups:
return sysconf_seq_show_groups(s);
case state_fields:
return sysconf_seq_show_fields(s);
default:
BUG();
return -EINVAL;
}
}
static struct seq_operations sysconf_seq_ops = {
.start = sysconf_seq_start,
.next = sysconf_seq_next,
.stop = sysconf_seq_stop,
.show = sysconf_seq_show,
};
static int sysconf_debugfs_open(struct inode *inode, struct file *file)
{
return seq_open(file, &sysconf_seq_ops);
}
static const struct file_operations sysconf_debugfs_ops = {
.owner = THIS_MODULE,
.open = sysconf_debugfs_open,
.read = seq_read,
.llseek = seq_lseek,
.release = seq_release,
};
static int __init sysconf_debugfs_init(void)
{
debugfs_create_file("sysconf", S_IFREG | S_IRUGO,
NULL, NULL, &sysconf_debugfs_ops);
return 0;
}
subsys_initcall(sysconf_debugfs_init);
#endif
/* This is called early to allow board start up code to use sysconf
* registers (in particular console devices). */
void __init sysconf_early_init(struct platform_device *pdevs, int pdevs_num)
{
int i;
pr_debug("%s(pdevs=%p, pdevs_num=%d)\n", __func__, pdevs, pdevs_num);
/* I don't like panicing, but if we failed here, we probably
* don't have any way to report things have gone wrong.
* So a panic here at least gives some hope of being
* able to debug the problem. */
sysconf_blocks_num = pdevs_num;
sysconf_blocks = alloc_bootmem(sizeof(*sysconf_blocks) *
sysconf_blocks_num);
if (!sysconf_blocks)
panic("Failed to allocate memory for sysconf blocks!");
for (i = 0; i < sysconf_blocks_num; i++) {
struct sysconf_block *block = &sysconf_blocks[i];
struct stm_plat_sysconf_data *data = pdevs[i].dev.platform_data;
struct resource *mem;
block->pdev = &pdevs[i];
mem = platform_get_resource(&pdevs[i], IORESOURCE_MEM, 0);
BUG_ON(!mem);
block->size = mem->end - mem->start + 1;
block->base = ioremap(mem->start, block->size);
if (!block->base)
panic("Unable to ioremap %s registers!",
dev_name(&block->pdev->dev));
sysconf_groups_num += data->groups_num;
}
sysconf_groups = alloc_bootmem(sizeof(*sysconf_groups) *
sysconf_groups_num);
if (!sysconf_groups)
panic("Failed to allocate memory for sysconf groups!\n");
for (i = 0; i < sysconf_blocks_num; i++) {
struct stm_plat_sysconf_data *data = pdevs[i].dev.platform_data;
struct sysconf_block *block = &sysconf_blocks[i];
int j;
for (j = 0; j < data->groups_num; j++) {
struct stm_plat_sysconf_group *info = &data->groups[j];
struct sysconf_group *group;
BUG_ON(info->group < 0 ||
info->group >= sysconf_groups_num);
group = &sysconf_groups[info->group];
BUG_ON(group->base != NULL);
group->base = block->base + info->offset;
group->name = info->name;
group->reg_name = info->reg_name;
group->block = block;
}
}
}
static int __init sysconf_probe(struct platform_device *pdev)
{
int result = -EINVAL;
int i;
pr_debug("%s(pdev=%p)\n", __func__, pdev);
/* Confirm that the device has been initialized earlier */
for (i = 0; i < sysconf_blocks_num; i++) {
if (sysconf_blocks[i].pdev == pdev) {
result = 0;
break;
}
}
if (result == 0) {
struct resource *mem = platform_get_resource(pdev,
IORESOURCE_MEM, 0);
BUG_ON(!mem);
if (request_mem_region(mem->start, mem->end -
mem->start + 1, pdev->name) == NULL) {
pr_err("Memory region request failed for %s!\n",
dev_name(&pdev->dev));
result = -EBUSY;
}
}
pr_debug("%s()=%d\n", __func__, result);
return result;
}
static struct platform_driver sysconf_driver = {
.probe = sysconf_probe,
.driver = {
.name = DRIVER_NAME,
.owner = THIS_MODULE,
},
};
static int __init sysconf_init(void)
{
return platform_driver_register(&sysconf_driver);
}
arch_initcall(sysconf_init);