1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright IBM Corp. 2012 4 * 5 * Author(s): 6 * Jan Glauber <jang@linux.vnet.ibm.com> 7 * 8 * The System z PCI code is a rewrite from a prototype by 9 * the following people (Kudoz!): 10 * Alexander Schmidt 11 * Christoph Raisch 12 * Hannes Hering 13 * Hoang-Nam Nguyen 14 * Jan-Bernd Themann 15 * Stefan Roscher 16 * Thomas Klein 17 */ 18 19 #define KMSG_COMPONENT "zpci" 20 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt 21 22 #include <linux/kernel.h> 23 #include <linux/slab.h> 24 #include <linux/err.h> 25 #include <linux/export.h> 26 #include <linux/delay.h> 27 #include <linux/seq_file.h> 28 #include <linux/jump_label.h> 29 #include <linux/pci.h> 30 31 #include <asm/isc.h> 32 #include <asm/airq.h> 33 #include <asm/facility.h> 34 #include <asm/pci_insn.h> 35 #include <asm/pci_clp.h> 36 #include <asm/pci_dma.h> 37 38 /* list of all detected zpci devices */ 39 static LIST_HEAD(zpci_list); 40 static DEFINE_SPINLOCK(zpci_list_lock); 41 42 static DECLARE_BITMAP(zpci_domain, ZPCI_NR_DEVICES); 43 static DEFINE_SPINLOCK(zpci_domain_lock); 44 45 #define ZPCI_IOMAP_ENTRIES \ 46 min(((unsigned long) ZPCI_NR_DEVICES * PCI_BAR_COUNT / 2), \ 47 ZPCI_IOMAP_MAX_ENTRIES) 48 49 static DEFINE_SPINLOCK(zpci_iomap_lock); 50 static unsigned long *zpci_iomap_bitmap; 51 struct zpci_iomap_entry *zpci_iomap_start; 52 EXPORT_SYMBOL_GPL(zpci_iomap_start); 53 54 DEFINE_STATIC_KEY_FALSE(have_mio); 55 56 static struct kmem_cache *zdev_fmb_cache; 57 58 struct zpci_dev *get_zdev_by_fid(u32 fid) 59 { 60 struct zpci_dev *tmp, *zdev = NULL; 61 62 spin_lock(&zpci_list_lock); 63 list_for_each_entry(tmp, &zpci_list, entry) { 64 if (tmp->fid == fid) { 65 zdev = tmp; 66 break; 67 } 68 } 69 spin_unlock(&zpci_list_lock); 70 return zdev; 71 } 72 73 void zpci_remove_reserved_devices(void) 74 { 75 struct zpci_dev *tmp, *zdev; 76 enum zpci_state state; 77 LIST_HEAD(remove); 78 79 spin_lock(&zpci_list_lock); 80 list_for_each_entry_safe(zdev, tmp, &zpci_list, entry) { 81 if (zdev->state == ZPCI_FN_STATE_STANDBY && 82 !clp_get_state(zdev->fid, &state) && 83 state == ZPCI_FN_STATE_RESERVED) 84 list_move_tail(&zdev->entry, &remove); 85 } 86 spin_unlock(&zpci_list_lock); 87 88 list_for_each_entry_safe(zdev, tmp, &remove, entry) 89 zpci_remove_device(zdev); 90 } 91 92 static struct zpci_dev *get_zdev_by_bus(struct pci_bus *bus) 93 { 94 return (bus && bus->sysdata) ? (struct zpci_dev *) bus->sysdata : NULL; 95 } 96 97 int pci_domain_nr(struct pci_bus *bus) 98 { 99 return ((struct zpci_dev *) bus->sysdata)->domain; 100 } 101 EXPORT_SYMBOL_GPL(pci_domain_nr); 102 103 int pci_proc_domain(struct pci_bus *bus) 104 { 105 return pci_domain_nr(bus); 106 } 107 EXPORT_SYMBOL_GPL(pci_proc_domain); 108 109 /* Modify PCI: Register I/O address translation parameters */ 110 int zpci_register_ioat(struct zpci_dev *zdev, u8 dmaas, 111 u64 base, u64 limit, u64 iota) 112 { 113 u64 req = ZPCI_CREATE_REQ(zdev->fh, dmaas, ZPCI_MOD_FC_REG_IOAT); 114 struct zpci_fib fib = {0}; 115 u8 status; 116 117 WARN_ON_ONCE(iota & 0x3fff); 118 fib.pba = base; 119 fib.pal = limit; 120 fib.iota = iota | ZPCI_IOTA_RTTO_FLAG; 121 return zpci_mod_fc(req, &fib, &status) ? -EIO : 0; 122 } 123 124 /* Modify PCI: Unregister I/O address translation parameters */ 125 int zpci_unregister_ioat(struct zpci_dev *zdev, u8 dmaas) 126 { 127 u64 req = ZPCI_CREATE_REQ(zdev->fh, dmaas, ZPCI_MOD_FC_DEREG_IOAT); 128 struct zpci_fib fib = {0}; 129 u8 cc, status; 130 131 cc = zpci_mod_fc(req, &fib, &status); 132 if (cc == 3) /* Function already gone. */ 133 cc = 0; 134 return cc ? -EIO : 0; 135 } 136 137 /* Modify PCI: Set PCI function measurement parameters */ 138 int zpci_fmb_enable_device(struct zpci_dev *zdev) 139 { 140 u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, ZPCI_MOD_FC_SET_MEASURE); 141 struct zpci_fib fib = {0}; 142 u8 cc, status; 143 144 if (zdev->fmb || sizeof(*zdev->fmb) < zdev->fmb_length) 145 return -EINVAL; 146 147 zdev->fmb = kmem_cache_zalloc(zdev_fmb_cache, GFP_KERNEL); 148 if (!zdev->fmb) 149 return -ENOMEM; 150 WARN_ON((u64) zdev->fmb & 0xf); 151 152 /* reset software counters */ 153 atomic64_set(&zdev->allocated_pages, 0); 154 atomic64_set(&zdev->mapped_pages, 0); 155 atomic64_set(&zdev->unmapped_pages, 0); 156 157 fib.fmb_addr = virt_to_phys(zdev->fmb); 158 cc = zpci_mod_fc(req, &fib, &status); 159 if (cc) { 160 kmem_cache_free(zdev_fmb_cache, zdev->fmb); 161 zdev->fmb = NULL; 162 } 163 return cc ? -EIO : 0; 164 } 165 166 /* Modify PCI: Disable PCI function measurement */ 167 int zpci_fmb_disable_device(struct zpci_dev *zdev) 168 { 169 u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, ZPCI_MOD_FC_SET_MEASURE); 170 struct zpci_fib fib = {0}; 171 u8 cc, status; 172 173 if (!zdev->fmb) 174 return -EINVAL; 175 176 /* Function measurement is disabled if fmb address is zero */ 177 cc = zpci_mod_fc(req, &fib, &status); 178 if (cc == 3) /* Function already gone. */ 179 cc = 0; 180 181 if (!cc) { 182 kmem_cache_free(zdev_fmb_cache, zdev->fmb); 183 zdev->fmb = NULL; 184 } 185 return cc ? -EIO : 0; 186 } 187 188 static int zpci_cfg_load(struct zpci_dev *zdev, int offset, u32 *val, u8 len) 189 { 190 u64 req = ZPCI_CREATE_REQ(zdev->fh, ZPCI_PCIAS_CFGSPC, len); 191 u64 data; 192 int rc; 193 194 rc = __zpci_load(&data, req, offset); 195 if (!rc) { 196 data = le64_to_cpu((__force __le64) data); 197 data >>= (8 - len) * 8; 198 *val = (u32) data; 199 } else 200 *val = 0xffffffff; 201 return rc; 202 } 203 204 static int zpci_cfg_store(struct zpci_dev *zdev, int offset, u32 val, u8 len) 205 { 206 u64 req = ZPCI_CREATE_REQ(zdev->fh, ZPCI_PCIAS_CFGSPC, len); 207 u64 data = val; 208 int rc; 209 210 data <<= (8 - len) * 8; 211 data = (__force u64) cpu_to_le64(data); 212 rc = __zpci_store(data, req, offset); 213 return rc; 214 } 215 216 resource_size_t pcibios_align_resource(void *data, const struct resource *res, 217 resource_size_t size, 218 resource_size_t align) 219 { 220 return 0; 221 } 222 223 /* combine single writes by using store-block insn */ 224 void __iowrite64_copy(void __iomem *to, const void *from, size_t count) 225 { 226 zpci_memcpy_toio(to, from, count); 227 } 228 229 void __iomem *ioremap(unsigned long ioaddr, unsigned long size) 230 { 231 struct vm_struct *area; 232 unsigned long offset; 233 234 if (!size) 235 return NULL; 236 237 if (!static_branch_unlikely(&have_mio)) 238 return (void __iomem *) ioaddr; 239 240 offset = ioaddr & ~PAGE_MASK; 241 ioaddr &= PAGE_MASK; 242 size = PAGE_ALIGN(size + offset); 243 area = get_vm_area(size, VM_IOREMAP); 244 if (!area) 245 return NULL; 246 247 if (ioremap_page_range((unsigned long) area->addr, 248 (unsigned long) area->addr + size, 249 ioaddr, PAGE_KERNEL)) { 250 vunmap(area->addr); 251 return NULL; 252 } 253 return (void __iomem *) ((unsigned long) area->addr + offset); 254 } 255 EXPORT_SYMBOL(ioremap); 256 257 void iounmap(volatile void __iomem *addr) 258 { 259 if (static_branch_likely(&have_mio)) 260 vunmap((__force void *) ((unsigned long) addr & PAGE_MASK)); 261 } 262 EXPORT_SYMBOL(iounmap); 263 264 /* Create a virtual mapping cookie for a PCI BAR */ 265 static void __iomem *pci_iomap_range_fh(struct pci_dev *pdev, int bar, 266 unsigned long offset, unsigned long max) 267 { 268 struct zpci_dev *zdev = to_zpci(pdev); 269 int idx; 270 271 idx = zdev->bars[bar].map_idx; 272 spin_lock(&zpci_iomap_lock); 273 /* Detect overrun */ 274 WARN_ON(!++zpci_iomap_start[idx].count); 275 zpci_iomap_start[idx].fh = zdev->fh; 276 zpci_iomap_start[idx].bar = bar; 277 spin_unlock(&zpci_iomap_lock); 278 279 return (void __iomem *) ZPCI_ADDR(idx) + offset; 280 } 281 282 static void __iomem *pci_iomap_range_mio(struct pci_dev *pdev, int bar, 283 unsigned long offset, 284 unsigned long max) 285 { 286 unsigned long barsize = pci_resource_len(pdev, bar); 287 struct zpci_dev *zdev = to_zpci(pdev); 288 void __iomem *iova; 289 290 iova = ioremap((unsigned long) zdev->bars[bar].mio_wt, barsize); 291 return iova ? iova + offset : iova; 292 } 293 294 void __iomem *pci_iomap_range(struct pci_dev *pdev, int bar, 295 unsigned long offset, unsigned long max) 296 { 297 if (!pci_resource_len(pdev, bar) || bar >= PCI_BAR_COUNT) 298 return NULL; 299 300 if (static_branch_likely(&have_mio)) 301 return pci_iomap_range_mio(pdev, bar, offset, max); 302 else 303 return pci_iomap_range_fh(pdev, bar, offset, max); 304 } 305 EXPORT_SYMBOL(pci_iomap_range); 306 307 void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen) 308 { 309 return pci_iomap_range(dev, bar, 0, maxlen); 310 } 311 EXPORT_SYMBOL(pci_iomap); 312 313 static void __iomem *pci_iomap_wc_range_mio(struct pci_dev *pdev, int bar, 314 unsigned long offset, unsigned long max) 315 { 316 unsigned long barsize = pci_resource_len(pdev, bar); 317 struct zpci_dev *zdev = to_zpci(pdev); 318 void __iomem *iova; 319 320 iova = ioremap((unsigned long) zdev->bars[bar].mio_wb, barsize); 321 return iova ? iova + offset : iova; 322 } 323 324 void __iomem *pci_iomap_wc_range(struct pci_dev *pdev, int bar, 325 unsigned long offset, unsigned long max) 326 { 327 if (!pci_resource_len(pdev, bar) || bar >= PCI_BAR_COUNT) 328 return NULL; 329 330 if (static_branch_likely(&have_mio)) 331 return pci_iomap_wc_range_mio(pdev, bar, offset, max); 332 else 333 return pci_iomap_range_fh(pdev, bar, offset, max); 334 } 335 EXPORT_SYMBOL(pci_iomap_wc_range); 336 337 void __iomem *pci_iomap_wc(struct pci_dev *dev, int bar, unsigned long maxlen) 338 { 339 return pci_iomap_wc_range(dev, bar, 0, maxlen); 340 } 341 EXPORT_SYMBOL(pci_iomap_wc); 342 343 static void pci_iounmap_fh(struct pci_dev *pdev, void __iomem *addr) 344 { 345 unsigned int idx = ZPCI_IDX(addr); 346 347 spin_lock(&zpci_iomap_lock); 348 /* Detect underrun */ 349 WARN_ON(!zpci_iomap_start[idx].count); 350 if (!--zpci_iomap_start[idx].count) { 351 zpci_iomap_start[idx].fh = 0; 352 zpci_iomap_start[idx].bar = 0; 353 } 354 spin_unlock(&zpci_iomap_lock); 355 } 356 357 static void pci_iounmap_mio(struct pci_dev *pdev, void __iomem *addr) 358 { 359 iounmap(addr); 360 } 361 362 void pci_iounmap(struct pci_dev *pdev, void __iomem *addr) 363 { 364 if (static_branch_likely(&have_mio)) 365 pci_iounmap_mio(pdev, addr); 366 else 367 pci_iounmap_fh(pdev, addr); 368 } 369 EXPORT_SYMBOL(pci_iounmap); 370 371 static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, 372 int size, u32 *val) 373 { 374 struct zpci_dev *zdev = get_zdev_by_bus(bus); 375 int ret; 376 377 if (!zdev || devfn != ZPCI_DEVFN) 378 ret = -ENODEV; 379 else 380 ret = zpci_cfg_load(zdev, where, val, size); 381 382 return ret; 383 } 384 385 static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, 386 int size, u32 val) 387 { 388 struct zpci_dev *zdev = get_zdev_by_bus(bus); 389 int ret; 390 391 if (!zdev || devfn != ZPCI_DEVFN) 392 ret = -ENODEV; 393 else 394 ret = zpci_cfg_store(zdev, where, val, size); 395 396 return ret; 397 } 398 399 static struct pci_ops pci_root_ops = { 400 .read = pci_read, 401 .write = pci_write, 402 }; 403 404 #ifdef CONFIG_PCI_IOV 405 static struct resource iov_res = { 406 .name = "PCI IOV res", 407 .start = 0, 408 .end = -1, 409 .flags = IORESOURCE_MEM, 410 }; 411 #endif 412 413 static void zpci_map_resources(struct pci_dev *pdev) 414 { 415 struct zpci_dev *zdev = to_zpci(pdev); 416 resource_size_t len; 417 int i; 418 419 for (i = 0; i < PCI_BAR_COUNT; i++) { 420 len = pci_resource_len(pdev, i); 421 if (!len) 422 continue; 423 424 if (zpci_use_mio(zdev)) 425 pdev->resource[i].start = 426 (resource_size_t __force) zdev->bars[i].mio_wb; 427 else 428 pdev->resource[i].start = (resource_size_t __force) 429 pci_iomap_range_fh(pdev, i, 0, 0); 430 pdev->resource[i].end = pdev->resource[i].start + len - 1; 431 } 432 433 #ifdef CONFIG_PCI_IOV 434 for (i = 0; i < PCI_SRIOV_NUM_BARS; i++) { 435 int bar = i + PCI_IOV_RESOURCES; 436 437 len = pci_resource_len(pdev, bar); 438 if (!len) 439 continue; 440 pdev->resource[bar].parent = &iov_res; 441 } 442 #endif 443 } 444 445 static void zpci_unmap_resources(struct pci_dev *pdev) 446 { 447 struct zpci_dev *zdev = to_zpci(pdev); 448 resource_size_t len; 449 int i; 450 451 if (zpci_use_mio(zdev)) 452 return; 453 454 for (i = 0; i < PCI_BAR_COUNT; i++) { 455 len = pci_resource_len(pdev, i); 456 if (!len) 457 continue; 458 pci_iounmap_fh(pdev, (void __iomem __force *) 459 pdev->resource[i].start); 460 } 461 } 462 463 static int zpci_alloc_iomap(struct zpci_dev *zdev) 464 { 465 unsigned long entry; 466 467 spin_lock(&zpci_iomap_lock); 468 entry = find_first_zero_bit(zpci_iomap_bitmap, ZPCI_IOMAP_ENTRIES); 469 if (entry == ZPCI_IOMAP_ENTRIES) { 470 spin_unlock(&zpci_iomap_lock); 471 return -ENOSPC; 472 } 473 set_bit(entry, zpci_iomap_bitmap); 474 spin_unlock(&zpci_iomap_lock); 475 return entry; 476 } 477 478 static void zpci_free_iomap(struct zpci_dev *zdev, int entry) 479 { 480 spin_lock(&zpci_iomap_lock); 481 memset(&zpci_iomap_start[entry], 0, sizeof(struct zpci_iomap_entry)); 482 clear_bit(entry, zpci_iomap_bitmap); 483 spin_unlock(&zpci_iomap_lock); 484 } 485 486 static struct resource *__alloc_res(struct zpci_dev *zdev, unsigned long start, 487 unsigned long size, unsigned long flags) 488 { 489 struct resource *r; 490 491 r = kzalloc(sizeof(*r), GFP_KERNEL); 492 if (!r) 493 return NULL; 494 495 r->start = start; 496 r->end = r->start + size - 1; 497 r->flags = flags; 498 r->name = zdev->res_name; 499 500 if (request_resource(&iomem_resource, r)) { 501 kfree(r); 502 return NULL; 503 } 504 return r; 505 } 506 507 static int zpci_setup_bus_resources(struct zpci_dev *zdev, 508 struct list_head *resources) 509 { 510 unsigned long addr, size, flags; 511 struct resource *res; 512 int i, entry; 513 514 snprintf(zdev->res_name, sizeof(zdev->res_name), 515 "PCI Bus %04x:%02x", zdev->domain, ZPCI_BUS_NR); 516 517 for (i = 0; i < PCI_BAR_COUNT; i++) { 518 if (!zdev->bars[i].size) 519 continue; 520 entry = zpci_alloc_iomap(zdev); 521 if (entry < 0) 522 return entry; 523 zdev->bars[i].map_idx = entry; 524 525 /* only MMIO is supported */ 526 flags = IORESOURCE_MEM; 527 if (zdev->bars[i].val & 8) 528 flags |= IORESOURCE_PREFETCH; 529 if (zdev->bars[i].val & 4) 530 flags |= IORESOURCE_MEM_64; 531 532 if (zpci_use_mio(zdev)) 533 addr = (unsigned long) zdev->bars[i].mio_wb; 534 else 535 addr = ZPCI_ADDR(entry); 536 size = 1UL << zdev->bars[i].size; 537 538 res = __alloc_res(zdev, addr, size, flags); 539 if (!res) { 540 zpci_free_iomap(zdev, entry); 541 return -ENOMEM; 542 } 543 zdev->bars[i].res = res; 544 pci_add_resource(resources, res); 545 } 546 547 return 0; 548 } 549 550 static void zpci_cleanup_bus_resources(struct zpci_dev *zdev) 551 { 552 int i; 553 554 for (i = 0; i < PCI_BAR_COUNT; i++) { 555 if (!zdev->bars[i].size || !zdev->bars[i].res) 556 continue; 557 558 zpci_free_iomap(zdev, zdev->bars[i].map_idx); 559 release_resource(zdev->bars[i].res); 560 kfree(zdev->bars[i].res); 561 } 562 } 563 564 int pcibios_add_device(struct pci_dev *pdev) 565 { 566 struct resource *res; 567 int i; 568 569 if (pdev->is_physfn) 570 pdev->no_vf_scan = 1; 571 572 pdev->dev.groups = zpci_attr_groups; 573 pdev->dev.dma_ops = &s390_pci_dma_ops; 574 zpci_map_resources(pdev); 575 576 for (i = 0; i < PCI_BAR_COUNT; i++) { 577 res = &pdev->resource[i]; 578 if (res->parent || !res->flags) 579 continue; 580 pci_claim_resource(pdev, i); 581 } 582 583 return 0; 584 } 585 586 void pcibios_release_device(struct pci_dev *pdev) 587 { 588 zpci_unmap_resources(pdev); 589 } 590 591 int pcibios_enable_device(struct pci_dev *pdev, int mask) 592 { 593 struct zpci_dev *zdev = to_zpci(pdev); 594 595 zpci_debug_init_device(zdev, dev_name(&pdev->dev)); 596 zpci_fmb_enable_device(zdev); 597 598 return pci_enable_resources(pdev, mask); 599 } 600 601 void pcibios_disable_device(struct pci_dev *pdev) 602 { 603 struct zpci_dev *zdev = to_zpci(pdev); 604 605 zpci_fmb_disable_device(zdev); 606 zpci_debug_exit_device(zdev); 607 } 608 609 #ifdef CONFIG_HIBERNATE_CALLBACKS 610 static int zpci_restore(struct device *dev) 611 { 612 struct pci_dev *pdev = to_pci_dev(dev); 613 struct zpci_dev *zdev = to_zpci(pdev); 614 int ret = 0; 615 616 if (zdev->state != ZPCI_FN_STATE_ONLINE) 617 goto out; 618 619 ret = clp_enable_fh(zdev, ZPCI_NR_DMA_SPACES); 620 if (ret) 621 goto out; 622 623 zpci_map_resources(pdev); 624 zpci_register_ioat(zdev, 0, zdev->start_dma, zdev->end_dma, 625 (u64) zdev->dma_table); 626 627 out: 628 return ret; 629 } 630 631 static int zpci_freeze(struct device *dev) 632 { 633 struct pci_dev *pdev = to_pci_dev(dev); 634 struct zpci_dev *zdev = to_zpci(pdev); 635 636 if (zdev->state != ZPCI_FN_STATE_ONLINE) 637 return 0; 638 639 zpci_unregister_ioat(zdev, 0); 640 zpci_unmap_resources(pdev); 641 return clp_disable_fh(zdev); 642 } 643 644 struct dev_pm_ops pcibios_pm_ops = { 645 .thaw_noirq = zpci_restore, 646 .freeze_noirq = zpci_freeze, 647 .restore_noirq = zpci_restore, 648 .poweroff_noirq = zpci_freeze, 649 }; 650 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 651 652 static int zpci_alloc_domain(struct zpci_dev *zdev) 653 { 654 if (zpci_unique_uid) { 655 zdev->domain = (u16) zdev->uid; 656 if (zdev->domain >= ZPCI_NR_DEVICES) 657 return 0; 658 659 spin_lock(&zpci_domain_lock); 660 if (test_bit(zdev->domain, zpci_domain)) { 661 spin_unlock(&zpci_domain_lock); 662 return -EEXIST; 663 } 664 set_bit(zdev->domain, zpci_domain); 665 spin_unlock(&zpci_domain_lock); 666 return 0; 667 } 668 669 spin_lock(&zpci_domain_lock); 670 zdev->domain = find_first_zero_bit(zpci_domain, ZPCI_NR_DEVICES); 671 if (zdev->domain == ZPCI_NR_DEVICES) { 672 spin_unlock(&zpci_domain_lock); 673 return -ENOSPC; 674 } 675 set_bit(zdev->domain, zpci_domain); 676 spin_unlock(&zpci_domain_lock); 677 return 0; 678 } 679 680 static void zpci_free_domain(struct zpci_dev *zdev) 681 { 682 if (zdev->domain >= ZPCI_NR_DEVICES) 683 return; 684 685 spin_lock(&zpci_domain_lock); 686 clear_bit(zdev->domain, zpci_domain); 687 spin_unlock(&zpci_domain_lock); 688 } 689 690 void pcibios_remove_bus(struct pci_bus *bus) 691 { 692 struct zpci_dev *zdev = get_zdev_by_bus(bus); 693 694 zpci_exit_slot(zdev); 695 zpci_cleanup_bus_resources(zdev); 696 zpci_destroy_iommu(zdev); 697 zpci_free_domain(zdev); 698 699 spin_lock(&zpci_list_lock); 700 list_del(&zdev->entry); 701 spin_unlock(&zpci_list_lock); 702 703 zpci_dbg(3, "rem fid:%x\n", zdev->fid); 704 kfree(zdev); 705 } 706 707 static int zpci_scan_bus(struct zpci_dev *zdev) 708 { 709 LIST_HEAD(resources); 710 int ret; 711 712 ret = zpci_setup_bus_resources(zdev, &resources); 713 if (ret) 714 goto error; 715 716 zdev->bus = pci_scan_root_bus(NULL, ZPCI_BUS_NR, &pci_root_ops, 717 zdev, &resources); 718 if (!zdev->bus) { 719 ret = -EIO; 720 goto error; 721 } 722 zdev->bus->max_bus_speed = zdev->max_bus_speed; 723 pci_bus_add_devices(zdev->bus); 724 return 0; 725 726 error: 727 zpci_cleanup_bus_resources(zdev); 728 pci_free_resource_list(&resources); 729 return ret; 730 } 731 732 int zpci_enable_device(struct zpci_dev *zdev) 733 { 734 int rc; 735 736 rc = clp_enable_fh(zdev, ZPCI_NR_DMA_SPACES); 737 if (rc) 738 goto out; 739 740 rc = zpci_dma_init_device(zdev); 741 if (rc) 742 goto out_dma; 743 744 zdev->state = ZPCI_FN_STATE_ONLINE; 745 return 0; 746 747 out_dma: 748 clp_disable_fh(zdev); 749 out: 750 return rc; 751 } 752 EXPORT_SYMBOL_GPL(zpci_enable_device); 753 754 int zpci_disable_device(struct zpci_dev *zdev) 755 { 756 zpci_dma_exit_device(zdev); 757 return clp_disable_fh(zdev); 758 } 759 EXPORT_SYMBOL_GPL(zpci_disable_device); 760 761 int zpci_create_device(struct zpci_dev *zdev) 762 { 763 int rc; 764 765 rc = zpci_alloc_domain(zdev); 766 if (rc) 767 goto out; 768 769 rc = zpci_init_iommu(zdev); 770 if (rc) 771 goto out_free; 772 773 mutex_init(&zdev->lock); 774 if (zdev->state == ZPCI_FN_STATE_CONFIGURED) { 775 rc = zpci_enable_device(zdev); 776 if (rc) 777 goto out_destroy_iommu; 778 } 779 rc = zpci_scan_bus(zdev); 780 if (rc) 781 goto out_disable; 782 783 spin_lock(&zpci_list_lock); 784 list_add_tail(&zdev->entry, &zpci_list); 785 spin_unlock(&zpci_list_lock); 786 787 zpci_init_slot(zdev); 788 789 return 0; 790 791 out_disable: 792 if (zdev->state == ZPCI_FN_STATE_ONLINE) 793 zpci_disable_device(zdev); 794 out_destroy_iommu: 795 zpci_destroy_iommu(zdev); 796 out_free: 797 zpci_free_domain(zdev); 798 out: 799 return rc; 800 } 801 802 void zpci_remove_device(struct zpci_dev *zdev) 803 { 804 if (!zdev->bus) 805 return; 806 807 pci_stop_root_bus(zdev->bus); 808 pci_remove_root_bus(zdev->bus); 809 } 810 811 int zpci_report_error(struct pci_dev *pdev, 812 struct zpci_report_error_header *report) 813 { 814 struct zpci_dev *zdev = to_zpci(pdev); 815 816 return sclp_pci_report(report, zdev->fh, zdev->fid); 817 } 818 EXPORT_SYMBOL(zpci_report_error); 819 820 static int zpci_mem_init(void) 821 { 822 BUILD_BUG_ON(!is_power_of_2(__alignof__(struct zpci_fmb)) || 823 __alignof__(struct zpci_fmb) < sizeof(struct zpci_fmb)); 824 825 zdev_fmb_cache = kmem_cache_create("PCI_FMB_cache", sizeof(struct zpci_fmb), 826 __alignof__(struct zpci_fmb), 0, NULL); 827 if (!zdev_fmb_cache) 828 goto error_fmb; 829 830 zpci_iomap_start = kcalloc(ZPCI_IOMAP_ENTRIES, 831 sizeof(*zpci_iomap_start), GFP_KERNEL); 832 if (!zpci_iomap_start) 833 goto error_iomap; 834 835 zpci_iomap_bitmap = kcalloc(BITS_TO_LONGS(ZPCI_IOMAP_ENTRIES), 836 sizeof(*zpci_iomap_bitmap), GFP_KERNEL); 837 if (!zpci_iomap_bitmap) 838 goto error_iomap_bitmap; 839 840 return 0; 841 error_iomap_bitmap: 842 kfree(zpci_iomap_start); 843 error_iomap: 844 kmem_cache_destroy(zdev_fmb_cache); 845 error_fmb: 846 return -ENOMEM; 847 } 848 849 static void zpci_mem_exit(void) 850 { 851 kfree(zpci_iomap_bitmap); 852 kfree(zpci_iomap_start); 853 kmem_cache_destroy(zdev_fmb_cache); 854 } 855 856 static unsigned int s390_pci_probe __initdata = 1; 857 static unsigned int s390_pci_no_mio __initdata; 858 unsigned int s390_pci_force_floating __initdata; 859 static unsigned int s390_pci_initialized; 860 861 char * __init pcibios_setup(char *str) 862 { 863 if (!strcmp(str, "off")) { 864 s390_pci_probe = 0; 865 return NULL; 866 } 867 if (!strcmp(str, "nomio")) { 868 s390_pci_no_mio = 1; 869 return NULL; 870 } 871 if (!strcmp(str, "force_floating")) { 872 s390_pci_force_floating = 1; 873 return NULL; 874 } 875 return str; 876 } 877 878 bool zpci_is_enabled(void) 879 { 880 return s390_pci_initialized; 881 } 882 883 static int __init pci_base_init(void) 884 { 885 int rc; 886 887 if (!s390_pci_probe) 888 return 0; 889 890 if (!test_facility(69) || !test_facility(71)) 891 return 0; 892 893 if (test_facility(153) && !s390_pci_no_mio) { 894 static_branch_enable(&have_mio); 895 ctl_set_bit(2, 5); 896 } 897 898 rc = zpci_debug_init(); 899 if (rc) 900 goto out; 901 902 rc = zpci_mem_init(); 903 if (rc) 904 goto out_mem; 905 906 rc = zpci_irq_init(); 907 if (rc) 908 goto out_irq; 909 910 rc = zpci_dma_init(); 911 if (rc) 912 goto out_dma; 913 914 rc = clp_scan_pci_devices(); 915 if (rc) 916 goto out_find; 917 918 s390_pci_initialized = 1; 919 return 0; 920 921 out_find: 922 zpci_dma_exit(); 923 out_dma: 924 zpci_irq_exit(); 925 out_irq: 926 zpci_mem_exit(); 927 out_mem: 928 zpci_debug_exit(); 929 out: 930 return rc; 931 } 932 subsys_initcall_sync(pci_base_init); 933 934 void zpci_rescan(void) 935 { 936 if (zpci_is_enabled()) 937 clp_rescan_pci_devices_simple(); 938 } 939