1 /*
2  * Copyright (C) 2016 ARM Limited, All Rights Reserved.
3  * Author: Marc Zyngier <marc.zyngier@arm.com>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
16  */
17 
18 #include <linux/bitops.h>
19 #include <linux/interrupt.h>
20 #include <linux/irqchip.h>
21 #include <linux/irqchip/chained_irq.h>
22 #include <linux/irqchip/irq-partition-percpu.h>
23 #include <linux/irqdomain.h>
24 #include <linux/seq_file.h>
25 #include <linux/slab.h>
26 
27 struct partition_desc {
28 	int				nr_parts;
29 	struct partition_affinity	*parts;
30 	struct irq_domain		*domain;
31 	struct irq_desc			*chained_desc;
32 	unsigned long			*bitmap;
33 	struct irq_domain_ops		ops;
34 };
35 
36 static bool partition_check_cpu(struct partition_desc *part,
37 				unsigned int cpu, unsigned int hwirq)
38 {
39 	return cpumask_test_cpu(cpu, &part->parts[hwirq].mask);
40 }
41 
42 static void partition_irq_mask(struct irq_data *d)
43 {
44 	struct partition_desc *part = irq_data_get_irq_chip_data(d);
45 	struct irq_chip *chip = irq_desc_get_chip(part->chained_desc);
46 	struct irq_data *data = irq_desc_get_irq_data(part->chained_desc);
47 
48 	if (partition_check_cpu(part, smp_processor_id(), d->hwirq) &&
49 	    chip->irq_mask)
50 		chip->irq_mask(data);
51 }
52 
53 static void partition_irq_unmask(struct irq_data *d)
54 {
55 	struct partition_desc *part = irq_data_get_irq_chip_data(d);
56 	struct irq_chip *chip = irq_desc_get_chip(part->chained_desc);
57 	struct irq_data *data = irq_desc_get_irq_data(part->chained_desc);
58 
59 	if (partition_check_cpu(part, smp_processor_id(), d->hwirq) &&
60 	    chip->irq_unmask)
61 		chip->irq_unmask(data);
62 }
63 
64 static int partition_irq_set_irqchip_state(struct irq_data *d,
65 					   enum irqchip_irq_state which,
66 					   bool val)
67 {
68 	struct partition_desc *part = irq_data_get_irq_chip_data(d);
69 	struct irq_chip *chip = irq_desc_get_chip(part->chained_desc);
70 	struct irq_data *data = irq_desc_get_irq_data(part->chained_desc);
71 
72 	if (partition_check_cpu(part, smp_processor_id(), d->hwirq) &&
73 	    chip->irq_set_irqchip_state)
74 		return chip->irq_set_irqchip_state(data, which, val);
75 
76 	return -EINVAL;
77 }
78 
79 static int partition_irq_get_irqchip_state(struct irq_data *d,
80 					   enum irqchip_irq_state which,
81 					   bool *val)
82 {
83 	struct partition_desc *part = irq_data_get_irq_chip_data(d);
84 	struct irq_chip *chip = irq_desc_get_chip(part->chained_desc);
85 	struct irq_data *data = irq_desc_get_irq_data(part->chained_desc);
86 
87 	if (partition_check_cpu(part, smp_processor_id(), d->hwirq) &&
88 	    chip->irq_get_irqchip_state)
89 		return chip->irq_get_irqchip_state(data, which, val);
90 
91 	return -EINVAL;
92 }
93 
94 static int partition_irq_set_type(struct irq_data *d, unsigned int type)
95 {
96 	struct partition_desc *part = irq_data_get_irq_chip_data(d);
97 	struct irq_chip *chip = irq_desc_get_chip(part->chained_desc);
98 	struct irq_data *data = irq_desc_get_irq_data(part->chained_desc);
99 
100 	if (chip->irq_set_type)
101 		return chip->irq_set_type(data, type);
102 
103 	return -EINVAL;
104 }
105 
106 static void partition_irq_print_chip(struct irq_data *d, struct seq_file *p)
107 {
108 	struct partition_desc *part = irq_data_get_irq_chip_data(d);
109 	struct irq_chip *chip = irq_desc_get_chip(part->chained_desc);
110 	struct irq_data *data = irq_desc_get_irq_data(part->chained_desc);
111 
112 	seq_printf(p, " %5s-%lu", chip->name, data->hwirq);
113 }
114 
115 static struct irq_chip partition_irq_chip = {
116 	.irq_mask		= partition_irq_mask,
117 	.irq_unmask		= partition_irq_unmask,
118 	.irq_set_type		= partition_irq_set_type,
119 	.irq_get_irqchip_state	= partition_irq_get_irqchip_state,
120 	.irq_set_irqchip_state	= partition_irq_set_irqchip_state,
121 	.irq_print_chip		= partition_irq_print_chip,
122 };
123 
124 static void partition_handle_irq(struct irq_desc *desc)
125 {
126 	struct partition_desc *part = irq_desc_get_handler_data(desc);
127 	struct irq_chip *chip = irq_desc_get_chip(desc);
128 	int cpu = smp_processor_id();
129 	int hwirq;
130 
131 	chained_irq_enter(chip, desc);
132 
133 	for_each_set_bit(hwirq, part->bitmap, part->nr_parts) {
134 		if (partition_check_cpu(part, cpu, hwirq))
135 			break;
136 	}
137 
138 	if (unlikely(hwirq == part->nr_parts)) {
139 		handle_bad_irq(desc);
140 	} else {
141 		unsigned int irq;
142 		irq = irq_find_mapping(part->domain, hwirq);
143 		generic_handle_irq(irq);
144 	}
145 
146 	chained_irq_exit(chip, desc);
147 }
148 
149 static int partition_domain_alloc(struct irq_domain *domain, unsigned int virq,
150 				  unsigned int nr_irqs, void *arg)
151 {
152 	int ret;
153 	irq_hw_number_t hwirq;
154 	unsigned int type;
155 	struct irq_fwspec *fwspec = arg;
156 	struct partition_desc *part;
157 
158 	BUG_ON(nr_irqs != 1);
159 	ret = domain->ops->translate(domain, fwspec, &hwirq, &type);
160 	if (ret)
161 		return ret;
162 
163 	part = domain->host_data;
164 
165 	set_bit(hwirq, part->bitmap);
166 	irq_set_chained_handler_and_data(irq_desc_get_irq(part->chained_desc),
167 					 partition_handle_irq, part);
168 	irq_set_percpu_devid_partition(virq, &part->parts[hwirq].mask);
169 	irq_domain_set_info(domain, virq, hwirq, &partition_irq_chip, part,
170 			    handle_percpu_devid_irq, NULL, NULL);
171 	irq_set_status_flags(virq, IRQ_NOAUTOEN);
172 
173 	return 0;
174 }
175 
176 static void partition_domain_free(struct irq_domain *domain, unsigned int virq,
177 				  unsigned int nr_irqs)
178 {
179 	struct irq_data *d;
180 
181 	BUG_ON(nr_irqs != 1);
182 
183 	d = irq_domain_get_irq_data(domain, virq);
184 	irq_set_handler(virq, NULL);
185 	irq_domain_reset_irq_data(d);
186 }
187 
188 int partition_translate_id(struct partition_desc *desc, void *partition_id)
189 {
190 	struct partition_affinity *part = NULL;
191 	int i;
192 
193 	for (i = 0; i < desc->nr_parts; i++) {
194 		if (desc->parts[i].partition_id == partition_id) {
195 			part = &desc->parts[i];
196 			break;
197 		}
198 	}
199 
200 	if (WARN_ON(!part)) {
201 		pr_err("Failed to find partition\n");
202 		return -EINVAL;
203 	}
204 
205 	return i;
206 }
207 
208 struct partition_desc *partition_create_desc(struct fwnode_handle *fwnode,
209 					     struct partition_affinity *parts,
210 					     int nr_parts,
211 					     int chained_irq,
212 					     const struct irq_domain_ops *ops)
213 {
214 	struct partition_desc *desc;
215 	struct irq_domain *d;
216 
217 	BUG_ON(!ops->select || !ops->translate);
218 
219 	desc = kzalloc(sizeof(*desc), GFP_KERNEL);
220 	if (!desc)
221 		return NULL;
222 
223 	desc->ops = *ops;
224 	desc->ops.free = partition_domain_free;
225 	desc->ops.alloc = partition_domain_alloc;
226 
227 	d = irq_domain_create_linear(fwnode, nr_parts, &desc->ops, desc);
228 	if (!d)
229 		goto out;
230 	desc->domain = d;
231 
232 	desc->bitmap = kzalloc(sizeof(long) * BITS_TO_LONGS(nr_parts),
233 			       GFP_KERNEL);
234 	if (WARN_ON(!desc->bitmap))
235 		goto out;
236 
237 	desc->chained_desc = irq_to_desc(chained_irq);
238 	desc->nr_parts = nr_parts;
239 	desc->parts = parts;
240 
241 	return desc;
242 out:
243 	if (d)
244 		irq_domain_remove(d);
245 	kfree(desc);
246 
247 	return NULL;
248 }
249 
250 struct irq_domain *partition_get_domain(struct partition_desc *dsc)
251 {
252 	if (dsc)
253 		return dsc->domain;
254 
255 	return NULL;
256 }
257