fsl_msi.c 10.6 KB
Newer Older
1
/*
2
 * Copyright (C) 2007-2011 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
#include "fsl_msi.h"
27
#include "fsl_pci.h"
28

29
30
LIST_HEAD(msi_head);

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

36
37
38
39
struct fsl_msi_cascade_data {
	struct fsl_msi *msi_data;
	int index;
};
40
41
42
43
44
45
46
47
48
49

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
*/
50
static void fsl_msi_end_irq(struct irq_data *d)
51
52
53
54
{
}

static struct irq_chip fsl_msi_chip = {
55
56
	.irq_mask	= mask_msi_irq,
	.irq_unmask	= unmask_msi_irq,
57
	.irq_ack	= fsl_msi_end_irq,
58
	.name		= "FSL-MSI",
59
60
61
62
63
};

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

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

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

	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)
{
81
	int rc;
82

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

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

	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;
108
	struct fsl_msi *msi_data;
109
110
111
112

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

	return;
}

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

131
132
	msg->address_lo = msi_data->msi_addr_lo + lower_32_bits(base);
	msg->address_hi = msi_data->msi_addr_hi + upper_32_bits(base);
133

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

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

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

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

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

184
static void fsl_msi_cascade(unsigned int irq, struct irq_desc *desc)
185
{
186
	struct irq_chip *chip = get_irq_desc_chip(desc);
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
	if ((msi_data->feature &  FSL_PIC_IP_MASK) == FSL_PIC_IP_IPIC) {
200
201
		if (chip->irq_mask_ack)
			chip->irq_mask_ack(&desc->irq_data);
202
		else {
203
204
			chip->irq_mask(&desc->irq_data);
			chip->irq_ack(&desc->irq_data);
205
206
207
208
209
210
		}
	}

	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
	}
	desc->status &= ~IRQ_INPROGRESS;

	switch (msi_data->feature & FSL_PIC_IP_MASK) {
	case FSL_PIC_IP_MPIC:
242
		chip->irq_eoi(&desc->irq_data);
243
244
		break;
	case FSL_PIC_IP_IPIC:
245
246
		if (!(desc->status & IRQ_DISABLED) && chip->irq_unmask)
			chip->irq_unmask(&desc->irq_data);
247
248
249
		break;
	}
unlock:
250
	raw_spin_unlock(&desc->lock);
251
252
}

253
static int fsl_of_msi_remove(struct platform_device *ofdev)
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
{
	struct fsl_msi *msi = ofdev->dev.platform_data;
	int virq, i;
	struct fsl_msi_cascade_data *cascade_data;

	if (msi->list.prev != NULL)
		list_del(&msi->list);
	for (i = 0; i < NR_MSI_REG; i++) {
		virq = msi->msi_virqs[i];
		if (virq != NO_IRQ) {
			cascade_data = get_irq_data(virq);
			kfree(cascade_data);
			irq_dispose_mapping(virq);
		}
	}
	if (msi->bitmap.bitmap)
		msi_bitmap_free(&msi->bitmap);
	iounmap(msi->msi_regs);
	kfree(msi);

	return 0;
}

277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
static int __devinit fsl_msi_setup_hwirq(struct fsl_msi *msi,
					 struct platform_device *dev,
					 int offset, int irq_index)
{
	struct fsl_msi_cascade_data *cascade_data = NULL;
	int virt_msir;

	virt_msir = irq_of_parse_and_map(dev->dev.of_node, irq_index);
	if (virt_msir == NO_IRQ) {
		dev_err(&dev->dev, "%s: Cannot translate IRQ index %d\n",
			__func__, irq_index);
		return 0;
	}

	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");
		return -ENOMEM;
	}

	msi->msi_virqs[irq_index] = virt_msir;
	cascade_data->index = offset + irq_index;
	cascade_data->msi_data = msi;
	set_irq_data(virt_msir, cascade_data);
	set_irq_chained_handler(virt_msir, fsl_msi_cascade);

	return 0;
}

306
static int __devinit fsl_of_msi_probe(struct platform_device *dev)
307
308
309
{
	struct fsl_msi *msi;
	struct resource res;
310
	int err, i, j, irq_index, count;
311
312
	int rc;
	const u32 *p;
313
	struct fsl_msi_feature *features;
314
315
	int len;
	u32 offset;
316
	static const u32 all_avail[] = { 0, NR_MSI_IRQS };
317

318
319
320
321
	if (!dev->dev.of_match)
		return -EINVAL;
	features = dev->dev.of_match->data;

322
323
324
325
326
	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");
327
		return -ENOMEM;
328
	}
329
	dev->dev.platform_data = msi;
330

331
	msi->irqhost = irq_alloc_host(dev->dev.of_node, IRQ_HOST_MAP_LINEAR,
332
				      NR_MSI_IRQS, &fsl_msi_host_ops, 0);
333
334
335
336
337
338
339
340

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

	/* Get the MSI reg base */
341
	err = of_address_to_resource(dev->dev.of_node, 0, &res);
342
343
	if (err) {
		dev_err(&dev->dev, "%s resource error!\n",
344
				dev->dev.of_node->full_name);
345
346
347
348
349
350
351
352
353
		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;
	}

354
	msi->feature = features->fsl_pic_ip;
355
356
357
358

	msi->irqhost->host_data = msi;

	msi->msi_addr_hi = 0x0;
359
	msi->msi_addr_lo = features->msiir_offset + (res.start & 0xfffff);
360
361
362
363
364
365
366

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

367
368
369
370
	p = of_get_property(dev->dev.of_node, "msi-available-ranges", &len);
	if (p && len % (2 * sizeof(u32)) != 0) {
		dev_err(&dev->dev, "%s: Malformed msi-available-ranges property\n",
			__func__);
371
372
373
		err = -EINVAL;
		goto error_out;
	}
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393

	if (!p)
		p = all_avail;

	for (irq_index = 0, i = 0; i < len / (2 * sizeof(u32)); i++) {
		if (p[i * 2] % IRQS_PER_MSI_REG ||
		    p[i * 2 + 1] % IRQS_PER_MSI_REG) {
			printk(KERN_WARNING "%s: %s: msi available range of %u at %u is not IRQ-aligned\n",
			       __func__, dev->dev.of_node->full_name,
			       p[i * 2 + 1], p[i * 2]);
			err = -EINVAL;
			goto error_out;
		}

		offset = p[i * 2] / IRQS_PER_MSI_REG;
		count = p[i * 2 + 1] / IRQS_PER_MSI_REG;

		for (j = 0; j < count; j++, irq_index++) {
			err = fsl_msi_setup_hwirq(msi, dev, offset, irq_index);
			if (err)
394
				goto error_out;
395
396
397
		}
	}

398
	list_add_tail(&msi->list, &msi_head);
399

400
401
402
403
404
405
406
407
408
409
	/* 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;
	}
410
411
	return 0;
error_out:
412
	fsl_of_msi_remove(dev);
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
	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,
	},
	{}
};

438
static struct platform_driver fsl_of_msi_driver = {
439
440
441
442
443
	.driver = {
		.name = "fsl-msi",
		.owner = THIS_MODULE,
		.of_match_table = fsl_of_msi_ids,
	},
444
	.probe = fsl_of_msi_probe,
445
	.remove = fsl_of_msi_remove,
446
447
448
449
};

static __init int fsl_of_msi_init(void)
{
450
	return platform_driver_register(&fsl_of_msi_driver);
451
452
453
}

subsys_initcall(fsl_of_msi_init);