1/*
2 * irqchip.c: Common API for in kernel interrupt controllers
3 * Copyright (c) 2007, Intel Corporation.
4 * Copyright 2010 Red Hat, Inc. and/or its affiliates.
5 * Copyright (c) 2013, Alexander Graf <agraf@suse.de>
6 *
7 * This program is free software; you can redistribute it and/or modify it
8 * under the terms and conditions of the GNU General Public License,
9 * version 2, as published by the Free Software Foundation.
10 *
11 * This program is distributed in the hope it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14 * more details.
15 *
16 * You should have received a copy of the GNU General Public License along with
17 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
18 * Place - Suite 330, Boston, MA 02111-1307 USA.
19 *
20 * This file is derived from virt/kvm/irq_comm.c.
21 *
22 * Authors:
23 *   Yaozu (Eddie) Dong <Eddie.dong@intel.com>
24 *   Alexander Graf <agraf@suse.de>
25 */
26
27#include <linux/kvm_host.h>
28#include <linux/slab.h>
29#include <linux/srcu.h>
30#include <linux/export.h>
31#include <trace/events/kvm.h>
32#include "irq.h"
33
34struct kvm_irq_routing_table {
35	int chip[KVM_NR_IRQCHIPS][KVM_IRQCHIP_NUM_PINS];
36	struct kvm_kernel_irq_routing_entry *rt_entries;
37	u32 nr_rt_entries;
38	/*
39	 * Array indexed by gsi. Each entry contains list of irq chips
40	 * the gsi is connected to.
41	 */
42	struct hlist_head map[0];
43};
44
45int kvm_irq_map_gsi(struct kvm *kvm,
46		    struct kvm_kernel_irq_routing_entry *entries, int gsi)
47{
48	struct kvm_irq_routing_table *irq_rt;
49	struct kvm_kernel_irq_routing_entry *e;
50	int n = 0;
51
52	irq_rt = srcu_dereference_check(kvm->irq_routing, &kvm->irq_srcu,
53					lockdep_is_held(&kvm->irq_lock));
54	if (irq_rt && gsi < irq_rt->nr_rt_entries) {
55		hlist_for_each_entry(e, &irq_rt->map[gsi], link) {
56			entries[n] = *e;
57			++n;
58		}
59	}
60
61	return n;
62}
63
64int kvm_irq_map_chip_pin(struct kvm *kvm, unsigned irqchip, unsigned pin)
65{
66	struct kvm_irq_routing_table *irq_rt;
67
68	irq_rt = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu);
69	return irq_rt->chip[irqchip][pin];
70}
71
72int kvm_send_userspace_msi(struct kvm *kvm, struct kvm_msi *msi)
73{
74	struct kvm_kernel_irq_routing_entry route;
75
76	if (!irqchip_in_kernel(kvm) || msi->flags != 0)
77		return -EINVAL;
78
79	route.msi.address_lo = msi->address_lo;
80	route.msi.address_hi = msi->address_hi;
81	route.msi.data = msi->data;
82
83	return kvm_set_msi(&route, kvm, KVM_USERSPACE_IRQ_SOURCE_ID, 1, false);
84}
85
86/*
87 * Return value:
88 *  < 0   Interrupt was ignored (masked or not delivered for other reasons)
89 *  = 0   Interrupt was coalesced (previous irq is still pending)
90 *  > 0   Number of CPUs interrupt was delivered to
91 */
92int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level,
93		bool line_status)
94{
95	struct kvm_kernel_irq_routing_entry irq_set[KVM_NR_IRQCHIPS];
96	int ret = -1, i, idx;
97
98	trace_kvm_set_irq(irq, level, irq_source_id);
99
100	/* Not possible to detect if the guest uses the PIC or the
101	 * IOAPIC.  So set the bit in both. The guest will ignore
102	 * writes to the unused one.
103	 */
104	idx = srcu_read_lock(&kvm->irq_srcu);
105	i = kvm_irq_map_gsi(kvm, irq_set, irq);
106	srcu_read_unlock(&kvm->irq_srcu, idx);
107
108	while (i--) {
109		int r;
110		r = irq_set[i].set(&irq_set[i], kvm, irq_source_id, level,
111				   line_status);
112		if (r < 0)
113			continue;
114
115		ret = r + ((ret < 0) ? 0 : ret);
116	}
117
118	return ret;
119}
120
121void kvm_free_irq_routing(struct kvm *kvm)
122{
123	/* Called only during vm destruction. Nobody can use the pointer
124	   at this stage */
125	kfree(kvm->irq_routing);
126}
127
128static int setup_routing_entry(struct kvm_irq_routing_table *rt,
129			       struct kvm_kernel_irq_routing_entry *e,
130			       const struct kvm_irq_routing_entry *ue)
131{
132	int r = -EINVAL;
133	struct kvm_kernel_irq_routing_entry *ei;
134
135	/*
136	 * Do not allow GSI to be mapped to the same irqchip more than once.
137	 * Allow only one to one mapping between GSI and MSI.
138	 */
139	hlist_for_each_entry(ei, &rt->map[ue->gsi], link)
140		if (ei->type == KVM_IRQ_ROUTING_MSI ||
141		    ue->type == KVM_IRQ_ROUTING_MSI ||
142		    ue->u.irqchip.irqchip == ei->irqchip.irqchip)
143			return r;
144
145	e->gsi = ue->gsi;
146	e->type = ue->type;
147	r = kvm_set_routing_entry(e, ue);
148	if (r)
149		goto out;
150	if (e->type == KVM_IRQ_ROUTING_IRQCHIP)
151		rt->chip[e->irqchip.irqchip][e->irqchip.pin] = e->gsi;
152
153	hlist_add_head(&e->link, &rt->map[e->gsi]);
154	r = 0;
155out:
156	return r;
157}
158
159int kvm_set_irq_routing(struct kvm *kvm,
160			const struct kvm_irq_routing_entry *ue,
161			unsigned nr,
162			unsigned flags)
163{
164	struct kvm_irq_routing_table *new, *old;
165	u32 i, j, nr_rt_entries = 0;
166	int r;
167
168	for (i = 0; i < nr; ++i) {
169		if (ue[i].gsi >= KVM_MAX_IRQ_ROUTES)
170			return -EINVAL;
171		nr_rt_entries = max(nr_rt_entries, ue[i].gsi);
172	}
173
174	nr_rt_entries += 1;
175
176	new = kzalloc(sizeof(*new) + (nr_rt_entries * sizeof(struct hlist_head))
177		      + (nr * sizeof(struct kvm_kernel_irq_routing_entry)),
178		      GFP_KERNEL);
179
180	if (!new)
181		return -ENOMEM;
182
183	new->rt_entries = (void *)&new->map[nr_rt_entries];
184
185	new->nr_rt_entries = nr_rt_entries;
186	for (i = 0; i < KVM_NR_IRQCHIPS; i++)
187		for (j = 0; j < KVM_IRQCHIP_NUM_PINS; j++)
188			new->chip[i][j] = -1;
189
190	for (i = 0; i < nr; ++i) {
191		r = -EINVAL;
192		if (ue->flags)
193			goto out;
194		r = setup_routing_entry(new, &new->rt_entries[i], ue);
195		if (r)
196			goto out;
197		++ue;
198	}
199
200	mutex_lock(&kvm->irq_lock);
201	old = kvm->irq_routing;
202	rcu_assign_pointer(kvm->irq_routing, new);
203	kvm_irq_routing_update(kvm);
204	mutex_unlock(&kvm->irq_lock);
205
206	synchronize_srcu_expedited(&kvm->irq_srcu);
207
208	new = old;
209	r = 0;
210
211out:
212	kfree(new);
213	return r;
214}
215