~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/s390/pci/pci.c

Version: ~ [ linux-5.6-rc3 ] ~ [ linux-5.5.6 ] ~ [ linux-5.4.22 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.106 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.171 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.214 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.214 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.82 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp