1
2
3
4
5
6
7
8
9
10#include <linux/irq.h>
11#include <linux/pci.h>
12#include <linux/msi.h>
13#include <linux/of_platform.h>
14#include <linux/interrupt.h>
15#include <linux/export.h>
16#include <linux/kernel.h>
17#include <asm/prom.h>
18#include <asm/hw_irq.h>
19#include <asm/ppc-pci.h>
20#include <asm/dcr.h>
21#include <asm/dcr-regs.h>
22#include <asm/msi_bitmap.h>
23
24#define PEIH_TERMADH 0x00
25#define PEIH_TERMADL 0x08
26#define PEIH_MSIED 0x10
27#define PEIH_MSIMK 0x18
28#define PEIH_MSIASS 0x20
29#define PEIH_FLUSH0 0x30
30#define PEIH_FLUSH1 0x38
31#define PEIH_CNTRST 0x48
32
33static int msi_irqs;
34
35struct ppc4xx_msi {
36 u32 msi_addr_lo;
37 u32 msi_addr_hi;
38 void __iomem *msi_regs;
39 int *msi_virqs;
40 struct msi_bitmap bitmap;
41 struct device_node *msi_dev;
42};
43
44static struct ppc4xx_msi ppc4xx_msi;
45
46static int ppc4xx_msi_init_allocator(struct platform_device *dev,
47 struct ppc4xx_msi *msi_data)
48{
49 int err;
50
51 err = msi_bitmap_alloc(&msi_data->bitmap, msi_irqs,
52 dev->dev.of_node);
53 if (err)
54 return err;
55
56 err = msi_bitmap_reserve_dt_hwirqs(&msi_data->bitmap);
57 if (err < 0) {
58 msi_bitmap_free(&msi_data->bitmap);
59 return err;
60 }
61
62 return 0;
63}
64
65static int ppc4xx_setup_msi_irqs(struct pci_dev *dev, int nvec, int type)
66{
67 int int_no = -ENOMEM;
68 unsigned int virq;
69 struct msi_msg msg;
70 struct msi_desc *entry;
71 struct ppc4xx_msi *msi_data = &ppc4xx_msi;
72
73 dev_dbg(&dev->dev, "PCIE-MSI:%s called. vec %x type %d\n",
74 __func__, nvec, type);
75 if (type == PCI_CAP_ID_MSIX)
76 pr_debug("ppc4xx msi: MSI-X untested, trying anyway.\n");
77
78 msi_data->msi_virqs = kmalloc_array(msi_irqs, sizeof(int), GFP_KERNEL);
79 if (!msi_data->msi_virqs)
80 return -ENOMEM;
81
82 for_each_pci_msi_entry(entry, dev) {
83 int_no = msi_bitmap_alloc_hwirqs(&msi_data->bitmap, 1);
84 if (int_no >= 0)
85 break;
86 if (int_no < 0) {
87 pr_debug("%s: fail allocating msi interrupt\n",
88 __func__);
89 }
90 virq = irq_of_parse_and_map(msi_data->msi_dev, int_no);
91 if (!virq) {
92 dev_err(&dev->dev, "%s: fail mapping irq\n", __func__);
93 msi_bitmap_free_hwirqs(&msi_data->bitmap, int_no, 1);
94 return -ENOSPC;
95 }
96 dev_dbg(&dev->dev, "%s: virq = %d\n", __func__, virq);
97
98
99 msg.address_hi = msi_data->msi_addr_hi;
100 msg.address_lo = msi_data->msi_addr_lo;
101
102 irq_set_msi_desc(virq, entry);
103 msg.data = int_no;
104 pci_write_msi_msg(virq, &msg);
105 }
106 return 0;
107}
108
109void ppc4xx_teardown_msi_irqs(struct pci_dev *dev)
110{
111 struct msi_desc *entry;
112 struct ppc4xx_msi *msi_data = &ppc4xx_msi;
113 irq_hw_number_t hwirq;
114
115 dev_dbg(&dev->dev, "PCIE-MSI: tearing down msi irqs\n");
116
117 for_each_pci_msi_entry(entry, dev) {
118 if (!entry->irq)
119 continue;
120 hwirq = virq_to_hw(entry->irq);
121 irq_set_msi_desc(entry->irq, NULL);
122 irq_dispose_mapping(entry->irq);
123 msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);
124 }
125}
126
127static int ppc4xx_setup_pcieh_hw(struct platform_device *dev,
128 struct resource res, struct ppc4xx_msi *msi)
129{
130 const u32 *msi_data;
131 const u32 *msi_mask;
132 const u32 *sdr_addr;
133 dma_addr_t msi_phys;
134 void *msi_virt;
135 int err;
136
137 sdr_addr = of_get_property(dev->dev.of_node, "sdr-base", NULL);
138 if (!sdr_addr)
139 return -EINVAL;
140
141 msi_data = of_get_property(dev->dev.of_node, "msi-data", NULL);
142 if (!msi_data)
143 return -EINVAL;
144
145 msi_mask = of_get_property(dev->dev.of_node, "msi-mask", NULL);
146 if (!msi_mask)
147 return -EINVAL;
148
149 msi->msi_dev = of_find_node_by_name(NULL, "ppc4xx-msi");
150 if (!msi->msi_dev)
151 return -ENODEV;
152
153 msi->msi_regs = of_iomap(msi->msi_dev, 0);
154 if (!msi->msi_regs) {
155 dev_err(&dev->dev, "of_iomap failed\n");
156 err = -ENOMEM;
157 goto node_put;
158 }
159 dev_dbg(&dev->dev, "PCIE-MSI: msi register mapped 0x%x 0x%x\n",
160 (u32) (msi->msi_regs + PEIH_TERMADH), (u32) (msi->msi_regs));
161
162 msi_virt = dma_alloc_coherent(&dev->dev, 64, &msi_phys, GFP_KERNEL);
163 if (!msi_virt) {
164 err = -ENOMEM;
165 goto iounmap;
166 }
167 msi->msi_addr_hi = upper_32_bits(msi_phys);
168 msi->msi_addr_lo = lower_32_bits(msi_phys & 0xffffffff);
169 dev_dbg(&dev->dev, "PCIE-MSI: msi address high 0x%x, low 0x%x\n",
170 msi->msi_addr_hi, msi->msi_addr_lo);
171
172 mtdcri(SDR0, *sdr_addr, upper_32_bits(res.start));
173 mtdcri(SDR0, *sdr_addr + 1, lower_32_bits(res.start));
174
175
176 out_be32(msi->msi_regs + PEIH_TERMADH, msi->msi_addr_hi);
177 out_be32(msi->msi_regs + PEIH_TERMADL, msi->msi_addr_lo);
178
179
180 out_be32(msi->msi_regs + PEIH_MSIED, *msi_data);
181 out_be32(msi->msi_regs + PEIH_MSIMK, *msi_mask);
182
183 dma_free_coherent(&dev->dev, 64, msi_virt, msi_phys);
184
185 return 0;
186
187iounmap:
188 iounmap(msi->msi_regs);
189node_put:
190 of_node_put(msi->msi_dev);
191 return err;
192}
193
194static int ppc4xx_of_msi_remove(struct platform_device *dev)
195{
196 struct ppc4xx_msi *msi = dev->dev.platform_data;
197 int i;
198 int virq;
199
200 for (i = 0; i < msi_irqs; i++) {
201 virq = msi->msi_virqs[i];
202 if (virq)
203 irq_dispose_mapping(virq);
204 }
205
206 if (msi->bitmap.bitmap)
207 msi_bitmap_free(&msi->bitmap);
208 iounmap(msi->msi_regs);
209 of_node_put(msi->msi_dev);
210
211 return 0;
212}
213
214static int ppc4xx_msi_probe(struct platform_device *dev)
215{
216 struct ppc4xx_msi *msi;
217 struct resource res;
218 int err = 0;
219 struct pci_controller *phb;
220
221 dev_dbg(&dev->dev, "PCIE-MSI: Setting up MSI support...\n");
222
223 msi = devm_kzalloc(&dev->dev, sizeof(*msi), GFP_KERNEL);
224 if (!msi)
225 return -ENOMEM;
226 dev->dev.platform_data = msi;
227
228
229 err = of_address_to_resource(dev->dev.of_node, 0, &res);
230 if (err) {
231 dev_err(&dev->dev, "%pOF resource error!\n", dev->dev.of_node);
232 return err;
233 }
234
235 msi_irqs = of_irq_count(dev->dev.of_node);
236 if (!msi_irqs)
237 return -ENODEV;
238
239 err = ppc4xx_setup_pcieh_hw(dev, res, msi);
240 if (err)
241 return err;
242
243 err = ppc4xx_msi_init_allocator(dev, msi);
244 if (err) {
245 dev_err(&dev->dev, "Error allocating MSI bitmap\n");
246 goto error_out;
247 }
248 ppc4xx_msi = *msi;
249
250 list_for_each_entry(phb, &hose_list, list_node) {
251 phb->controller_ops.setup_msi_irqs = ppc4xx_setup_msi_irqs;
252 phb->controller_ops.teardown_msi_irqs = ppc4xx_teardown_msi_irqs;
253 }
254 return 0;
255
256error_out:
257 ppc4xx_of_msi_remove(dev);
258 return err;
259}
260static const struct of_device_id ppc4xx_msi_ids[] = {
261 {
262 .compatible = "amcc,ppc4xx-msi",
263 },
264 {}
265};
266static struct platform_driver ppc4xx_msi_driver = {
267 .probe = ppc4xx_msi_probe,
268 .remove = ppc4xx_of_msi_remove,
269 .driver = {
270 .name = "ppc4xx-msi",
271 .of_match_table = ppc4xx_msi_ids,
272 },
273
274};
275
276static __init int ppc4xx_msi_init(void)
277{
278 return platform_driver_register(&ppc4xx_msi_driver);
279}
280
281subsys_initcall(ppc4xx_msi_init);
282
