1 // SPDX-License-Identifier: GPL-2.0
3 * Copyright IBM Corp. 2012
6 * Jan Glauber <jang@linux.vnet.ibm.com>
8 * The System z PCI code is a rewrite from a prototype by
9 * the following people (Kudoz!):
19 #define KMSG_COMPONENT "zpci"
20 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
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 #include <linux/printk.h>
34 #include <asm/facility.h>
35 #include <asm/pci_insn.h>
36 #include <asm/pci_clp.h>
37 #include <asm/pci_dma.h>
41 /* list of all detected zpci devices */
42 static LIST_HEAD(zpci_list
);
43 static DEFINE_SPINLOCK(zpci_list_lock
);
45 static DECLARE_BITMAP(zpci_domain
, ZPCI_DOMAIN_BITMAP_SIZE
);
46 static DEFINE_SPINLOCK(zpci_domain_lock
);
48 #define ZPCI_IOMAP_ENTRIES \
49 min(((unsigned long) ZPCI_NR_DEVICES * PCI_STD_NUM_BARS / 2), \
50 ZPCI_IOMAP_MAX_ENTRIES)
52 unsigned int s390_pci_no_rid
;
54 static DEFINE_SPINLOCK(zpci_iomap_lock
);
55 static unsigned long *zpci_iomap_bitmap
;
56 struct zpci_iomap_entry
*zpci_iomap_start
;
57 EXPORT_SYMBOL_GPL(zpci_iomap_start
);
59 DEFINE_STATIC_KEY_FALSE(have_mio
);
61 static struct kmem_cache
*zdev_fmb_cache
;
63 struct zpci_dev
*get_zdev_by_fid(u32 fid
)
65 struct zpci_dev
*tmp
, *zdev
= NULL
;
67 spin_lock(&zpci_list_lock
);
68 list_for_each_entry(tmp
, &zpci_list
, entry
) {
69 if (tmp
->fid
== fid
) {
74 spin_unlock(&zpci_list_lock
);
78 void zpci_remove_reserved_devices(void)
80 struct zpci_dev
*tmp
, *zdev
;
81 enum zpci_state state
;
84 spin_lock(&zpci_list_lock
);
85 list_for_each_entry_safe(zdev
, tmp
, &zpci_list
, entry
) {
86 if (zdev
->state
== ZPCI_FN_STATE_STANDBY
&&
87 !clp_get_state(zdev
->fid
, &state
) &&
88 state
== ZPCI_FN_STATE_RESERVED
)
89 list_move_tail(&zdev
->entry
, &remove
);
91 spin_unlock(&zpci_list_lock
);
93 list_for_each_entry_safe(zdev
, tmp
, &remove
, entry
)
97 int pci_domain_nr(struct pci_bus
*bus
)
99 return ((struct zpci_bus
*) bus
->sysdata
)->domain_nr
;
101 EXPORT_SYMBOL_GPL(pci_domain_nr
);
103 int pci_proc_domain(struct pci_bus
*bus
)
105 return pci_domain_nr(bus
);
107 EXPORT_SYMBOL_GPL(pci_proc_domain
);
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
)
113 u64 req
= ZPCI_CREATE_REQ(zdev
->fh
, dmaas
, ZPCI_MOD_FC_REG_IOAT
);
114 struct zpci_fib fib
= {0};
117 WARN_ON_ONCE(iota
& 0x3fff);
120 fib
.iota
= iota
| ZPCI_IOTA_RTTO_FLAG
;
121 return zpci_mod_fc(req
, &fib
, &status
) ? -EIO
: 0;
124 /* Modify PCI: Unregister I/O address translation parameters */
125 int zpci_unregister_ioat(struct zpci_dev
*zdev
, u8 dmaas
)
127 u64 req
= ZPCI_CREATE_REQ(zdev
->fh
, dmaas
, ZPCI_MOD_FC_DEREG_IOAT
);
128 struct zpci_fib fib
= {0};
131 cc
= zpci_mod_fc(req
, &fib
, &status
);
132 if (cc
== 3) /* Function already gone. */
134 return cc
? -EIO
: 0;
137 /* Modify PCI: Set PCI function measurement parameters */
138 int zpci_fmb_enable_device(struct zpci_dev
*zdev
)
140 u64 req
= ZPCI_CREATE_REQ(zdev
->fh
, 0, ZPCI_MOD_FC_SET_MEASURE
);
141 struct zpci_fib fib
= {0};
144 if (zdev
->fmb
|| sizeof(*zdev
->fmb
) < zdev
->fmb_length
)
147 zdev
->fmb
= kmem_cache_zalloc(zdev_fmb_cache
, GFP_KERNEL
);
150 WARN_ON((u64
) zdev
->fmb
& 0xf);
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);
157 fib
.fmb_addr
= virt_to_phys(zdev
->fmb
);
158 cc
= zpci_mod_fc(req
, &fib
, &status
);
160 kmem_cache_free(zdev_fmb_cache
, zdev
->fmb
);
163 return cc
? -EIO
: 0;
166 /* Modify PCI: Disable PCI function measurement */
167 int zpci_fmb_disable_device(struct zpci_dev
*zdev
)
169 u64 req
= ZPCI_CREATE_REQ(zdev
->fh
, 0, ZPCI_MOD_FC_SET_MEASURE
);
170 struct zpci_fib fib
= {0};
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. */
182 kmem_cache_free(zdev_fmb_cache
, zdev
->fmb
);
185 return cc
? -EIO
: 0;
188 static int zpci_cfg_load(struct zpci_dev
*zdev
, int offset
, u32
*val
, u8 len
)
190 u64 req
= ZPCI_CREATE_REQ(zdev
->fh
, ZPCI_PCIAS_CFGSPC
, len
);
194 rc
= __zpci_load(&data
, req
, offset
);
196 data
= le64_to_cpu((__force __le64
) data
);
197 data
>>= (8 - len
) * 8;
204 static int zpci_cfg_store(struct zpci_dev
*zdev
, int offset
, u32 val
, u8 len
)
206 u64 req
= ZPCI_CREATE_REQ(zdev
->fh
, ZPCI_PCIAS_CFGSPC
, len
);
210 data
<<= (8 - len
) * 8;
211 data
= (__force u64
) cpu_to_le64(data
);
212 rc
= __zpci_store(data
, req
, offset
);
216 resource_size_t
pcibios_align_resource(void *data
, const struct resource
*res
,
217 resource_size_t size
,
218 resource_size_t align
)
223 /* combine single writes by using store-block insn */
224 void __iowrite64_copy(void __iomem
*to
, const void *from
, size_t count
)
226 zpci_memcpy_toio(to
, from
, count
);
229 void __iomem
*ioremap(phys_addr_t addr
, size_t size
)
231 unsigned long offset
, vaddr
;
232 struct vm_struct
*area
;
233 phys_addr_t last_addr
;
235 last_addr
= addr
+ size
- 1;
236 if (!size
|| last_addr
< addr
)
239 if (!static_branch_unlikely(&have_mio
))
240 return (void __iomem
*) addr
;
242 offset
= addr
& ~PAGE_MASK
;
244 size
= PAGE_ALIGN(size
+ offset
);
245 area
= get_vm_area(size
, VM_IOREMAP
);
249 vaddr
= (unsigned long) area
->addr
;
250 if (ioremap_page_range(vaddr
, vaddr
+ size
, addr
, PAGE_KERNEL
)) {
254 return (void __iomem
*) ((unsigned long) area
->addr
+ offset
);
256 EXPORT_SYMBOL(ioremap
);
258 void iounmap(volatile void __iomem
*addr
)
260 if (static_branch_likely(&have_mio
))
261 vunmap((__force
void *) ((unsigned long) addr
& PAGE_MASK
));
263 EXPORT_SYMBOL(iounmap
);
265 /* Create a virtual mapping cookie for a PCI BAR */
266 static void __iomem
*pci_iomap_range_fh(struct pci_dev
*pdev
, int bar
,
267 unsigned long offset
, unsigned long max
)
269 struct zpci_dev
*zdev
= to_zpci(pdev
);
272 idx
= zdev
->bars
[bar
].map_idx
;
273 spin_lock(&zpci_iomap_lock
);
275 WARN_ON(!++zpci_iomap_start
[idx
].count
);
276 zpci_iomap_start
[idx
].fh
= zdev
->fh
;
277 zpci_iomap_start
[idx
].bar
= bar
;
278 spin_unlock(&zpci_iomap_lock
);
280 return (void __iomem
*) ZPCI_ADDR(idx
) + offset
;
283 static void __iomem
*pci_iomap_range_mio(struct pci_dev
*pdev
, int bar
,
284 unsigned long offset
,
287 unsigned long barsize
= pci_resource_len(pdev
, bar
);
288 struct zpci_dev
*zdev
= to_zpci(pdev
);
291 iova
= ioremap((unsigned long) zdev
->bars
[bar
].mio_wt
, barsize
);
292 return iova
? iova
+ offset
: iova
;
295 void __iomem
*pci_iomap_range(struct pci_dev
*pdev
, int bar
,
296 unsigned long offset
, unsigned long max
)
298 if (bar
>= PCI_STD_NUM_BARS
|| !pci_resource_len(pdev
, bar
))
301 if (static_branch_likely(&have_mio
))
302 return pci_iomap_range_mio(pdev
, bar
, offset
, max
);
304 return pci_iomap_range_fh(pdev
, bar
, offset
, max
);
306 EXPORT_SYMBOL(pci_iomap_range
);
308 void __iomem
*pci_iomap(struct pci_dev
*dev
, int bar
, unsigned long maxlen
)
310 return pci_iomap_range(dev
, bar
, 0, maxlen
);
312 EXPORT_SYMBOL(pci_iomap
);
314 static void __iomem
*pci_iomap_wc_range_mio(struct pci_dev
*pdev
, int bar
,
315 unsigned long offset
, unsigned long max
)
317 unsigned long barsize
= pci_resource_len(pdev
, bar
);
318 struct zpci_dev
*zdev
= to_zpci(pdev
);
321 iova
= ioremap((unsigned long) zdev
->bars
[bar
].mio_wb
, barsize
);
322 return iova
? iova
+ offset
: iova
;
325 void __iomem
*pci_iomap_wc_range(struct pci_dev
*pdev
, int bar
,
326 unsigned long offset
, unsigned long max
)
328 if (bar
>= PCI_STD_NUM_BARS
|| !pci_resource_len(pdev
, bar
))
331 if (static_branch_likely(&have_mio
))
332 return pci_iomap_wc_range_mio(pdev
, bar
, offset
, max
);
334 return pci_iomap_range_fh(pdev
, bar
, offset
, max
);
336 EXPORT_SYMBOL(pci_iomap_wc_range
);
338 void __iomem
*pci_iomap_wc(struct pci_dev
*dev
, int bar
, unsigned long maxlen
)
340 return pci_iomap_wc_range(dev
, bar
, 0, maxlen
);
342 EXPORT_SYMBOL(pci_iomap_wc
);
344 static void pci_iounmap_fh(struct pci_dev
*pdev
, void __iomem
*addr
)
346 unsigned int idx
= ZPCI_IDX(addr
);
348 spin_lock(&zpci_iomap_lock
);
349 /* Detect underrun */
350 WARN_ON(!zpci_iomap_start
[idx
].count
);
351 if (!--zpci_iomap_start
[idx
].count
) {
352 zpci_iomap_start
[idx
].fh
= 0;
353 zpci_iomap_start
[idx
].bar
= 0;
355 spin_unlock(&zpci_iomap_lock
);
358 static void pci_iounmap_mio(struct pci_dev
*pdev
, void __iomem
*addr
)
363 void pci_iounmap(struct pci_dev
*pdev
, void __iomem
*addr
)
365 if (static_branch_likely(&have_mio
))
366 pci_iounmap_mio(pdev
, addr
);
368 pci_iounmap_fh(pdev
, addr
);
370 EXPORT_SYMBOL(pci_iounmap
);
372 static int pci_read(struct pci_bus
*bus
, unsigned int devfn
, int where
,
375 struct zpci_dev
*zdev
= get_zdev_by_bus(bus
, devfn
);
377 return (zdev
) ? zpci_cfg_load(zdev
, where
, val
, size
) : -ENODEV
;
380 static int pci_write(struct pci_bus
*bus
, unsigned int devfn
, int where
,
383 struct zpci_dev
*zdev
= get_zdev_by_bus(bus
, devfn
);
385 return (zdev
) ? zpci_cfg_store(zdev
, where
, val
, size
) : -ENODEV
;
388 static struct pci_ops pci_root_ops
= {
393 #ifdef CONFIG_PCI_IOV
394 static struct resource iov_res
= {
395 .name
= "PCI IOV res",
398 .flags
= IORESOURCE_MEM
,
402 static void zpci_map_resources(struct pci_dev
*pdev
)
404 struct zpci_dev
*zdev
= to_zpci(pdev
);
408 for (i
= 0; i
< PCI_STD_NUM_BARS
; i
++) {
409 len
= pci_resource_len(pdev
, i
);
413 if (zpci_use_mio(zdev
))
414 pdev
->resource
[i
].start
=
415 (resource_size_t __force
) zdev
->bars
[i
].mio_wt
;
417 pdev
->resource
[i
].start
= (resource_size_t __force
)
418 pci_iomap_range_fh(pdev
, i
, 0, 0);
419 pdev
->resource
[i
].end
= pdev
->resource
[i
].start
+ len
- 1;
422 #ifdef CONFIG_PCI_IOV
423 for (i
= 0; i
< PCI_SRIOV_NUM_BARS
; i
++) {
424 int bar
= i
+ PCI_IOV_RESOURCES
;
426 len
= pci_resource_len(pdev
, bar
);
429 pdev
->resource
[bar
].parent
= &iov_res
;
434 static void zpci_unmap_resources(struct pci_dev
*pdev
)
436 struct zpci_dev
*zdev
= to_zpci(pdev
);
440 if (zpci_use_mio(zdev
))
443 for (i
= 0; i
< PCI_STD_NUM_BARS
; i
++) {
444 len
= pci_resource_len(pdev
, i
);
447 pci_iounmap_fh(pdev
, (void __iomem __force
*)
448 pdev
->resource
[i
].start
);
452 static int zpci_alloc_iomap(struct zpci_dev
*zdev
)
456 spin_lock(&zpci_iomap_lock
);
457 entry
= find_first_zero_bit(zpci_iomap_bitmap
, ZPCI_IOMAP_ENTRIES
);
458 if (entry
== ZPCI_IOMAP_ENTRIES
) {
459 spin_unlock(&zpci_iomap_lock
);
462 set_bit(entry
, zpci_iomap_bitmap
);
463 spin_unlock(&zpci_iomap_lock
);
467 static void zpci_free_iomap(struct zpci_dev
*zdev
, int entry
)
469 spin_lock(&zpci_iomap_lock
);
470 memset(&zpci_iomap_start
[entry
], 0, sizeof(struct zpci_iomap_entry
));
471 clear_bit(entry
, zpci_iomap_bitmap
);
472 spin_unlock(&zpci_iomap_lock
);
475 static struct resource
*__alloc_res(struct zpci_dev
*zdev
, unsigned long start
,
476 unsigned long size
, unsigned long flags
)
480 r
= kzalloc(sizeof(*r
), GFP_KERNEL
);
485 r
->end
= r
->start
+ size
- 1;
487 r
->name
= zdev
->res_name
;
489 if (request_resource(&iomem_resource
, r
)) {
496 int zpci_setup_bus_resources(struct zpci_dev
*zdev
,
497 struct list_head
*resources
)
499 unsigned long addr
, size
, flags
;
500 struct resource
*res
;
503 snprintf(zdev
->res_name
, sizeof(zdev
->res_name
),
504 "PCI Bus %04x:%02x", zdev
->uid
, ZPCI_BUS_NR
);
506 for (i
= 0; i
< PCI_STD_NUM_BARS
; i
++) {
507 if (!zdev
->bars
[i
].size
)
509 entry
= zpci_alloc_iomap(zdev
);
512 zdev
->bars
[i
].map_idx
= entry
;
514 /* only MMIO is supported */
515 flags
= IORESOURCE_MEM
;
516 if (zdev
->bars
[i
].val
& 8)
517 flags
|= IORESOURCE_PREFETCH
;
518 if (zdev
->bars
[i
].val
& 4)
519 flags
|= IORESOURCE_MEM_64
;
521 if (zpci_use_mio(zdev
))
522 addr
= (unsigned long) zdev
->bars
[i
].mio_wt
;
524 addr
= ZPCI_ADDR(entry
);
525 size
= 1UL << zdev
->bars
[i
].size
;
527 res
= __alloc_res(zdev
, addr
, size
, flags
);
529 zpci_free_iomap(zdev
, entry
);
532 zdev
->bars
[i
].res
= res
;
533 pci_add_resource(resources
, res
);
539 static void zpci_cleanup_bus_resources(struct zpci_dev
*zdev
)
543 for (i
= 0; i
< PCI_STD_NUM_BARS
; i
++) {
544 if (!zdev
->bars
[i
].size
|| !zdev
->bars
[i
].res
)
547 zpci_free_iomap(zdev
, zdev
->bars
[i
].map_idx
);
548 release_resource(zdev
->bars
[i
].res
);
549 kfree(zdev
->bars
[i
].res
);
553 int pcibios_add_device(struct pci_dev
*pdev
)
555 struct resource
*res
;
559 pdev
->no_vf_scan
= 1;
561 pdev
->dev
.groups
= zpci_attr_groups
;
562 pdev
->dev
.dma_ops
= &s390_pci_dma_ops
;
563 zpci_map_resources(pdev
);
565 for (i
= 0; i
< PCI_STD_NUM_BARS
; i
++) {
566 res
= &pdev
->resource
[i
];
567 if (res
->parent
|| !res
->flags
)
569 pci_claim_resource(pdev
, i
);
575 void pcibios_release_device(struct pci_dev
*pdev
)
577 zpci_unmap_resources(pdev
);
580 int pcibios_enable_device(struct pci_dev
*pdev
, int mask
)
582 struct zpci_dev
*zdev
= to_zpci(pdev
);
584 zpci_debug_init_device(zdev
, dev_name(&pdev
->dev
));
585 zpci_fmb_enable_device(zdev
);
587 return pci_enable_resources(pdev
, mask
);
590 void pcibios_disable_device(struct pci_dev
*pdev
)
592 struct zpci_dev
*zdev
= to_zpci(pdev
);
594 zpci_fmb_disable_device(zdev
);
595 zpci_debug_exit_device(zdev
);
598 static int __zpci_register_domain(int domain
)
600 spin_lock(&zpci_domain_lock
);
601 if (test_bit(domain
, zpci_domain
)) {
602 spin_unlock(&zpci_domain_lock
);
603 pr_err("Domain %04x is already assigned\n", domain
);
606 set_bit(domain
, zpci_domain
);
607 spin_unlock(&zpci_domain_lock
);
611 static int __zpci_alloc_domain(void)
615 spin_lock(&zpci_domain_lock
);
617 * We can always auto allocate domains below ZPCI_NR_DEVICES.
618 * There is either a free domain or we have reached the maximum in
619 * which case we would have bailed earlier.
621 domain
= find_first_zero_bit(zpci_domain
, ZPCI_NR_DEVICES
);
622 set_bit(domain
, zpci_domain
);
623 spin_unlock(&zpci_domain_lock
);
627 int zpci_alloc_domain(int domain
)
629 if (zpci_unique_uid
) {
631 return __zpci_register_domain(domain
);
632 pr_warn("UID checking was active but no UID is provided: switching to automatic domain allocation\n");
633 update_uid_checking(false);
635 return __zpci_alloc_domain();
638 void zpci_free_domain(int domain
)
640 spin_lock(&zpci_domain_lock
);
641 clear_bit(domain
, zpci_domain
);
642 spin_unlock(&zpci_domain_lock
);
646 int zpci_enable_device(struct zpci_dev
*zdev
)
650 rc
= clp_enable_fh(zdev
, ZPCI_NR_DMA_SPACES
);
654 rc
= zpci_dma_init_device(zdev
);
658 zdev
->state
= ZPCI_FN_STATE_ONLINE
;
662 clp_disable_fh(zdev
);
666 EXPORT_SYMBOL_GPL(zpci_enable_device
);
668 int zpci_disable_device(struct zpci_dev
*zdev
)
670 zpci_dma_exit_device(zdev
);
671 return clp_disable_fh(zdev
);
673 EXPORT_SYMBOL_GPL(zpci_disable_device
);
675 int zpci_create_device(struct zpci_dev
*zdev
)
679 kref_init(&zdev
->kref
);
681 spin_lock(&zpci_list_lock
);
682 list_add_tail(&zdev
->entry
, &zpci_list
);
683 spin_unlock(&zpci_list_lock
);
685 rc
= zpci_init_iommu(zdev
);
689 mutex_init(&zdev
->lock
);
690 if (zdev
->state
== ZPCI_FN_STATE_CONFIGURED
) {
691 rc
= zpci_enable_device(zdev
);
693 goto out_destroy_iommu
;
696 rc
= zpci_bus_device_register(zdev
, &pci_root_ops
);
703 if (zdev
->state
== ZPCI_FN_STATE_ONLINE
)
704 zpci_disable_device(zdev
);
707 zpci_destroy_iommu(zdev
);
709 spin_lock(&zpci_list_lock
);
710 list_del(&zdev
->entry
);
711 spin_unlock(&zpci_list_lock
);
715 void zpci_release_device(struct kref
*kref
)
717 struct zpci_dev
*zdev
= container_of(kref
, struct zpci_dev
, kref
);
719 if (zdev
->zbus
->bus
) {
720 struct pci_dev
*pdev
;
722 pdev
= pci_get_slot(zdev
->zbus
->bus
, zdev
->devfn
);
724 pci_stop_and_remove_bus_device_locked(pdev
);
727 switch (zdev
->state
) {
728 case ZPCI_FN_STATE_ONLINE
:
729 case ZPCI_FN_STATE_CONFIGURED
:
730 zpci_disable_device(zdev
);
732 case ZPCI_FN_STATE_STANDBY
:
733 if (zdev
->has_hp_slot
)
734 zpci_exit_slot(zdev
);
735 zpci_cleanup_bus_resources(zdev
);
736 zpci_bus_device_unregister(zdev
);
737 zpci_destroy_iommu(zdev
);
743 spin_lock(&zpci_list_lock
);
744 list_del(&zdev
->entry
);
745 spin_unlock(&zpci_list_lock
);
746 zpci_dbg(3, "rem fid:%x\n", zdev
->fid
);
750 int zpci_report_error(struct pci_dev
*pdev
,
751 struct zpci_report_error_header
*report
)
753 struct zpci_dev
*zdev
= to_zpci(pdev
);
755 return sclp_pci_report(report
, zdev
->fh
, zdev
->fid
);
757 EXPORT_SYMBOL(zpci_report_error
);
759 static int zpci_mem_init(void)
761 BUILD_BUG_ON(!is_power_of_2(__alignof__(struct zpci_fmb
)) ||
762 __alignof__(struct zpci_fmb
) < sizeof(struct zpci_fmb
));
764 zdev_fmb_cache
= kmem_cache_create("PCI_FMB_cache", sizeof(struct zpci_fmb
),
765 __alignof__(struct zpci_fmb
), 0, NULL
);
769 zpci_iomap_start
= kcalloc(ZPCI_IOMAP_ENTRIES
,
770 sizeof(*zpci_iomap_start
), GFP_KERNEL
);
771 if (!zpci_iomap_start
)
774 zpci_iomap_bitmap
= kcalloc(BITS_TO_LONGS(ZPCI_IOMAP_ENTRIES
),
775 sizeof(*zpci_iomap_bitmap
), GFP_KERNEL
);
776 if (!zpci_iomap_bitmap
)
777 goto error_iomap_bitmap
;
781 kfree(zpci_iomap_start
);
783 kmem_cache_destroy(zdev_fmb_cache
);
788 static void zpci_mem_exit(void)
790 kfree(zpci_iomap_bitmap
);
791 kfree(zpci_iomap_start
);
792 kmem_cache_destroy(zdev_fmb_cache
);
795 static unsigned int s390_pci_probe __initdata
= 1;
796 static unsigned int s390_pci_no_mio __initdata
;
797 unsigned int s390_pci_force_floating __initdata
;
798 static unsigned int s390_pci_initialized
;
800 char * __init
pcibios_setup(char *str
)
802 if (!strcmp(str
, "off")) {
806 if (!strcmp(str
, "nomio")) {
810 if (!strcmp(str
, "force_floating")) {
811 s390_pci_force_floating
= 1;
814 if (!strcmp(str
, "norid")) {
821 bool zpci_is_enabled(void)
823 return s390_pci_initialized
;
826 static int __init
pci_base_init(void)
833 if (!test_facility(69) || !test_facility(71))
836 if (test_facility(153) && !s390_pci_no_mio
) {
837 static_branch_enable(&have_mio
);
841 rc
= zpci_debug_init();
845 rc
= zpci_mem_init();
849 rc
= zpci_irq_init();
853 rc
= zpci_dma_init();
857 rc
= clp_scan_pci_devices();
861 s390_pci_initialized
= 1;
875 subsys_initcall_sync(pci_base_init
);
877 void zpci_rescan(void)
879 if (zpci_is_enabled())
880 clp_rescan_pci_devices_simple(NULL
);