Merge remote-tracking branch 'pci/next'
[karo-tx-linux.git] / drivers / pci / msi.c
1 /*
2  * File:        msi.c
3  * Purpose:     PCI Message Signaled Interrupt (MSI)
4  *
5  * Copyright (C) 2003-2004 Intel
6  * Copyright (C) Tom Long Nguyen (tom.l.nguyen@intel.com)
7  */
8
9 #include <linux/err.h>
10 #include <linux/mm.h>
11 #include <linux/irq.h>
12 #include <linux/interrupt.h>
13 #include <linux/export.h>
14 #include <linux/ioport.h>
15 #include <linux/pci.h>
16 #include <linux/proc_fs.h>
17 #include <linux/msi.h>
18 #include <linux/smp.h>
19 #include <linux/errno.h>
20 #include <linux/io.h>
21 #include <linux/slab.h>
22 #include <linux/irqdomain.h>
23 #include <linux/of_irq.h>
24
25 #include "pci.h"
26
27 static int pci_msi_enable = 1;
28 int pci_msi_ignore_mask;
29
30 #define msix_table_size(flags)  ((flags & PCI_MSIX_FLAGS_QSIZE) + 1)
31
32 #ifdef CONFIG_PCI_MSI_IRQ_DOMAIN
33 static struct irq_domain *pci_msi_default_domain;
34 static DEFINE_MUTEX(pci_msi_domain_lock);
35
36 struct irq_domain * __weak arch_get_pci_msi_domain(struct pci_dev *dev)
37 {
38         return pci_msi_default_domain;
39 }
40
41 static struct irq_domain *pci_msi_get_domain(struct pci_dev *dev)
42 {
43         struct irq_domain *domain;
44
45         domain = dev_get_msi_domain(&dev->dev);
46         if (domain)
47                 return domain;
48
49         return arch_get_pci_msi_domain(dev);
50 }
51
52 static int pci_msi_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
53 {
54         struct irq_domain *domain;
55
56         domain = pci_msi_get_domain(dev);
57         if (domain)
58                 return pci_msi_domain_alloc_irqs(domain, dev, nvec, type);
59
60         return arch_setup_msi_irqs(dev, nvec, type);
61 }
62
63 static void pci_msi_teardown_msi_irqs(struct pci_dev *dev)
64 {
65         struct irq_domain *domain;
66
67         domain = pci_msi_get_domain(dev);
68         if (domain)
69                 pci_msi_domain_free_irqs(domain, dev);
70         else
71                 arch_teardown_msi_irqs(dev);
72 }
73 #else
74 #define pci_msi_setup_msi_irqs          arch_setup_msi_irqs
75 #define pci_msi_teardown_msi_irqs       arch_teardown_msi_irqs
76 #endif
77
78 /* Arch hooks */
79
80 int __weak arch_setup_msi_irq(struct pci_dev *dev, struct msi_desc *desc)
81 {
82         struct msi_controller *chip = dev->bus->msi;
83         int err;
84
85         if (!chip || !chip->setup_irq)
86                 return -EINVAL;
87
88         err = chip->setup_irq(chip, dev, desc);
89         if (err < 0)
90                 return err;
91
92         irq_set_chip_data(desc->irq, chip);
93
94         return 0;
95 }
96
97 void __weak arch_teardown_msi_irq(unsigned int irq)
98 {
99         struct msi_controller *chip = irq_get_chip_data(irq);
100
101         if (!chip || !chip->teardown_irq)
102                 return;
103
104         chip->teardown_irq(chip, irq);
105 }
106
107 int __weak arch_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
108 {
109         struct msi_controller *chip = dev->bus->msi;
110         struct msi_desc *entry;
111         int ret;
112
113         if (chip && chip->setup_irqs)
114                 return chip->setup_irqs(chip, dev, nvec, type);
115         /*
116          * If an architecture wants to support multiple MSI, it needs to
117          * override arch_setup_msi_irqs()
118          */
119         if (type == PCI_CAP_ID_MSI && nvec > 1)
120                 return 1;
121
122         for_each_pci_msi_entry(entry, dev) {
123                 ret = arch_setup_msi_irq(dev, entry);
124                 if (ret < 0)
125                         return ret;
126                 if (ret > 0)
127                         return -ENOSPC;
128         }
129
130         return 0;
131 }
132
133 /*
134  * We have a default implementation available as a separate non-weak
135  * function, as it is used by the Xen x86 PCI code
136  */
137 void default_teardown_msi_irqs(struct pci_dev *dev)
138 {
139         int i;
140         struct msi_desc *entry;
141
142         for_each_pci_msi_entry(entry, dev)
143                 if (entry->irq)
144                         for (i = 0; i < entry->nvec_used; i++)
145                                 arch_teardown_msi_irq(entry->irq + i);
146 }
147
148 void __weak arch_teardown_msi_irqs(struct pci_dev *dev)
149 {
150         return default_teardown_msi_irqs(dev);
151 }
152
153 static void default_restore_msi_irq(struct pci_dev *dev, int irq)
154 {
155         struct msi_desc *entry;
156
157         entry = NULL;
158         if (dev->msix_enabled) {
159                 for_each_pci_msi_entry(entry, dev) {
160                         if (irq == entry->irq)
161                                 break;
162                 }
163         } else if (dev->msi_enabled)  {
164                 entry = irq_get_msi_desc(irq);
165         }
166
167         if (entry)
168                 __pci_write_msi_msg(entry, &entry->msg);
169 }
170
171 void __weak arch_restore_msi_irqs(struct pci_dev *dev)
172 {
173         return default_restore_msi_irqs(dev);
174 }
175
176 static inline __attribute_const__ u32 msi_mask(unsigned x)
177 {
178         /* Don't shift by >= width of type */
179         if (x >= 5)
180                 return 0xffffffff;
181         return (1 << (1 << x)) - 1;
182 }
183
184 /*
185  * PCI 2.3 does not specify mask bits for each MSI interrupt.  Attempting to
186  * mask all MSI interrupts by clearing the MSI enable bit does not work
187  * reliably as devices without an INTx disable bit will then generate a
188  * level IRQ which will never be cleared.
189  */
190 u32 __pci_msi_desc_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
191 {
192         u32 mask_bits = desc->masked;
193
194         if (pci_msi_ignore_mask || !desc->msi_attrib.maskbit)
195                 return 0;
196
197         mask_bits &= ~mask;
198         mask_bits |= flag;
199         pci_write_config_dword(msi_desc_to_pci_dev(desc), desc->mask_pos,
200                                mask_bits);
201
202         return mask_bits;
203 }
204
205 static void msi_mask_irq(struct msi_desc *desc, u32 mask, u32 flag)
206 {
207         desc->masked = __pci_msi_desc_mask_irq(desc, mask, flag);
208 }
209
210 /*
211  * This internal function does not flush PCI writes to the device.
212  * All users must ensure that they read from the device before either
213  * assuming that the device state is up to date, or returning out of this
214  * file.  This saves a few milliseconds when initialising devices with lots
215  * of MSI-X interrupts.
216  */
217 u32 __pci_msix_desc_mask_irq(struct msi_desc *desc, u32 flag)
218 {
219         u32 mask_bits = desc->masked;
220         unsigned offset = desc->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE +
221                                                 PCI_MSIX_ENTRY_VECTOR_CTRL;
222
223         if (pci_msi_ignore_mask)
224                 return 0;
225
226         mask_bits &= ~PCI_MSIX_ENTRY_CTRL_MASKBIT;
227         if (flag)
228                 mask_bits |= PCI_MSIX_ENTRY_CTRL_MASKBIT;
229         writel(mask_bits, desc->mask_base + offset);
230
231         return mask_bits;
232 }
233
234 static void msix_mask_irq(struct msi_desc *desc, u32 flag)
235 {
236         desc->masked = __pci_msix_desc_mask_irq(desc, flag);
237 }
238
239 static void msi_set_mask_bit(struct irq_data *data, u32 flag)
240 {
241         struct msi_desc *desc = irq_data_get_msi_desc(data);
242
243         if (desc->msi_attrib.is_msix) {
244                 msix_mask_irq(desc, flag);
245                 readl(desc->mask_base);         /* Flush write to device */
246         } else {
247                 unsigned offset = data->irq - desc->irq;
248                 msi_mask_irq(desc, 1 << offset, flag << offset);
249         }
250 }
251
252 /**
253  * pci_msi_mask_irq - Generic irq chip callback to mask PCI/MSI interrupts
254  * @data:       pointer to irqdata associated to that interrupt
255  */
256 void pci_msi_mask_irq(struct irq_data *data)
257 {
258         msi_set_mask_bit(data, 1);
259 }
260
261 /**
262  * pci_msi_unmask_irq - Generic irq chip callback to unmask PCI/MSI interrupts
263  * @data:       pointer to irqdata associated to that interrupt
264  */
265 void pci_msi_unmask_irq(struct irq_data *data)
266 {
267         msi_set_mask_bit(data, 0);
268 }
269
270 void default_restore_msi_irqs(struct pci_dev *dev)
271 {
272         struct msi_desc *entry;
273
274         for_each_pci_msi_entry(entry, dev)
275                 default_restore_msi_irq(dev, entry->irq);
276 }
277
278 void __pci_read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
279 {
280         struct pci_dev *dev = msi_desc_to_pci_dev(entry);
281
282         BUG_ON(dev->current_state != PCI_D0);
283
284         if (entry->msi_attrib.is_msix) {
285                 void __iomem *base = entry->mask_base +
286                         entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
287
288                 msg->address_lo = readl(base + PCI_MSIX_ENTRY_LOWER_ADDR);
289                 msg->address_hi = readl(base + PCI_MSIX_ENTRY_UPPER_ADDR);
290                 msg->data = readl(base + PCI_MSIX_ENTRY_DATA);
291         } else {
292                 int pos = dev->msi_cap;
293                 u16 data;
294
295                 pci_read_config_dword(dev, pos + PCI_MSI_ADDRESS_LO,
296                                       &msg->address_lo);
297                 if (entry->msi_attrib.is_64) {
298                         pci_read_config_dword(dev, pos + PCI_MSI_ADDRESS_HI,
299                                               &msg->address_hi);
300                         pci_read_config_word(dev, pos + PCI_MSI_DATA_64, &data);
301                 } else {
302                         msg->address_hi = 0;
303                         pci_read_config_word(dev, pos + PCI_MSI_DATA_32, &data);
304                 }
305                 msg->data = data;
306         }
307 }
308
309 void __pci_write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
310 {
311         struct pci_dev *dev = msi_desc_to_pci_dev(entry);
312
313         if (dev->current_state != PCI_D0) {
314                 /* Don't touch the hardware now */
315         } else if (entry->msi_attrib.is_msix) {
316                 void __iomem *base;
317                 base = entry->mask_base +
318                         entry->msi_attrib.entry_nr * PCI_MSIX_ENTRY_SIZE;
319
320                 writel(msg->address_lo, base + PCI_MSIX_ENTRY_LOWER_ADDR);
321                 writel(msg->address_hi, base + PCI_MSIX_ENTRY_UPPER_ADDR);
322                 writel(msg->data, base + PCI_MSIX_ENTRY_DATA);
323         } else {
324                 int pos = dev->msi_cap;
325                 u16 msgctl;
326
327                 pci_read_config_word(dev, pos + PCI_MSI_FLAGS, &msgctl);
328                 msgctl &= ~PCI_MSI_FLAGS_QSIZE;
329                 msgctl |= entry->msi_attrib.multiple << 4;
330                 pci_write_config_word(dev, pos + PCI_MSI_FLAGS, msgctl);
331
332                 pci_write_config_dword(dev, pos + PCI_MSI_ADDRESS_LO,
333                                        msg->address_lo);
334                 if (entry->msi_attrib.is_64) {
335                         pci_write_config_dword(dev, pos + PCI_MSI_ADDRESS_HI,
336                                                msg->address_hi);
337                         pci_write_config_word(dev, pos + PCI_MSI_DATA_64,
338                                               msg->data);
339                 } else {
340                         pci_write_config_word(dev, pos + PCI_MSI_DATA_32,
341                                               msg->data);
342                 }
343         }
344         entry->msg = *msg;
345 }
346
347 void pci_write_msi_msg(unsigned int irq, struct msi_msg *msg)
348 {
349         struct msi_desc *entry = irq_get_msi_desc(irq);
350
351         __pci_write_msi_msg(entry, msg);
352 }
353 EXPORT_SYMBOL_GPL(pci_write_msi_msg);
354
355 static void free_msi_irqs(struct pci_dev *dev)
356 {
357         struct list_head *msi_list = dev_to_msi_list(&dev->dev);
358         struct msi_desc *entry, *tmp;
359         struct attribute **msi_attrs;
360         struct device_attribute *dev_attr;
361         int i, count = 0;
362
363         for_each_pci_msi_entry(entry, dev)
364                 if (entry->irq)
365                         for (i = 0; i < entry->nvec_used; i++)
366                                 BUG_ON(irq_has_action(entry->irq + i));
367
368         pci_msi_teardown_msi_irqs(dev);
369
370         list_for_each_entry_safe(entry, tmp, msi_list, list) {
371                 if (entry->msi_attrib.is_msix) {
372                         if (list_is_last(&entry->list, msi_list))
373                                 iounmap(entry->mask_base);
374                 }
375
376                 list_del(&entry->list);
377                 kfree(entry);
378         }
379
380         if (dev->msi_irq_groups) {
381                 sysfs_remove_groups(&dev->dev.kobj, dev->msi_irq_groups);
382                 msi_attrs = dev->msi_irq_groups[0]->attrs;
383                 while (msi_attrs[count]) {
384                         dev_attr = container_of(msi_attrs[count],
385                                                 struct device_attribute, attr);
386                         kfree(dev_attr->attr.name);
387                         kfree(dev_attr);
388                         ++count;
389                 }
390                 kfree(msi_attrs);
391                 kfree(dev->msi_irq_groups[0]);
392                 kfree(dev->msi_irq_groups);
393                 dev->msi_irq_groups = NULL;
394         }
395 }
396
397 static void pci_intx_for_msi(struct pci_dev *dev, int enable)
398 {
399         if (!(dev->dev_flags & PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG))
400                 pci_intx(dev, enable);
401 }
402
403 static void __pci_restore_msi_state(struct pci_dev *dev)
404 {
405         u16 control;
406         struct msi_desc *entry;
407
408         if (!dev->msi_enabled)
409                 return;
410
411         entry = irq_get_msi_desc(dev->irq);
412
413         pci_intx_for_msi(dev, 0);
414         pci_msi_set_enable(dev, 0);
415         arch_restore_msi_irqs(dev);
416
417         pci_read_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, &control);
418         msi_mask_irq(entry, msi_mask(entry->msi_attrib.multi_cap),
419                      entry->masked);
420         control &= ~PCI_MSI_FLAGS_QSIZE;
421         control |= (entry->msi_attrib.multiple << 4) | PCI_MSI_FLAGS_ENABLE;
422         pci_write_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, control);
423 }
424
425 static void __pci_restore_msix_state(struct pci_dev *dev)
426 {
427         struct msi_desc *entry;
428
429         if (!dev->msix_enabled)
430                 return;
431         BUG_ON(list_empty(dev_to_msi_list(&dev->dev)));
432
433         /* route the table */
434         pci_intx_for_msi(dev, 0);
435         pci_msix_clear_and_set_ctrl(dev, 0,
436                                 PCI_MSIX_FLAGS_ENABLE | PCI_MSIX_FLAGS_MASKALL);
437
438         arch_restore_msi_irqs(dev);
439         for_each_pci_msi_entry(entry, dev)
440                 msix_mask_irq(entry, entry->masked);
441
442         pci_msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_MASKALL, 0);
443 }
444
445 void pci_restore_msi_state(struct pci_dev *dev)
446 {
447         __pci_restore_msi_state(dev);
448         __pci_restore_msix_state(dev);
449 }
450 EXPORT_SYMBOL_GPL(pci_restore_msi_state);
451
452 static ssize_t msi_mode_show(struct device *dev, struct device_attribute *attr,
453                              char *buf)
454 {
455         struct msi_desc *entry;
456         unsigned long irq;
457         int retval;
458
459         retval = kstrtoul(attr->attr.name, 10, &irq);
460         if (retval)
461                 return retval;
462
463         entry = irq_get_msi_desc(irq);
464         if (entry)
465                 return sprintf(buf, "%s\n",
466                                 entry->msi_attrib.is_msix ? "msix" : "msi");
467
468         return -ENODEV;
469 }
470
471 static int populate_msi_sysfs(struct pci_dev *pdev)
472 {
473         struct attribute **msi_attrs;
474         struct attribute *msi_attr;
475         struct device_attribute *msi_dev_attr;
476         struct attribute_group *msi_irq_group;
477         const struct attribute_group **msi_irq_groups;
478         struct msi_desc *entry;
479         int ret = -ENOMEM;
480         int num_msi = 0;
481         int count = 0;
482         int i;
483
484         /* Determine how many msi entries we have */
485         for_each_pci_msi_entry(entry, pdev)
486                 num_msi += entry->nvec_used;
487         if (!num_msi)
488                 return 0;
489
490         /* Dynamically create the MSI attributes for the PCI device */
491         msi_attrs = kzalloc(sizeof(void *) * (num_msi + 1), GFP_KERNEL);
492         if (!msi_attrs)
493                 return -ENOMEM;
494         for_each_pci_msi_entry(entry, pdev) {
495                 for (i = 0; i < entry->nvec_used; i++) {
496                         msi_dev_attr = kzalloc(sizeof(*msi_dev_attr), GFP_KERNEL);
497                         if (!msi_dev_attr)
498                                 goto error_attrs;
499                         msi_attrs[count] = &msi_dev_attr->attr;
500
501                         sysfs_attr_init(&msi_dev_attr->attr);
502                         msi_dev_attr->attr.name = kasprintf(GFP_KERNEL, "%d",
503                                                             entry->irq + i);
504                         if (!msi_dev_attr->attr.name)
505                                 goto error_attrs;
506                         msi_dev_attr->attr.mode = S_IRUGO;
507                         msi_dev_attr->show = msi_mode_show;
508                         ++count;
509                 }
510         }
511
512         msi_irq_group = kzalloc(sizeof(*msi_irq_group), GFP_KERNEL);
513         if (!msi_irq_group)
514                 goto error_attrs;
515         msi_irq_group->name = "msi_irqs";
516         msi_irq_group->attrs = msi_attrs;
517
518         msi_irq_groups = kzalloc(sizeof(void *) * 2, GFP_KERNEL);
519         if (!msi_irq_groups)
520                 goto error_irq_group;
521         msi_irq_groups[0] = msi_irq_group;
522
523         ret = sysfs_create_groups(&pdev->dev.kobj, msi_irq_groups);
524         if (ret)
525                 goto error_irq_groups;
526         pdev->msi_irq_groups = msi_irq_groups;
527
528         return 0;
529
530 error_irq_groups:
531         kfree(msi_irq_groups);
532 error_irq_group:
533         kfree(msi_irq_group);
534 error_attrs:
535         count = 0;
536         msi_attr = msi_attrs[count];
537         while (msi_attr) {
538                 msi_dev_attr = container_of(msi_attr, struct device_attribute, attr);
539                 kfree(msi_attr->name);
540                 kfree(msi_dev_attr);
541                 ++count;
542                 msi_attr = msi_attrs[count];
543         }
544         kfree(msi_attrs);
545         return ret;
546 }
547
548 static struct msi_desc *msi_setup_entry(struct pci_dev *dev, int nvec)
549 {
550         u16 control;
551         struct msi_desc *entry;
552
553         /* MSI Entry Initialization */
554         entry = alloc_msi_entry(&dev->dev);
555         if (!entry)
556                 return NULL;
557
558         pci_read_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, &control);
559
560         entry->msi_attrib.is_msix       = 0;
561         entry->msi_attrib.is_64         = !!(control & PCI_MSI_FLAGS_64BIT);
562         entry->msi_attrib.entry_nr      = 0;
563         entry->msi_attrib.maskbit       = !!(control & PCI_MSI_FLAGS_MASKBIT);
564         entry->msi_attrib.default_irq   = dev->irq;     /* Save IOAPIC IRQ */
565         entry->msi_attrib.multi_cap     = (control & PCI_MSI_FLAGS_QMASK) >> 1;
566         entry->msi_attrib.multiple      = ilog2(__roundup_pow_of_two(nvec));
567         entry->nvec_used                = nvec;
568
569         if (control & PCI_MSI_FLAGS_64BIT)
570                 entry->mask_pos = dev->msi_cap + PCI_MSI_MASK_64;
571         else
572                 entry->mask_pos = dev->msi_cap + PCI_MSI_MASK_32;
573
574         /* Save the initial mask status */
575         if (entry->msi_attrib.maskbit)
576                 pci_read_config_dword(dev, entry->mask_pos, &entry->masked);
577
578         return entry;
579 }
580
581 static int msi_verify_entries(struct pci_dev *dev)
582 {
583         struct msi_desc *entry;
584
585         for_each_pci_msi_entry(entry, dev) {
586                 if (!dev->no_64bit_msi || !entry->msg.address_hi)
587                         continue;
588                 dev_err(&dev->dev, "Device has broken 64-bit MSI but arch"
589                         " tried to assign one above 4G\n");
590                 return -EIO;
591         }
592         return 0;
593 }
594
595 /**
596  * msi_capability_init - configure device's MSI capability structure
597  * @dev: pointer to the pci_dev data structure of MSI device function
598  * @nvec: number of interrupts to allocate
599  *
600  * Setup the MSI capability structure of the device with the requested
601  * number of interrupts.  A return value of zero indicates the successful
602  * setup of an entry with the new MSI irq.  A negative return value indicates
603  * an error, and a positive return value indicates the number of interrupts
604  * which could have been allocated.
605  */
606 static int msi_capability_init(struct pci_dev *dev, int nvec)
607 {
608         struct msi_desc *entry;
609         int ret;
610         unsigned mask;
611
612         pci_msi_set_enable(dev, 0);     /* Disable MSI during set up */
613
614         entry = msi_setup_entry(dev, nvec);
615         if (!entry)
616                 return -ENOMEM;
617
618         /* All MSIs are unmasked by default, Mask them all */
619         mask = msi_mask(entry->msi_attrib.multi_cap);
620         msi_mask_irq(entry, mask, mask);
621
622         list_add_tail(&entry->list, dev_to_msi_list(&dev->dev));
623
624         /* Configure MSI capability structure */
625         ret = pci_msi_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSI);
626         if (ret) {
627                 msi_mask_irq(entry, mask, ~mask);
628                 free_msi_irqs(dev);
629                 return ret;
630         }
631
632         ret = msi_verify_entries(dev);
633         if (ret) {
634                 msi_mask_irq(entry, mask, ~mask);
635                 free_msi_irqs(dev);
636                 return ret;
637         }
638
639         ret = populate_msi_sysfs(dev);
640         if (ret) {
641                 msi_mask_irq(entry, mask, ~mask);
642                 free_msi_irqs(dev);
643                 return ret;
644         }
645
646         /* Set MSI enabled bits  */
647         pci_intx_for_msi(dev, 0);
648         pci_msi_set_enable(dev, 1);
649         dev->msi_enabled = 1;
650
651         pcibios_free_irq(dev);
652         dev->irq = entry->irq;
653         return 0;
654 }
655
656 static void __iomem *msix_map_region(struct pci_dev *dev, unsigned nr_entries)
657 {
658         resource_size_t phys_addr;
659         u32 table_offset;
660         unsigned long flags;
661         u8 bir;
662
663         pci_read_config_dword(dev, dev->msix_cap + PCI_MSIX_TABLE,
664                               &table_offset);
665         bir = (u8)(table_offset & PCI_MSIX_TABLE_BIR);
666         flags = pci_resource_flags(dev, bir);
667         if (!flags || (flags & IORESOURCE_UNSET))
668                 return NULL;
669
670         table_offset &= PCI_MSIX_TABLE_OFFSET;
671         phys_addr = pci_resource_start(dev, bir) + table_offset;
672
673         return ioremap_nocache(phys_addr, nr_entries * PCI_MSIX_ENTRY_SIZE);
674 }
675
676 static int msix_setup_entries(struct pci_dev *dev, void __iomem *base,
677                               struct msix_entry *entries, int nvec)
678 {
679         struct msi_desc *entry;
680         int i;
681
682         for (i = 0; i < nvec; i++) {
683                 entry = alloc_msi_entry(&dev->dev);
684                 if (!entry) {
685                         if (!i)
686                                 iounmap(base);
687                         else
688                                 free_msi_irqs(dev);
689                         /* No enough memory. Don't try again */
690                         return -ENOMEM;
691                 }
692
693                 entry->msi_attrib.is_msix       = 1;
694                 entry->msi_attrib.is_64         = 1;
695                 entry->msi_attrib.entry_nr      = entries[i].entry;
696                 entry->msi_attrib.default_irq   = dev->irq;
697                 entry->mask_base                = base;
698                 entry->nvec_used                = 1;
699
700                 list_add_tail(&entry->list, dev_to_msi_list(&dev->dev));
701         }
702
703         return 0;
704 }
705
706 static void msix_program_entries(struct pci_dev *dev,
707                                  struct msix_entry *entries)
708 {
709         struct msi_desc *entry;
710         int i = 0;
711
712         for_each_pci_msi_entry(entry, dev) {
713                 int offset = entries[i].entry * PCI_MSIX_ENTRY_SIZE +
714                                                 PCI_MSIX_ENTRY_VECTOR_CTRL;
715
716                 entries[i].vector = entry->irq;
717                 entry->masked = readl(entry->mask_base + offset);
718                 msix_mask_irq(entry, 1);
719                 i++;
720         }
721 }
722
723 /**
724  * msix_capability_init - configure device's MSI-X capability
725  * @dev: pointer to the pci_dev data structure of MSI-X device function
726  * @entries: pointer to an array of struct msix_entry entries
727  * @nvec: number of @entries
728  *
729  * Setup the MSI-X capability structure of device function with a
730  * single MSI-X irq. A return of zero indicates the successful setup of
731  * requested MSI-X entries with allocated irqs or non-zero for otherwise.
732  **/
733 static int msix_capability_init(struct pci_dev *dev,
734                                 struct msix_entry *entries, int nvec)
735 {
736         int ret;
737         u16 control;
738         void __iomem *base;
739
740         /* Ensure MSI-X is disabled while it is set up */
741         pci_msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_ENABLE, 0);
742
743         pci_read_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, &control);
744         /* Request & Map MSI-X table region */
745         base = msix_map_region(dev, msix_table_size(control));
746         if (!base)
747                 return -ENOMEM;
748
749         ret = msix_setup_entries(dev, base, entries, nvec);
750         if (ret)
751                 return ret;
752
753         ret = pci_msi_setup_msi_irqs(dev, nvec, PCI_CAP_ID_MSIX);
754         if (ret)
755                 goto out_avail;
756
757         /* Check if all MSI entries honor device restrictions */
758         ret = msi_verify_entries(dev);
759         if (ret)
760                 goto out_free;
761
762         /*
763          * Some devices require MSI-X to be enabled before we can touch the
764          * MSI-X registers.  We need to mask all the vectors to prevent
765          * interrupts coming in before they're fully set up.
766          */
767         pci_msix_clear_and_set_ctrl(dev, 0,
768                                 PCI_MSIX_FLAGS_MASKALL | PCI_MSIX_FLAGS_ENABLE);
769
770         msix_program_entries(dev, entries);
771
772         ret = populate_msi_sysfs(dev);
773         if (ret)
774                 goto out_free;
775
776         /* Set MSI-X enabled bits and unmask the function */
777         pci_intx_for_msi(dev, 0);
778         dev->msix_enabled = 1;
779         pci_msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_MASKALL, 0);
780
781         pcibios_free_irq(dev);
782         return 0;
783
784 out_avail:
785         if (ret < 0) {
786                 /*
787                  * If we had some success, report the number of irqs
788                  * we succeeded in setting up.
789                  */
790                 struct msi_desc *entry;
791                 int avail = 0;
792
793                 for_each_pci_msi_entry(entry, dev) {
794                         if (entry->irq != 0)
795                                 avail++;
796                 }
797                 if (avail != 0)
798                         ret = avail;
799         }
800
801 out_free:
802         free_msi_irqs(dev);
803
804         return ret;
805 }
806
807 /**
808  * pci_msi_supported - check whether MSI may be enabled on a device
809  * @dev: pointer to the pci_dev data structure of MSI device function
810  * @nvec: how many MSIs have been requested ?
811  *
812  * Look at global flags, the device itself, and its parent buses
813  * to determine if MSI/-X are supported for the device. If MSI/-X is
814  * supported return 1, else return 0.
815  **/
816 static int pci_msi_supported(struct pci_dev *dev, int nvec)
817 {
818         struct pci_bus *bus;
819
820         /* MSI must be globally enabled and supported by the device */
821         if (!pci_msi_enable)
822                 return 0;
823
824         if (!dev || dev->no_msi || dev->current_state != PCI_D0)
825                 return 0;
826
827         /*
828          * You can't ask to have 0 or less MSIs configured.
829          *  a) it's stupid ..
830          *  b) the list manipulation code assumes nvec >= 1.
831          */
832         if (nvec < 1)
833                 return 0;
834
835         /*
836          * Any bridge which does NOT route MSI transactions from its
837          * secondary bus to its primary bus must set NO_MSI flag on
838          * the secondary pci_bus.
839          * We expect only arch-specific PCI host bus controller driver
840          * or quirks for specific PCI bridges to be setting NO_MSI.
841          */
842         for (bus = dev->bus; bus; bus = bus->parent)
843                 if (bus->bus_flags & PCI_BUS_FLAGS_NO_MSI)
844                         return 0;
845
846         return 1;
847 }
848
849 /**
850  * pci_msi_vec_count - Return the number of MSI vectors a device can send
851  * @dev: device to report about
852  *
853  * This function returns the number of MSI vectors a device requested via
854  * Multiple Message Capable register. It returns a negative errno if the
855  * device is not capable sending MSI interrupts. Otherwise, the call succeeds
856  * and returns a power of two, up to a maximum of 2^5 (32), according to the
857  * MSI specification.
858  **/
859 int pci_msi_vec_count(struct pci_dev *dev)
860 {
861         int ret;
862         u16 msgctl;
863
864         if (!dev->msi_cap)
865                 return -EINVAL;
866
867         pci_read_config_word(dev, dev->msi_cap + PCI_MSI_FLAGS, &msgctl);
868         ret = 1 << ((msgctl & PCI_MSI_FLAGS_QMASK) >> 1);
869
870         return ret;
871 }
872 EXPORT_SYMBOL(pci_msi_vec_count);
873
874 void pci_msi_shutdown(struct pci_dev *dev)
875 {
876         struct msi_desc *desc;
877         u32 mask;
878
879         if (!pci_msi_enable || !dev || !dev->msi_enabled)
880                 return;
881
882         BUG_ON(list_empty(dev_to_msi_list(&dev->dev)));
883         desc = first_pci_msi_entry(dev);
884
885         pci_msi_set_enable(dev, 0);
886         pci_intx_for_msi(dev, 1);
887         dev->msi_enabled = 0;
888
889         /* Return the device with MSI unmasked as initial states */
890         mask = msi_mask(desc->msi_attrib.multi_cap);
891         /* Keep cached state to be restored */
892         __pci_msi_desc_mask_irq(desc, mask, ~mask);
893
894         /* Restore dev->irq to its default pin-assertion irq */
895         dev->irq = desc->msi_attrib.default_irq;
896         pcibios_alloc_irq(dev);
897 }
898
899 void pci_disable_msi(struct pci_dev *dev)
900 {
901         if (!pci_msi_enable || !dev || !dev->msi_enabled)
902                 return;
903
904         pci_msi_shutdown(dev);
905         free_msi_irqs(dev);
906 }
907 EXPORT_SYMBOL(pci_disable_msi);
908
909 /**
910  * pci_msix_vec_count - return the number of device's MSI-X table entries
911  * @dev: pointer to the pci_dev data structure of MSI-X device function
912  * This function returns the number of device's MSI-X table entries and
913  * therefore the number of MSI-X vectors device is capable of sending.
914  * It returns a negative errno if the device is not capable of sending MSI-X
915  * interrupts.
916  **/
917 int pci_msix_vec_count(struct pci_dev *dev)
918 {
919         u16 control;
920
921         if (!dev->msix_cap)
922                 return -EINVAL;
923
924         pci_read_config_word(dev, dev->msix_cap + PCI_MSIX_FLAGS, &control);
925         return msix_table_size(control);
926 }
927 EXPORT_SYMBOL(pci_msix_vec_count);
928
929 /**
930  * pci_enable_msix - configure device's MSI-X capability structure
931  * @dev: pointer to the pci_dev data structure of MSI-X device function
932  * @entries: pointer to an array of MSI-X entries
933  * @nvec: number of MSI-X irqs requested for allocation by device driver
934  *
935  * Setup the MSI-X capability structure of device function with the number
936  * of requested irqs upon its software driver call to request for
937  * MSI-X mode enabled on its hardware device function. A return of zero
938  * indicates the successful configuration of MSI-X capability structure
939  * with new allocated MSI-X irqs. A return of < 0 indicates a failure.
940  * Or a return of > 0 indicates that driver request is exceeding the number
941  * of irqs or MSI-X vectors available. Driver should use the returned value to
942  * re-send its request.
943  **/
944 int pci_enable_msix(struct pci_dev *dev, struct msix_entry *entries, int nvec)
945 {
946         int nr_entries;
947         int i, j;
948
949         if (!pci_msi_supported(dev, nvec))
950                 return -EINVAL;
951
952         if (!entries)
953                 return -EINVAL;
954
955         nr_entries = pci_msix_vec_count(dev);
956         if (nr_entries < 0)
957                 return nr_entries;
958         if (nvec > nr_entries)
959                 return nr_entries;
960
961         /* Check for any invalid entries */
962         for (i = 0; i < nvec; i++) {
963                 if (entries[i].entry >= nr_entries)
964                         return -EINVAL;         /* invalid entry */
965                 for (j = i + 1; j < nvec; j++) {
966                         if (entries[i].entry == entries[j].entry)
967                                 return -EINVAL; /* duplicate entry */
968                 }
969         }
970         WARN_ON(!!dev->msix_enabled);
971
972         /* Check whether driver already requested for MSI irq */
973         if (dev->msi_enabled) {
974                 dev_info(&dev->dev, "can't enable MSI-X (MSI IRQ already assigned)\n");
975                 return -EINVAL;
976         }
977         return msix_capability_init(dev, entries, nvec);
978 }
979 EXPORT_SYMBOL(pci_enable_msix);
980
981 void pci_msix_shutdown(struct pci_dev *dev)
982 {
983         struct msi_desc *entry;
984
985         if (!pci_msi_enable || !dev || !dev->msix_enabled)
986                 return;
987
988         /* Return the device with MSI-X masked as initial states */
989         for_each_pci_msi_entry(entry, dev) {
990                 /* Keep cached states to be restored */
991                 __pci_msix_desc_mask_irq(entry, 1);
992         }
993
994         pci_msix_clear_and_set_ctrl(dev, PCI_MSIX_FLAGS_ENABLE, 0);
995         pci_intx_for_msi(dev, 1);
996         dev->msix_enabled = 0;
997         pcibios_alloc_irq(dev);
998 }
999
1000 void pci_disable_msix(struct pci_dev *dev)
1001 {
1002         if (!pci_msi_enable || !dev || !dev->msix_enabled)
1003                 return;
1004
1005         pci_msix_shutdown(dev);
1006         free_msi_irqs(dev);
1007 }
1008 EXPORT_SYMBOL(pci_disable_msix);
1009
1010 void pci_no_msi(void)
1011 {
1012         pci_msi_enable = 0;
1013 }
1014
1015 /**
1016  * pci_msi_enabled - is MSI enabled?
1017  *
1018  * Returns true if MSI has not been disabled by the command-line option
1019  * pci=nomsi.
1020  **/
1021 int pci_msi_enabled(void)
1022 {
1023         return pci_msi_enable;
1024 }
1025 EXPORT_SYMBOL(pci_msi_enabled);
1026
1027 void pci_msi_init_pci_dev(struct pci_dev *dev)
1028 {
1029 }
1030
1031 /**
1032  * pci_enable_msi_range - configure device's MSI capability structure
1033  * @dev: device to configure
1034  * @minvec: minimal number of interrupts to configure
1035  * @maxvec: maximum number of interrupts to configure
1036  *
1037  * This function tries to allocate a maximum possible number of interrupts in a
1038  * range between @minvec and @maxvec. It returns a negative errno if an error
1039  * occurs. If it succeeds, it returns the actual number of interrupts allocated
1040  * and updates the @dev's irq member to the lowest new interrupt number;
1041  * the other interrupt numbers allocated to this device are consecutive.
1042  **/
1043 int pci_enable_msi_range(struct pci_dev *dev, int minvec, int maxvec)
1044 {
1045         int nvec;
1046         int rc;
1047
1048         if (!pci_msi_supported(dev, minvec))
1049                 return -EINVAL;
1050
1051         WARN_ON(!!dev->msi_enabled);
1052
1053         /* Check whether driver already requested MSI-X irqs */
1054         if (dev->msix_enabled) {
1055                 dev_info(&dev->dev,
1056                          "can't enable MSI (MSI-X already enabled)\n");
1057                 return -EINVAL;
1058         }
1059
1060         if (maxvec < minvec)
1061                 return -ERANGE;
1062
1063         nvec = pci_msi_vec_count(dev);
1064         if (nvec < 0)
1065                 return nvec;
1066         else if (nvec < minvec)
1067                 return -EINVAL;
1068         else if (nvec > maxvec)
1069                 nvec = maxvec;
1070
1071         do {
1072                 rc = msi_capability_init(dev, nvec);
1073                 if (rc < 0) {
1074                         return rc;
1075                 } else if (rc > 0) {
1076                         if (rc < minvec)
1077                                 return -ENOSPC;
1078                         nvec = rc;
1079                 }
1080         } while (rc);
1081
1082         return nvec;
1083 }
1084 EXPORT_SYMBOL(pci_enable_msi_range);
1085
1086 /**
1087  * pci_enable_msix_range - configure device's MSI-X capability structure
1088  * @dev: pointer to the pci_dev data structure of MSI-X device function
1089  * @entries: pointer to an array of MSI-X entries
1090  * @minvec: minimum number of MSI-X irqs requested
1091  * @maxvec: maximum number of MSI-X irqs requested
1092  *
1093  * Setup the MSI-X capability structure of device function with a maximum
1094  * possible number of interrupts in the range between @minvec and @maxvec
1095  * upon its software driver call to request for MSI-X mode enabled on its
1096  * hardware device function. It returns a negative errno if an error occurs.
1097  * If it succeeds, it returns the actual number of interrupts allocated and
1098  * indicates the successful configuration of MSI-X capability structure
1099  * with new allocated MSI-X interrupts.
1100  **/
1101 int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
1102                                int minvec, int maxvec)
1103 {
1104         int nvec = maxvec;
1105         int rc;
1106
1107         if (maxvec < minvec)
1108                 return -ERANGE;
1109
1110         do {
1111                 rc = pci_enable_msix(dev, entries, nvec);
1112                 if (rc < 0) {
1113                         return rc;
1114                 } else if (rc > 0) {
1115                         if (rc < minvec)
1116                                 return -ENOSPC;
1117                         nvec = rc;
1118                 }
1119         } while (rc);
1120
1121         return nvec;
1122 }
1123 EXPORT_SYMBOL(pci_enable_msix_range);
1124
1125 struct pci_dev *msi_desc_to_pci_dev(struct msi_desc *desc)
1126 {
1127         return to_pci_dev(desc->dev);
1128 }
1129
1130 void *msi_desc_to_pci_sysdata(struct msi_desc *desc)
1131 {
1132         struct pci_dev *dev = msi_desc_to_pci_dev(desc);
1133
1134         return dev->bus->sysdata;
1135 }
1136 EXPORT_SYMBOL_GPL(msi_desc_to_pci_sysdata);
1137
1138 #ifdef CONFIG_PCI_MSI_IRQ_DOMAIN
1139 /**
1140  * pci_msi_domain_write_msg - Helper to write MSI message to PCI config space
1141  * @irq_data:   Pointer to interrupt data of the MSI interrupt
1142  * @msg:        Pointer to the message
1143  */
1144 void pci_msi_domain_write_msg(struct irq_data *irq_data, struct msi_msg *msg)
1145 {
1146         struct msi_desc *desc = irq_data_get_msi_desc(irq_data);
1147
1148         /*
1149          * For MSI-X desc->irq is always equal to irq_data->irq. For
1150          * MSI only the first interrupt of MULTI MSI passes the test.
1151          */
1152         if (desc->irq == irq_data->irq)
1153                 __pci_write_msi_msg(desc, msg);
1154 }
1155
1156 /**
1157  * pci_msi_domain_calc_hwirq - Generate a unique ID for an MSI source
1158  * @dev:        Pointer to the PCI device
1159  * @desc:       Pointer to the msi descriptor
1160  *
1161  * The ID number is only used within the irqdomain.
1162  */
1163 irq_hw_number_t pci_msi_domain_calc_hwirq(struct pci_dev *dev,
1164                                           struct msi_desc *desc)
1165 {
1166         return (irq_hw_number_t)desc->msi_attrib.entry_nr |
1167                 PCI_DEVID(dev->bus->number, dev->devfn) << 11 |
1168                 (pci_domain_nr(dev->bus) & 0xFFFFFFFF) << 27;
1169 }
1170
1171 static inline bool pci_msi_desc_is_multi_msi(struct msi_desc *desc)
1172 {
1173         return !desc->msi_attrib.is_msix && desc->nvec_used > 1;
1174 }
1175
1176 /**
1177  * pci_msi_domain_check_cap - Verify that @domain supports the capabilities for @dev
1178  * @domain:     The interrupt domain to check
1179  * @info:       The domain info for verification
1180  * @dev:        The device to check
1181  *
1182  * Returns:
1183  *  0 if the functionality is supported
1184  *  1 if Multi MSI is requested, but the domain does not support it
1185  *  -ENOTSUPP otherwise
1186  */
1187 int pci_msi_domain_check_cap(struct irq_domain *domain,
1188                              struct msi_domain_info *info, struct device *dev)
1189 {
1190         struct msi_desc *desc = first_pci_msi_entry(to_pci_dev(dev));
1191
1192         /* Special handling to support pci_enable_msi_range() */
1193         if (pci_msi_desc_is_multi_msi(desc) &&
1194             !(info->flags & MSI_FLAG_MULTI_PCI_MSI))
1195                 return 1;
1196         else if (desc->msi_attrib.is_msix && !(info->flags & MSI_FLAG_PCI_MSIX))
1197                 return -ENOTSUPP;
1198
1199         return 0;
1200 }
1201
1202 static int pci_msi_domain_handle_error(struct irq_domain *domain,
1203                                        struct msi_desc *desc, int error)
1204 {
1205         /* Special handling to support pci_enable_msi_range() */
1206         if (pci_msi_desc_is_multi_msi(desc) && error == -ENOSPC)
1207                 return 1;
1208
1209         return error;
1210 }
1211
1212 #ifdef GENERIC_MSI_DOMAIN_OPS
1213 static void pci_msi_domain_set_desc(msi_alloc_info_t *arg,
1214                                     struct msi_desc *desc)
1215 {
1216         arg->desc = desc;
1217         arg->hwirq = pci_msi_domain_calc_hwirq(msi_desc_to_pci_dev(desc),
1218                                                desc);
1219 }
1220 #else
1221 #define pci_msi_domain_set_desc         NULL
1222 #endif
1223
1224 static struct msi_domain_ops pci_msi_domain_ops_default = {
1225         .set_desc       = pci_msi_domain_set_desc,
1226         .msi_check      = pci_msi_domain_check_cap,
1227         .handle_error   = pci_msi_domain_handle_error,
1228 };
1229
1230 static void pci_msi_domain_update_dom_ops(struct msi_domain_info *info)
1231 {
1232         struct msi_domain_ops *ops = info->ops;
1233
1234         if (ops == NULL) {
1235                 info->ops = &pci_msi_domain_ops_default;
1236         } else {
1237                 if (ops->set_desc == NULL)
1238                         ops->set_desc = pci_msi_domain_set_desc;
1239                 if (ops->msi_check == NULL)
1240                         ops->msi_check = pci_msi_domain_check_cap;
1241                 if (ops->handle_error == NULL)
1242                         ops->handle_error = pci_msi_domain_handle_error;
1243         }
1244 }
1245
1246 static void pci_msi_domain_update_chip_ops(struct msi_domain_info *info)
1247 {
1248         struct irq_chip *chip = info->chip;
1249
1250         BUG_ON(!chip);
1251         if (!chip->irq_write_msi_msg)
1252                 chip->irq_write_msi_msg = pci_msi_domain_write_msg;
1253         if (!chip->irq_mask)
1254                 chip->irq_mask = pci_msi_mask_irq;
1255         if (!chip->irq_unmask)
1256                 chip->irq_unmask = pci_msi_unmask_irq;
1257 }
1258
1259 /**
1260  * pci_msi_create_irq_domain - Create a MSI interrupt domain
1261  * @fwnode:     Optional fwnode of the interrupt controller
1262  * @info:       MSI domain info
1263  * @parent:     Parent irq domain
1264  *
1265  * Updates the domain and chip ops and creates a MSI interrupt domain.
1266  *
1267  * Returns:
1268  * A domain pointer or NULL in case of failure.
1269  */
1270 struct irq_domain *pci_msi_create_irq_domain(struct fwnode_handle *fwnode,
1271                                              struct msi_domain_info *info,
1272                                              struct irq_domain *parent)
1273 {
1274         struct irq_domain *domain;
1275
1276         if (info->flags & MSI_FLAG_USE_DEF_DOM_OPS)
1277                 pci_msi_domain_update_dom_ops(info);
1278         if (info->flags & MSI_FLAG_USE_DEF_CHIP_OPS)
1279                 pci_msi_domain_update_chip_ops(info);
1280
1281         domain = msi_create_irq_domain(fwnode, info, parent);
1282         if (!domain)
1283                 return NULL;
1284
1285         domain->bus_token = DOMAIN_BUS_PCI_MSI;
1286         return domain;
1287 }
1288
1289 /**
1290  * pci_msi_domain_alloc_irqs - Allocate interrupts for @dev in @domain
1291  * @domain:     The interrupt domain to allocate from
1292  * @dev:        The device for which to allocate
1293  * @nvec:       The number of interrupts to allocate
1294  * @type:       Unused to allow simpler migration from the arch_XXX interfaces
1295  *
1296  * Returns:
1297  * A virtual interrupt number or an error code in case of failure
1298  */
1299 int pci_msi_domain_alloc_irqs(struct irq_domain *domain, struct pci_dev *dev,
1300                               int nvec, int type)
1301 {
1302         return msi_domain_alloc_irqs(domain, &dev->dev, nvec);
1303 }
1304
1305 /**
1306  * pci_msi_domain_free_irqs - Free interrupts for @dev in @domain
1307  * @domain:     The interrupt domain
1308  * @dev:        The device for which to free interrupts
1309  */
1310 void pci_msi_domain_free_irqs(struct irq_domain *domain, struct pci_dev *dev)
1311 {
1312         msi_domain_free_irqs(domain, &dev->dev);
1313 }
1314
1315 /**
1316  * pci_msi_create_default_irq_domain - Create a default MSI interrupt domain
1317  * @fwnode:     Optional fwnode of the interrupt controller
1318  * @info:       MSI domain info
1319  * @parent:     Parent irq domain
1320  *
1321  * Returns: A domain pointer or NULL in case of failure. If successful
1322  * the default PCI/MSI irqdomain pointer is updated.
1323  */
1324 struct irq_domain *pci_msi_create_default_irq_domain(struct fwnode_handle *fwnode,
1325                 struct msi_domain_info *info, struct irq_domain *parent)
1326 {
1327         struct irq_domain *domain;
1328
1329         mutex_lock(&pci_msi_domain_lock);
1330         if (pci_msi_default_domain) {
1331                 pr_err("PCI: default irq domain for PCI MSI has already been created.\n");
1332                 domain = NULL;
1333         } else {
1334                 domain = pci_msi_create_irq_domain(fwnode, info, parent);
1335                 pci_msi_default_domain = domain;
1336         }
1337         mutex_unlock(&pci_msi_domain_lock);
1338
1339         return domain;
1340 }
1341
1342 static int get_msi_id_cb(struct pci_dev *pdev, u16 alias, void *data)
1343 {
1344         u32 *pa = data;
1345
1346         *pa = alias;
1347         return 0;
1348 }
1349 /**
1350  * pci_msi_domain_get_msi_rid - Get the MSI requester id (RID)
1351  * @domain:     The interrupt domain
1352  * @pdev:       The PCI device.
1353  *
1354  * The RID for a device is formed from the alias, with a firmware
1355  * supplied mapping applied
1356  *
1357  * Returns: The RID.
1358  */
1359 u32 pci_msi_domain_get_msi_rid(struct irq_domain *domain, struct pci_dev *pdev)
1360 {
1361         struct device_node *of_node;
1362         u32 rid = 0;
1363
1364         pci_for_each_dma_alias(pdev, get_msi_id_cb, &rid);
1365
1366         of_node = irq_domain_get_of_node(domain);
1367         if (of_node)
1368                 rid = of_msi_map_rid(&pdev->dev, of_node, rid);
1369
1370         return rid;
1371 }
1372
1373 /**
1374  * pci_msi_get_device_domain - Get the MSI domain for a given PCI device
1375  * @pdev:       The PCI device
1376  *
1377  * Use the firmware data to find a device-specific MSI domain
1378  * (i.e. not one that is ste as a default).
1379  *
1380  * Returns: The coresponding MSI domain or NULL if none has been found.
1381  */
1382 struct irq_domain *pci_msi_get_device_domain(struct pci_dev *pdev)
1383 {
1384         u32 rid = 0;
1385
1386         pci_for_each_dma_alias(pdev, get_msi_id_cb, &rid);
1387         return of_msi_map_get_device_domain(&pdev->dev, rid);
1388 }
1389 #endif /* CONFIG_PCI_MSI_IRQ_DOMAIN */