linux/drivers/mfd/abx500-core.c
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2007-2010 ST-Ericsson
   3 * License terms: GNU General Public License (GPL) version 2
   4 * Register access functions for the ABX500 Mixed Signal IC family.
   5 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
   6 */
   7
   8#include <linux/list.h>
   9#include <linux/slab.h>
  10#include <linux/err.h>
  11#include <linux/module.h>
  12#include <linux/mfd/abx500.h>
  13
  14static LIST_HEAD(abx500_list);
  15
  16struct abx500_device_entry {
  17        struct list_head list;
  18        struct abx500_ops ops;
  19        struct device *dev;
  20};
  21
  22static void lookup_ops(struct device *dev, struct abx500_ops **ops)
  23{
  24        struct abx500_device_entry *dev_entry;
  25
  26        *ops = NULL;
  27        list_for_each_entry(dev_entry, &abx500_list, list) {
  28                if (dev_entry->dev == dev) {
  29                        *ops = &dev_entry->ops;
  30                        return;
  31                }
  32        }
  33}
  34
  35int abx500_register_ops(struct device *dev, struct abx500_ops *ops)
  36{
  37        struct abx500_device_entry *dev_entry;
  38
  39        dev_entry = kzalloc(sizeof(struct abx500_device_entry), GFP_KERNEL);
  40        if (!dev_entry) {
  41                dev_err(dev, "register_ops kzalloc failed");
  42                return -ENOMEM;
  43        }
  44        dev_entry->dev = dev;
  45        memcpy(&dev_entry->ops, ops, sizeof(struct abx500_ops));
  46
  47        list_add_tail(&dev_entry->list, &abx500_list);
  48        return 0;
  49}
  50EXPORT_SYMBOL(abx500_register_ops);
  51
  52void abx500_remove_ops(struct device *dev)
  53{
  54        struct abx500_device_entry *dev_entry, *tmp;
  55
  56        list_for_each_entry_safe(dev_entry, tmp, &abx500_list, list)
  57        {
  58                if (dev_entry->dev == dev) {
  59                        list_del(&dev_entry->list);
  60                        kfree(dev_entry);
  61                }
  62        }
  63}
  64EXPORT_SYMBOL(abx500_remove_ops);
  65
  66int abx500_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
  67        u8 value)
  68{
  69        struct abx500_ops *ops;
  70
  71        lookup_ops(dev->parent, &ops);
  72        if ((ops != NULL) && (ops->set_register != NULL))
  73                return ops->set_register(dev, bank, reg, value);
  74        else
  75                return -ENOTSUPP;
  76}
  77EXPORT_SYMBOL(abx500_set_register_interruptible);
  78
  79int abx500_get_register_interruptible(struct device *dev, u8 bank, u8 reg,
  80        u8 *value)
  81{
  82        struct abx500_ops *ops;
  83
  84        lookup_ops(dev->parent, &ops);
  85        if ((ops != NULL) && (ops->get_register != NULL))
  86                return ops->get_register(dev, bank, reg, value);
  87        else
  88                return -ENOTSUPP;
  89}
  90EXPORT_SYMBOL(abx500_get_register_interruptible);
  91
  92int abx500_get_register_page_interruptible(struct device *dev, u8 bank,
  93        u8 first_reg, u8 *regvals, u8 numregs)
  94{
  95        struct abx500_ops *ops;
  96
  97        lookup_ops(dev->parent, &ops);
  98        if ((ops != NULL) && (ops->get_register_page != NULL))
  99                return ops->get_register_page(dev, bank,
 100                        first_reg, regvals, numregs);
 101        else
 102                return -ENOTSUPP;
 103}
 104EXPORT_SYMBOL(abx500_get_register_page_interruptible);
 105
 106int abx500_mask_and_set_register_interruptible(struct device *dev, u8 bank,
 107        u8 reg, u8 bitmask, u8 bitvalues)
 108{
 109        struct abx500_ops *ops;
 110
 111        lookup_ops(dev->parent, &ops);
 112        if ((ops != NULL) && (ops->mask_and_set_register != NULL))
 113                return ops->mask_and_set_register(dev, bank,
 114                        reg, bitmask, bitvalues);
 115        else
 116                return -ENOTSUPP;
 117}
 118EXPORT_SYMBOL(abx500_mask_and_set_register_interruptible);
 119
 120int abx500_get_chip_id(struct device *dev)
 121{
 122        struct abx500_ops *ops;
 123
 124        lookup_ops(dev->parent, &ops);
 125        if ((ops != NULL) && (ops->get_chip_id != NULL))
 126                return ops->get_chip_id(dev);
 127        else
 128                return -ENOTSUPP;
 129}
 130EXPORT_SYMBOL(abx500_get_chip_id);
 131
 132int abx500_event_registers_startup_state_get(struct device *dev, u8 *event)
 133{
 134        struct abx500_ops *ops;
 135
 136        lookup_ops(dev->parent, &ops);
 137        if ((ops != NULL) && (ops->event_registers_startup_state_get != NULL))
 138                return ops->event_registers_startup_state_get(dev, event);
 139        else
 140                return -ENOTSUPP;
 141}
 142EXPORT_SYMBOL(abx500_event_registers_startup_state_get);
 143
 144int abx500_startup_irq_enabled(struct device *dev, unsigned int irq)
 145{
 146        struct abx500_ops *ops;
 147
 148        lookup_ops(dev->parent, &ops);
 149        if ((ops != NULL) && (ops->startup_irq_enabled != NULL))
 150                return ops->startup_irq_enabled(dev, irq);
 151        else
 152                return -ENOTSUPP;
 153}
 154EXPORT_SYMBOL(abx500_startup_irq_enabled);
 155
 156void abx500_dump_all_banks(void)
 157{
 158        struct abx500_ops *ops;
 159        struct device dummy_child = {0};
 160        struct abx500_device_entry *dev_entry;
 161
 162        list_for_each_entry(dev_entry, &abx500_list, list) {
 163                dummy_child.parent = dev_entry->dev;
 164                ops = &dev_entry->ops;
 165
 166                if ((ops != NULL) && (ops->dump_all_banks != NULL))
 167                        ops->dump_all_banks(&dummy_child);
 168        }
 169}
 170EXPORT_SYMBOL(abx500_dump_all_banks);
 171
 172MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
 173MODULE_DESCRIPTION("ABX500 core driver");
 174MODULE_LICENSE("GPL");
 175
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.