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