fsl_msi.c 9 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
28
29
30
31
32
#include "fsl_msi.h"

struct fsl_msi_feature {
	u32 fsl_pic_ip;
	u32 msiir_offset;
};

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

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,
55
	.name		= "FSL-MSI",
56
57
58
59
60
};

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

64
	irq_to_desc(virq)->status |= IRQ_TYPE_EDGE_FALLING;
65

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

	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)
{
78
	int rc;
79

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

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

	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;
105
	struct fsl_msi *msi_data;
106
107
108
109

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

	return;
}

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

128
129
130
131
	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;
132
133
134
135
136
137
138
139
140
	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)
{
141
	int rc, hwirq = NO_IRQ;
142
143
144
	unsigned int virq;
	struct msi_desc *entry;
	struct msi_msg msg;
145
	struct fsl_msi *msi_data;
146
147

	list_for_each_entry(entry, &pdev->msi_list, list) {
148
149
		msi_data = get_irq_chip_data(entry->irq);

150
		hwirq = msi_bitmap_alloc_hwirqs(&msi_data->bitmap, 1);
151
152
153
154
155
156
157
158
159
160
		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) {
161
			pr_debug("%s: fail mapping hwirq 0x%x\n",
162
					__func__, hwirq);
163
			msi_bitmap_free_hwirqs(&msi_data->bitmap, hwirq, 1);
164
165
166
			rc = -ENOSPC;
			goto out_free;
		}
167
		set_irq_data(virq, msi_data);
168
169
		set_irq_msi(virq, entry);

170
		fsl_compose_msi_msg(pdev, hwirq, &msg, msi_data);
171
172
173
174
175
176
177
178
		write_msi_msg(virq, &msg);
	}
	return 0;

out_free:
	return rc;
}

179
static void fsl_msi_cascade(unsigned int irq, struct irq_desc *desc)
180
181
{
	unsigned int cascade_irq;
182
	struct fsl_msi *msi_data;
183
184
185
186
	int msir_index = -1;
	u32 msir_value = 0;
	u32 intr_index;
	u32 have_shift = 0;
187
188
189
190
	struct fsl_msi_cascade_data *cascade_data;

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

192
	raw_spin_lock(&desc->lock);
193
194
195
196
197
198
199
200
201
202
203
204
	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;

205
	msir_index = cascade_data->index;
206
207
208
209
210

	if (msir_index >= NR_MSI_REG)
		cascade_irq = NO_IRQ;

	desc->status |= IRQ_INPROGRESS;
211
	switch (msi_data->feature & FSL_PIC_IP_MASK) {
212
213
214
215
216
217
218
219
220
221
222
223
224
	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,
225
226
				msir_index * IRQS_PER_MSI_REG +
					intr_index + have_shift);
227
228
		if (cascade_irq != NO_IRQ)
			generic_handle_irq(cascade_irq);
229
230
		have_shift += intr_index + 1;
		msir_value = msir_value >> (intr_index + 1);
231
232
233
234
235
236
237
238
239
240
241
242
243
	}
	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:
244
	raw_spin_unlock(&desc->lock);
245
246
247
248
249
250
251
252
253
254
255
}

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;
256
	struct fsl_msi_feature *features = match->data;
257
	struct fsl_msi_cascade_data *cascade_data = NULL;
258
259
260
261
262
263
264
265
266
267

	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;
	}

268
269
	msi->irqhost = irq_alloc_host(dev->node, IRQ_HOST_MAP_LINEAR,
				      NR_MSI_IRQS, &fsl_msi_host_ops, 0);
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290

	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;
	}

291
	msi->feature = features->fsl_pic_ip;
292
293
294
295

	msi->irqhost->host_data = msi;

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

	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;
	}

	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) {
324
325
326
327
328
329
330
331
332
333
334
335
			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;
			}
			cascade_data->index = i;
			cascade_data->msi_data = msi;
			set_irq_data(virt_msir, (void *)cascade_data);
336
337
338
339
			set_irq_chained_handler(virt_msir, fsl_msi_cascade);
		}
	}

340
341
342
343
344
345
346
347
348
349
	/* 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;
	}
350
351
352
353
354
355
356
357
358
359
360
361
362
363
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
	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);