fsl_msi.c 9.29 KB
Newer Older
1
/*
2
 * Copyright (C) 2007-2010 Freescale Semiconductor, Inc.
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 *
 * Author: Tony Li <tony.li@freescale.com>
 *	   Jason Jin <Jason.jin@freescale.com>
 *
 * The hwirq alloc and free code reuse from sysdev/mpic_msi.c
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; version 2 of the
 * License.
 *
 */
#include <linux/irq.h>
#include <linux/bootmem.h>
#include <linux/msi.h>
#include <linux/pci.h>
19
#include <linux/slab.h>
20
21
22
23
24
#include <linux/of_platform.h>
#include <sysdev/fsl_soc.h>
#include <asm/prom.h>
#include <asm/hw_irq.h>
#include <asm/ppc-pci.h>
25
#include <asm/mpic.h>
26
27
#include "fsl_msi.h"

28
29
LIST_HEAD(msi_head);

30
31
32
33
34
struct fsl_msi_feature {
	u32 fsl_pic_ip;
	u32 msiir_offset;
};

35
36
37
38
struct fsl_msi_cascade_data {
	struct fsl_msi *msi_data;
	int index;
};
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

static inline u32 fsl_msi_read(u32 __iomem *base, unsigned int reg)
{
	return in_be32(base + (reg >> 2));
}

/*
 * We do not need this actually. The MSIR register has been read once
 * in the cascade interrupt. So, this MSI interrupt has been acked
*/
static void fsl_msi_end_irq(unsigned int virq)
{
}

static struct irq_chip fsl_msi_chip = {
	.mask		= mask_msi_irq,
	.unmask		= unmask_msi_irq,
	.ack		= fsl_msi_end_irq,
57
	.name		= "FSL-MSI",
58
59
60
61
62
};

static int fsl_msi_host_map(struct irq_host *h, unsigned int virq,
				irq_hw_number_t hw)
{
63
	struct fsl_msi *msi_data = h->host_data;
64
65
	struct irq_chip *chip = &fsl_msi_chip;

66
	irq_to_desc(virq)->status |= IRQ_TYPE_EDGE_FALLING;
67

68
	set_irq_chip_data(virq, msi_data);
69
	set_irq_chip_and_handler(virq, chip, handle_edge_irq);
70
71
72
73
74
75
76
77
78
79

	return 0;
}

static struct irq_host_ops fsl_msi_host_ops = {
	.map = fsl_msi_host_map,
};

static int fsl_msi_init_allocator(struct fsl_msi *msi_data)
{
80
	int rc;
81

82
83
84
85
	rc = msi_bitmap_alloc(&msi_data->bitmap, NR_MSI_IRQS,
			      msi_data->irqhost->of_node);
	if (rc)
		return rc;
86

87
88
89
90
	rc = msi_bitmap_reserve_dt_hwirqs(&msi_data->bitmap);
	if (rc < 0) {
		msi_bitmap_free(&msi_data->bitmap);
		return rc;
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
	}

	return 0;
}

static int fsl_msi_check_device(struct pci_dev *pdev, int nvec, int type)
{
	if (type == PCI_CAP_ID_MSIX)
		pr_debug("fslmsi: MSI-X untested, trying anyway.\n");

	return 0;
}

static void fsl_teardown_msi_irqs(struct pci_dev *pdev)
{
	struct msi_desc *entry;
107
	struct fsl_msi *msi_data;
108
109
110
111

	list_for_each_entry(entry, &pdev->msi_list, list) {
		if (entry->irq == NO_IRQ)
			continue;
112
		msi_data = get_irq_data(entry->irq);
113
		set_irq_msi(entry->irq, NULL);
114
115
		msi_bitmap_free_hwirqs(&msi_data->bitmap,
				       virq_to_hw(entry->irq), 1);
116
117
118
119
120
121
122
		irq_dispose_mapping(entry->irq);
	}

	return;
}

static void fsl_compose_msi_msg(struct pci_dev *pdev, int hwirq,
123
124
				struct msi_msg *msg,
				struct fsl_msi *fsl_msi_data)
125
{
126
	struct fsl_msi *msi_data = fsl_msi_data;
127
128
	struct pci_controller *hose = pci_bus_to_host(pdev->bus);
	u32 base = 0;
129

130
131
132
133
	pci_bus_read_config_dword(hose->bus,
		PCI_DEVFN(0, 0), PCI_BASE_ADDRESS_0, &base);

	msg->address_lo = msi_data->msi_addr_lo + base;
134
135
136
137
138
139
140
141
142
	msg->address_hi = msi_data->msi_addr_hi;
	msg->data = hwirq;

	pr_debug("%s: allocated srs: %d, ibs: %d\n",
		__func__, hwirq / IRQS_PER_MSI_REG, hwirq % IRQS_PER_MSI_REG);
}

static int fsl_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
{
143
	int rc, hwirq = -ENOMEM;
144
145
146
	unsigned int virq;
	struct msi_desc *entry;
	struct msi_msg msg;
147
	struct fsl_msi *msi_data;
148
149

	list_for_each_entry(entry, &pdev->msi_list, list) {
150
151
152
153
154
		list_for_each_entry(msi_data, &msi_head, list) {
			hwirq = msi_bitmap_alloc_hwirqs(&msi_data->bitmap, 1);
			if (hwirq >= 0)
				break;
		}
155

156
157
158
159
160
161
162
163
164
165
		if (hwirq < 0) {
			rc = hwirq;
			pr_debug("%s: fail allocating msi interrupt\n",
					__func__);
			goto out_free;
		}

		virq = irq_create_mapping(msi_data->irqhost, hwirq);

		if (virq == NO_IRQ) {
166
			pr_debug("%s: fail mapping hwirq 0x%x\n",
167
					__func__, hwirq);
168
			msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);
169
170
171
			rc = -ENOSPC;
			goto out_free;
		}
172
		set_irq_data(virq, msi_data);
173
174
		set_irq_msi(virq, entry);

175
		fsl_compose_msi_msg(pdev, hwirq, &msg, msi_data);
176
177
178
179
180
		write_msi_msg(virq, &msg);
	}
	return 0;

out_free:
181
	/* free by the caller of this function */
182
183
184
	return rc;
}

185
static void fsl_msi_cascade(unsigned int irq, struct irq_desc *desc)
186
187
{
	unsigned int cascade_irq;
188
	struct fsl_msi *msi_data;
189
190
191
192
	int msir_index = -1;
	u32 msir_value = 0;
	u32 intr_index;
	u32 have_shift = 0;
193
194
195
196
	struct fsl_msi_cascade_data *cascade_data;

	cascade_data = (struct fsl_msi_cascade_data *)get_irq_data(irq);
	msi_data = cascade_data->msi_data;
197

198
	raw_spin_lock(&desc->lock);
199
200
201
202
203
204
205
206
207
208
209
210
	if ((msi_data->feature &  FSL_PIC_IP_MASK) == FSL_PIC_IP_IPIC) {
		if (desc->chip->mask_ack)
			desc->chip->mask_ack(irq);
		else {
			desc->chip->mask(irq);
			desc->chip->ack(irq);
		}
	}

	if (unlikely(desc->status & IRQ_INPROGRESS))
		goto unlock;

211
	msir_index = cascade_data->index;
212
213
214
215
216

	if (msir_index >= NR_MSI_REG)
		cascade_irq = NO_IRQ;

	desc->status |= IRQ_INPROGRESS;
217
	switch (msi_data->feature & FSL_PIC_IP_MASK) {
218
219
220
221
222
223
224
225
226
227
228
229
230
	case FSL_PIC_IP_MPIC:
		msir_value = fsl_msi_read(msi_data->msi_regs,
			msir_index * 0x10);
		break;
	case FSL_PIC_IP_IPIC:
		msir_value = fsl_msi_read(msi_data->msi_regs, msir_index * 0x4);
		break;
	}

	while (msir_value) {
		intr_index = ffs(msir_value) - 1;

		cascade_irq = irq_linear_revmap(msi_data->irqhost,
231
232
				msir_index * IRQS_PER_MSI_REG +
					intr_index + have_shift);
233
234
		if (cascade_irq != NO_IRQ)
			generic_handle_irq(cascade_irq);
235
236
		have_shift += intr_index + 1;
		msir_value = msir_value >> (intr_index + 1);
237
238
239
240
241
242
243
244
245
246
247
248
249
	}
	desc->status &= ~IRQ_INPROGRESS;

	switch (msi_data->feature & FSL_PIC_IP_MASK) {
	case FSL_PIC_IP_MPIC:
		desc->chip->eoi(irq);
		break;
	case FSL_PIC_IP_IPIC:
		if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
			desc->chip->unmask(irq);
		break;
	}
unlock:
250
	raw_spin_unlock(&desc->lock);
251
252
253
254
255
256
257
258
259
260
261
}

static int __devinit fsl_of_msi_probe(struct of_device *dev,
				const struct of_device_id *match)
{
	struct fsl_msi *msi;
	struct resource res;
	int err, i, count;
	int rc;
	int virt_msir;
	const u32 *p;
262
	struct fsl_msi_feature *features = match->data;
263
	struct fsl_msi_cascade_data *cascade_data = NULL;
264
265
	int len;
	u32 offset;
266
267
268
269
270
271
272
273
274
275

	printk(KERN_DEBUG "Setting up Freescale MSI support\n");

	msi = kzalloc(sizeof(struct fsl_msi), GFP_KERNEL);
	if (!msi) {
		dev_err(&dev->dev, "No memory for MSI structure\n");
		err = -ENOMEM;
		goto error_out;
	}

276
277
	msi->irqhost = irq_alloc_host(dev->node, IRQ_HOST_MAP_LINEAR,
				      NR_MSI_IRQS, &fsl_msi_host_ops, 0);
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298

	if (msi->irqhost == NULL) {
		dev_err(&dev->dev, "No memory for MSI irqhost\n");
		err = -ENOMEM;
		goto error_out;
	}

	/* Get the MSI reg base */
	err = of_address_to_resource(dev->node, 0, &res);
	if (err) {
		dev_err(&dev->dev, "%s resource error!\n",
				dev->node->full_name);
		goto error_out;
	}

	msi->msi_regs = ioremap(res.start, res.end - res.start + 1);
	if (!msi->msi_regs) {
		dev_err(&dev->dev, "ioremap problem failed\n");
		goto error_out;
	}

299
	msi->feature = features->fsl_pic_ip;
300
301
302
303

	msi->irqhost->host_data = msi;

	msi->msi_addr_hi = 0x0;
304
	msi->msi_addr_lo = features->msiir_offset + (res.start & 0xfffff);
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324

	rc = fsl_msi_init_allocator(msi);
	if (rc) {
		dev_err(&dev->dev, "Error allocating MSI bitmap\n");
		goto error_out;
	}

	p = of_get_property(dev->node, "interrupts", &count);
	if (!p) {
		dev_err(&dev->dev, "no interrupts property found on %s\n",
				dev->node->full_name);
		err = -ENODEV;
		goto error_out;
	}
	if (count % 8 != 0) {
		dev_err(&dev->dev, "Malformed interrupts property on %s\n",
				dev->node->full_name);
		err = -EINVAL;
		goto error_out;
	}
325
326
327
328
	offset = 0;
	p = of_get_property(dev->node, "msi-available-ranges", &len);
	if (p)
		offset = *p / IRQS_PER_MSI_REG;
329
330
331
332
333
334
335

	count /= sizeof(u32);
	for (i = 0; i < count / 2; i++) {
		if (i > NR_MSI_REG)
			break;
		virt_msir = irq_of_parse_and_map(dev->node, i);
		if (virt_msir != NO_IRQ) {
336
337
338
339
340
341
342
343
344
			cascade_data = kzalloc(
					sizeof(struct fsl_msi_cascade_data),
					GFP_KERNEL);
			if (!cascade_data) {
				dev_err(&dev->dev,
					"No memory for MSI cascade data\n");
				err = -ENOMEM;
				goto error_out;
			}
345
			cascade_data->index = i + offset;
346
347
			cascade_data->msi_data = msi;
			set_irq_data(virt_msir, (void *)cascade_data);
348
349
350
351
			set_irq_chained_handler(virt_msir, fsl_msi_cascade);
		}
	}

352
353
	list_add_tail(&msi->list, &msi_head);

354
355
356
357
358
359
360
361
362
363
	/* The multiple setting ppc_md.setup_msi_irqs will not harm things */
	if (!ppc_md.setup_msi_irqs) {
		ppc_md.setup_msi_irqs = fsl_setup_msi_irqs;
		ppc_md.teardown_msi_irqs = fsl_teardown_msi_irqs;
		ppc_md.msi_check_device = fsl_msi_check_device;
	} else if (ppc_md.setup_msi_irqs != fsl_setup_msi_irqs) {
		dev_err(&dev->dev, "Different MSI driver already installed!\n");
		err = -ENODEV;
		goto error_out;
	}
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
	return 0;
error_out:
	kfree(msi);
	return err;
}

static const struct fsl_msi_feature mpic_msi_feature = {
	.fsl_pic_ip = FSL_PIC_IP_MPIC,
	.msiir_offset = 0x140,
};

static const struct fsl_msi_feature ipic_msi_feature = {
	.fsl_pic_ip = FSL_PIC_IP_IPIC,
	.msiir_offset = 0x38,
};

static const struct of_device_id fsl_of_msi_ids[] = {
	{
		.compatible = "fsl,mpic-msi",
		.data = (void *)&mpic_msi_feature,
	},
	{
		.compatible = "fsl,ipic-msi",
		.data = (void *)&ipic_msi_feature,
	},
	{}
};

static struct of_platform_driver fsl_of_msi_driver = {
	.name = "fsl-msi",
	.match_table = fsl_of_msi_ids,
	.probe = fsl_of_msi_probe,
};

static __init int fsl_of_msi_init(void)
{
	return of_register_platform_driver(&fsl_of_msi_driver);
}

subsys_initcall(fsl_of_msi_init);