[deliverable/linux.git] / arch / powerpc / platforms / pseries / msi.c

/*
 * Copyright 2006 Jake Moilanen <moilanen@austin.ibm.com>, IBM Corp.
 * Copyright 2006-2007 Michael Ellerman, IBM Corp.
 *
 * 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/device.h>
#include <linux/irq.h>
#include <linux/msi.h>

#include <asm/rtas.h>
#include <asm/hw_irq.h>
#include <asm/ppc-pci.h>

static int query_token, change_token;

#define RTAS_QUERY_FN		0
#define RTAS_CHANGE_FN		1
#define RTAS_RESET_FN		2
#define RTAS_CHANGE_MSI_FN	3
#define RTAS_CHANGE_MSIX_FN	4

static struct pci_dn *get_pdn(struct pci_dev *pdev)
{
	struct device_node *dn;
	struct pci_dn *pdn;

	dn = pci_device_to_OF_node(pdev);
	if (!dn) {
		dev_dbg(&pdev->dev, "rtas_msi: No OF device node\n");
		return NULL;
	}

	pdn = PCI_DN(dn);
	if (!pdn) {
		dev_dbg(&pdev->dev, "rtas_msi: No PCI DN\n");
		return NULL;
	}

	return pdn;
}

/* RTAS Helpers */

static int rtas_change_msi(struct pci_dn *pdn, u32 func, u32 num_irqs)
{
	u32 addr, seq_num, rtas_ret[3];
	unsigned long buid;
	int rc;

	addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
	buid = pdn->phb->buid;

	seq_num = 1;
	do {
		if (func == RTAS_CHANGE_MSI_FN || func == RTAS_CHANGE_MSIX_FN)
			rc = rtas_call(change_token, 6, 4, rtas_ret, addr,
					BUID_HI(buid), BUID_LO(buid),
					func, num_irqs, seq_num);
		else
			rc = rtas_call(change_token, 6, 3, rtas_ret, addr,
					BUID_HI(buid), BUID_LO(buid),
					func, num_irqs, seq_num);

		seq_num = rtas_ret[1];
	} while (rtas_busy_delay(rc));

	/*
	 * If the RTAS call succeeded, check the number of irqs is actually
	 * what we asked for. If not, return an error.
	 */
	if (rc == 0 && rtas_ret[0] != num_irqs)
		rc = -ENOSPC;

	pr_debug("rtas_msi: ibm,change_msi(func=%d,num=%d), got %d rc = %d\n",
		 func, num_irqs, rtas_ret[0], rc);

	return rc;
}

static void rtas_disable_msi(struct pci_dev *pdev)
{
	struct pci_dn *pdn;

	pdn = get_pdn(pdev);
	if (!pdn)
		return;

	if (rtas_change_msi(pdn, RTAS_CHANGE_FN, 0))
		pr_debug("rtas_msi: Setting MSIs to 0 failed!\n");
}

static int rtas_query_irq_number(struct pci_dn *pdn, int offset)
{
	u32 addr, rtas_ret[2];
	unsigned long buid;
	int rc;

	addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
	buid = pdn->phb->buid;

	do {
		rc = rtas_call(query_token, 4, 3, rtas_ret, addr,
			       BUID_HI(buid), BUID_LO(buid), offset);
	} while (rtas_busy_delay(rc));

	if (rc) {
		pr_debug("rtas_msi: error (%d) querying source number\n", rc);
		return rc;
	}

	return rtas_ret[0];
}

static void rtas_teardown_msi_irqs(struct pci_dev *pdev)
{
	struct msi_desc *entry;

	list_for_each_entry(entry, &pdev->msi_list, list) {
		if (entry->irq == NO_IRQ)
			continue;

		set_irq_msi(entry->irq, NULL);
		irq_dispose_mapping(entry->irq);
	}

	rtas_disable_msi(pdev);
}

static int check_req_msi(struct pci_dev *pdev, int nvec)
{
	struct device_node *dn;
	struct pci_dn *pdn;
	const u32 *req_msi;

	pdn = get_pdn(pdev);
	if (!pdn)
		return -ENODEV;

	dn = pdn->node;

	req_msi = of_get_property(dn, "ibm,req#msi", NULL);
	if (!req_msi) {
		pr_debug("rtas_msi: No ibm,req#msi on %s\n", dn->full_name);
		return -ENOENT;
	}

	if (*req_msi < nvec) {
		pr_debug("rtas_msi: ibm,req#msi requests < %d MSIs\n", nvec);
		return -ENOSPC;
	}

	return 0;
}

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

	return check_req_msi(pdev, nvec);
}

static int rtas_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
{
	struct pci_dn *pdn;
	int hwirq, virq, i, rc;
	struct msi_desc *entry;

	pdn = get_pdn(pdev);
	if (!pdn)
		return -ENODEV;

	/*
	 * Try the new more explicit firmware interface, if that fails fall
	 * back to the old interface. The old interface is known to never
	 * return MSI-Xs.
	 */
	if (type == PCI_CAP_ID_MSI) {
		rc = rtas_change_msi(pdn, RTAS_CHANGE_MSI_FN, nvec);

		if (rc) {
			pr_debug("rtas_msi: trying the old firmware call.\n");
			rc = rtas_change_msi(pdn, RTAS_CHANGE_FN, nvec);
		}
	} else
		rc = rtas_change_msi(pdn, RTAS_CHANGE_MSIX_FN, nvec);

	if (rc) {
		pr_debug("rtas_msi: rtas_change_msi() failed\n");
		return rc;
	}

	i = 0;
	list_for_each_entry(entry, &pdev->msi_list, list) {
		hwirq = rtas_query_irq_number(pdn, i);
		if (hwirq < 0) {
			pr_debug("rtas_msi: error (%d) getting hwirq\n", rc);
			return hwirq;
		}

		virq = irq_create_mapping(NULL, hwirq);

		if (virq == NO_IRQ) {
			pr_debug("rtas_msi: Failed mapping hwirq %d\n", hwirq);
			return -ENOSPC;
		}

		dev_dbg(&pdev->dev, "rtas_msi: allocated virq %d\n", virq);
		set_irq_msi(virq, entry);
		unmask_msi_irq(virq);
	}

	return 0;
}

static void rtas_msi_pci_irq_fixup(struct pci_dev *pdev)
{
	/* No LSI -> leave MSIs (if any) configured */
	if (pdev->irq == NO_IRQ) {
		dev_dbg(&pdev->dev, "rtas_msi: no LSI, nothing to do.\n");
		return;
	}

	/* No MSI -> MSIs can't have been assigned by fw, leave LSI */
	if (check_req_msi(pdev, 1)) {
		dev_dbg(&pdev->dev, "rtas_msi: no req#msi, nothing to do.\n");
		return;
	}

	dev_dbg(&pdev->dev, "rtas_msi: disabling existing MSI.\n");
	rtas_disable_msi(pdev);
}

static int rtas_msi_init(void)
{
	query_token  = rtas_token("ibm,query-interrupt-source-number");
	change_token = rtas_token("ibm,change-msi");

	if ((query_token == RTAS_UNKNOWN_SERVICE) ||
			(change_token == RTAS_UNKNOWN_SERVICE)) {
		pr_debug("rtas_msi: no RTAS tokens, no MSI support.\n");
		return -1;
	}

	pr_debug("rtas_msi: Registering RTAS MSI callbacks.\n");

	WARN_ON(ppc_md.setup_msi_irqs);
	ppc_md.setup_msi_irqs = rtas_setup_msi_irqs;
	ppc_md.teardown_msi_irqs = rtas_teardown_msi_irqs;
	ppc_md.msi_check_device = rtas_msi_check_device;

	WARN_ON(ppc_md.pci_irq_fixup);
	ppc_md.pci_irq_fixup = rtas_msi_pci_irq_fixup;

	return 0;
}
arch_initcall(rtas_msi_init);
Commit	Line	Data
85f2bf9f ME	1	/*
	2	* Copyright 2006 Jake Moilanen <moilanen@austin.ibm.com>, IBM Corp.
	3	* Copyright 2006-2007 Michael Ellerman, IBM Corp.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License
	7	* as published by the Free Software Foundation; version 2 of the
	8	* License.
	9	*
	10	*/
	11
	12	#include <linux/device.h>
	13	#include <linux/irq.h>
	14	#include <linux/msi.h>
	15
	16	#include <asm/rtas.h>
	17	#include <asm/hw_irq.h>
	18	#include <asm/ppc-pci.h>
	19
	20	static int query_token, change_token;
	21
	22	#define RTAS_QUERY_FN 0
	23	#define RTAS_CHANGE_FN 1
	24	#define RTAS_RESET_FN 2
	25	#define RTAS_CHANGE_MSI_FN 3
	26	#define RTAS_CHANGE_MSIX_FN 4
	27
	28	static struct pci_dn get_pdn(struct pci_dev pdev)
	29	{
	30	struct device_node *dn;
	31	struct pci_dn *pdn;
	32
	33	dn = pci_device_to_OF_node(pdev);
	34	if (!dn) {
	35	dev_dbg(&pdev->dev, "rtas_msi: No OF device node\n");
	36	return NULL;
	37	}
	38
	39	pdn = PCI_DN(dn);
	40	if (!pdn) {
	41	dev_dbg(&pdev->dev, "rtas_msi: No PCI DN\n");
	42	return NULL;
	43	}
	44
	45	return pdn;
	46	}
	47
	48	/* RTAS Helpers */
	49
	50	static int rtas_change_msi(struct pci_dn *pdn, u32 func, u32 num_irqs)
	51	{
	52	u32 addr, seq_num, rtas_ret[3];
	53	unsigned long buid;
	54	int rc;
	55
	56	addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
	57	buid = pdn->phb->buid;
	58
	59	seq_num = 1;
	60	do {
	61	if (func == RTAS_CHANGE_MSI_FN \|\| func == RTAS_CHANGE_MSIX_FN)
	62	rc = rtas_call(change_token, 6, 4, rtas_ret, addr,
	63	BUID_HI(buid), BUID_LO(buid),
	64	func, num_irqs, seq_num);
65	else
66	rc = rtas_call(change_token, 6, 3, rtas_ret, addr,
67	BUID_HI(buid), BUID_LO(buid),
68	func, num_irqs, seq_num);
69
70	seq_num = rtas_ret[1];
71	} while (rtas_busy_delay(rc));
72
d385366a ME	73	/*
	74	* If the RTAS call succeeded, check the number of irqs is actually
	75	* what we asked for. If not, return an error.
	76	*/
	77	if (rc == 0 && rtas_ret[0] != num_irqs)
	78	rc = -ENOSPC;
85f2bf9f	79
d385366a ME	80	pr_debug("rtas_msi: ibm,change_msi(func=%d,num=%d), got %d rc = %d\n",
d385366a ME	81	func, num_irqs, rtas_ret[0], rc);
85f2bf9f ME	82
	83	return rc;
	84	}
	85
	86	static void rtas_disable_msi(struct pci_dev *pdev)
	87	{
	88	struct pci_dn *pdn;
	89
	90	pdn = get_pdn(pdev);
	91	if (!pdn)
	92	return;
	93
d385366a	94	if (rtas_change_msi(pdn, RTAS_CHANGE_FN, 0))
85f2bf9f ME	95	pr_debug("rtas_msi: Setting MSIs to 0 failed!\n");
	96	}
	97
	98	static int rtas_query_irq_number(struct pci_dn *pdn, int offset)
	99	{
	100	u32 addr, rtas_ret[2];
	101	unsigned long buid;
	102	int rc;
	103
	104	addr = rtas_config_addr(pdn->busno, pdn->devfn, 0);
	105	buid = pdn->phb->buid;
	106
	107	do {
	108	rc = rtas_call(query_token, 4, 3, rtas_ret, addr,
	109	BUID_HI(buid), BUID_LO(buid), offset);
	110	} while (rtas_busy_delay(rc));
	111
	112	if (rc) {
	113	pr_debug("rtas_msi: error (%d) querying source number\n", rc);
	114	return rc;
	115	}
	116
	117	return rtas_ret[0];
	118	}
	119
	120	static void rtas_teardown_msi_irqs(struct pci_dev *pdev)
	121	{
	122	struct msi_desc *entry;
	123
	124	list_for_each_entry(entry, &pdev->msi_list, list) {
	125	if (entry->irq == NO_IRQ)
	126	continue;
	127
	128	set_irq_msi(entry->irq, NULL);
	129	irq_dispose_mapping(entry->irq);
	130	}
	131
	132	rtas_disable_msi(pdev);
	133	}
	134
	135	static int check_req_msi(struct pci_dev *pdev, int nvec)
	136	{
	137	struct device_node *dn;
	138	struct pci_dn *pdn;
	139	const u32 *req_msi;
	140
	141	pdn = get_pdn(pdev);
	142	if (!pdn)
	143	return -ENODEV;
	144
	145	dn = pdn->node;
	146
	147	req_msi = of_get_property(dn, "ibm,req#msi", NULL);
	148	if (!req_msi) {
	149	pr_debug("rtas_msi: No ibm,req#msi on %s\n", dn->full_name);
	150	return -ENOENT;
	151	}
	152
	153	if (*req_msi < nvec) {
	154	pr_debug("rtas_msi: ibm,req#msi requests < %d MSIs\n", nvec);
	155	return -ENOSPC;
	156	}
	157
	158	return 0;
159	}
160
161	static int rtas_msi_check_device(struct pci_dev *pdev, int nvec, int type)
162	{
163	if (type == PCI_CAP_ID_MSIX)
164	pr_debug("rtas_msi: MSI-X untested, trying anyway.\n");
165
166	return check_req_msi(pdev, nvec);
167	}
168
169	static int rtas_setup_msi_irqs(struct pci_dev *pdev, int nvec, int type)
170	{
171	struct pci_dn *pdn;
172	int hwirq, virq, i, rc;
173	struct msi_desc *entry;
174
175	pdn = get_pdn(pdev);
176	if (!pdn)
177	return -ENODEV;
178
179	/*
180	* Try the new more explicit firmware interface, if that fails fall
181	* back to the old interface. The old interface is known to never
182	* return MSI-Xs.
183	*/
184	if (type == PCI_CAP_ID_MSI) {
185	rc = rtas_change_msi(pdn, RTAS_CHANGE_MSI_FN, nvec);
186
d385366a	187	if (rc) {
85f2bf9f ME	188	pr_debug("rtas_msi: trying the old firmware call.\n");
	189	rc = rtas_change_msi(pdn, RTAS_CHANGE_FN, nvec);
	190	}
	191	} else
	192	rc = rtas_change_msi(pdn, RTAS_CHANGE_MSIX_FN, nvec);
	193
d385366a	194	if (rc) {
85f2bf9f	195	pr_debug("rtas_msi: rtas_change_msi() failed\n");
fcbe8090	196	return rc;
85f2bf9f ME	197	}
	198
	199	i = 0;
	200	list_for_each_entry(entry, &pdev->msi_list, list) {
	201	hwirq = rtas_query_irq_number(pdn, i);
	202	if (hwirq < 0) {
85f2bf9f	203	pr_debug("rtas_msi: error (%d) getting hwirq\n", rc);
fcbe8090	204	return hwirq;
85f2bf9f ME	205	}
	206
	207	virq = irq_create_mapping(NULL, hwirq);
	208
	209	if (virq == NO_IRQ) {
	210	pr_debug("rtas_msi: Failed mapping hwirq %d\n", hwirq);
fcbe8090	211	return -ENOSPC;
85f2bf9f ME	212	}
	213
	214	dev_dbg(&pdev->dev, "rtas_msi: allocated virq %d\n", virq);
	215	set_irq_msi(virq, entry);
	216	unmask_msi_irq(virq);
	217	}
	218
	219	return 0;
85f2bf9f ME	220	}
	221
	222	static void rtas_msi_pci_irq_fixup(struct pci_dev *pdev)
	223	{
	224	/* No LSI -> leave MSIs (if any) configured */
	225	if (pdev->irq == NO_IRQ) {
	226	dev_dbg(&pdev->dev, "rtas_msi: no LSI, nothing to do.\n");
	227	return;
	228	}
	229
	230	/* No MSI -> MSIs can't have been assigned by fw, leave LSI */
	231	if (check_req_msi(pdev, 1)) {
	232	dev_dbg(&pdev->dev, "rtas_msi: no req#msi, nothing to do.\n");
	233	return;
	234	}
	235
	236	dev_dbg(&pdev->dev, "rtas_msi: disabling existing MSI.\n");
	237	rtas_disable_msi(pdev);
	238	}
	239
	240	static int rtas_msi_init(void)
	241	{
	242	query_token = rtas_token("ibm,query-interrupt-source-number");
	243	change_token = rtas_token("ibm,change-msi");
	244
	245	if ((query_token == RTAS_UNKNOWN_SERVICE) \|\|
	246	(change_token == RTAS_UNKNOWN_SERVICE)) {
	247	pr_debug("rtas_msi: no RTAS tokens, no MSI support.\n");
	248	return -1;
	249	}
	250
	251	pr_debug("rtas_msi: Registering RTAS MSI callbacks.\n");
	252
	253	WARN_ON(ppc_md.setup_msi_irqs);
	254	ppc_md.setup_msi_irqs = rtas_setup_msi_irqs;
	255	ppc_md.teardown_msi_irqs = rtas_teardown_msi_irqs;
	256	ppc_md.msi_check_device = rtas_msi_check_device;
	257
	258	WARN_ON(ppc_md.pci_irq_fixup);
	259	ppc_md.pci_irq_fixup = rtas_msi_pci_irq_fixup;
	260
	261	return 0;
	262	}
	263	arch_initcall(rtas_msi_init);