1
2
3
4
5
6
7
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/platform_device.h>
16#include <linux/pm_runtime.h>
17#include <linux/soundwire/sdw_intel.h>
18#include "cadence_master.h"
19#include "intel.h"
20
21#define SDW_LINK_TYPE 4
22#define SDW_MAX_LINKS 4
23#define SDW_SHIM_LCAP 0x0
24#define SDW_SHIM_BASE 0x2C000
25#define SDW_ALH_BASE 0x2C800
26#define SDW_LINK_BASE 0x30000
27#define SDW_LINK_SIZE 0x10000
28
29static int ctrl_link_mask;
30module_param_named(sdw_link_mask, ctrl_link_mask, int, 0444);
31MODULE_PARM_DESC(sdw_link_mask, "Intel link mask (one bit per link)");
32
33static bool is_link_enabled(struct fwnode_handle *fw_node, int i)
34{
35 struct fwnode_handle *link;
36 char name[32];
37 u32 quirk_mask = 0;
38
39
40 snprintf(name, sizeof(name),
41 "mipi-sdw-link-%d-subproperties", i);
42
43 link = fwnode_get_named_child_node(fw_node, name);
44 if (!link)
45 return false;
46
47 fwnode_property_read_u32(link,
48 "intel-quirk-mask",
49 &quirk_mask);
50
51 if (quirk_mask & SDW_INTEL_QUIRK_MASK_BUS_DISABLE)
52 return false;
53
54 return true;
55}
56
57static int sdw_intel_cleanup(struct sdw_intel_ctx *ctx)
58{
59 struct sdw_intel_link_res *link = ctx->links;
60 u32 link_mask;
61 int i;
62
63 if (!link)
64 return 0;
65
66 link_mask = ctx->link_mask;
67
68 for (i = 0; i < ctx->count; i++, link++) {
69 if (!(link_mask & BIT(i)))
70 continue;
71
72 if (link->pdev) {
73 pm_runtime_disable(&link->pdev->dev);
74 platform_device_unregister(link->pdev);
75 }
76
77 if (!link->clock_stop_quirks)
78 pm_runtime_put_noidle(link->dev);
79 }
80
81 return 0;
82}
83
84static int
85sdw_intel_scan_controller(struct sdw_intel_acpi_info *info)
86{
87 struct acpi_device *adev;
88 int ret, i;
89 u8 count;
90
91 if (acpi_bus_get_device(info->handle, &adev))
92 return -EINVAL;
93
94
95 count = 0;
96 ret = fwnode_property_read_u8_array(acpi_fwnode_handle(adev),
97 "mipi-sdw-master-count", &count, 1);
98
99
100
101
102
103
104
105
106
107
108
109
110
111 if (ret) {
112 dev_err(&adev->dev,
113 "Failed to read mipi-sdw-master-count: %d\n", ret);
114 return -EINVAL;
115 }
116
117
118 if (count > SDW_MAX_LINKS) {
119 dev_err(&adev->dev, "Link count %d exceeds max %d\n",
120 count, SDW_MAX_LINKS);
121 return -EINVAL;
122 }
123
124 if (!count) {
125 dev_warn(&adev->dev, "No SoundWire links detected\n");
126 return -EINVAL;
127 }
128 dev_dbg(&adev->dev, "ACPI reports %d SDW Link devices\n", count);
129
130 info->count = count;
131 info->link_mask = 0;
132
133 for (i = 0; i < count; i++) {
134 if (ctrl_link_mask && !(ctrl_link_mask & BIT(i))) {
135 dev_dbg(&adev->dev,
136 "Link %d masked, will not be enabled\n", i);
137 continue;
138 }
139
140 if (!is_link_enabled(acpi_fwnode_handle(adev), i)) {
141 dev_dbg(&adev->dev,
142 "Link %d not selected in firmware\n", i);
143 continue;
144 }
145
146 info->link_mask |= BIT(i);
147 }
148
149 return 0;
150}
151
152#define HDA_DSP_REG_ADSPIC2 (0x10)
153#define HDA_DSP_REG_ADSPIS2 (0x14)
154#define HDA_DSP_REG_ADSPIC2_SNDW BIT(5)
155
156
157
158
159
160
161void sdw_intel_enable_irq(void __iomem *mmio_base, bool enable)
162{
163 u32 val;
164
165 val = readl(mmio_base + HDA_DSP_REG_ADSPIC2);
166
167 if (enable)
168 val |= HDA_DSP_REG_ADSPIC2_SNDW;
169 else
170 val &= ~HDA_DSP_REG_ADSPIC2_SNDW;
171
172 writel(val, mmio_base + HDA_DSP_REG_ADSPIC2);
173}
174EXPORT_SYMBOL_NS(sdw_intel_enable_irq, SOUNDWIRE_INTEL_INIT);
175
176irqreturn_t sdw_intel_thread(int irq, void *dev_id)
177{
178 struct sdw_intel_ctx *ctx = dev_id;
179 struct sdw_intel_link_res *link;
180
181 list_for_each_entry(link, &ctx->link_list, list)
182 sdw_cdns_irq(irq, link->cdns);
183
184 sdw_intel_enable_irq(ctx->mmio_base, true);
185 return IRQ_HANDLED;
186}
187EXPORT_SYMBOL_NS(sdw_intel_thread, SOUNDWIRE_INTEL_INIT);
188
189static struct sdw_intel_ctx
190*sdw_intel_probe_controller(struct sdw_intel_res *res)
191{
192 struct platform_device_info pdevinfo;
193 struct platform_device *pdev;
194 struct sdw_intel_link_res *link;
195 struct sdw_intel_ctx *ctx;
196 struct acpi_device *adev;
197 struct sdw_slave *slave;
198 struct list_head *node;
199 struct sdw_bus *bus;
200 u32 link_mask;
201 int num_slaves = 0;
202 int count;
203 int i;
204
205 if (!res)
206 return NULL;
207
208 if (acpi_bus_get_device(res->handle, &adev))
209 return NULL;
210
211 if (!res->count)
212 return NULL;
213
214 count = res->count;
215 dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count);
216
217 ctx = devm_kzalloc(&adev->dev, sizeof(*ctx), GFP_KERNEL);
218 if (!ctx)
219 return NULL;
220
221 ctx->count = count;
222 ctx->links = devm_kcalloc(&adev->dev, ctx->count,
223 sizeof(*ctx->links), GFP_KERNEL);
224 if (!ctx->links)
225 return NULL;
226
227 ctx->count = count;
228 ctx->mmio_base = res->mmio_base;
229 ctx->link_mask = res->link_mask;
230 ctx->handle = res->handle;
231 mutex_init(&ctx->shim_lock);
232
233 link = ctx->links;
234 link_mask = ctx->link_mask;
235
236 INIT_LIST_HEAD(&ctx->link_list);
237
238
239 for (i = 0; i < count; i++, link++) {
240 if (!(link_mask & BIT(i))) {
241 dev_dbg(&adev->dev,
242 "Link %d masked, will not be enabled\n", i);
243 continue;
244 }
245
246 link->mmio_base = res->mmio_base;
247 link->registers = res->mmio_base + SDW_LINK_BASE
248 + (SDW_LINK_SIZE * i);
249 link->shim = res->mmio_base + SDW_SHIM_BASE;
250 link->alh = res->mmio_base + SDW_ALH_BASE;
251
252 link->ops = res->ops;
253 link->dev = res->dev;
254
255 link->clock_stop_quirks = res->clock_stop_quirks;
256 link->shim_lock = &ctx->shim_lock;
257 link->shim_mask = &ctx->shim_mask;
258 link->link_mask = link_mask;
259
260 memset(&pdevinfo, 0, sizeof(pdevinfo));
261
262 pdevinfo.parent = res->parent;
263 pdevinfo.name = "intel-sdw";
264 pdevinfo.id = i;
265 pdevinfo.fwnode = acpi_fwnode_handle(adev);
266 pdevinfo.data = link;
267 pdevinfo.size_data = sizeof(*link);
268
269 pdev = platform_device_register_full(&pdevinfo);
270 if (IS_ERR(pdev)) {
271 dev_err(&adev->dev,
272 "platform device creation failed: %ld\n",
273 PTR_ERR(pdev));
274 goto err;
275 }
276 link->pdev = pdev;
277 link->cdns = platform_get_drvdata(pdev);
278
279 list_add_tail(&link->list, &ctx->link_list);
280 bus = &link->cdns->bus;
281
282 list_for_each(node, &bus->slaves)
283 num_slaves++;
284 }
285
286 ctx->ids = devm_kcalloc(&adev->dev, num_slaves,
287 sizeof(*ctx->ids), GFP_KERNEL);
288 if (!ctx->ids)
289 goto err;
290
291 ctx->num_slaves = num_slaves;
292 i = 0;
293 list_for_each_entry(link, &ctx->link_list, list) {
294 bus = &link->cdns->bus;
295 list_for_each_entry(slave, &bus->slaves, node) {
296 ctx->ids[i].id = slave->id;
297 ctx->ids[i].link_id = bus->link_id;
298 i++;
299 }
300 }
301
302 return ctx;
303
304err:
305 ctx->count = i;
306 sdw_intel_cleanup(ctx);
307 return NULL;
308}
309
310static int
311sdw_intel_startup_controller(struct sdw_intel_ctx *ctx)
312{
313 struct acpi_device *adev;
314 struct sdw_intel_link_res *link;
315 u32 caps;
316 u32 link_mask;
317 int i;
318
319 if (acpi_bus_get_device(ctx->handle, &adev))
320 return -EINVAL;
321
322
323 caps = ioread32(ctx->mmio_base + SDW_SHIM_BASE + SDW_SHIM_LCAP);
324 caps &= GENMASK(2, 0);
325
326
327 if (caps < ctx->count) {
328 dev_err(&adev->dev,
329 "BIOS master count is larger than hardware capabilities\n");
330 return -EINVAL;
331 }
332
333 if (!ctx->links)
334 return -EINVAL;
335
336 link = ctx->links;
337 link_mask = ctx->link_mask;
338
339
340 for (i = 0; i < ctx->count; i++, link++) {
341 if (!(link_mask & BIT(i)))
342 continue;
343
344 intel_master_startup(link->pdev);
345
346 if (!link->clock_stop_quirks) {
347
348
349
350
351
352
353 pm_runtime_get_noresume(link->dev);
354 }
355 }
356
357 return 0;
358}
359
360static acpi_status sdw_intel_acpi_cb(acpi_handle handle, u32 level,
361 void *cdata, void **return_value)
362{
363 struct sdw_intel_acpi_info *info = cdata;
364 struct acpi_device *adev;
365 acpi_status status;
366 u64 adr;
367
368 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
369 if (ACPI_FAILURE(status))
370 return AE_OK;
371
372 if (acpi_bus_get_device(handle, &adev)) {
373 pr_err("%s: Couldn't find ACPI handle\n", __func__);
374 return AE_NOT_FOUND;
375 }
376
377 info->handle = handle;
378
379
380
381
382
383
384
385
386 if (FIELD_GET(GENMASK(31, 28), adr) != SDW_LINK_TYPE)
387 return AE_OK;
388
389
390 return AE_CTRL_TERMINATE;
391}
392
393
394
395
396
397
398
399
400
401
402
403int sdw_intel_acpi_scan(acpi_handle *parent_handle,
404 struct sdw_intel_acpi_info *info)
405{
406 acpi_status status;
407
408 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
409 parent_handle, 1,
410 sdw_intel_acpi_cb,
411 NULL, info, NULL);
412 if (ACPI_FAILURE(status))
413 return -ENODEV;
414
415 return sdw_intel_scan_controller(info);
416}
417EXPORT_SYMBOL_NS(sdw_intel_acpi_scan, SOUNDWIRE_INTEL_INIT);
418
419
420
421
422
423
424
425
426
427
428
429struct sdw_intel_ctx
430*sdw_intel_probe(struct sdw_intel_res *res)
431{
432 return sdw_intel_probe_controller(res);
433}
434EXPORT_SYMBOL_NS(sdw_intel_probe, SOUNDWIRE_INTEL_INIT);
435
436
437
438
439
440
441
442
443int sdw_intel_startup(struct sdw_intel_ctx *ctx)
444{
445 return sdw_intel_startup_controller(ctx);
446}
447EXPORT_SYMBOL_NS(sdw_intel_startup, SOUNDWIRE_INTEL_INIT);
448
449
450
451
452
453
454void sdw_intel_exit(struct sdw_intel_ctx *ctx)
455{
456 sdw_intel_cleanup(ctx);
457}
458EXPORT_SYMBOL_NS(sdw_intel_exit, SOUNDWIRE_INTEL_INIT);
459
460void sdw_intel_process_wakeen_event(struct sdw_intel_ctx *ctx)
461{
462 struct sdw_intel_link_res *link;
463 u32 link_mask;
464 int i;
465
466 if (!ctx->links)
467 return;
468
469 link = ctx->links;
470 link_mask = ctx->link_mask;
471
472
473 for (i = 0; i < ctx->count; i++, link++) {
474 if (!(link_mask & BIT(i)))
475 continue;
476
477 intel_master_process_wakeen_event(link->pdev);
478 }
479}
480EXPORT_SYMBOL_NS(sdw_intel_process_wakeen_event, SOUNDWIRE_INTEL_INIT);
481
482MODULE_LICENSE("Dual BSD/GPL");
483MODULE_DESCRIPTION("Intel Soundwire Init Library");
484
