25b743abfb59442b52ccec0057573716249bdbbf
[linux-2.6.git] / drivers / dca / dca-core.c
1 /*
2  * Copyright(c) 2007 - 2009 Intel Corporation. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify it
5  * under the terms of the GNU General Public License as published by the Free
6  * Software Foundation; either version 2 of the License, or (at your option)
7  * any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but WITHOUT
10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12  * more details.
13  *
14  * You should have received a copy of the GNU General Public License along with
15  * this program; if not, write to the Free Software Foundation, Inc., 59
16  * Temple Place - Suite 330, Boston, MA  02111-1307, USA.
17  *
18  * The full GNU General Public License is included in this distribution in the
19  * file called COPYING.
20  */
21
22 /*
23  * This driver supports an interface for DCA clients and providers to meet.
24  */
25
26 #include <linux/kernel.h>
27 #include <linux/notifier.h>
28 #include <linux/device.h>
29 #include <linux/dca.h>
30
31 #define DCA_VERSION "1.8"
32
33 MODULE_VERSION(DCA_VERSION);
34 MODULE_LICENSE("GPL");
35 MODULE_AUTHOR("Intel Corporation");
36
37 static DEFINE_SPINLOCK(dca_lock);
38
39 static LIST_HEAD(dca_providers);
40
41 static struct dca_provider *dca_find_provider_by_dev(struct device *dev)
42 {
43         struct dca_provider *dca, *ret = NULL;
44
45         list_for_each_entry(dca, &dca_providers, node) {
46                 if ((!dev) || (dca->ops->dev_managed(dca, dev))) {
47                         ret = dca;
48                         break;
49                 }
50         }
51
52         return ret;
53 }
54
55 /**
56  * dca_add_requester - add a dca client to the list
57  * @dev - the device that wants dca service
58  */
59 int dca_add_requester(struct device *dev)
60 {
61         struct dca_provider *dca;
62         int err, slot = -ENODEV;
63         unsigned long flags;
64
65         if (!dev)
66                 return -EFAULT;
67
68         spin_lock_irqsave(&dca_lock, flags);
69
70         /* check if the requester has not been added already */
71         dca = dca_find_provider_by_dev(dev);
72         if (dca) {
73                 spin_unlock_irqrestore(&dca_lock, flags);
74                 return -EEXIST;
75         }
76
77         list_for_each_entry(dca, &dca_providers, node) {
78                 slot = dca->ops->add_requester(dca, dev);
79                 if (slot >= 0)
80                         break;
81         }
82
83         spin_unlock_irqrestore(&dca_lock, flags);
84
85         if (slot < 0)
86                 return slot;
87
88         err = dca_sysfs_add_req(dca, dev, slot);
89         if (err) {
90                 spin_lock_irqsave(&dca_lock, flags);
91                 if (dca == dca_find_provider_by_dev(dev))
92                         dca->ops->remove_requester(dca, dev);
93                 spin_unlock_irqrestore(&dca_lock, flags);
94                 return err;
95         }
96
97         return 0;
98 }
99 EXPORT_SYMBOL_GPL(dca_add_requester);
100
101 /**
102  * dca_remove_requester - remove a dca client from the list
103  * @dev - the device that wants dca service
104  */
105 int dca_remove_requester(struct device *dev)
106 {
107         struct dca_provider *dca;
108         int slot;
109         unsigned long flags;
110
111         if (!dev)
112                 return -EFAULT;
113
114         spin_lock_irqsave(&dca_lock, flags);
115         dca = dca_find_provider_by_dev(dev);
116         if (!dca) {
117                 spin_unlock_irqrestore(&dca_lock, flags);
118                 return -ENODEV;
119         }
120         slot = dca->ops->remove_requester(dca, dev);
121         spin_unlock_irqrestore(&dca_lock, flags);
122
123         if (slot < 0)
124                 return slot;
125
126         dca_sysfs_remove_req(dca, slot);
127
128         return 0;
129 }
130 EXPORT_SYMBOL_GPL(dca_remove_requester);
131
132 /**
133  * dca_common_get_tag - return the dca tag (serves both new and old api)
134  * @dev - the device that wants dca service
135  * @cpu - the cpuid as returned by get_cpu()
136  */
137 u8 dca_common_get_tag(struct device *dev, int cpu)
138 {
139         struct dca_provider *dca;
140         u8 tag;
141         unsigned long flags;
142
143         spin_lock_irqsave(&dca_lock, flags);
144
145         dca = dca_find_provider_by_dev(dev);
146         if (!dca) {
147                 spin_unlock_irqrestore(&dca_lock, flags);
148                 return -ENODEV;
149         }
150         tag = dca->ops->get_tag(dca, dev, cpu);
151
152         spin_unlock_irqrestore(&dca_lock, flags);
153         return tag;
154 }
155
156 /**
157  * dca3_get_tag - return the dca tag to the requester device
158  *                for the given cpu (new api)
159  * @dev - the device that wants dca service
160  * @cpu - the cpuid as returned by get_cpu()
161  */
162 u8 dca3_get_tag(struct device *dev, int cpu)
163 {
164         if (!dev)
165                 return -EFAULT;
166
167         return dca_common_get_tag(dev, cpu);
168 }
169 EXPORT_SYMBOL_GPL(dca3_get_tag);
170
171 /**
172  * dca_get_tag - return the dca tag for the given cpu (old api)
173  * @cpu - the cpuid as returned by get_cpu()
174  */
175 u8 dca_get_tag(int cpu)
176 {
177         struct device *dev = NULL;
178
179         return dca_common_get_tag(dev, cpu);
180 }
181 EXPORT_SYMBOL_GPL(dca_get_tag);
182
183 /**
184  * alloc_dca_provider - get data struct for describing a dca provider
185  * @ops - pointer to struct of dca operation function pointers
186  * @priv_size - size of extra mem to be added for provider's needs
187  */
188 struct dca_provider *alloc_dca_provider(struct dca_ops *ops, int priv_size)
189 {
190         struct dca_provider *dca;
191         int alloc_size;
192
193         alloc_size = (sizeof(*dca) + priv_size);
194         dca = kzalloc(alloc_size, GFP_KERNEL);
195         if (!dca)
196                 return NULL;
197         dca->ops = ops;
198
199         return dca;
200 }
201 EXPORT_SYMBOL_GPL(alloc_dca_provider);
202
203 /**
204  * free_dca_provider - release the dca provider data struct
205  * @ops - pointer to struct of dca operation function pointers
206  * @priv_size - size of extra mem to be added for provider's needs
207  */
208 void free_dca_provider(struct dca_provider *dca)
209 {
210         kfree(dca);
211 }
212 EXPORT_SYMBOL_GPL(free_dca_provider);
213
214 static BLOCKING_NOTIFIER_HEAD(dca_provider_chain);
215
216 /**
217  * register_dca_provider - register a dca provider
218  * @dca - struct created by alloc_dca_provider()
219  * @dev - device providing dca services
220  */
221 int register_dca_provider(struct dca_provider *dca, struct device *dev)
222 {
223         int err;
224         unsigned long flags;
225
226         err = dca_sysfs_add_provider(dca, dev);
227         if (err)
228                 return err;
229
230         spin_lock_irqsave(&dca_lock, flags);
231         list_add(&dca->node, &dca_providers);
232         spin_unlock_irqrestore(&dca_lock, flags);
233
234         blocking_notifier_call_chain(&dca_provider_chain,
235                                      DCA_PROVIDER_ADD, NULL);
236         return 0;
237 }
238 EXPORT_SYMBOL_GPL(register_dca_provider);
239
240 /**
241  * unregister_dca_provider - remove a dca provider
242  * @dca - struct created by alloc_dca_provider()
243  */
244 void unregister_dca_provider(struct dca_provider *dca)
245 {
246         unsigned long flags;
247
248         blocking_notifier_call_chain(&dca_provider_chain,
249                                      DCA_PROVIDER_REMOVE, NULL);
250
251         spin_lock_irqsave(&dca_lock, flags);
252         list_del(&dca->node);
253         spin_unlock_irqrestore(&dca_lock, flags);
254
255         dca_sysfs_remove_provider(dca);
256 }
257 EXPORT_SYMBOL_GPL(unregister_dca_provider);
258
259 /**
260  * dca_register_notify - register a client's notifier callback
261  */
262 void dca_register_notify(struct notifier_block *nb)
263 {
264         blocking_notifier_chain_register(&dca_provider_chain, nb);
265 }
266 EXPORT_SYMBOL_GPL(dca_register_notify);
267
268 /**
269  * dca_unregister_notify - remove a client's notifier callback
270  */
271 void dca_unregister_notify(struct notifier_block *nb)
272 {
273         blocking_notifier_chain_unregister(&dca_provider_chain, nb);
274 }
275 EXPORT_SYMBOL_GPL(dca_unregister_notify);
276
277 static int __init dca_init(void)
278 {
279         printk(KERN_ERR "dca service started, version %s\n", DCA_VERSION);
280         return dca_sysfs_init();
281 }
282
283 static void __exit dca_exit(void)
284 {
285         dca_sysfs_exit();
286 }
287
288 arch_initcall(dca_init);
289 module_exit(dca_exit);
290