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