1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright 2016-17 IBM Corp.
4  */
5 
6 #define pr_fmt(fmt) "vas: " fmt
7 
8 #include <linux/module.h>
9 #include <linux/kernel.h>
10 #include <linux/export.h>
11 #include <linux/types.h>
12 #include <linux/slab.h>
13 #include <linux/platform_device.h>
14 #include <linux/of_platform.h>
15 #include <linux/of_address.h>
16 #include <linux/of.h>
17 #include <linux/irqdomain.h>
18 #include <linux/interrupt.h>
19 #include <asm/prom.h>
20 #include <asm/xive.h>
21 
22 #include "vas.h"
23 
24 DEFINE_MUTEX(vas_mutex);
25 static LIST_HEAD(vas_instances);
26 
27 static DEFINE_PER_CPU(int, cpu_vas_id);
28 
29 static int vas_irq_fault_window_setup(struct vas_instance *vinst)
30 {
31 	int rc = 0;
32 
33 	rc = request_threaded_irq(vinst->virq, vas_fault_handler,
34 				vas_fault_thread_fn, 0, vinst->name, vinst);
35 
36 	if (rc) {
37 		pr_err("VAS[%d]: Request IRQ(%d) failed with %d\n",
38 				vinst->vas_id, vinst->virq, rc);
39 		goto out;
40 	}
41 
42 	rc = vas_setup_fault_window(vinst);
43 	if (rc)
44 		free_irq(vinst->virq, vinst);
45 
46 out:
47 	return rc;
48 }
49 
50 static int init_vas_instance(struct platform_device *pdev)
51 {
52 	struct device_node *dn = pdev->dev.of_node;
53 	struct vas_instance *vinst;
54 	struct xive_irq_data *xd;
55 	uint32_t chipid, hwirq;
56 	struct resource *res;
57 	int rc, cpu, vasid;
58 
59 	rc = of_property_read_u32(dn, "ibm,vas-id", &vasid);
60 	if (rc) {
61 		pr_err("No ibm,vas-id property for %s?\n", pdev->name);
62 		return -ENODEV;
63 	}
64 
65 	rc = of_property_read_u32(dn, "ibm,chip-id", &chipid);
66 	if (rc) {
67 		pr_err("No ibm,chip-id property for %s?\n", pdev->name);
68 		return -ENODEV;
69 	}
70 
71 	if (pdev->num_resources != 4) {
72 		pr_err("Unexpected DT configuration for [%s, %d]\n",
73 				pdev->name, vasid);
74 		return -ENODEV;
75 	}
76 
77 	vinst = kzalloc(sizeof(*vinst), GFP_KERNEL);
78 	if (!vinst)
79 		return -ENOMEM;
80 
81 	vinst->name = kasprintf(GFP_KERNEL, "vas-%d", vasid);
82 	if (!vinst->name) {
83 		kfree(vinst);
84 		return -ENOMEM;
85 	}
86 
87 	INIT_LIST_HEAD(&vinst->node);
88 	ida_init(&vinst->ida);
89 	mutex_init(&vinst->mutex);
90 	vinst->vas_id = vasid;
91 	vinst->pdev = pdev;
92 
93 	res = &pdev->resource[0];
94 	vinst->hvwc_bar_start = res->start;
95 
96 	res = &pdev->resource[1];
97 	vinst->uwc_bar_start = res->start;
98 
99 	res = &pdev->resource[2];
100 	vinst->paste_base_addr = res->start;
101 
102 	res = &pdev->resource[3];
103 	if (res->end > 62) {
104 		pr_err("Bad 'paste_win_id_shift' in DT, %llx\n", res->end);
105 		goto free_vinst;
106 	}
107 
108 	vinst->paste_win_id_shift = 63 - res->end;
109 
110 	hwirq = xive_native_alloc_irq_on_chip(chipid);
111 	if (!hwirq) {
112 		pr_err("Inst%d: Unable to allocate global irq for chip %d\n",
113 				vinst->vas_id, chipid);
114 		return -ENOENT;
115 	}
116 
117 	vinst->virq = irq_create_mapping(NULL, hwirq);
118 	if (!vinst->virq) {
119 		pr_err("Inst%d: Unable to map global irq %d\n",
120 				vinst->vas_id, hwirq);
121 		return -EINVAL;
122 	}
123 
124 	xd = irq_get_handler_data(vinst->virq);
125 	if (!xd) {
126 		pr_err("Inst%d: Invalid virq %d\n",
127 				vinst->vas_id, vinst->virq);
128 		return -EINVAL;
129 	}
130 
131 	vinst->irq_port = xd->trig_page;
132 	pr_devel("Initialized instance [%s, %d] paste_base 0x%llx paste_win_id_shift 0x%llx IRQ %d Port 0x%llx\n",
133 			pdev->name, vasid, vinst->paste_base_addr,
134 			vinst->paste_win_id_shift, vinst->virq,
135 			vinst->irq_port);
136 
137 	for_each_possible_cpu(cpu) {
138 		if (cpu_to_chip_id(cpu) == of_get_ibm_chip_id(dn))
139 			per_cpu(cpu_vas_id, cpu) = vasid;
140 	}
141 
142 	mutex_lock(&vas_mutex);
143 	list_add(&vinst->node, &vas_instances);
144 	mutex_unlock(&vas_mutex);
145 
146 	spin_lock_init(&vinst->fault_lock);
147 	/*
148 	 * IRQ and fault handling setup is needed only for user space
149 	 * send windows.
150 	 */
151 	if (vinst->virq) {
152 		rc = vas_irq_fault_window_setup(vinst);
153 		/*
154 		 * Fault window is used only for user space send windows.
155 		 * So if vinst->virq is NULL, tx_win_open returns -ENODEV
156 		 * for user space.
157 		 */
158 		if (rc)
159 			vinst->virq = 0;
160 	}
161 
162 	vas_instance_init_dbgdir(vinst);
163 
164 	dev_set_drvdata(&pdev->dev, vinst);
165 
166 	return 0;
167 
168 free_vinst:
169 	kfree(vinst->name);
170 	kfree(vinst);
171 	return -ENODEV;
172 
173 }
174 
175 /*
176  * Although this is read/used multiple times, it is written to only
177  * during initialization.
178  */
179 struct vas_instance *find_vas_instance(int vasid)
180 {
181 	struct list_head *ent;
182 	struct vas_instance *vinst;
183 
184 	mutex_lock(&vas_mutex);
185 
186 	if (vasid == -1)
187 		vasid = per_cpu(cpu_vas_id, smp_processor_id());
188 
189 	list_for_each(ent, &vas_instances) {
190 		vinst = list_entry(ent, struct vas_instance, node);
191 		if (vinst->vas_id == vasid) {
192 			mutex_unlock(&vas_mutex);
193 			return vinst;
194 		}
195 	}
196 	mutex_unlock(&vas_mutex);
197 
198 	pr_devel("Instance %d not found\n", vasid);
199 	return NULL;
200 }
201 
202 int chip_to_vas_id(int chipid)
203 {
204 	int cpu;
205 
206 	for_each_possible_cpu(cpu) {
207 		if (cpu_to_chip_id(cpu) == chipid)
208 			return per_cpu(cpu_vas_id, cpu);
209 	}
210 	return -1;
211 }
212 EXPORT_SYMBOL(chip_to_vas_id);
213 
214 static int vas_probe(struct platform_device *pdev)
215 {
216 	return init_vas_instance(pdev);
217 }
218 
219 static const struct of_device_id powernv_vas_match[] = {
220 	{ .compatible = "ibm,vas",},
221 	{},
222 };
223 
224 static struct platform_driver vas_driver = {
225 	.driver = {
226 		.name = "vas",
227 		.of_match_table = powernv_vas_match,
228 	},
229 	.probe = vas_probe,
230 };
231 
232 static int __init vas_init(void)
233 {
234 	int found = 0;
235 	struct device_node *dn;
236 
237 	platform_driver_register(&vas_driver);
238 
239 	for_each_compatible_node(dn, NULL, "ibm,vas") {
240 		of_platform_device_create(dn, NULL, NULL);
241 		found++;
242 	}
243 
244 	if (!found) {
245 		platform_driver_unregister(&vas_driver);
246 		return -ENODEV;
247 	}
248 
249 	pr_devel("Found %d instances\n", found);
250 
251 	return 0;
252 }
253 device_initcall(vas_init);
254