drivers/mfd/abx500-core.c

   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/mfd/abx500.h>
  12
  13 static LIST_HEAD(abx500_list);
  14
  15 struct abx500_device_entry {
  16         struct list_head list;
  17         struct abx500_ops ops;
  18         struct device *dev;
  19 };
  20
  21 static void lookup_ops(struct device *dev, struct abx500_ops **ops)
  22 {
  23         struct abx500_device_entry *dev_entry;
  24
  25         *ops = NULL;
  26         list_for_each_entry(dev_entry, &abx500_list, list) {
  27                 if (dev_entry->dev == dev) {
  28                         *ops = &dev_entry->ops;
  29                         return;
  30                 }
  31         }
  32 }
  33
  34 int abx500_register_ops(struct device *dev, struct abx500_ops *ops)
  35 {
  36         struct abx500_device_entry *dev_entry;
  37
  38         dev_entry = kzalloc(sizeof(struct abx500_device_entry), GFP_KERNEL);
  39         if (IS_ERR(dev_entry)) {
  40                 dev_err(dev, "register_ops kzalloc failed");
  41                 return -ENOMEM;
  42         }
  43         dev_entry->dev = dev;
  44         memcpy(&dev_entry->ops, ops, sizeof(struct abx500_ops));
  45
  46         list_add_tail(&dev_entry->list, &abx500_list);
  47         return 0;
  48 }
  49 EXPORT_SYMBOL(abx500_register_ops);
  50
  51 void abx500_remove_ops(struct device *dev)
  52 {
  53         struct abx500_device_entry *dev_entry, *tmp;
  54
  55         list_for_each_entry_safe(dev_entry, tmp, &abx500_list, list)
  56         {
  57                 if (dev_entry->dev == dev) {
  58                         list_del(&dev_entry->list);
  59                         kfree(dev_entry);
  60                 }
  61         }
  62 }
  63 EXPORT_SYMBOL(abx500_remove_ops);
  64
  65 int abx500_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
  66         u8 value)
  67 {
  68         struct abx500_ops *ops;
  69
  70         lookup_ops(dev->parent, &ops);
  71         if ((ops != NULL) && (ops->set_register != NULL))
  72                 return ops->set_register(dev, bank, reg, value);
  73         else
  74                 return -ENOTSUPP;
  75 }
  76 EXPORT_SYMBOL(abx500_set_register_interruptible);
  77
  78 int abx500_get_register_interruptible(struct device *dev, u8 bank, u8 reg,
  79         u8 *value)
  80 {
  81         struct abx500_ops *ops;
  82
  83         lookup_ops(dev->parent, &ops);
  84         if ((ops != NULL) && (ops->get_register != NULL))
  85                 return ops->get_register(dev, bank, reg, value);
  86         else
  87                 return -ENOTSUPP;
  88 }
  89 EXPORT_SYMBOL(abx500_get_register_interruptible);
  90
  91 int abx500_get_register_page_interruptible(struct device *dev, u8 bank,
  92         u8 first_reg, u8 *regvals, u8 numregs)
  93 {
  94         struct abx500_ops *ops;
  95
  96         lookup_ops(dev->parent, &ops);
  97         if ((ops != NULL) && (ops->get_register_page != NULL))
  98                 return ops->get_register_page(dev, bank,
  99                         first_reg, regvals, numregs);
 100         else
 101                 return -ENOTSUPP;
 102 }
 103 EXPORT_SYMBOL(abx500_get_register_page_interruptible);
 104
 105 int abx500_mask_and_set_register_interruptible(struct device *dev, u8 bank,
 106         u8 reg, u8 bitmask, u8 bitvalues)
 107 {
 108         struct abx500_ops *ops;
 109
 110         lookup_ops(dev->parent, &ops);
 111         if ((ops != NULL) && (ops->mask_and_set_register != NULL))
 112                 return ops->mask_and_set_register(dev, bank,
 113                         reg, bitmask, bitvalues);
 114         else
 115                 return -ENOTSUPP;
 116 }
 117 EXPORT_SYMBOL(abx500_mask_and_set_register_interruptible);
 118
 119 int abx500_get_chip_id(struct device *dev)
 120 {
 121         struct abx500_ops *ops;
 122
 123         lookup_ops(dev->parent, &ops);
 124         if ((ops != NULL) && (ops->get_chip_id != NULL))
 125                 return ops->get_chip_id(dev);
 126         else
 127                 return -ENOTSUPP;
 128 }
 129 EXPORT_SYMBOL(abx500_get_chip_id);
 130
 131 int abx500_event_registers_startup_state_get(struct device *dev, u8 *event)
 132 {
 133         struct abx500_ops *ops;
 134
 135         lookup_ops(dev->parent, &ops);
 136         if ((ops != NULL) && (ops->event_registers_startup_state_get != NULL))
 137                 return ops->event_registers_startup_state_get(dev, event);
 138         else
 139                 return -ENOTSUPP;
 140 }
 141 EXPORT_SYMBOL(abx500_event_registers_startup_state_get);
 142
 143 int abx500_startup_irq_enabled(struct device *dev, unsigned int irq)
 144 {
 145         struct abx500_ops *ops;
 146
 147         lookup_ops(dev->parent, &ops);
 148         if ((ops != NULL) && (ops->startup_irq_enabled != NULL))
 149                 return ops->startup_irq_enabled(dev, irq);
 150         else
 151                 return -ENOTSUPP;
 152 }
 153 EXPORT_SYMBOL(abx500_startup_irq_enabled);
 154
 155 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
 156 MODULE_DESCRIPTION("ABX500 core driver");
 157 MODULE_LICENSE("GPL");