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_set_status_flags(virq, 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
187
	struct irq_chip *chip = irq_desc_get_chip(desc);
	struct irq_data *idata = irq_desc_get_irq_data(desc);
188
	unsigned int cascade_irq;
189
	struct fsl_msi *msi_data;
190
191
192
193
	int msir_index = -1;
	u32 msir_value = 0;
	u32 intr_index;
	u32 have_shift = 0;
194
195
196
197
	struct fsl_msi_cascade_data *cascade_data;

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

199
	raw_spin_lock(&desc->lock);
200
	if ((msi_data->feature &  FSL_PIC_IP_MASK) == FSL_PIC_IP_IPIC) {
201
		if (chip->irq_mask_ack)
202
			chip->irq_mask_ack(idata);
203
		else {
204
205
			chip->irq_mask(idata);
			chip->irq_ack(idata);
206
207
208
		}
	}

209
	if (unlikely(irqd_irq_inprogress(idata)))
210
211
		goto unlock;

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

	if (msir_index >= NR_MSI_REG)
		cascade_irq = NO_IRQ;

217
	irqd_set_chained_irq_inprogress(idata);
218
	switch (msi_data->feature & FSL_PIC_IP_MASK) {
219
220
221
222
223
224
225
226
227
228
229
230
231
	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,
232
233
				msir_index * IRQS_PER_MSI_REG +
					intr_index + have_shift);
234
235
		if (cascade_irq != NO_IRQ)
			generic_handle_irq(cascade_irq);
236
237
		have_shift += intr_index + 1;
		msir_value = msir_value >> (intr_index + 1);
238
	}
239
	irqd_clr_chained_irq_inprogress(idata);
240
241
242

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

254
static int fsl_of_msi_remove(struct platform_device *ofdev)
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
{
	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;
}

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

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

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

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

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

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

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

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

	msi->irqhost->host_data = msi;

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

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

368
369
370
371
	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__);
372
373
374
		err = -EINVAL;
		goto error_out;
	}
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394

	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)
395
				goto error_out;
396
397
398
		}
	}

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

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

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

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

subsys_initcall(fsl_of_msi_init);