mfd: Convert 88pm860x to use regmap api
[linux-2.6.git] / 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/module.h>
12 #include <linux/mfd/abx500.h>
13
14 static LIST_HEAD(abx500_list);
15
16 struct abx500_device_entry {
17         struct list_head list;
18         struct abx500_ops ops;
19         struct device *dev;
20 };
21
22 static 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
35 int 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 }
50 EXPORT_SYMBOL(abx500_register_ops);
51
52 void 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 }
64 EXPORT_SYMBOL(abx500_remove_ops);
65
66 int 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 }
77 EXPORT_SYMBOL(abx500_set_register_interruptible);
78
79 int 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 }
90 EXPORT_SYMBOL(abx500_get_register_interruptible);
91
92 int 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 }
104 EXPORT_SYMBOL(abx500_get_register_page_interruptible);
105
106 int 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 }
118 EXPORT_SYMBOL(abx500_mask_and_set_register_interruptible);
119
120 int 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 }
130 EXPORT_SYMBOL(abx500_get_chip_id);
131
132 int 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 }
142 EXPORT_SYMBOL(abx500_event_registers_startup_state_get);
143
144 int 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 }
154 EXPORT_SYMBOL(abx500_startup_irq_enabled);
155
156 MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
157 MODULE_DESCRIPTION("ABX500 core driver");
158 MODULE_LICENSE("GPL");