This source file includes following definitions.
- sdw_intel_cleanup_pdev
- sdw_intel_add_controller
- sdw_intel_acpi_cb
- sdw_intel_init
- sdw_intel_exit
1
2
3
4
5
6
7
8
9
10 #include <linux/acpi.h>
11 #include <linux/export.h>
12 #include <linux/module.h>
13 #include <linux/platform_device.h>
14 #include <linux/soundwire/sdw_intel.h>
15 #include "intel.h"
16
17 #define SDW_LINK_TYPE 4
18 #define SDW_MAX_LINKS 4
19 #define SDW_SHIM_LCAP 0x0
20 #define SDW_SHIM_BASE 0x2C000
21 #define SDW_ALH_BASE 0x2C800
22 #define SDW_LINK_BASE 0x30000
23 #define SDW_LINK_SIZE 0x10000
24
25 static int link_mask;
26 module_param_named(sdw_link_mask, link_mask, int, 0444);
27 MODULE_PARM_DESC(sdw_link_mask, "Intel link mask (one bit per link)");
28
29 struct sdw_link_data {
30 struct sdw_intel_link_res res;
31 struct platform_device *pdev;
32 };
33
34 struct sdw_intel_ctx {
35 int count;
36 struct sdw_link_data *links;
37 };
38
39 static int sdw_intel_cleanup_pdev(struct sdw_intel_ctx *ctx)
40 {
41 struct sdw_link_data *link = ctx->links;
42 int i;
43
44 if (!link)
45 return 0;
46
47 for (i = 0; i < ctx->count; i++) {
48 if (link->pdev)
49 platform_device_unregister(link->pdev);
50 link++;
51 }
52
53 kfree(ctx->links);
54 ctx->links = NULL;
55
56 return 0;
57 }
58
59 static struct sdw_intel_ctx
60 *sdw_intel_add_controller(struct sdw_intel_res *res)
61 {
62 struct platform_device_info pdevinfo;
63 struct platform_device *pdev;
64 struct sdw_link_data *link;
65 struct sdw_intel_ctx *ctx;
66 struct acpi_device *adev;
67 int ret, i;
68 u8 count;
69 u32 caps;
70
71 if (acpi_bus_get_device(res->handle, &adev))
72 return NULL;
73
74
75 count = 0;
76 ret = fwnode_property_read_u8_array(acpi_fwnode_handle(adev),
77 "mipi-sdw-master-count", &count, 1);
78
79
80 if (ret) {
81 dev_err(&adev->dev,
82 "Failed to read mipi-sdw-master-count: %d\n", ret);
83 count = SDW_MAX_LINKS;
84 }
85
86
87 caps = ioread32(res->mmio_base + SDW_SHIM_BASE + SDW_SHIM_LCAP);
88 caps &= GENMASK(2, 0);
89
90
91 count = min_t(u8, caps, count);
92
93
94 if (count > SDW_MAX_LINKS) {
95 dev_err(&adev->dev, "Link count %d exceeds max %d\n",
96 count, SDW_MAX_LINKS);
97 return NULL;
98 } else if (!count) {
99 dev_warn(&adev->dev, "No SoundWire links detected\n");
100 return NULL;
101 }
102
103 dev_dbg(&adev->dev, "Creating %d SDW Link devices\n", count);
104
105 ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
106 if (!ctx)
107 return NULL;
108
109 ctx->count = count;
110 ctx->links = kcalloc(ctx->count, sizeof(*ctx->links), GFP_KERNEL);
111 if (!ctx->links)
112 goto link_err;
113
114 link = ctx->links;
115
116
117 for (i = 0; i < count; i++) {
118 if (link_mask && !(link_mask & BIT(i))) {
119 dev_dbg(&adev->dev,
120 "Link %d masked, will not be enabled\n", i);
121 link++;
122 continue;
123 }
124
125 link->res.irq = res->irq;
126 link->res.registers = res->mmio_base + SDW_LINK_BASE
127 + (SDW_LINK_SIZE * i);
128 link->res.shim = res->mmio_base + SDW_SHIM_BASE;
129 link->res.alh = res->mmio_base + SDW_ALH_BASE;
130
131 link->res.ops = res->ops;
132 link->res.arg = res->arg;
133
134 memset(&pdevinfo, 0, sizeof(pdevinfo));
135
136 pdevinfo.parent = res->parent;
137 pdevinfo.name = "int-sdw";
138 pdevinfo.id = i;
139 pdevinfo.fwnode = acpi_fwnode_handle(adev);
140 pdevinfo.data = &link->res;
141 pdevinfo.size_data = sizeof(link->res);
142
143 pdev = platform_device_register_full(&pdevinfo);
144 if (IS_ERR(pdev)) {
145 dev_err(&adev->dev,
146 "platform device creation failed: %ld\n",
147 PTR_ERR(pdev));
148 goto pdev_err;
149 }
150
151 link->pdev = pdev;
152 link++;
153 }
154
155 return ctx;
156
157 pdev_err:
158 sdw_intel_cleanup_pdev(ctx);
159 link_err:
160 kfree(ctx);
161 return NULL;
162 }
163
164 static acpi_status sdw_intel_acpi_cb(acpi_handle handle, u32 level,
165 void *cdata, void **return_value)
166 {
167 struct sdw_intel_res *res = cdata;
168 struct acpi_device *adev;
169 acpi_status status;
170 u64 adr;
171
172 status = acpi_evaluate_integer(handle, METHOD_NAME__ADR, NULL, &adr);
173 if (ACPI_FAILURE(status))
174 return AE_OK;
175
176 if (acpi_bus_get_device(handle, &adev)) {
177 pr_err("%s: Couldn't find ACPI handle\n", __func__);
178 return AE_NOT_FOUND;
179 }
180
181 res->handle = handle;
182
183
184
185
186
187
188
189
190 if ((adr & GENMASK(31, 28)) >> 28 != SDW_LINK_TYPE)
191 return AE_OK;
192
193
194 return AE_CTRL_TERMINATE;
195 }
196
197
198
199
200
201
202
203
204
205 void *sdw_intel_init(acpi_handle *parent_handle, struct sdw_intel_res *res)
206 {
207 acpi_status status;
208
209 status = acpi_walk_namespace(ACPI_TYPE_DEVICE,
210 parent_handle, 1,
211 sdw_intel_acpi_cb,
212 NULL, res, NULL);
213 if (ACPI_FAILURE(status))
214 return NULL;
215
216 return sdw_intel_add_controller(res);
217 }
218 EXPORT_SYMBOL(sdw_intel_init);
219
220
221
222
223
224
225
226 void sdw_intel_exit(void *arg)
227 {
228 struct sdw_intel_ctx *ctx = arg;
229
230 sdw_intel_cleanup_pdev(ctx);
231 kfree(ctx);
232 }
233 EXPORT_SYMBOL(sdw_intel_exit);
234
235 MODULE_LICENSE("Dual BSD/GPL");
236 MODULE_DESCRIPTION("Intel Soundwire Init Library");