1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
2 // Copyright(c) 2015-17 Intel Corporation.
3 
4 /*
5  * SDW Intel Init Routines
6  *
7  * Initializes and creates SDW devices based on ACPI and Hardware values
8  */
9 
10 #include <linux/acpi.h>
11 #include <linux/export.h>
12 #include <linux/interrupt.h>
13 #include <linux/io.h>
14 #include <linux/module.h>
15 #include <linux/auxiliary_bus.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/soundwire/sdw_intel.h>
18 #include "cadence_master.h"
19 #include "intel.h"
20 #include "intel_auxdevice.h"
21 
22 static void intel_link_dev_release(struct device *dev)
23 {
24 	struct auxiliary_device *auxdev = to_auxiliary_dev(dev);
25 	struct sdw_intel_link_dev *ldev = auxiliary_dev_to_sdw_intel_link_dev(auxdev);
26 
27 	kfree(ldev);
28 }
29 
30 /* alloc, init and add link devices */
31 static struct sdw_intel_link_dev *intel_link_dev_register(struct sdw_intel_res *res,
32 							  struct sdw_intel_ctx *ctx,
33 							  struct fwnode_handle *fwnode,
34 							  const char *name,
35 							  int link_id)
36 {
37 	struct sdw_intel_link_dev *ldev;
38 	struct sdw_intel_link_res *link;
39 	struct auxiliary_device *auxdev;
40 	int ret;
41 
42 	ldev = kzalloc(sizeof(*ldev), GFP_KERNEL);
43 	if (!ldev)
44 		return ERR_PTR(-ENOMEM);
45 
46 	auxdev = &ldev->auxdev;
47 	auxdev->name = name;
48 	auxdev->dev.parent = res->parent;
49 	auxdev->dev.fwnode = fwnode;
50 	auxdev->dev.release = intel_link_dev_release;
51 
52 	/* we don't use an IDA since we already have a link ID */
53 	auxdev->id = link_id;
54 
55 	/*
56 	 * keep a handle on the allocated memory, to be used in all other functions.
57 	 * Since the same pattern is used to skip links that are not enabled, there is
58 	 * no need to check if ctx->ldev[i] is NULL later on.
59 	 */
60 	ctx->ldev[link_id] = ldev;
61 
62 	/* Add link information used in the driver probe */
63 	link = &ldev->link_res;
64 	link->hw_ops = res->hw_ops;
65 	link->mmio_base = res->mmio_base;
66 	link->registers = res->mmio_base + SDW_LINK_BASE
67 		+ (SDW_LINK_SIZE * link_id);
68 	link->shim = res->mmio_base + res->shim_base;
69 	link->alh = res->mmio_base + res->alh_base;
70 
71 	link->ops = res->ops;
72 	link->dev = res->dev;
73 
74 	link->clock_stop_quirks = res->clock_stop_quirks;
75 	link->shim_lock = &ctx->shim_lock;
76 	link->shim_mask = &ctx->shim_mask;
77 	link->link_mask = ctx->link_mask;
78 
79 	/* now follow the two-step init/add sequence */
80 	ret = auxiliary_device_init(auxdev);
81 	if (ret < 0) {
82 		dev_err(res->parent, "failed to initialize link dev %s link_id %d\n",
83 			name, link_id);
84 		kfree(ldev);
85 		return ERR_PTR(ret);
86 	}
87 
88 	ret = auxiliary_device_add(&ldev->auxdev);
89 	if (ret < 0) {
90 		dev_err(res->parent, "failed to add link dev %s link_id %d\n",
91 			ldev->auxdev.name, link_id);
92 		/* ldev will be freed with the put_device() and .release sequence */
93 		auxiliary_device_uninit(&ldev->auxdev);
94 		return ERR_PTR(ret);
95 	}
96 
97 	return ldev;
98 }
99 
100 static void intel_link_dev_unregister(struct sdw_intel_link_dev *ldev)
101 {
102 	auxiliary_device_delete(&ldev->auxdev);
103 	auxiliary_device_uninit(&ldev->auxdev);
104 }
105 
106 static int sdw_intel_cleanup(struct sdw_intel_ctx *ctx)
107 {
108 	struct sdw_intel_link_dev *ldev;
109 	u32 link_mask;
110 	int i;
111 
112 	link_mask = ctx->link_mask;
113 
114 	for (i = 0; i < ctx->count; i++) {
115 		if (!(link_mask & BIT(i)))
116 			continue;
117 
118 		ldev = ctx->ldev[i];
119 
120 		pm_runtime_disable(&ldev->auxdev.dev);
121 		if (!ldev->link_res.clock_stop_quirks)
122 			pm_runtime_put_noidle(ldev->link_res.dev);
123 
124 		intel_link_dev_unregister(ldev);
125 	}
126 
127 	return 0;
128 }
129 
130 irqreturn_t sdw_intel_thread(int irq, void *dev_id)
131 {
132 	struct sdw_intel_ctx *ctx = dev_id;
133 	struct sdw_intel_link_res *link;
134 
135 	list_for_each_entry(link, &ctx->link_list, list)
136 		sdw_cdns_irq(irq, link->cdns);
137 
138 	return IRQ_HANDLED;
139 }
140 EXPORT_SYMBOL_NS(sdw_intel_thread, SOUNDWIRE_INTEL_INIT);
141 
142 static struct sdw_intel_ctx
143 *sdw_intel_probe_controller(struct sdw_intel_res *res)
144 {
145 	struct sdw_intel_link_res *link;
146 	struct sdw_intel_link_dev *ldev;
147 	struct sdw_intel_ctx *ctx;
148 	struct acpi_device *adev;
149 	struct sdw_slave *slave;
150 	struct list_head *node;
151 	struct sdw_bus *bus;
152 	u32 link_mask;
153 	int num_slaves = 0;
154 	int count;
155 	int i;
156 
157 	if (!res)
158 		return NULL;
159 
160 	adev = acpi_fetch_acpi_dev(res->handle);
161 	if (!adev)
162 		return NULL;
163 
164 	if (!res->count)
165 		return NULL;
166 
167 	count = res->count;
168 	dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count);
169 
170 	/*
171 	 * we need to alloc/free memory manually and can't use devm:
172 	 * this routine may be called from a workqueue, and not from
173 	 * the parent .probe.
174 	 * If devm_ was used, the memory might never be freed on errors.
175 	 */
176 	ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
177 	if (!ctx)
178 		return NULL;
179 
180 	ctx->count = count;
181 
182 	/*
183 	 * allocate the array of pointers. The link-specific data is allocated
184 	 * as part of the first loop below and released with the auxiliary_device_uninit().
185 	 * If some links are disabled, the link pointer will remain NULL. Given that the
186 	 * number of links is small, this is simpler than using a list to keep track of links.
187 	 */
188 	ctx->ldev = kcalloc(ctx->count, sizeof(*ctx->ldev), GFP_KERNEL);
189 	if (!ctx->ldev) {
190 		kfree(ctx);
191 		return NULL;
192 	}
193 
194 	ctx->mmio_base = res->mmio_base;
195 	ctx->shim_base = res->shim_base;
196 	ctx->alh_base = res->alh_base;
197 	ctx->link_mask = res->link_mask;
198 	ctx->handle = res->handle;
199 	mutex_init(&ctx->shim_lock);
200 
201 	link_mask = ctx->link_mask;
202 
203 	INIT_LIST_HEAD(&ctx->link_list);
204 
205 	for (i = 0; i < count; i++) {
206 		if (!(link_mask & BIT(i)))
207 			continue;
208 
209 		/*
210 		 * init and add a device for each link
211 		 *
212 		 * The name of the device will be soundwire_intel.link.[i],
213 		 * with the "soundwire_intel" module prefix automatically added
214 		 * by the auxiliary bus core.
215 		 */
216 		ldev = intel_link_dev_register(res,
217 					       ctx,
218 					       acpi_fwnode_handle(adev),
219 					       "link",
220 					       i);
221 		if (IS_ERR(ldev))
222 			goto err;
223 
224 		link = &ldev->link_res;
225 		link->cdns = auxiliary_get_drvdata(&ldev->auxdev);
226 
227 		if (!link->cdns) {
228 			dev_err(&adev->dev, "failed to get link->cdns\n");
229 			/*
230 			 * 1 will be subtracted from i in the err label, but we need to call
231 			 * intel_link_dev_unregister for this ldev, so plus 1 now
232 			 */
233 			i++;
234 			goto err;
235 		}
236 		list_add_tail(&link->list, &ctx->link_list);
237 		bus = &link->cdns->bus;
238 		/* Calculate number of slaves */
239 		list_for_each(node, &bus->slaves)
240 			num_slaves++;
241 	}
242 
243 	ctx->ids = kcalloc(num_slaves, sizeof(*ctx->ids), GFP_KERNEL);
244 	if (!ctx->ids)
245 		goto err;
246 
247 	ctx->num_slaves = num_slaves;
248 	i = 0;
249 	list_for_each_entry(link, &ctx->link_list, list) {
250 		bus = &link->cdns->bus;
251 		list_for_each_entry(slave, &bus->slaves, node) {
252 			ctx->ids[i].id = slave->id;
253 			ctx->ids[i].link_id = bus->link_id;
254 			i++;
255 		}
256 	}
257 
258 	return ctx;
259 
260 err:
261 	while (i--) {
262 		if (!(link_mask & BIT(i)))
263 			continue;
264 		ldev = ctx->ldev[i];
265 		intel_link_dev_unregister(ldev);
266 	}
267 	kfree(ctx->ldev);
268 	kfree(ctx);
269 	return NULL;
270 }
271 
272 static int
273 sdw_intel_startup_controller(struct sdw_intel_ctx *ctx)
274 {
275 	struct acpi_device *adev = acpi_fetch_acpi_dev(ctx->handle);
276 	struct sdw_intel_link_dev *ldev;
277 	u32 link_mask;
278 	int i;
279 
280 	if (!adev)
281 		return -EINVAL;
282 
283 	if (!ctx->ldev)
284 		return -EINVAL;
285 
286 	link_mask = ctx->link_mask;
287 
288 	/* Startup SDW Master devices */
289 	for (i = 0; i < ctx->count; i++) {
290 		if (!(link_mask & BIT(i)))
291 			continue;
292 
293 		ldev = ctx->ldev[i];
294 
295 		intel_link_startup(&ldev->auxdev);
296 
297 		if (!ldev->link_res.clock_stop_quirks) {
298 			/*
299 			 * we need to prevent the parent PCI device
300 			 * from entering pm_runtime suspend, so that
301 			 * power rails to the SoundWire IP are not
302 			 * turned off.
303 			 */
304 			pm_runtime_get_noresume(ldev->link_res.dev);
305 		}
306 	}
307 
308 	return 0;
309 }
310 
311 /**
312  * sdw_intel_probe() - SoundWire Intel probe routine
313  * @res: resource data
314  *
315  * This registers an auxiliary device for each Master handled by the controller,
316  * and SoundWire Master and Slave devices will be created by the auxiliary
317  * device probe. All the information necessary is stored in the context, and
318  * the res argument pointer can be freed after this step.
319  * This function will be called after sdw_intel_acpi_scan() by SOF probe.
320  */
321 struct sdw_intel_ctx
322 *sdw_intel_probe(struct sdw_intel_res *res)
323 {
324 	return sdw_intel_probe_controller(res);
325 }
326 EXPORT_SYMBOL_NS(sdw_intel_probe, SOUNDWIRE_INTEL_INIT);
327 
328 /**
329  * sdw_intel_startup() - SoundWire Intel startup
330  * @ctx: SoundWire context allocated in the probe
331  *
332  * Startup Intel SoundWire controller. This function will be called after
333  * Intel Audio DSP is powered up.
334  */
335 int sdw_intel_startup(struct sdw_intel_ctx *ctx)
336 {
337 	return sdw_intel_startup_controller(ctx);
338 }
339 EXPORT_SYMBOL_NS(sdw_intel_startup, SOUNDWIRE_INTEL_INIT);
340 /**
341  * sdw_intel_exit() - SoundWire Intel exit
342  * @ctx: SoundWire context allocated in the probe
343  *
344  * Delete the controller instances created and cleanup
345  */
346 void sdw_intel_exit(struct sdw_intel_ctx *ctx)
347 {
348 	sdw_intel_cleanup(ctx);
349 	kfree(ctx->ids);
350 	kfree(ctx->ldev);
351 	kfree(ctx);
352 }
353 EXPORT_SYMBOL_NS(sdw_intel_exit, SOUNDWIRE_INTEL_INIT);
354 
355 void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx)
356 {
357 	struct sdw_intel_link_dev *ldev;
358 	u32 link_mask;
359 	int i;
360 
361 	if (!ctx->ldev)
362 		return;
363 
364 	link_mask = ctx->link_mask;
365 
366 	/* Startup SDW Master devices */
367 	for (i = 0; i < ctx->count; i++) {
368 		if (!(link_mask & BIT(i)))
369 			continue;
370 
371 		ldev = ctx->ldev[i];
372 
373 		intel_link_process_wakeen_event(&ldev->auxdev);
374 	}
375 }
376 EXPORT_SYMBOL_NS(sdw_intel_process_wakeen_event, SOUNDWIRE_INTEL_INIT);
377 
378 MODULE_LICENSE("Dual BSD/GPL");
379 MODULE_DESCRIPTION("Intel Soundwire Init Library");
380