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#include <linux/slab.h> 31 32#define DCA_VERSION "1.12.1" 33 34MODULE_VERSION(DCA_VERSION); 35MODULE_LICENSE("GPL"); 36MODULE_AUTHOR("Intel Corporation"); 37 38static DEFINE_SPINLOCK(dca_lock); 39 40static LIST_HEAD(dca_domains); 41 42static BLOCKING_NOTIFIER_HEAD(dca_provider_chain); 43 44static int dca_providers_blocked; 45 46static struct pci_bus *dca_pci_rc_from_dev(struct device *dev) 47{ 48 struct pci_dev *pdev = to_pci_dev(dev); 49 struct pci_bus *bus = pdev->bus; 50 51 while (bus->parent) 52 bus = bus->parent; 53 54 return bus; 55} 56 57static struct dca_domain *dca_allocate_domain(struct pci_bus *rc) 58{ 59 struct dca_domain *domain; 60 61 domain = kzalloc(sizeof(*domain), GFP_NOWAIT); 62 if (!domain) 63 return NULL; 64 65 INIT_LIST_HEAD(&domain->dca_providers); 66 domain->pci_rc = rc; 67 68 return domain; 69} 70 71static void dca_free_domain(struct dca_domain *domain) 72{ 73 list_del(&domain->node); 74 kfree(domain); 75} 76 77static int dca_provider_ioat_ver_3_0(struct device *dev) 78{ 79 struct pci_dev *pdev = to_pci_dev(dev); 80 81 return ((pdev->vendor == PCI_VENDOR_ID_INTEL) && 82 ((pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG0) || 83 (pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG1) || 84 (pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG2) || 85 (pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG3) || 86 (pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG4) || 87 (pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG5) || 88 (pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG6) || 89 (pdev->device == PCI_DEVICE_ID_INTEL_IOAT_TBG7))); 90} 91 92static void unregister_dca_providers(void) 93{ 94 struct dca_provider *dca, *_dca; 95 struct list_head unregistered_providers; 96 struct dca_domain *domain; 97 unsigned long flags; 98 99 blocking_notifier_call_chain(&dca_provider_chain, 100 DCA_PROVIDER_REMOVE, NULL); 101 102 INIT_LIST_HEAD(&unregistered_providers); 103 104 spin_lock_irqsave(&dca_lock, flags); 105 106 if (list_empty(&dca_domains)) { 107 spin_unlock_irqrestore(&dca_lock, flags); 108 return; 109 } 110 111 /* at this point only one domain in the list is expected */ 112 domain = list_first_entry(&dca_domains, struct dca_domain, node); 113 if (!domain) 114 return; 115 116 list_for_each_entry_safe(dca, _dca, &domain->dca_providers, node) { 117 list_del(&dca->node); 118 list_add(&dca->node, &unregistered_providers); 119 } 120 121 dca_free_domain(domain); 122 123 spin_unlock_irqrestore(&dca_lock, flags); 124 125 list_for_each_entry_safe(dca, _dca, &unregistered_providers, node) { 126 dca_sysfs_remove_provider(dca); 127 list_del(&dca->node); 128 } 129} 130 131static struct dca_domain *dca_find_domain(struct pci_bus *rc) 132{ 133 struct dca_domain *domain; 134 135 list_for_each_entry(domain, &dca_domains, node) 136 if (domain->pci_rc == rc) 137 return domain; 138 139 return NULL; 140} 141 142static struct dca_domain *dca_get_domain(struct device *dev) 143{ 144 struct pci_bus *rc; 145 struct dca_domain *domain; 146 147 rc = dca_pci_rc_from_dev(dev); 148 domain = dca_find_domain(rc); 149 150 if (!domain) { 151 if (dca_provider_ioat_ver_3_0(dev) && !list_empty(&dca_domains)) { 152 dca_providers_blocked = 1; 153 } else { 154 domain = dca_allocate_domain(rc); 155 if (domain) 156 list_add(&domain->node, &dca_domains); 157 } 158 } 159 160 return domain; 161} 162 163static struct dca_provider *dca_find_provider_by_dev(struct device *dev) 164{ 165 struct dca_provider *dca; 166 struct pci_bus *rc; 167 struct dca_domain *domain; 168 169 if (dev) { 170 rc = dca_pci_rc_from_dev(dev); 171 domain = dca_find_domain(rc); 172 if (!domain) 173 return NULL; 174 } else { 175 if (!list_empty(&dca_domains)) 176 domain = list_first_entry(&dca_domains, 177 struct dca_domain, 178 node); 179 else 180 return NULL; 181 } 182 183 list_for_each_entry(dca, &domain->dca_providers, node) 184 if ((!dev) || (dca->ops->dev_managed(dca, dev))) 185 return dca; 186 187 return NULL; 188} 189 190/** 191 * dca_add_requester - add a dca client to the list 192 * @dev - the device that wants dca service 193 */ 194int dca_add_requester(struct device *dev) 195{ 196 struct dca_provider *dca; 197 int err, slot = -ENODEV; 198 unsigned long flags; 199 struct pci_bus *pci_rc; 200 struct dca_domain *domain; 201 202 if (!dev) 203 return -EFAULT; 204 205 spin_lock_irqsave(&dca_lock, flags); 206 207 /* check if the requester has not been added already */ 208 dca = dca_find_provider_by_dev(dev); 209 if (dca) { 210 spin_unlock_irqrestore(&dca_lock, flags); 211 return -EEXIST; 212 } 213 214 pci_rc = dca_pci_rc_from_dev(dev); 215 domain = dca_find_domain(pci_rc); 216 if (!domain) { 217 spin_unlock_irqrestore(&dca_lock, flags); 218 return -ENODEV; 219 } 220 221 list_for_each_entry(dca, &domain->dca_providers, node) { 222 slot = dca->ops->add_requester(dca, dev); 223 if (slot >= 0) 224 break; 225 } 226 227 spin_unlock_irqrestore(&dca_lock, flags); 228 229 if (slot < 0) 230 return slot; 231 232 err = dca_sysfs_add_req(dca, dev, slot); 233 if (err) { 234 spin_lock_irqsave(&dca_lock, flags); 235 if (dca == dca_find_provider_by_dev(dev)) 236 dca->ops->remove_requester(dca, dev); 237 spin_unlock_irqrestore(&dca_lock, flags); 238 return err; 239 } 240 241 return 0; 242} 243EXPORT_SYMBOL_GPL(dca_add_requester); 244 245/** 246 * dca_remove_requester - remove a dca client from the list 247 * @dev - the device that wants dca service 248 */ 249int dca_remove_requester(struct device *dev) 250{ 251 struct dca_provider *dca; 252 int slot; 253 unsigned long flags; 254 255 if (!dev) 256 return -EFAULT; 257 258 spin_lock_irqsave(&dca_lock, flags); 259 dca = dca_find_provider_by_dev(dev); 260 if (!dca) { 261 spin_unlock_irqrestore(&dca_lock, flags); 262 return -ENODEV; 263 } 264 slot = dca->ops->remove_requester(dca, dev); 265 spin_unlock_irqrestore(&dca_lock, flags); 266 267 if (slot < 0) 268 return slot; 269 270 dca_sysfs_remove_req(dca, slot); 271 272 return 0; 273} 274EXPORT_SYMBOL_GPL(dca_remove_requester); 275 276/** 277 * dca_common_get_tag - return the dca tag (serves both new and old api) 278 * @dev - the device that wants dca service 279 * @cpu - the cpuid as returned by get_cpu() 280 */ 281u8 dca_common_get_tag(struct device *dev, int cpu) 282{ 283 struct dca_provider *dca; 284 u8 tag; 285 unsigned long flags; 286 287 spin_lock_irqsave(&dca_lock, flags); 288 289 dca = dca_find_provider_by_dev(dev); 290 if (!dca) { 291 spin_unlock_irqrestore(&dca_lock, flags); 292 return -ENODEV; 293 } 294 tag = dca->ops->get_tag(dca, dev, cpu); 295 296 spin_unlock_irqrestore(&dca_lock, flags); 297 return tag; 298} 299 300/** 301 * dca3_get_tag - return the dca tag to the requester device 302 * for the given cpu (new api) 303 * @dev - the device that wants dca service 304 * @cpu - the cpuid as returned by get_cpu() 305 */ 306u8 dca3_get_tag(struct device *dev, int cpu) 307{ 308 if (!dev) 309 return -EFAULT; 310 311 return dca_common_get_tag(dev, cpu); 312} 313EXPORT_SYMBOL_GPL(dca3_get_tag); 314 315/** 316 * dca_get_tag - return the dca tag for the given cpu (old api) 317 * @cpu - the cpuid as returned by get_cpu() 318 */ 319u8 dca_get_tag(int cpu) 320{ 321 struct device *dev = NULL; 322 323 return dca_common_get_tag(dev, cpu); 324} 325EXPORT_SYMBOL_GPL(dca_get_tag); 326 327/** 328 * alloc_dca_provider - get data struct for describing a dca provider 329 * @ops - pointer to struct of dca operation function pointers 330 * @priv_size - size of extra mem to be added for provider's needs 331 */ 332struct dca_provider *alloc_dca_provider(struct dca_ops *ops, int priv_size) 333{ 334 struct dca_provider *dca; 335 int alloc_size; 336 337 alloc_size = (sizeof(*dca) + priv_size); 338 dca = kzalloc(alloc_size, GFP_KERNEL); 339 if (!dca) 340 return NULL; 341 dca->ops = ops; 342 343 return dca; 344} 345EXPORT_SYMBOL_GPL(alloc_dca_provider); 346 347/** 348 * free_dca_provider - release the dca provider data struct 349 * @ops - pointer to struct of dca operation function pointers 350 * @priv_size - size of extra mem to be added for provider's needs 351 */ 352void free_dca_provider(struct dca_provider *dca) 353{ 354 kfree(dca); 355} 356EXPORT_SYMBOL_GPL(free_dca_provider); 357 358/** 359 * register_dca_provider - register a dca provider 360 * @dca - struct created by alloc_dca_provider() 361 * @dev - device providing dca services 362 */ 363int register_dca_provider(struct dca_provider *dca, struct device *dev) 364{ 365 int err; 366 unsigned long flags; 367 struct dca_domain *domain; 368 369 spin_lock_irqsave(&dca_lock, flags); 370 if (dca_providers_blocked) { 371 spin_unlock_irqrestore(&dca_lock, flags); 372 return -ENODEV; 373 } 374 spin_unlock_irqrestore(&dca_lock, flags); 375 376 err = dca_sysfs_add_provider(dca, dev); 377 if (err) 378 return err; 379 380 spin_lock_irqsave(&dca_lock, flags); 381 domain = dca_get_domain(dev); 382 if (!domain) { 383 if (dca_providers_blocked) { 384 spin_unlock_irqrestore(&dca_lock, flags); 385 dca_sysfs_remove_provider(dca); 386 unregister_dca_providers(); 387 } else { 388 spin_unlock_irqrestore(&dca_lock, flags); 389 } 390 return -ENODEV; 391 } 392 list_add(&dca->node, &domain->dca_providers); 393 spin_unlock_irqrestore(&dca_lock, flags); 394 395 blocking_notifier_call_chain(&dca_provider_chain, 396 DCA_PROVIDER_ADD, NULL); 397 return 0; 398} 399EXPORT_SYMBOL_GPL(register_dca_provider); 400 401/** 402 * unregister_dca_provider - remove a dca provider 403 * @dca - struct created by alloc_dca_provider() 404 */ 405void unregister_dca_provider(struct dca_provider *dca, struct device *dev) 406{ 407 unsigned long flags; 408 struct pci_bus *pci_rc; 409 struct dca_domain *domain; 410 411 blocking_notifier_call_chain(&dca_provider_chain, 412 DCA_PROVIDER_REMOVE, NULL); 413 414 spin_lock_irqsave(&dca_lock, flags); 415 416 list_del(&dca->node); 417 418 pci_rc = dca_pci_rc_from_dev(dev); 419 domain = dca_find_domain(pci_rc); 420 if (list_empty(&domain->dca_providers)) 421 dca_free_domain(domain); 422 423 spin_unlock_irqrestore(&dca_lock, flags); 424 425 dca_sysfs_remove_provider(dca); 426} 427EXPORT_SYMBOL_GPL(unregister_dca_provider); 428 429/** 430 * dca_register_notify - register a client's notifier callback 431 */ 432void dca_register_notify(struct notifier_block *nb) 433{ 434 blocking_notifier_chain_register(&dca_provider_chain, nb); 435} 436EXPORT_SYMBOL_GPL(dca_register_notify); 437 438/** 439 * dca_unregister_notify - remove a client's notifier callback 440 */ 441void dca_unregister_notify(struct notifier_block *nb) 442{ 443 blocking_notifier_chain_unregister(&dca_provider_chain, nb); 444} 445EXPORT_SYMBOL_GPL(dca_unregister_notify); 446 447static int __init dca_init(void) 448{ 449 pr_info("dca service started, version %s\n", DCA_VERSION); 450 return dca_sysfs_init(); 451} 452 453static void __exit dca_exit(void) 454{ 455 dca_sysfs_exit(); 456} 457 458arch_initcall(dca_init); 459module_exit(dca_exit); 460