1 /* 2 * pci_dn.c 3 * 4 * Copyright (C) 2001 Todd Inglett, IBM Corporation 5 * 6 * PCI manipulation via device_nodes. 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 #include <linux/kernel.h> 23 #include <linux/pci.h> 24 #include <linux/string.h> 25 #include <linux/export.h> 26 #include <linux/init.h> 27 #include <linux/gfp.h> 28 29 #include <asm/io.h> 30 #include <asm/prom.h> 31 #include <asm/pci-bridge.h> 32 #include <asm/ppc-pci.h> 33 #include <asm/firmware.h> 34 #include <asm/eeh.h> 35 36 /* 37 * The function is used to find the firmware data of one 38 * specific PCI device, which is attached to the indicated 39 * PCI bus. For VFs, their firmware data is linked to that 40 * one of PF's bridge. For other devices, their firmware 41 * data is linked to that of their bridge. 42 */ 43 static struct pci_dn *pci_bus_to_pdn(struct pci_bus *bus) 44 { 45 struct pci_bus *pbus; 46 struct device_node *dn; 47 struct pci_dn *pdn; 48 49 /* 50 * We probably have virtual bus which doesn't 51 * have associated bridge. 52 */ 53 pbus = bus; 54 while (pbus) { 55 if (pci_is_root_bus(pbus) || pbus->self) 56 break; 57 58 pbus = pbus->parent; 59 } 60 61 /* 62 * Except virtual bus, all PCI buses should 63 * have device nodes. 64 */ 65 dn = pci_bus_to_OF_node(pbus); 66 pdn = dn ? PCI_DN(dn) : NULL; 67 68 return pdn; 69 } 70 71 struct pci_dn *pci_get_pdn_by_devfn(struct pci_bus *bus, 72 int devfn) 73 { 74 struct device_node *dn = NULL; 75 struct pci_dn *parent, *pdn; 76 struct pci_dev *pdev = NULL; 77 78 /* Fast path: fetch from PCI device */ 79 list_for_each_entry(pdev, &bus->devices, bus_list) { 80 if (pdev->devfn == devfn) { 81 if (pdev->dev.archdata.pci_data) 82 return pdev->dev.archdata.pci_data; 83 84 dn = pci_device_to_OF_node(pdev); 85 break; 86 } 87 } 88 89 /* Fast path: fetch from device node */ 90 pdn = dn ? PCI_DN(dn) : NULL; 91 if (pdn) 92 return pdn; 93 94 /* Slow path: fetch from firmware data hierarchy */ 95 parent = pci_bus_to_pdn(bus); 96 if (!parent) 97 return NULL; 98 99 list_for_each_entry(pdn, &parent->child_list, list) { 100 if (pdn->busno == bus->number && 101 pdn->devfn == devfn) 102 return pdn; 103 } 104 105 return NULL; 106 } 107 108 struct pci_dn *pci_get_pdn(struct pci_dev *pdev) 109 { 110 struct device_node *dn; 111 struct pci_dn *parent, *pdn; 112 113 /* Search device directly */ 114 if (pdev->dev.archdata.pci_data) 115 return pdev->dev.archdata.pci_data; 116 117 /* Check device node */ 118 dn = pci_device_to_OF_node(pdev); 119 pdn = dn ? PCI_DN(dn) : NULL; 120 if (pdn) 121 return pdn; 122 123 /* 124 * VFs don't have device nodes. We hook their 125 * firmware data to PF's bridge. 126 */ 127 parent = pci_bus_to_pdn(pdev->bus); 128 if (!parent) 129 return NULL; 130 131 list_for_each_entry(pdn, &parent->child_list, list) { 132 if (pdn->busno == pdev->bus->number && 133 pdn->devfn == pdev->devfn) 134 return pdn; 135 } 136 137 return NULL; 138 } 139 140 #ifdef CONFIG_PCI_IOV 141 static struct pci_dn *add_one_dev_pci_data(struct pci_dn *parent, 142 int vf_index, 143 int busno, int devfn) 144 { 145 struct pci_dn *pdn; 146 147 /* Except PHB, we always have the parent */ 148 if (!parent) 149 return NULL; 150 151 pdn = kzalloc(sizeof(*pdn), GFP_KERNEL); 152 if (!pdn) 153 return NULL; 154 155 pdn->phb = parent->phb; 156 pdn->parent = parent; 157 pdn->busno = busno; 158 pdn->devfn = devfn; 159 #ifdef CONFIG_PPC_POWERNV 160 pdn->vf_index = vf_index; 161 pdn->pe_number = IODA_INVALID_PE; 162 #endif 163 INIT_LIST_HEAD(&pdn->child_list); 164 INIT_LIST_HEAD(&pdn->list); 165 list_add_tail(&pdn->list, &parent->child_list); 166 167 return pdn; 168 } 169 #endif 170 171 struct pci_dn *add_dev_pci_data(struct pci_dev *pdev) 172 { 173 #ifdef CONFIG_PCI_IOV 174 struct pci_dn *parent, *pdn; 175 int i; 176 177 /* Only support IOV for now */ 178 if (!pdev->is_physfn) 179 return pci_get_pdn(pdev); 180 181 /* Check if VFs have been populated */ 182 pdn = pci_get_pdn(pdev); 183 if (!pdn || (pdn->flags & PCI_DN_FLAG_IOV_VF)) 184 return NULL; 185 186 pdn->flags |= PCI_DN_FLAG_IOV_VF; 187 parent = pci_bus_to_pdn(pdev->bus); 188 if (!parent) 189 return NULL; 190 191 for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) { 192 struct eeh_dev *edev __maybe_unused; 193 194 pdn = add_one_dev_pci_data(parent, i, 195 pci_iov_virtfn_bus(pdev, i), 196 pci_iov_virtfn_devfn(pdev, i)); 197 if (!pdn) { 198 dev_warn(&pdev->dev, "%s: Cannot create firmware data for VF#%d\n", 199 __func__, i); 200 return NULL; 201 } 202 203 #ifdef CONFIG_EEH 204 /* Create the EEH device for the VF */ 205 edev = eeh_dev_init(pdn); 206 BUG_ON(!edev); 207 edev->physfn = pdev; 208 #endif /* CONFIG_EEH */ 209 } 210 #endif /* CONFIG_PCI_IOV */ 211 212 return pci_get_pdn(pdev); 213 } 214 215 void remove_dev_pci_data(struct pci_dev *pdev) 216 { 217 #ifdef CONFIG_PCI_IOV 218 struct pci_dn *parent; 219 struct pci_dn *pdn, *tmp; 220 int i; 221 222 /* 223 * VF and VF PE are created/released dynamically, so we need to 224 * bind/unbind them. Otherwise the VF and VF PE would be mismatched 225 * when re-enabling SR-IOV. 226 */ 227 if (pdev->is_virtfn) { 228 pdn = pci_get_pdn(pdev); 229 #ifdef CONFIG_PPC_POWERNV 230 pdn->pe_number = IODA_INVALID_PE; 231 #endif 232 return; 233 } 234 235 /* Only support IOV PF for now */ 236 if (!pdev->is_physfn) 237 return; 238 239 /* Check if VFs have been populated */ 240 pdn = pci_get_pdn(pdev); 241 if (!pdn || !(pdn->flags & PCI_DN_FLAG_IOV_VF)) 242 return; 243 244 pdn->flags &= ~PCI_DN_FLAG_IOV_VF; 245 parent = pci_bus_to_pdn(pdev->bus); 246 if (!parent) 247 return; 248 249 /* 250 * We might introduce flag to pci_dn in future 251 * so that we can release VF's firmware data in 252 * a batch mode. 253 */ 254 for (i = 0; i < pci_sriov_get_totalvfs(pdev); i++) { 255 struct eeh_dev *edev __maybe_unused; 256 257 list_for_each_entry_safe(pdn, tmp, 258 &parent->child_list, list) { 259 if (pdn->busno != pci_iov_virtfn_bus(pdev, i) || 260 pdn->devfn != pci_iov_virtfn_devfn(pdev, i)) 261 continue; 262 263 #ifdef CONFIG_EEH 264 /* Release EEH device for the VF */ 265 edev = pdn_to_eeh_dev(pdn); 266 if (edev) { 267 pdn->edev = NULL; 268 kfree(edev); 269 } 270 #endif /* CONFIG_EEH */ 271 272 if (!list_empty(&pdn->list)) 273 list_del(&pdn->list); 274 275 kfree(pdn); 276 } 277 } 278 #endif /* CONFIG_PCI_IOV */ 279 } 280 281 struct pci_dn *pci_add_device_node_info(struct pci_controller *hose, 282 struct device_node *dn) 283 { 284 const __be32 *type = of_get_property(dn, "ibm,pci-config-space-type", NULL); 285 const __be32 *regs; 286 struct device_node *parent; 287 struct pci_dn *pdn; 288 #ifdef CONFIG_EEH 289 struct eeh_dev *edev; 290 #endif 291 292 pdn = kzalloc(sizeof(*pdn), GFP_KERNEL); 293 if (pdn == NULL) 294 return NULL; 295 dn->data = pdn; 296 pdn->phb = hose; 297 #ifdef CONFIG_PPC_POWERNV 298 pdn->pe_number = IODA_INVALID_PE; 299 #endif 300 regs = of_get_property(dn, "reg", NULL); 301 if (regs) { 302 u32 addr = of_read_number(regs, 1); 303 304 /* First register entry is addr (00BBSS00) */ 305 pdn->busno = (addr >> 16) & 0xff; 306 pdn->devfn = (addr >> 8) & 0xff; 307 } 308 309 /* vendor/device IDs and class code */ 310 regs = of_get_property(dn, "vendor-id", NULL); 311 pdn->vendor_id = regs ? of_read_number(regs, 1) : 0; 312 regs = of_get_property(dn, "device-id", NULL); 313 pdn->device_id = regs ? of_read_number(regs, 1) : 0; 314 regs = of_get_property(dn, "class-code", NULL); 315 pdn->class_code = regs ? of_read_number(regs, 1) : 0; 316 317 /* Extended config space */ 318 pdn->pci_ext_config_space = (type && of_read_number(type, 1) == 1); 319 320 /* Create EEH device */ 321 #ifdef CONFIG_EEH 322 edev = eeh_dev_init(pdn); 323 if (!edev) { 324 kfree(pdn); 325 return NULL; 326 } 327 #endif 328 329 /* Attach to parent node */ 330 INIT_LIST_HEAD(&pdn->child_list); 331 INIT_LIST_HEAD(&pdn->list); 332 parent = of_get_parent(dn); 333 pdn->parent = parent ? PCI_DN(parent) : NULL; 334 if (pdn->parent) 335 list_add_tail(&pdn->list, &pdn->parent->child_list); 336 337 return pdn; 338 } 339 EXPORT_SYMBOL_GPL(pci_add_device_node_info); 340 341 void pci_remove_device_node_info(struct device_node *dn) 342 { 343 struct pci_dn *pdn = dn ? PCI_DN(dn) : NULL; 344 struct device_node *parent; 345 #ifdef CONFIG_EEH 346 struct eeh_dev *edev = pdn_to_eeh_dev(pdn); 347 348 if (edev) 349 edev->pdn = NULL; 350 #endif 351 352 if (!pdn) 353 return; 354 355 WARN_ON(!list_empty(&pdn->child_list)); 356 list_del(&pdn->list); 357 358 parent = of_get_parent(dn); 359 if (parent) 360 of_node_put(parent); 361 362 dn->data = NULL; 363 kfree(pdn); 364 } 365 EXPORT_SYMBOL_GPL(pci_remove_device_node_info); 366 367 /* 368 * Traverse a device tree stopping each PCI device in the tree. 369 * This is done depth first. As each node is processed, a "pre" 370 * function is called and the children are processed recursively. 371 * 372 * The "pre" func returns a value. If non-zero is returned from 373 * the "pre" func, the traversal stops and this value is returned. 374 * This return value is useful when using traverse as a method of 375 * finding a device. 376 * 377 * NOTE: we do not run the func for devices that do not appear to 378 * be PCI except for the start node which we assume (this is good 379 * because the start node is often a phb which may be missing PCI 380 * properties). 381 * We use the class-code as an indicator. If we run into 382 * one of these nodes we also assume its siblings are non-pci for 383 * performance. 384 */ 385 void *pci_traverse_device_nodes(struct device_node *start, 386 void *(*fn)(struct device_node *, void *), 387 void *data) 388 { 389 struct device_node *dn, *nextdn; 390 void *ret; 391 392 /* We started with a phb, iterate all childs */ 393 for (dn = start->child; dn; dn = nextdn) { 394 const __be32 *classp; 395 u32 class = 0; 396 397 nextdn = NULL; 398 classp = of_get_property(dn, "class-code", NULL); 399 if (classp) 400 class = of_read_number(classp, 1); 401 402 if (fn) { 403 ret = fn(dn, data); 404 if (ret) 405 return ret; 406 } 407 408 /* If we are a PCI bridge, go down */ 409 if (dn->child && ((class >> 8) == PCI_CLASS_BRIDGE_PCI || 410 (class >> 8) == PCI_CLASS_BRIDGE_CARDBUS)) 411 /* Depth first...do children */ 412 nextdn = dn->child; 413 else if (dn->sibling) 414 /* ok, try next sibling instead. */ 415 nextdn = dn->sibling; 416 if (!nextdn) { 417 /* Walk up to next valid sibling. */ 418 do { 419 dn = dn->parent; 420 if (dn == start) 421 return NULL; 422 } while (dn->sibling == NULL); 423 nextdn = dn->sibling; 424 } 425 } 426 return NULL; 427 } 428 EXPORT_SYMBOL_GPL(pci_traverse_device_nodes); 429 430 static struct pci_dn *pci_dn_next_one(struct pci_dn *root, 431 struct pci_dn *pdn) 432 { 433 struct list_head *next = pdn->child_list.next; 434 435 if (next != &pdn->child_list) 436 return list_entry(next, struct pci_dn, list); 437 438 while (1) { 439 if (pdn == root) 440 return NULL; 441 442 next = pdn->list.next; 443 if (next != &pdn->parent->child_list) 444 break; 445 446 pdn = pdn->parent; 447 } 448 449 return list_entry(next, struct pci_dn, list); 450 } 451 452 void *traverse_pci_dn(struct pci_dn *root, 453 void *(*fn)(struct pci_dn *, void *), 454 void *data) 455 { 456 struct pci_dn *pdn = root; 457 void *ret; 458 459 /* Only scan the child nodes */ 460 for (pdn = pci_dn_next_one(root, pdn); pdn; 461 pdn = pci_dn_next_one(root, pdn)) { 462 ret = fn(pdn, data); 463 if (ret) 464 return ret; 465 } 466 467 return NULL; 468 } 469 470 static void *add_pdn(struct device_node *dn, void *data) 471 { 472 struct pci_controller *hose = data; 473 struct pci_dn *pdn; 474 475 pdn = pci_add_device_node_info(hose, dn); 476 if (!pdn) 477 return ERR_PTR(-ENOMEM); 478 479 return NULL; 480 } 481 482 /** 483 * pci_devs_phb_init_dynamic - setup pci devices under this PHB 484 * phb: pci-to-host bridge (top-level bridge connecting to cpu) 485 * 486 * This routine is called both during boot, (before the memory 487 * subsystem is set up, before kmalloc is valid) and during the 488 * dynamic lpar operation of adding a PHB to a running system. 489 */ 490 void pci_devs_phb_init_dynamic(struct pci_controller *phb) 491 { 492 struct device_node *dn = phb->dn; 493 struct pci_dn *pdn; 494 495 /* PHB nodes themselves must not match */ 496 pdn = pci_add_device_node_info(phb, dn); 497 if (pdn) { 498 pdn->devfn = pdn->busno = -1; 499 pdn->vendor_id = pdn->device_id = pdn->class_code = 0; 500 pdn->phb = phb; 501 phb->pci_data = pdn; 502 } 503 504 /* Update dn->phb ptrs for new phb and children devices */ 505 pci_traverse_device_nodes(dn, add_pdn, phb); 506 } 507 508 /** 509 * pci_devs_phb_init - Initialize phbs and pci devs under them. 510 * 511 * This routine walks over all phb's (pci-host bridges) on the 512 * system, and sets up assorted pci-related structures 513 * (including pci info in the device node structs) for each 514 * pci device found underneath. This routine runs once, 515 * early in the boot sequence. 516 */ 517 static int __init pci_devs_phb_init(void) 518 { 519 struct pci_controller *phb, *tmp; 520 521 /* This must be done first so the device nodes have valid pci info! */ 522 list_for_each_entry_safe(phb, tmp, &hose_list, list_node) 523 pci_devs_phb_init_dynamic(phb); 524 525 return 0; 526 } 527 528 core_initcall(pci_devs_phb_init); 529 530 static void pci_dev_pdn_setup(struct pci_dev *pdev) 531 { 532 struct pci_dn *pdn; 533 534 if (pdev->dev.archdata.pci_data) 535 return; 536 537 /* Setup the fast path */ 538 pdn = pci_get_pdn(pdev); 539 pdev->dev.archdata.pci_data = pdn; 540 } 541 DECLARE_PCI_FIXUP_EARLY(PCI_ANY_ID, PCI_ANY_ID, pci_dev_pdn_setup); 542