Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ASoC: SOF: imx: stop using the imx8_*_clocks API
Merge series from Laurentiu Mihalcea <laurentiumihalcea111@gmail.com>:
The imx8_*_clocks API requires keeping track of all of the clocks used
by the IMX SOF driver via an array. This is unnecessary and doesn't
scale well. As such, remove it altogether and replace it with
devm_clk_bulk_get_all() and friends.
+53
-103
-24
sound/soc/sof/imx/imx-common.c
-24
sound/soc/sof/imx/imx-common.c
···
74
74
}
75
75
EXPORT_SYMBOL(imx8_dump);
76
76
77
-
int imx8_parse_clocks(struct snd_sof_dev *sdev, struct imx_clocks *clks)
78
-
{
79
-
int ret;
80
-
81
-
ret = devm_clk_bulk_get(sdev->dev, clks->num_dsp_clks, clks->dsp_clks);
82
-
if (ret)
83
-
dev_err(sdev->dev, "Failed to request DSP clocks\n");
84
-
85
-
return ret;
86
-
}
87
-
EXPORT_SYMBOL(imx8_parse_clocks);
88
-
89
-
int imx8_enable_clocks(struct snd_sof_dev *sdev, struct imx_clocks *clks)
90
-
{
91
-
return clk_bulk_prepare_enable(clks->num_dsp_clks, clks->dsp_clks);
92
-
}
93
-
EXPORT_SYMBOL(imx8_enable_clocks);
94
-
95
-
void imx8_disable_clocks(struct snd_sof_dev *sdev, struct imx_clocks *clks)
96
-
{
97
-
clk_bulk_disable_unprepare(clks->num_dsp_clks, clks->dsp_clks);
98
-
}
99
-
EXPORT_SYMBOL(imx8_disable_clocks);
100
-
101
77
MODULE_LICENSE("Dual BSD/GPL");
-9
sound/soc/sof/imx/imx-common.h
-9
sound/soc/sof/imx/imx-common.h
···
15
15
16
16
void imx8_dump(struct snd_sof_dev *sdev, u32 flags);
17
17
18
-
struct imx_clocks {
19
-
struct clk_bulk_data *dsp_clks;
20
-
int num_dsp_clks;
21
-
};
22
-
23
-
int imx8_parse_clocks(struct snd_sof_dev *sdev, struct imx_clocks *clks);
24
-
int imx8_enable_clocks(struct snd_sof_dev *sdev, struct imx_clocks *clks);
25
-
void imx8_disable_clocks(struct snd_sof_dev *sdev, struct imx_clocks *clks);
26
-
27
18
#endif
+17
-24
sound/soc/sof/imx/imx8.c
+17
-24
sound/soc/sof/imx/imx8.c
···
41
41
#define MBOX_OFFSET 0x800000
42
42
#define MBOX_SIZE 0x1000
43
43
44
-
/* DSP clocks */
45
-
static struct clk_bulk_data imx8_dsp_clks[] = {
46
-
{ .id = "ipg" },
47
-
{ .id = "ocram" },
48
-
{ .id = "core" },
49
-
};
50
-
51
44
struct imx8_priv {
52
45
struct device *dev;
53
46
struct snd_sof_dev *sdev;
···
57
64
struct device **pd_dev;
58
65
struct device_link **link;
59
66
60
-
struct imx_clocks *clks;
67
+
struct clk_bulk_data *clks;
68
+
int clk_num;
61
69
};
62
70
63
71
static int imx8_get_mailbox_offset(struct snd_sof_dev *sdev)
···
190
196
if (!priv)
191
197
return -ENOMEM;
192
198
193
-
priv->clks = devm_kzalloc(&pdev->dev, sizeof(*priv->clks), GFP_KERNEL);
194
-
if (!priv->clks)
195
-
return -ENOMEM;
196
-
197
199
sdev->num_cores = 1;
198
200
sdev->pdata->hw_pdata = priv;
199
201
priv->dev = sdev->dev;
···
303
313
/* set default mailbox offset for FW ready message */
304
314
sdev->dsp_box.offset = MBOX_OFFSET;
305
315
306
-
/* init clocks info */
307
-
priv->clks->dsp_clks = imx8_dsp_clks;
308
-
priv->clks->num_dsp_clks = ARRAY_SIZE(imx8_dsp_clks);
309
-
310
-
ret = imx8_parse_clocks(sdev, priv->clks);
311
-
if (ret < 0)
316
+
ret = devm_clk_bulk_get_all(sdev->dev, &priv->clks);
317
+
if (ret < 0) {
318
+
dev_err(sdev->dev, "failed to fetch clocks: %d\n", ret);
312
319
goto exit_pdev_unregister;
320
+
}
321
+
priv->clk_num = ret;
313
322
314
-
ret = imx8_enable_clocks(sdev, priv->clks);
315
-
if (ret < 0)
323
+
ret = clk_bulk_prepare_enable(priv->clk_num, priv->clks);
324
+
if (ret < 0) {
325
+
dev_err(sdev->dev, "failed to enable clocks: %d\n", ret);
316
326
goto exit_pdev_unregister;
327
+
}
317
328
318
329
return 0;
319
330
···
334
343
struct imx8_priv *priv = sdev->pdata->hw_pdata;
335
344
int i;
336
345
337
-
imx8_disable_clocks(sdev, priv->clks);
346
+
clk_bulk_disable_unprepare(priv->clk_num, priv->clks);
338
347
platform_device_unregister(priv->ipc_dev);
339
348
340
349
for (i = 0; i < priv->num_domains; i++) {
···
364
373
for (i = 0; i < DSP_MU_CHAN_NUM; i++)
365
374
imx_dsp_free_channel(priv->dsp_ipc, i);
366
375
367
-
imx8_disable_clocks(sdev, priv->clks);
376
+
clk_bulk_disable_unprepare(priv->clk_num, priv->clks);
368
377
}
369
378
370
379
static int imx8_resume(struct snd_sof_dev *sdev)
···
373
382
int ret;
374
383
int i;
375
384
376
-
ret = imx8_enable_clocks(sdev, priv->clks);
377
-
if (ret < 0)
385
+
ret = clk_bulk_prepare_enable(priv->clk_num, priv->clks);
386
+
if (ret < 0) {
387
+
dev_err(sdev->dev, "failed to enable clocks: %d\n", ret);
378
388
return ret;
389
+
}
379
390
380
391
for (i = 0; i < DSP_MU_CHAN_NUM; i++)
381
392
imx_dsp_request_channel(priv->dsp_ipc, i);
+17
-23
sound/soc/sof/imx/imx8m.c
+17
-23
sound/soc/sof/imx/imx8m.c
···
26
26
#define MBOX_OFFSET 0x800000
27
27
#define MBOX_SIZE 0x1000
28
28
29
-
static struct clk_bulk_data imx8m_dsp_clks[] = {
30
-
{ .id = "ipg" },
31
-
{ .id = "ocram" },
32
-
{ .id = "core" },
33
-
};
34
-
35
29
/* DAP registers */
36
30
#define IMX8M_DAP_DEBUG 0x28800000
37
31
#define IMX8M_DAP_DEBUG_SIZE (64 * 1024)
···
48
54
struct imx_dsp_ipc *dsp_ipc;
49
55
struct platform_device *ipc_dev;
50
56
51
-
struct imx_clocks *clks;
57
+
struct clk_bulk_data *clks;
58
+
int clk_num;
52
59
53
60
void __iomem *dap;
54
61
struct regmap *regmap;
···
158
163
if (!priv)
159
164
return -ENOMEM;
160
165
161
-
priv->clks = devm_kzalloc(&pdev->dev, sizeof(*priv->clks), GFP_KERNEL);
162
-
if (!priv->clks)
163
-
return -ENOMEM;
164
-
165
166
sdev->num_cores = 1;
166
167
sdev->pdata->hw_pdata = priv;
167
168
priv->dev = sdev->dev;
···
241
250
goto exit_pdev_unregister;
242
251
}
243
252
244
-
/* init clocks info */
245
-
priv->clks->dsp_clks = imx8m_dsp_clks;
246
-
priv->clks->num_dsp_clks = ARRAY_SIZE(imx8m_dsp_clks);
247
-
248
-
ret = imx8_parse_clocks(sdev, priv->clks);
249
-
if (ret < 0)
253
+
ret = devm_clk_bulk_get_all(sdev->dev, &priv->clks);
254
+
if (ret < 0) {
255
+
dev_err(sdev->dev, "failed to fetch clocks: %d\n", ret);
250
256
goto exit_pdev_unregister;
257
+
}
258
+
priv->clk_num = ret;
251
259
252
-
ret = imx8_enable_clocks(sdev, priv->clks);
253
-
if (ret < 0)
260
+
ret = clk_bulk_prepare_enable(priv->clk_num, priv->clks);
261
+
if (ret < 0) {
262
+
dev_err(sdev->dev, "failed to enable clocks: %d\n", ret);
254
263
goto exit_pdev_unregister;
264
+
}
255
265
256
266
return 0;
257
267
···
265
273
{
266
274
struct imx8m_priv *priv = sdev->pdata->hw_pdata;
267
275
268
-
imx8_disable_clocks(sdev, priv->clks);
276
+
clk_bulk_disable_unprepare(priv->clk_num, priv->clks);
269
277
platform_device_unregister(priv->ipc_dev);
270
278
}
271
279
···
328
336
int ret;
329
337
int i;
330
338
331
-
ret = imx8_enable_clocks(sdev, priv->clks);
332
-
if (ret < 0)
339
+
ret = clk_bulk_prepare_enable(priv->clk_num, priv->clks);
340
+
if (ret < 0) {
341
+
dev_err(sdev->dev, "failed to enable clocks: %d\n", ret);
333
342
return ret;
343
+
}
334
344
335
345
for (i = 0; i < DSP_MU_CHAN_NUM; i++)
336
346
imx_dsp_request_channel(priv->dsp_ipc, i);
···
348
354
for (i = 0; i < DSP_MU_CHAN_NUM; i++)
349
355
imx_dsp_free_channel(priv->dsp_ipc, i);
350
356
351
-
imx8_disable_clocks(sdev, priv->clks);
357
+
clk_bulk_disable_unprepare(priv->clk_num, priv->clks);
352
358
}
353
359
354
360
static int imx8m_dsp_runtime_resume(struct snd_sof_dev *sdev)
+19
-23
sound/soc/sof/imx/imx8ulp.c
+19
-23
sound/soc/sof/imx/imx8ulp.c
···
40
40
#define MBOX_OFFSET 0x800000
41
41
#define MBOX_SIZE 0x1000
42
42
43
-
static struct clk_bulk_data imx8ulp_dsp_clks[] = {
44
-
{ .id = "core" },
45
-
{ .id = "ipg" },
46
-
{ .id = "ocram" },
47
-
{ .id = "mu" },
48
-
};
49
-
50
43
struct imx8ulp_priv {
51
44
struct device *dev;
52
45
struct snd_sof_dev *sdev;
···
49
56
struct platform_device *ipc_dev;
50
57
51
58
struct regmap *regmap;
52
-
struct imx_clocks *clks;
59
+
struct clk_bulk_data *clks;
60
+
int clk_num;
53
61
};
54
62
55
63
static void imx8ulp_sim_lpav_start(struct imx8ulp_priv *priv)
···
169
175
if (!priv)
170
176
return -ENOMEM;
171
177
172
-
priv->clks = devm_kzalloc(&pdev->dev, sizeof(*priv->clks), GFP_KERNEL);
173
-
if (!priv->clks)
174
-
return -ENOMEM;
175
-
176
178
sdev->num_cores = 1;
177
179
sdev->pdata->hw_pdata = priv;
178
180
priv->dev = sdev->dev;
···
249
259
goto exit_pdev_unregister;
250
260
}
251
261
252
-
priv->clks->dsp_clks = imx8ulp_dsp_clks;
253
-
priv->clks->num_dsp_clks = ARRAY_SIZE(imx8ulp_dsp_clks);
254
-
255
-
ret = imx8_parse_clocks(sdev, priv->clks);
256
-
if (ret < 0)
262
+
ret = devm_clk_bulk_get_all(sdev->dev, &priv->clks);
263
+
if (ret < 0) {
264
+
dev_err(sdev->dev, "failed to fetch clocks: %d\n", ret);
257
265
goto exit_pdev_unregister;
266
+
}
267
+
priv->clk_num = ret;
258
268
259
-
ret = imx8_enable_clocks(sdev, priv->clks);
260
-
if (ret < 0)
269
+
ret = clk_bulk_prepare_enable(priv->clk_num, priv->clks);
270
+
if (ret < 0) {
271
+
dev_err(sdev->dev, "failed to enable clocks: %d\n", ret);
261
272
goto exit_pdev_unregister;
273
+
}
262
274
263
275
return 0;
264
276
···
274
282
{
275
283
struct imx8ulp_priv *priv = sdev->pdata->hw_pdata;
276
284
277
-
imx8_disable_clocks(sdev, priv->clks);
285
+
clk_bulk_disable_unprepare(priv->clk_num, priv->clks);
278
286
platform_device_unregister(priv->ipc_dev);
279
287
}
280
288
···
295
303
for (i = 0; i < DSP_MU_CHAN_NUM; i++)
296
304
imx_dsp_free_channel(priv->dsp_ipc, i);
297
305
298
-
imx8_disable_clocks(sdev, priv->clks);
306
+
clk_bulk_disable_unprepare(priv->clk_num, priv->clks);
299
307
300
308
return 0;
301
309
}
···
303
311
static int imx8ulp_resume(struct snd_sof_dev *sdev)
304
312
{
305
313
struct imx8ulp_priv *priv = (struct imx8ulp_priv *)sdev->pdata->hw_pdata;
306
-
int i;
314
+
int i, ret;
307
315
308
-
imx8_enable_clocks(sdev, priv->clks);
316
+
ret = clk_bulk_prepare_enable(priv->clk_num, priv->clks);
317
+
if (ret < 0) {
318
+
dev_err(sdev->dev, "failed to enable clocks: %d\n", ret);
319
+
return ret;
320
+
}
309
321
310
322
for (i = 0; i < DSP_MU_CHAN_NUM; i++)
311
323
imx_dsp_request_channel(priv->dsp_ipc, i);