blob: 3627ae075f4004d17b42263dbe3285435595e07d [file] [log] [blame]
Jan Glaubercd248342012-11-29 12:50:30 +01001/*
2 * Copyright IBM Corp. 2012
3 *
4 * Author(s):
5 * Jan Glauber <jang@linux.vnet.ibm.com>
6 *
7 * The System z PCI code is a rewrite from a prototype by
8 * the following people (Kudoz!):
Jan Glauberbedef752012-12-06 14:06:28 +01009 * Alexander Schmidt
10 * Christoph Raisch
11 * Hannes Hering
12 * Hoang-Nam Nguyen
13 * Jan-Bernd Themann
14 * Stefan Roscher
15 * Thomas Klein
Jan Glaubercd248342012-11-29 12:50:30 +010016 */
17
Gerald Schaefer896cb7e2014-07-16 17:21:01 +020018#define KMSG_COMPONENT "zpci"
19#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
Jan Glaubercd248342012-11-29 12:50:30 +010020
21#include <linux/kernel.h>
22#include <linux/slab.h>
23#include <linux/err.h>
24#include <linux/export.h>
25#include <linux/delay.h>
Jan Glauber9a4da8a2012-11-29 13:05:05 +010026#include <linux/irq.h>
27#include <linux/kernel_stat.h>
Jan Glaubercd248342012-11-29 12:50:30 +010028#include <linux/seq_file.h>
29#include <linux/pci.h>
30#include <linux/msi.h>
31
Jan Glauber9a4da8a2012-11-29 13:05:05 +010032#include <asm/isc.h>
33#include <asm/airq.h>
Jan Glaubercd248342012-11-29 12:50:30 +010034#include <asm/facility.h>
35#include <asm/pci_insn.h>
Jan Glaubera755a452012-11-29 12:55:21 +010036#include <asm/pci_clp.h>
Jan Glauber828b35f2012-11-29 14:33:30 +010037#include <asm/pci_dma.h>
Jan Glaubercd248342012-11-29 12:50:30 +010038
39#define DEBUG /* enable pr_debug */
40
Jan Glauber9a4da8a2012-11-29 13:05:05 +010041#define SIC_IRQ_MODE_ALL 0
42#define SIC_IRQ_MODE_SINGLE 1
43
Jan Glaubercd248342012-11-29 12:50:30 +010044#define ZPCI_NR_DMA_SPACES 1
45#define ZPCI_NR_DEVICES CONFIG_PCI_NR_FUNCTIONS
46
47/* list of all detected zpci devices */
Sebastian Ott67f43f32013-08-29 19:33:16 +020048static LIST_HEAD(zpci_list);
Sebastian Ott57b59182013-08-29 19:40:01 +020049static DEFINE_SPINLOCK(zpci_list_lock);
Martin Schwidefsky1f44a222013-06-27 09:01:09 +020050
Martin Schwidefsky1f44a222013-06-27 09:01:09 +020051static struct irq_chip zpci_irq_chip = {
52 .name = "zPCI",
Thomas Gleixner280510f2014-11-23 12:23:20 +010053 .irq_unmask = pci_msi_unmask_irq,
54 .irq_mask = pci_msi_mask_irq,
Martin Schwidefsky1f44a222013-06-27 09:01:09 +020055};
56
Jan Glaubercd248342012-11-29 12:50:30 +010057static DECLARE_BITMAP(zpci_domain, ZPCI_NR_DEVICES);
58static DEFINE_SPINLOCK(zpci_domain_lock);
59
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +020060static struct airq_iv *zpci_aisb_iv;
Martin Schwidefsky1f44a222013-06-27 09:01:09 +020061static struct airq_iv *zpci_aibv[ZPCI_NR_DEVICES];
Jan Glauber9a4da8a2012-11-29 13:05:05 +010062
Martin Schwidefskyf4eae942013-06-24 10:30:41 +020063/* Adapter interrupt definitions */
64static void zpci_irq_handler(struct airq_struct *airq);
65
66static struct airq_struct zpci_airq = {
67 .handler = zpci_irq_handler,
68 .isc = PCI_ISC,
69};
Jan Glauber9a4da8a2012-11-29 13:05:05 +010070
Jan Glaubercd248342012-11-29 12:50:30 +010071/* I/O Map */
72static DEFINE_SPINLOCK(zpci_iomap_lock);
73static DECLARE_BITMAP(zpci_iomap, ZPCI_IOMAP_MAX_ENTRIES);
74struct zpci_iomap_entry *zpci_iomap_start;
75EXPORT_SYMBOL_GPL(zpci_iomap_start);
76
Jan Glauberd0b08852012-12-11 14:53:35 +010077static struct kmem_cache *zdev_fmb_cache;
78
Jan Glaubercd248342012-11-29 12:50:30 +010079struct zpci_dev *get_zdev_by_fid(u32 fid)
80{
81 struct zpci_dev *tmp, *zdev = NULL;
82
Sebastian Ott57b59182013-08-29 19:40:01 +020083 spin_lock(&zpci_list_lock);
Jan Glaubercd248342012-11-29 12:50:30 +010084 list_for_each_entry(tmp, &zpci_list, entry) {
85 if (tmp->fid == fid) {
86 zdev = tmp;
87 break;
88 }
89 }
Sebastian Ott57b59182013-08-29 19:40:01 +020090 spin_unlock(&zpci_list_lock);
Jan Glaubercd248342012-11-29 12:50:30 +010091 return zdev;
92}
93
Jan Glaubercd248342012-11-29 12:50:30 +010094static 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
99int pci_domain_nr(struct pci_bus *bus)
100{
101 return ((struct zpci_dev *) bus->sysdata)->domain;
102}
103EXPORT_SYMBOL_GPL(pci_domain_nr);
104
105int pci_proc_domain(struct pci_bus *bus)
106{
107 return pci_domain_nr(bus);
108}
109EXPORT_SYMBOL_GPL(pci_proc_domain);
110
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100111/* Modify PCI: Register adapter interruptions */
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200112static int zpci_set_airq(struct zpci_dev *zdev)
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100113{
114 u64 req = ZPCI_CREATE_REQ(zdev->fh, 0, ZPCI_MOD_FC_REG_INT);
Sebastian Ottcb4deb62013-10-22 15:19:24 +0200115 struct zpci_fib fib = {0};
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100116
Sebastian Ottcb4deb62013-10-22 15:19:24 +0200117 fib.isc = PCI_ISC;
118 fib.sum = 1; /* enable summary notifications */
119 fib.noi = airq_iv_end(zdev->aibv);
120 fib.aibv = (unsigned long) zdev->aibv->vector;
121 fib.aibvo = 0; /* each zdev has its own interrupt vector */
122 fib.aisb = (unsigned long) zpci_aisb_iv->vector + (zdev->aisb/64)*8;
123 fib.aisbo = zdev->aisb & 63;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100124
Sebastian Ottcb4deb62013-10-22 15:19:24 +0200125 return zpci_mod_fc(req, &fib);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100126}
127
128struct mod_pci_args {
129 u64 base;
130 u64 limit;
131 u64 iota;
Jan Glauberd0b08852012-12-11 14:53:35 +0100132 u64 fmb_addr;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100133};
134
135static int mod_pci(struct zpci_dev *zdev, int fn, u8 dmaas, struct mod_pci_args *args)
136{
137 u64 req = ZPCI_CREATE_REQ(zdev->fh, dmaas, fn);
Sebastian Ottcb4deb62013-10-22 15:19:24 +0200138 struct zpci_fib fib = {0};
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100139
Sebastian Ottcb4deb62013-10-22 15:19:24 +0200140 fib.pba = args->base;
141 fib.pal = args->limit;
142 fib.iota = args->iota;
143 fib.fmb_addr = args->fmb_addr;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100144
Sebastian Ottcb4deb62013-10-22 15:19:24 +0200145 return zpci_mod_fc(req, &fib);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100146}
147
Jan Glauber828b35f2012-11-29 14:33:30 +0100148/* Modify PCI: Register I/O address translation parameters */
149int zpci_register_ioat(struct zpci_dev *zdev, u8 dmaas,
150 u64 base, u64 limit, u64 iota)
151{
Jan Glauberd0b08852012-12-11 14:53:35 +0100152 struct mod_pci_args args = { base, limit, iota, 0 };
Jan Glauber828b35f2012-11-29 14:33:30 +0100153
154 WARN_ON_ONCE(iota & 0x3fff);
155 args.iota |= ZPCI_IOTA_RTTO_FLAG;
156 return mod_pci(zdev, ZPCI_MOD_FC_REG_IOAT, dmaas, &args);
157}
158
159/* Modify PCI: Unregister I/O address translation parameters */
160int zpci_unregister_ioat(struct zpci_dev *zdev, u8 dmaas)
161{
Jan Glauberd0b08852012-12-11 14:53:35 +0100162 struct mod_pci_args args = { 0, 0, 0, 0 };
Jan Glauber828b35f2012-11-29 14:33:30 +0100163
164 return mod_pci(zdev, ZPCI_MOD_FC_DEREG_IOAT, dmaas, &args);
165}
166
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100167/* Modify PCI: Unregister adapter interruptions */
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200168static int zpci_clear_airq(struct zpci_dev *zdev)
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100169{
Jan Glauberd0b08852012-12-11 14:53:35 +0100170 struct mod_pci_args args = { 0, 0, 0, 0 };
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100171
172 return mod_pci(zdev, ZPCI_MOD_FC_DEREG_INT, 0, &args);
173}
174
Jan Glauberd0b08852012-12-11 14:53:35 +0100175/* Modify PCI: Set PCI function measurement parameters */
176int zpci_fmb_enable_device(struct zpci_dev *zdev)
177{
178 struct mod_pci_args args = { 0, 0, 0, 0 };
179
180 if (zdev->fmb)
181 return -EINVAL;
182
Wei Yongjun08b42122013-02-25 22:09:25 +0800183 zdev->fmb = kmem_cache_zalloc(zdev_fmb_cache, GFP_KERNEL);
Jan Glauberd0b08852012-12-11 14:53:35 +0100184 if (!zdev->fmb)
185 return -ENOMEM;
Jan Glauberd0b08852012-12-11 14:53:35 +0100186 WARN_ON((u64) zdev->fmb & 0xf);
187
Sebastian Ott60010182015-04-10 14:33:08 +0200188 /* reset software counters */
189 atomic64_set(&zdev->allocated_pages, 0);
190 atomic64_set(&zdev->mapped_pages, 0);
191 atomic64_set(&zdev->unmapped_pages, 0);
192
Jan Glauberd0b08852012-12-11 14:53:35 +0100193 args.fmb_addr = virt_to_phys(zdev->fmb);
194 return mod_pci(zdev, ZPCI_MOD_FC_SET_MEASURE, 0, &args);
195}
196
197/* Modify PCI: Disable PCI function measurement */
198int zpci_fmb_disable_device(struct zpci_dev *zdev)
199{
200 struct mod_pci_args args = { 0, 0, 0, 0 };
201 int rc;
202
203 if (!zdev->fmb)
204 return -EINVAL;
205
206 /* Function measurement is disabled if fmb address is zero */
207 rc = mod_pci(zdev, ZPCI_MOD_FC_SET_MEASURE, 0, &args);
208
209 kmem_cache_free(zdev_fmb_cache, zdev->fmb);
210 zdev->fmb = NULL;
211 return rc;
212}
213
Jan Glaubercd248342012-11-29 12:50:30 +0100214#define ZPCI_PCIAS_CFGSPC 15
215
216static int zpci_cfg_load(struct zpci_dev *zdev, int offset, u32 *val, u8 len)
217{
218 u64 req = ZPCI_CREATE_REQ(zdev->fh, ZPCI_PCIAS_CFGSPC, len);
219 u64 data;
220 int rc;
221
Martin Schwidefsky93893392013-06-25 14:52:23 +0200222 rc = zpci_load(&data, req, offset);
Sebastian Ottb170bad2013-04-16 14:17:15 +0200223 if (!rc) {
224 data = data << ((8 - len) * 8);
225 data = le64_to_cpu(data);
Jan Glaubercd248342012-11-29 12:50:30 +0100226 *val = (u32) data;
Sebastian Ottb170bad2013-04-16 14:17:15 +0200227 } else
Jan Glaubercd248342012-11-29 12:50:30 +0100228 *val = 0xffffffff;
229 return rc;
230}
231
232static int zpci_cfg_store(struct zpci_dev *zdev, int offset, u32 val, u8 len)
233{
234 u64 req = ZPCI_CREATE_REQ(zdev->fh, ZPCI_PCIAS_CFGSPC, len);
235 u64 data = val;
236 int rc;
237
238 data = cpu_to_le64(data);
239 data = data >> ((8 - len) * 8);
Martin Schwidefsky93893392013-06-25 14:52:23 +0200240 rc = zpci_store(data, req, offset);
Jan Glaubercd248342012-11-29 12:50:30 +0100241 return rc;
242}
243
Greg Kroah-Hartmanb881bc42012-12-21 14:06:37 -0800244void pcibios_fixup_bus(struct pci_bus *bus)
Jan Glaubercd248342012-11-29 12:50:30 +0100245{
246}
247
248resource_size_t pcibios_align_resource(void *data, const struct resource *res,
249 resource_size_t size,
250 resource_size_t align)
251{
252 return 0;
253}
254
Jan Glauber87bc3592012-12-06 14:30:28 +0100255/* combine single writes by using store-block insn */
256void __iowrite64_copy(void __iomem *to, const void *from, size_t count)
257{
258 zpci_memcpy_toio(to, from, count);
259}
260
Jan Glaubercd248342012-11-29 12:50:30 +0100261/* Create a virtual mapping cookie for a PCI BAR */
Michael S. Tsirkin8cfc99b2013-05-29 11:52:21 +0930262void __iomem *pci_iomap_range(struct pci_dev *pdev,
263 int bar,
264 unsigned long offset,
265 unsigned long max)
Jan Glaubercd248342012-11-29 12:50:30 +0100266{
Sebastian Ott198a5272015-06-23 14:06:35 +0200267 struct zpci_dev *zdev = to_zpci(pdev);
Jan Glaubercd248342012-11-29 12:50:30 +0100268 int idx;
269
270 if ((bar & 7) != bar)
271 return NULL;
272
273 idx = zdev->bars[bar].map_idx;
274 spin_lock(&zpci_iomap_lock);
Michael S. Tsirkin8cfc99b2013-05-29 11:52:21 +0930275 if (zpci_iomap_start[idx].count++) {
276 BUG_ON(zpci_iomap_start[idx].fh != zdev->fh ||
277 zpci_iomap_start[idx].bar != bar);
278 } else {
279 zpci_iomap_start[idx].fh = zdev->fh;
280 zpci_iomap_start[idx].bar = bar;
281 }
282 /* Detect overrun */
283 BUG_ON(!zpci_iomap_start[idx].count);
Jan Glaubercd248342012-11-29 12:50:30 +0100284 spin_unlock(&zpci_iomap_lock);
285
Sebastian Ott9e00caa2016-01-22 13:58:42 +0100286 return (void __iomem *) ZPCI_ADDR(idx) + offset;
Jan Glaubercd248342012-11-29 12:50:30 +0100287}
Sebastian Ottd9426082015-02-27 16:43:55 +0100288EXPORT_SYMBOL(pci_iomap_range);
Michael S. Tsirkin8cfc99b2013-05-29 11:52:21 +0930289
290void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
291{
292 return pci_iomap_range(dev, bar, 0, maxlen);
293}
294EXPORT_SYMBOL(pci_iomap);
Jan Glaubercd248342012-11-29 12:50:30 +0100295
296void pci_iounmap(struct pci_dev *pdev, void __iomem *addr)
297{
Sebastian Ott9e00caa2016-01-22 13:58:42 +0100298 unsigned int idx = ZPCI_IDX(addr);
Jan Glaubercd248342012-11-29 12:50:30 +0100299
Jan Glaubercd248342012-11-29 12:50:30 +0100300 spin_lock(&zpci_iomap_lock);
Michael S. Tsirkin8cfc99b2013-05-29 11:52:21 +0930301 /* Detect underrun */
302 BUG_ON(!zpci_iomap_start[idx].count);
303 if (!--zpci_iomap_start[idx].count) {
304 zpci_iomap_start[idx].fh = 0;
305 zpci_iomap_start[idx].bar = 0;
306 }
Jan Glaubercd248342012-11-29 12:50:30 +0100307 spin_unlock(&zpci_iomap_lock);
308}
Sebastian Ottd9426082015-02-27 16:43:55 +0100309EXPORT_SYMBOL(pci_iounmap);
Jan Glaubercd248342012-11-29 12:50:30 +0100310
311static int pci_read(struct pci_bus *bus, unsigned int devfn, int where,
312 int size, u32 *val)
313{
314 struct zpci_dev *zdev = get_zdev_by_bus(bus);
Sebastian Ott2c3700b2013-04-16 14:18:41 +0200315 int ret;
Jan Glaubercd248342012-11-29 12:50:30 +0100316
317 if (!zdev || devfn != ZPCI_DEVFN)
Sebastian Ott2c3700b2013-04-16 14:18:41 +0200318 ret = -ENODEV;
319 else
320 ret = zpci_cfg_load(zdev, where, val, size);
321
322 return ret;
Jan Glaubercd248342012-11-29 12:50:30 +0100323}
324
325static int pci_write(struct pci_bus *bus, unsigned int devfn, int where,
326 int size, u32 val)
327{
328 struct zpci_dev *zdev = get_zdev_by_bus(bus);
Sebastian Ott2c3700b2013-04-16 14:18:41 +0200329 int ret;
Jan Glaubercd248342012-11-29 12:50:30 +0100330
331 if (!zdev || devfn != ZPCI_DEVFN)
Sebastian Ott2c3700b2013-04-16 14:18:41 +0200332 ret = -ENODEV;
333 else
334 ret = zpci_cfg_store(zdev, where, val, size);
335
336 return ret;
Jan Glaubercd248342012-11-29 12:50:30 +0100337}
338
339static struct pci_ops pci_root_ops = {
340 .read = pci_read,
341 .write = pci_write,
342};
343
Martin Schwidefskyf4eae942013-06-24 10:30:41 +0200344static void zpci_irq_handler(struct airq_struct *airq)
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100345{
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200346 unsigned long si, ai;
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200347 struct airq_iv *aibv;
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200348 int irqs_on = 0;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100349
Heiko Carstens420f42e2013-01-02 15:18:18 +0100350 inc_irq_stat(IRQIO_PCI);
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200351 for (si = 0;;) {
352 /* Scan adapter summary indicator bit vector */
353 si = airq_iv_scan(zpci_aisb_iv, si, airq_iv_end(zpci_aisb_iv));
354 if (si == -1UL) {
355 if (irqs_on++)
356 /* End of second scan with interrupts on. */
357 break;
358 /* First scan complete, reenable interrupts. */
359 zpci_set_irq_ctrl(SIC_IRQ_MODE_SINGLE, NULL, PCI_ISC);
360 si = 0;
361 continue;
362 }
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100363
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200364 /* Scan the adapter interrupt vector for this device. */
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200365 aibv = zpci_aibv[si];
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200366 for (ai = 0;;) {
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200367 ai = airq_iv_scan(aibv, ai, airq_iv_end(aibv));
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200368 if (ai == -1UL)
369 break;
Heiko Carstens420f42e2013-01-02 15:18:18 +0100370 inc_irq_stat(IRQIO_MSI);
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200371 airq_iv_lock(aibv, ai);
372 generic_handle_irq(airq_iv_get_data(aibv, ai));
373 airq_iv_unlock(aibv, ai);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100374 }
375 }
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100376}
377
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200378int arch_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100379{
Sebastian Ott198a5272015-06-23 14:06:35 +0200380 struct zpci_dev *zdev = to_zpci(pdev);
Thomas Gleixner0a0a9422014-05-07 15:44:19 +0000381 unsigned int hwirq, msi_vecs;
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200382 unsigned long aisb;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100383 struct msi_desc *msi;
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200384 struct msi_msg msg;
Thomas Gleixner0a0a9422014-05-07 15:44:19 +0000385 int rc, irq;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100386
Alexander Gordeeva384c892013-12-16 09:34:54 +0100387 if (type == PCI_CAP_ID_MSI && nvec > 1)
388 return 1;
Sebastian Ottb19148f2014-10-29 19:12:04 +0100389 msi_vecs = min_t(unsigned int, nvec, zdev->max_msi);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100390
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200391 /* Allocate adapter summary indicator bit */
392 rc = -EIO;
393 aisb = airq_iv_alloc_bit(zpci_aisb_iv);
394 if (aisb == -1UL)
395 goto out;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100396 zdev->aisb = aisb;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100397
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200398 /* Create adapter interrupt vector */
399 rc = -ENOMEM;
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200400 zdev->aibv = airq_iv_create(msi_vecs, AIRQ_IV_DATA | AIRQ_IV_BITLOCK);
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200401 if (!zdev->aibv)
402 goto out_si;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100403
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200404 /* Wire up shortcut pointer */
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200405 zpci_aibv[aisb] = zdev->aibv;
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200406
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200407 /* Request MSI interrupts */
408 hwirq = 0;
Jiang Liudf516f42015-07-09 16:00:39 +0800409 for_each_pci_msi_entry(msi, pdev) {
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200410 rc = -EIO;
411 irq = irq_alloc_desc(0); /* Alloc irq on node 0 */
Thomas Gleixner0a0a9422014-05-07 15:44:19 +0000412 if (irq < 0)
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200413 goto out_msi;
414 rc = irq_set_msi_desc(irq, msi);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100415 if (rc)
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200416 goto out_msi;
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200417 irq_set_chip_and_handler(irq, &zpci_irq_chip,
418 handle_simple_irq);
419 msg.data = hwirq;
420 msg.address_lo = zdev->msi_addr & 0xffffffff;
421 msg.address_hi = zdev->msi_addr >> 32;
Jiang Liu83a18912014-11-09 23:10:34 +0800422 pci_write_msi_msg(irq, &msg);
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200423 airq_iv_set_data(zdev->aibv, hwirq, irq);
424 hwirq++;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100425 }
426
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200427 /* Enable adapter interrupts */
428 rc = zpci_set_airq(zdev);
429 if (rc)
430 goto out_msi;
431
432 return (msi_vecs == nvec) ? 0 : msi_vecs;
433
434out_msi:
Jiang Liudf516f42015-07-09 16:00:39 +0800435 for_each_pci_msi_entry(msi, pdev) {
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200436 if (hwirq-- == 0)
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200437 break;
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200438 irq_set_msi_desc(msi->irq, NULL);
439 irq_free_desc(msi->irq);
440 msi->msg.address_lo = 0;
441 msi->msg.address_hi = 0;
442 msi->msg.data = 0;
443 msi->irq = 0;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100444 }
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200445 zpci_aibv[aisb] = NULL;
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200446 airq_iv_release(zdev->aibv);
447out_si:
448 airq_iv_free_bit(zpci_aisb_iv, aisb);
449out:
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200450 return rc;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100451}
452
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200453void arch_teardown_msi_irqs(struct pci_dev *pdev)
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100454{
Sebastian Ott198a5272015-06-23 14:06:35 +0200455 struct zpci_dev *zdev = to_zpci(pdev);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100456 struct msi_desc *msi;
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200457 int rc;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100458
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200459 /* Disable adapter interrupts */
460 rc = zpci_clear_airq(zdev);
Sebastian Ott1f1dcbd2013-10-22 15:17:19 +0200461 if (rc)
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100462 return;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100463
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200464 /* Release MSI interrupts */
Jiang Liudf516f42015-07-09 16:00:39 +0800465 for_each_pci_msi_entry(msi, pdev) {
Yijing Wang8fb878c2014-07-08 10:08:05 +0800466 if (msi->msi_attrib.is_msix)
Thomas Gleixner23ed8d52014-11-23 11:55:58 +0100467 __pci_msix_desc_mask_irq(msi, 1);
Yijing Wang8fb878c2014-07-08 10:08:05 +0800468 else
Thomas Gleixner23ed8d52014-11-23 11:55:58 +0100469 __pci_msi_desc_mask_irq(msi, 1, 1);
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200470 irq_set_msi_desc(msi->irq, NULL);
471 irq_free_desc(msi->irq);
472 msi->msg.address_lo = 0;
473 msi->msg.address_hi = 0;
474 msi->msg.data = 0;
475 msi->irq = 0;
476 }
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100477
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200478 zpci_aibv[zdev->aisb] = NULL;
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200479 airq_iv_release(zdev->aibv);
480 airq_iv_free_bit(zpci_aisb_iv, zdev->aisb);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100481}
482
Sebastian Ott1803ba22015-02-27 16:43:21 +0100483static void zpci_map_resources(struct pci_dev *pdev)
Jan Glaubercd248342012-11-29 12:50:30 +0100484{
Jan Glaubercd248342012-11-29 12:50:30 +0100485 resource_size_t len;
486 int i;
487
488 for (i = 0; i < PCI_BAR_COUNT; i++) {
489 len = pci_resource_len(pdev, i);
490 if (!len)
491 continue;
Martin Schwidefsky5b9f2082014-10-30 10:30:45 +0100492 pdev->resource[i].start =
493 (resource_size_t __force) pci_iomap(pdev, i, 0);
Jan Glaubercd248342012-11-29 12:50:30 +0100494 pdev->resource[i].end = pdev->resource[i].start + len - 1;
Jan Glaubercd248342012-11-29 12:50:30 +0100495 }
Sebastian Ott944239c2013-06-05 16:06:16 +0200496}
497
Sebastian Ott1803ba22015-02-27 16:43:21 +0100498static void zpci_unmap_resources(struct pci_dev *pdev)
Sebastian Ott944239c2013-06-05 16:06:16 +0200499{
Sebastian Ott944239c2013-06-05 16:06:16 +0200500 resource_size_t len;
501 int i;
502
503 for (i = 0; i < PCI_BAR_COUNT; i++) {
504 len = pci_resource_len(pdev, i);
505 if (!len)
506 continue;
Martin Schwidefsky5b9f2082014-10-30 10:30:45 +0100507 pci_iounmap(pdev, (void __iomem __force *)
508 pdev->resource[i].start);
Sebastian Ott944239c2013-06-05 16:06:16 +0200509 }
510}
Jan Glaubercd248342012-11-29 12:50:30 +0100511
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100512static int __init zpci_irq_init(void)
513{
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200514 int rc;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100515
Martin Schwidefskyf4eae942013-06-24 10:30:41 +0200516 rc = register_adapter_interrupt(&zpci_airq);
517 if (rc)
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200518 goto out;
Martin Schwidefskyf4eae942013-06-24 10:30:41 +0200519 /* Set summary to 1 to be called every time for the ISC. */
520 *zpci_airq.lsi_ptr = 1;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100521
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200522 rc = -ENOMEM;
523 zpci_aisb_iv = airq_iv_create(ZPCI_NR_DEVICES, AIRQ_IV_ALLOC);
524 if (!zpci_aisb_iv)
525 goto out_airq;
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100526
Martin Schwidefsky93893392013-06-25 14:52:23 +0200527 zpci_set_irq_ctrl(SIC_IRQ_MODE_SINGLE, NULL, PCI_ISC);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100528 return 0;
529
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200530out_airq:
531 unregister_adapter_interrupt(&zpci_airq);
532out:
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100533 return rc;
534}
535
536static void zpci_irq_exit(void)
537{
Martin Schwidefsky5d0d8f42013-06-25 16:36:29 +0200538 airq_iv_release(zpci_aisb_iv);
Martin Schwidefskyf4eae942013-06-24 10:30:41 +0200539 unregister_adapter_interrupt(&zpci_airq);
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100540}
541
Jan Glaubercd248342012-11-29 12:50:30 +0100542static int zpci_alloc_iomap(struct zpci_dev *zdev)
543{
Sebastian Ottbf19c942016-01-22 13:59:35 +0100544 unsigned long entry;
Jan Glaubercd248342012-11-29 12:50:30 +0100545
546 spin_lock(&zpci_iomap_lock);
547 entry = find_first_zero_bit(zpci_iomap, ZPCI_IOMAP_MAX_ENTRIES);
548 if (entry == ZPCI_IOMAP_MAX_ENTRIES) {
549 spin_unlock(&zpci_iomap_lock);
550 return -ENOSPC;
551 }
552 set_bit(entry, zpci_iomap);
553 spin_unlock(&zpci_iomap_lock);
554 return entry;
555}
556
557static void zpci_free_iomap(struct zpci_dev *zdev, int entry)
558{
559 spin_lock(&zpci_iomap_lock);
560 memset(&zpci_iomap_start[entry], 0, sizeof(struct zpci_iomap_entry));
561 clear_bit(entry, zpci_iomap);
562 spin_unlock(&zpci_iomap_lock);
563}
564
Sebastian Ott7a572a3a2013-11-12 19:33:06 +0100565static struct resource *__alloc_res(struct zpci_dev *zdev, unsigned long start,
566 unsigned long size, unsigned long flags)
567{
568 struct resource *r;
569
570 r = kzalloc(sizeof(*r), GFP_KERNEL);
571 if (!r)
572 return NULL;
573
574 r->start = start;
575 r->end = r->start + size - 1;
576 r->flags = flags;
577 r->name = zdev->res_name;
578
579 if (request_resource(&iomem_resource, r)) {
580 kfree(r);
581 return NULL;
582 }
583 return r;
584}
585
586static int zpci_setup_bus_resources(struct zpci_dev *zdev,
587 struct list_head *resources)
588{
589 unsigned long addr, size, flags;
590 struct resource *res;
591 int i, entry;
592
593 snprintf(zdev->res_name, sizeof(zdev->res_name),
594 "PCI Bus %04x:%02x", zdev->domain, ZPCI_BUS_NR);
595
596 for (i = 0; i < PCI_BAR_COUNT; i++) {
597 if (!zdev->bars[i].size)
598 continue;
599 entry = zpci_alloc_iomap(zdev);
600 if (entry < 0)
601 return entry;
602 zdev->bars[i].map_idx = entry;
603
604 /* only MMIO is supported */
605 flags = IORESOURCE_MEM;
606 if (zdev->bars[i].val & 8)
607 flags |= IORESOURCE_PREFETCH;
608 if (zdev->bars[i].val & 4)
609 flags |= IORESOURCE_MEM_64;
610
Sebastian Ott9e00caa2016-01-22 13:58:42 +0100611 addr = ZPCI_ADDR(entry);
Sebastian Ott7a572a3a2013-11-12 19:33:06 +0100612 size = 1UL << zdev->bars[i].size;
613
614 res = __alloc_res(zdev, addr, size, flags);
615 if (!res) {
616 zpci_free_iomap(zdev, entry);
617 return -ENOMEM;
618 }
619 zdev->bars[i].res = res;
620 pci_add_resource(resources, res);
621 }
622
623 return 0;
624}
625
626static void zpci_cleanup_bus_resources(struct zpci_dev *zdev)
627{
628 int i;
629
630 for (i = 0; i < PCI_BAR_COUNT; i++) {
Sebastian Ott2b1df722015-07-28 19:10:45 +0200631 if (!zdev->bars[i].size || !zdev->bars[i].res)
Sebastian Ott7a572a3a2013-11-12 19:33:06 +0100632 continue;
633
634 zpci_free_iomap(zdev, zdev->bars[i].map_idx);
635 release_resource(zdev->bars[i].res);
636 kfree(zdev->bars[i].res);
637 }
638}
639
Sebastian Ottaf0a8a82013-04-16 14:13:21 +0200640int pcibios_add_device(struct pci_dev *pdev)
641{
Sebastian Ott198a5272015-06-23 14:06:35 +0200642 struct zpci_dev *zdev = to_zpci(pdev);
Sebastian Ottcb809182013-08-29 19:34:37 +0200643 struct resource *res;
644 int i;
645
646 zdev->pdev = pdev;
Sebastian Ottef4858c2014-04-30 14:50:09 -0600647 pdev->dev.groups = zpci_attr_groups;
Sebastian Ott1803ba22015-02-27 16:43:21 +0100648 zpci_map_resources(pdev);
Sebastian Ottcb809182013-08-29 19:34:37 +0200649
650 for (i = 0; i < PCI_BAR_COUNT; i++) {
651 res = &pdev->resource[i];
652 if (res->parent || !res->flags)
653 continue;
654 pci_claim_resource(pdev, i);
655 }
656
657 return 0;
658}
659
Sebastian Ott1803ba22015-02-27 16:43:21 +0100660void pcibios_release_device(struct pci_dev *pdev)
661{
662 zpci_unmap_resources(pdev);
663}
664
Sebastian Ottcb809182013-08-29 19:34:37 +0200665int pcibios_enable_device(struct pci_dev *pdev, int mask)
666{
Sebastian Ott198a5272015-06-23 14:06:35 +0200667 struct zpci_dev *zdev = to_zpci(pdev);
Sebastian Ottaf0a8a82013-04-16 14:13:21 +0200668
Sebastian Ott1c213512013-04-25 14:49:48 +0200669 zdev->pdev = pdev;
Sebastian Ottaf0a8a82013-04-16 14:13:21 +0200670 zpci_debug_init_device(zdev);
671 zpci_fmb_enable_device(zdev);
Sebastian Ottaf0a8a82013-04-16 14:13:21 +0200672
Bjorn Helgaasd7533232014-02-26 15:30:24 -0700673 return pci_enable_resources(pdev, mask);
Sebastian Ottaf0a8a82013-04-16 14:13:21 +0200674}
675
Sebastian Ottcb809182013-08-29 19:34:37 +0200676void pcibios_disable_device(struct pci_dev *pdev)
Sebastian Ott944239c2013-06-05 16:06:16 +0200677{
Sebastian Ott198a5272015-06-23 14:06:35 +0200678 struct zpci_dev *zdev = to_zpci(pdev);
Sebastian Ott944239c2013-06-05 16:06:16 +0200679
Sebastian Ott944239c2013-06-05 16:06:16 +0200680 zpci_fmb_disable_device(zdev);
681 zpci_debug_exit_device(zdev);
682 zdev->pdev = NULL;
683}
684
Sebastian Ott69db3b52013-09-25 12:27:43 +0200685#ifdef CONFIG_HIBERNATE_CALLBACKS
686static int zpci_restore(struct device *dev)
687{
Sebastian Ott1803ba22015-02-27 16:43:21 +0100688 struct pci_dev *pdev = to_pci_dev(dev);
Sebastian Ott198a5272015-06-23 14:06:35 +0200689 struct zpci_dev *zdev = to_zpci(pdev);
Sebastian Ott69db3b52013-09-25 12:27:43 +0200690 int ret = 0;
691
692 if (zdev->state != ZPCI_FN_STATE_ONLINE)
693 goto out;
694
695 ret = clp_enable_fh(zdev, ZPCI_NR_DMA_SPACES);
696 if (ret)
697 goto out;
698
Sebastian Ott1803ba22015-02-27 16:43:21 +0100699 zpci_map_resources(pdev);
Gerald Schaefer69eea952015-11-16 14:35:48 +0100700 zpci_register_ioat(zdev, 0, zdev->start_dma, zdev->end_dma,
Sebastian Ott69db3b52013-09-25 12:27:43 +0200701 (u64) zdev->dma_table);
702
703out:
704 return ret;
705}
706
707static int zpci_freeze(struct device *dev)
708{
Sebastian Ott1803ba22015-02-27 16:43:21 +0100709 struct pci_dev *pdev = to_pci_dev(dev);
Sebastian Ott198a5272015-06-23 14:06:35 +0200710 struct zpci_dev *zdev = to_zpci(pdev);
Sebastian Ott69db3b52013-09-25 12:27:43 +0200711
712 if (zdev->state != ZPCI_FN_STATE_ONLINE)
713 return 0;
714
715 zpci_unregister_ioat(zdev, 0);
Sebastian Ott1803ba22015-02-27 16:43:21 +0100716 zpci_unmap_resources(pdev);
Sebastian Ott69db3b52013-09-25 12:27:43 +0200717 return clp_disable_fh(zdev);
718}
719
720struct dev_pm_ops pcibios_pm_ops = {
721 .thaw_noirq = zpci_restore,
722 .freeze_noirq = zpci_freeze,
723 .restore_noirq = zpci_restore,
724 .poweroff_noirq = zpci_freeze,
725};
726#endif /* CONFIG_HIBERNATE_CALLBACKS */
727
Jan Glaubercd248342012-11-29 12:50:30 +0100728static int zpci_alloc_domain(struct zpci_dev *zdev)
729{
730 spin_lock(&zpci_domain_lock);
731 zdev->domain = find_first_zero_bit(zpci_domain, ZPCI_NR_DEVICES);
732 if (zdev->domain == ZPCI_NR_DEVICES) {
733 spin_unlock(&zpci_domain_lock);
734 return -ENOSPC;
735 }
736 set_bit(zdev->domain, zpci_domain);
737 spin_unlock(&zpci_domain_lock);
738 return 0;
739}
740
741static void zpci_free_domain(struct zpci_dev *zdev)
742{
743 spin_lock(&zpci_domain_lock);
744 clear_bit(zdev->domain, zpci_domain);
745 spin_unlock(&zpci_domain_lock);
746}
747
Sebastian Ott7d594322013-11-12 19:35:01 +0100748void pcibios_remove_bus(struct pci_bus *bus)
749{
750 struct zpci_dev *zdev = get_zdev_by_bus(bus);
751
752 zpci_exit_slot(zdev);
753 zpci_cleanup_bus_resources(zdev);
754 zpci_free_domain(zdev);
755
756 spin_lock(&zpci_list_lock);
757 list_del(&zdev->entry);
758 spin_unlock(&zpci_list_lock);
759
760 kfree(zdev);
761}
762
763static int zpci_scan_bus(struct zpci_dev *zdev)
764{
765 LIST_HEAD(resources);
766 int ret;
767
768 ret = zpci_setup_bus_resources(zdev, &resources);
769 if (ret)
Sebastian Ott2b1df722015-07-28 19:10:45 +0200770 goto error;
Sebastian Ott7d594322013-11-12 19:35:01 +0100771
772 zdev->bus = pci_scan_root_bus(NULL, ZPCI_BUS_NR, &pci_root_ops,
773 zdev, &resources);
774 if (!zdev->bus) {
Sebastian Ott2b1df722015-07-28 19:10:45 +0200775 ret = -EIO;
776 goto error;
Sebastian Ott7d594322013-11-12 19:35:01 +0100777 }
Sebastian Ott7d594322013-11-12 19:35:01 +0100778 zdev->bus->max_bus_speed = zdev->max_bus_speed;
Yijing Wangb97ea282015-03-16 11:18:56 +0800779 pci_bus_add_devices(zdev->bus);
Sebastian Ott7d594322013-11-12 19:35:01 +0100780 return 0;
Sebastian Ott2b1df722015-07-28 19:10:45 +0200781
782error:
783 zpci_cleanup_bus_resources(zdev);
784 pci_free_resource_list(&resources);
785 return ret;
Sebastian Ott7d594322013-11-12 19:35:01 +0100786}
787
Jan Glaubera755a452012-11-29 12:55:21 +0100788int zpci_enable_device(struct zpci_dev *zdev)
789{
790 int rc;
791
792 rc = clp_enable_fh(zdev, ZPCI_NR_DMA_SPACES);
793 if (rc)
794 goto out;
Jan Glauber828b35f2012-11-29 14:33:30 +0100795
796 rc = zpci_dma_init_device(zdev);
797 if (rc)
798 goto out_dma;
Sebastian Ott0ff70ec2013-08-29 19:35:19 +0200799
800 zdev->state = ZPCI_FN_STATE_ONLINE;
Jan Glaubera755a452012-11-29 12:55:21 +0100801 return 0;
Jan Glauber828b35f2012-11-29 14:33:30 +0100802
803out_dma:
804 clp_disable_fh(zdev);
Jan Glaubera755a452012-11-29 12:55:21 +0100805out:
806 return rc;
807}
808EXPORT_SYMBOL_GPL(zpci_enable_device);
809
Sebastian Ottcb65a662013-04-16 14:12:17 +0200810int zpci_disable_device(struct zpci_dev *zdev)
811{
812 zpci_dma_exit_device(zdev);
813 return clp_disable_fh(zdev);
814}
815EXPORT_SYMBOL_GPL(zpci_disable_device);
816
Jan Glaubercd248342012-11-29 12:50:30 +0100817int zpci_create_device(struct zpci_dev *zdev)
818{
819 int rc;
820
821 rc = zpci_alloc_domain(zdev);
822 if (rc)
823 goto out;
824
Sebastian Ott80ed1562015-04-10 14:34:33 +0200825 mutex_init(&zdev->lock);
Sebastian Ott1c213512013-04-25 14:49:48 +0200826 if (zdev->state == ZPCI_FN_STATE_CONFIGURED) {
827 rc = zpci_enable_device(zdev);
828 if (rc)
829 goto out_free;
Sebastian Ott1c213512013-04-25 14:49:48 +0200830 }
831 rc = zpci_scan_bus(zdev);
Jan Glaubercd248342012-11-29 12:50:30 +0100832 if (rc)
Sebastian Ott1c213512013-04-25 14:49:48 +0200833 goto out_disable;
Jan Glaubercd248342012-11-29 12:50:30 +0100834
Sebastian Ott57b59182013-08-29 19:40:01 +0200835 spin_lock(&zpci_list_lock);
Jan Glaubercd248342012-11-29 12:50:30 +0100836 list_add_tail(&zdev->entry, &zpci_list);
Sebastian Ott57b59182013-08-29 19:40:01 +0200837 spin_unlock(&zpci_list_lock);
Jan Glaubercd248342012-11-29 12:50:30 +0100838
Sebastian Ott67f43f32013-08-29 19:33:16 +0200839 zpci_init_slot(zdev);
840
Jan Glaubercd248342012-11-29 12:50:30 +0100841 return 0;
842
Sebastian Ott1c213512013-04-25 14:49:48 +0200843out_disable:
844 if (zdev->state == ZPCI_FN_STATE_ONLINE)
845 zpci_disable_device(zdev);
846out_free:
Jan Glaubercd248342012-11-29 12:50:30 +0100847 zpci_free_domain(zdev);
848out:
849 return rc;
850}
851
852void zpci_stop_device(struct zpci_dev *zdev)
853{
Jan Glauber828b35f2012-11-29 14:33:30 +0100854 zpci_dma_exit_device(zdev);
Jan Glaubercd248342012-11-29 12:50:30 +0100855 /*
856 * Note: SCLP disables fh via set-pci-fn so don't
857 * do that here.
858 */
859}
860EXPORT_SYMBOL_GPL(zpci_stop_device);
861
Jan Glaubercd248342012-11-29 12:50:30 +0100862static inline int barsize(u8 size)
863{
864 return (size) ? (1 << size) >> 10 : 0;
865}
866
867static int zpci_mem_init(void)
868{
Jan Glauberd0b08852012-12-11 14:53:35 +0100869 zdev_fmb_cache = kmem_cache_create("PCI_FMB_cache", sizeof(struct zpci_fmb),
870 16, 0, NULL);
871 if (!zdev_fmb_cache)
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200872 goto error_zdev;
Jan Glauberd0b08852012-12-11 14:53:35 +0100873
Jan Glaubercd248342012-11-29 12:50:30 +0100874 /* TODO: use realloc */
875 zpci_iomap_start = kzalloc(ZPCI_IOMAP_MAX_ENTRIES * sizeof(*zpci_iomap_start),
876 GFP_KERNEL);
877 if (!zpci_iomap_start)
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100878 goto error_iomap;
Jan Glaubercd248342012-11-29 12:50:30 +0100879 return 0;
880
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100881error_iomap:
Jan Glauberd0b08852012-12-11 14:53:35 +0100882 kmem_cache_destroy(zdev_fmb_cache);
Jan Glaubercd248342012-11-29 12:50:30 +0100883error_zdev:
884 return -ENOMEM;
885}
886
887static void zpci_mem_exit(void)
888{
889 kfree(zpci_iomap_start);
Jan Glauberd0b08852012-12-11 14:53:35 +0100890 kmem_cache_destroy(zdev_fmb_cache);
Jan Glaubercd248342012-11-29 12:50:30 +0100891}
892
Sebastian Ott257608f2013-12-12 17:55:22 +0100893static unsigned int s390_pci_probe = 1;
Sebastian Ottaa3b7c22013-12-12 17:48:32 +0100894static unsigned int s390_pci_initialized;
Jan Glaubercd248342012-11-29 12:50:30 +0100895
896char * __init pcibios_setup(char *str)
897{
Sebastian Ott257608f2013-12-12 17:55:22 +0100898 if (!strcmp(str, "off")) {
899 s390_pci_probe = 0;
Jan Glaubercd248342012-11-29 12:50:30 +0100900 return NULL;
901 }
902 return str;
903}
904
Sebastian Ottaa3b7c22013-12-12 17:48:32 +0100905bool zpci_is_enabled(void)
906{
907 return s390_pci_initialized;
908}
909
Jan Glaubercd248342012-11-29 12:50:30 +0100910static int __init pci_base_init(void)
911{
912 int rc;
913
Heiko Carstens1e5635d2013-01-30 15:52:16 +0100914 if (!s390_pci_probe)
Jan Glaubercd248342012-11-29 12:50:30 +0100915 return 0;
916
Heiko Carstens86cd7412015-02-14 11:23:21 +0100917 if (!test_facility(69) || !test_facility(71) || !test_facility(72))
Jan Glaubercd248342012-11-29 12:50:30 +0100918 return 0;
919
Jan Glauberd0b08852012-12-11 14:53:35 +0100920 rc = zpci_debug_init();
921 if (rc)
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200922 goto out;
Jan Glauberd0b08852012-12-11 14:53:35 +0100923
Jan Glaubercd248342012-11-29 12:50:30 +0100924 rc = zpci_mem_init();
925 if (rc)
926 goto out_mem;
927
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100928 rc = zpci_irq_init();
929 if (rc)
930 goto out_irq;
931
Jan Glauber828b35f2012-11-29 14:33:30 +0100932 rc = zpci_dma_init();
933 if (rc)
934 goto out_dma;
935
Sebastian Ott1d578962013-08-29 19:37:28 +0200936 rc = clp_scan_pci_devices();
Jan Glaubera755a452012-11-29 12:55:21 +0100937 if (rc)
938 goto out_find;
939
Sebastian Ottaa3b7c22013-12-12 17:48:32 +0100940 s390_pci_initialized = 1;
Jan Glaubercd248342012-11-29 12:50:30 +0100941 return 0;
942
Jan Glaubera755a452012-11-29 12:55:21 +0100943out_find:
Jan Glauber828b35f2012-11-29 14:33:30 +0100944 zpci_dma_exit();
945out_dma:
Jan Glauber9a4da8a2012-11-29 13:05:05 +0100946 zpci_irq_exit();
947out_irq:
Jan Glaubercd248342012-11-29 12:50:30 +0100948 zpci_mem_exit();
949out_mem:
Jan Glauberd0b08852012-12-11 14:53:35 +0100950 zpci_debug_exit();
Martin Schwidefsky1f44a222013-06-27 09:01:09 +0200951out:
Jan Glaubercd248342012-11-29 12:50:30 +0100952 return rc;
953}
Sebastian Ott67f43f32013-08-29 19:33:16 +0200954subsys_initcall_sync(pci_base_init);
Sebastian Ott57b59182013-08-29 19:40:01 +0200955
956void zpci_rescan(void)
957{
Sebastian Ottaa3b7c22013-12-12 17:48:32 +0100958 if (zpci_is_enabled())
959 clp_rescan_pci_devices_simple();
Sebastian Ott57b59182013-08-29 19:40:01 +0200960}