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 291