DCA: Add Direct Cache Access driver
[linux-2.6.git] / drivers / dca / dca-core.c
1 /*
2  * Copyright(c) 2007 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 MODULE_LICENSE("GPL");
32
33 /* For now we're assuming a single, global, DCA provider for the system. */
34
35 static DEFINE_SPINLOCK(dca_lock);
36
37 static struct dca_provider *global_dca = NULL;
38
39 /**
40  * dca_add_requester - add a dca client to the list
41  * @dev - the device that wants dca service
42  */
43 int dca_add_requester(struct device *dev)
44 {
45         int err, slot;
46
47         if (!global_dca)
48                 return -ENODEV;
49
50         spin_lock(&dca_lock);
51         slot = global_dca->ops->add_requester(global_dca, dev);
52         spin_unlock(&dca_lock);
53         if (slot < 0)
54                 return slot;
55
56         err = dca_sysfs_add_req(global_dca, dev, slot);
57         if (err) {
58                 spin_lock(&dca_lock);
59                 global_dca->ops->remove_requester(global_dca, dev);
60                 spin_unlock(&dca_lock);
61                 return err;
62         }
63
64         return 0;
65 }
66 EXPORT_SYMBOL_GPL(dca_add_requester);
67
68 /**
69  * dca_remove_requester - remove a dca client from the list
70  * @dev - the device that wants dca service
71  */
72 int dca_remove_requester(struct device *dev)
73 {
74         int slot;
75         if (!global_dca)
76                 return -ENODEV;
77
78         spin_lock(&dca_lock);
79         slot = global_dca->ops->remove_requester(global_dca, dev);
80         spin_unlock(&dca_lock);
81         if (slot < 0)
82                 return slot;
83
84         dca_sysfs_remove_req(global_dca, slot);
85         return 0;
86 }
87 EXPORT_SYMBOL_GPL(dca_remove_requester);
88
89 /**
90  * dca_get_tag - return the dca tag for the given cpu
91  * @cpu - the cpuid as returned by get_cpu()
92  */
93 u8 dca_get_tag(int cpu)
94 {
95         if (!global_dca)
96                 return -ENODEV;
97         return global_dca->ops->get_tag(global_dca, cpu);
98 }
99 EXPORT_SYMBOL_GPL(dca_get_tag);
100
101 /**
102  * alloc_dca_provider - get data struct for describing a dca provider
103  * @ops - pointer to struct of dca operation function pointers
104  * @priv_size - size of extra mem to be added for provider's needs
105  */
106 struct dca_provider *alloc_dca_provider(struct dca_ops *ops, int priv_size)
107 {
108         struct dca_provider *dca;
109         int alloc_size;
110
111         alloc_size = (sizeof(*dca) + priv_size);
112         dca = kzalloc(alloc_size, GFP_KERNEL);
113         if (!dca)
114                 return NULL;
115         dca->ops = ops;
116
117         return dca;
118 }
119 EXPORT_SYMBOL_GPL(alloc_dca_provider);
120
121 /**
122  * free_dca_provider - release the dca provider data struct
123  * @ops - pointer to struct of dca operation function pointers
124  * @priv_size - size of extra mem to be added for provider's needs
125  */
126 void free_dca_provider(struct dca_provider *dca)
127 {
128         kfree(dca);
129 }
130 EXPORT_SYMBOL_GPL(free_dca_provider);
131
132 static BLOCKING_NOTIFIER_HEAD(dca_provider_chain);
133
134 /**
135  * register_dca_provider - register a dca provider
136  * @dca - struct created by alloc_dca_provider()
137  * @dev - device providing dca services
138  */
139 int register_dca_provider(struct dca_provider *dca, struct device *dev)
140 {
141         int err;
142
143         if (global_dca)
144                 return -EEXIST;
145         err = dca_sysfs_add_provider(dca, dev);
146         if (err)
147                 return err;
148         global_dca = dca;
149         blocking_notifier_call_chain(&dca_provider_chain,
150                                      DCA_PROVIDER_ADD, NULL);
151         return 0;
152 }
153 EXPORT_SYMBOL_GPL(register_dca_provider);
154
155 /**
156  * unregister_dca_provider - remove a dca provider
157  * @dca - struct created by alloc_dca_provider()
158  */
159 void unregister_dca_provider(struct dca_provider *dca)
160 {
161         if (!global_dca)
162                 return;
163         blocking_notifier_call_chain(&dca_provider_chain,
164                                      DCA_PROVIDER_REMOVE, NULL);
165         global_dca = NULL;
166         dca_sysfs_remove_provider(dca);
167 }
168 EXPORT_SYMBOL_GPL(unregister_dca_provider);
169
170 /**
171  * dca_register_notify - register a client's notifier callback
172  */
173 void dca_register_notify(struct notifier_block *nb)
174 {
175         blocking_notifier_chain_register(&dca_provider_chain, nb);
176 }
177 EXPORT_SYMBOL_GPL(dca_register_notify);
178
179 /**
180  * dca_unregister_notify - remove a client's notifier callback
181  */
182 void dca_unregister_notify(struct notifier_block *nb)
183 {
184         blocking_notifier_chain_unregister(&dca_provider_chain, nb);
185 }
186 EXPORT_SYMBOL_GPL(dca_unregister_notify);
187
188 static int __init dca_init(void)
189 {
190         return dca_sysfs_init();
191 }
192
193 static void __exit dca_exit(void)
194 {
195         dca_sysfs_exit();
196 }
197
198 module_init(dca_init);
199 module_exit(dca_exit);
200