Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ASoC: fsl: Support register and unregister rpmsg
Merge series from Chancel Liu <chancel.liu@nxp.com>:
echo /lib/firmware/fw.elf > /sys/class/remoteproc/remoteproc0/firmware
(A) echo start > /sys/class/remoteproc/remoteproc0/state
(B) echo stop > /sys/class/remoteproc/remoteproc0/state
The rpmsg sound card is registered in (A) and unregistered in (B).
After "start", imx-audio-rpmsg registers devices for ASoC platform driver
and machine driver. Then sound card is registered. After "stop",
imx-audio-rpmsg unregisters devices for ASoC platform driver and machine
driver. Then sound card is unregistered.
+71
-32
+26
-17
sound/soc/fsl/fsl_rpmsg.c
+26
-17
sound/soc/fsl/fsl_rpmsg.c
···
135
135
136
136
static const struct snd_soc_component_driver fsl_component = {
137
137
.name = "fsl-rpmsg",
138
-
.legacy_dai_naming = 1,
139
138
};
140
139
141
140
static const struct fsl_rpmsg_soc_data imx7ulp_data = {
···
189
190
static int fsl_rpmsg_probe(struct platform_device *pdev)
190
191
{
191
192
struct device_node *np = pdev->dev.of_node;
193
+
struct snd_soc_dai_driver *dai_drv;
194
+
const char *dai_name;
192
195
struct fsl_rpmsg *rpmsg;
193
196
int ret;
197
+
198
+
dai_drv = devm_kzalloc(&pdev->dev, sizeof(struct snd_soc_dai_driver), GFP_KERNEL);
199
+
if (!dai_drv)
200
+
return -ENOMEM;
201
+
memcpy(dai_drv, &fsl_rpmsg_dai, sizeof(fsl_rpmsg_dai));
194
202
195
203
rpmsg = devm_kzalloc(&pdev->dev, sizeof(struct fsl_rpmsg), GFP_KERNEL);
196
204
if (!rpmsg)
···
205
199
206
200
rpmsg->soc_data = of_device_get_match_data(&pdev->dev);
207
201
208
-
fsl_rpmsg_dai.playback.rates = rpmsg->soc_data->rates;
209
-
fsl_rpmsg_dai.capture.rates = rpmsg->soc_data->rates;
210
-
fsl_rpmsg_dai.playback.formats = rpmsg->soc_data->formats;
211
-
fsl_rpmsg_dai.capture.formats = rpmsg->soc_data->formats;
202
+
if (rpmsg->soc_data) {
203
+
dai_drv->playback.rates = rpmsg->soc_data->rates;
204
+
dai_drv->capture.rates = rpmsg->soc_data->rates;
205
+
dai_drv->playback.formats = rpmsg->soc_data->formats;
206
+
dai_drv->capture.formats = rpmsg->soc_data->formats;
207
+
}
208
+
209
+
/* Use rpmsg channel name as cpu dai name */
210
+
ret = of_property_read_string(np, "fsl,rpmsg-channel-name", &dai_name);
211
+
if (ret) {
212
+
if (ret == -EINVAL) {
213
+
dai_name = "rpmsg-audio-channel";
214
+
} else {
215
+
dev_err(&pdev->dev, "Failed to get rpmsg channel name: %d!\n", ret);
216
+
return ret;
217
+
}
218
+
}
219
+
dai_drv->name = dai_name;
212
220
213
221
if (of_property_read_bool(np, "fsl,enable-lpa")) {
214
222
rpmsg->enable_lpa = 1;
···
256
236
pm_runtime_enable(&pdev->dev);
257
237
258
238
ret = devm_snd_soc_register_component(&pdev->dev, &fsl_component,
259
-
&fsl_rpmsg_dai, 1);
239
+
dai_drv, 1);
260
240
if (ret)
261
241
goto err_pm_disable;
262
-
263
-
rpmsg->card_pdev = platform_device_register_data(&pdev->dev,
264
-
"imx-audio-rpmsg",
265
-
PLATFORM_DEVID_AUTO,
266
-
NULL,
267
-
0);
268
-
if (IS_ERR(rpmsg->card_pdev)) {
269
-
dev_err(&pdev->dev, "failed to register rpmsg card\n");
270
-
ret = PTR_ERR(rpmsg->card_pdev);
271
-
goto err_pm_disable;
272
-
}
273
242
274
243
return 0;
275
244
+18
-3
sound/soc/fsl/imx-audio-rpmsg.c
+18
-3
sound/soc/fsl/imx-audio-rpmsg.c
···
12
12
*/
13
13
struct imx_audio_rpmsg {
14
14
struct platform_device *rpmsg_pdev;
15
+
struct platform_device *card_pdev;
15
16
};
16
17
17
18
static int imx_audio_rpmsg_cb(struct rpmsg_device *rpdev, void *data, int len,
···
88
87
89
88
/* Register platform driver for rpmsg routine */
90
89
data->rpmsg_pdev = platform_device_register_data(&rpdev->dev,
91
-
IMX_PCM_DRV_NAME,
92
-
PLATFORM_DEVID_AUTO,
90
+
rpdev->id.name,
91
+
PLATFORM_DEVID_NONE,
93
92
NULL, 0);
94
93
if (IS_ERR(data->rpmsg_pdev)) {
95
94
dev_err(&rpdev->dev, "failed to register rpmsg platform.\n");
96
95
ret = PTR_ERR(data->rpmsg_pdev);
96
+
}
97
+
98
+
data->card_pdev = platform_device_register_data(&rpdev->dev,
99
+
"imx-audio-rpmsg",
100
+
PLATFORM_DEVID_AUTO,
101
+
rpdev->id.name,
102
+
strlen(rpdev->id.name) + 1);
103
+
if (IS_ERR(data->card_pdev)) {
104
+
dev_err(&rpdev->dev, "failed to register rpmsg card.\n");
105
+
ret = PTR_ERR(data->card_pdev);
97
106
}
98
107
99
108
return ret;
···
116
105
if (data->rpmsg_pdev)
117
106
platform_device_unregister(data->rpmsg_pdev);
118
107
108
+
if (data->card_pdev)
109
+
platform_device_unregister(data->card_pdev);
110
+
119
111
dev_info(&rpdev->dev, "audio rpmsg driver is removed\n");
120
112
}
121
113
···
127
113
{ .name = "rpmsg-micfil-channel" },
128
114
{ },
129
115
};
116
+
MODULE_DEVICE_TABLE(rpmsg, imx_audio_rpmsg_id_table);
130
117
131
118
static struct rpmsg_driver imx_audio_rpmsg_driver = {
132
119
.drv.name = "imx_audio_rpmsg",
···
141
126
142
127
MODULE_DESCRIPTION("Freescale SoC Audio RPMSG interface");
143
128
MODULE_AUTHOR("Shengjiu Wang <shengjiu.wang@nxp.com>");
144
-
MODULE_ALIAS("platform:imx_audio_rpmsg");
129
+
MODULE_ALIAS("rpmsg:imx_audio_rpmsg");
145
130
MODULE_LICENSE("GPL v2");
+8
-3
sound/soc/fsl/imx-pcm-rpmsg.c
+8
-3
sound/soc/fsl/imx-pcm-rpmsg.c
···
732
732
goto fail;
733
733
}
734
734
735
-
/* platform component name is used by machine driver to link with */
736
-
component->name = info->rpdev->id.name;
737
-
738
735
#ifdef CONFIG_DEBUG_FS
739
736
component->debugfs_prefix = "rpmsg";
740
737
#endif
···
819
822
imx_rpmsg_pcm_resume)
820
823
};
821
824
825
+
static const struct platform_device_id imx_rpmsg_pcm_id_table[] = {
826
+
{ .name = "rpmsg-audio-channel" },
827
+
{ .name = "rpmsg-micfil-channel" },
828
+
{ },
829
+
};
830
+
MODULE_DEVICE_TABLE(platform, imx_rpmsg_pcm_id_table);
831
+
822
832
static struct platform_driver imx_pcm_rpmsg_driver = {
823
833
.probe = imx_rpmsg_pcm_probe,
824
834
.remove_new = imx_rpmsg_pcm_remove,
835
+
.id_table = imx_rpmsg_pcm_id_table,
825
836
.driver = {
826
837
.name = IMX_PCM_DRV_NAME,
827
838
.pm = &imx_rpmsg_pcm_pm_ops,
+19
-9
sound/soc/fsl/imx-rpmsg.c
+19
-9
sound/soc/fsl/imx-rpmsg.c
···
108
108
static int imx_rpmsg_probe(struct platform_device *pdev)
109
109
{
110
110
struct snd_soc_dai_link_component *dlc;
111
-
struct device *dev = pdev->dev.parent;
112
-
/* rpmsg_pdev is the platform device for the rpmsg node that probed us */
113
-
struct platform_device *rpmsg_pdev = to_platform_device(dev);
114
-
struct device_node *np = rpmsg_pdev->dev.of_node;
111
+
struct snd_soc_dai *cpu_dai;
112
+
struct device_node *np = NULL;
115
113
struct of_phandle_args args;
116
114
const char *platform_name;
117
115
struct imx_rpmsg *data;
···
124
126
ret = -ENOMEM;
125
127
goto fail;
126
128
}
127
-
128
-
ret = of_reserved_mem_device_init_by_idx(&pdev->dev, np, 0);
129
-
if (ret)
130
-
dev_warn(&pdev->dev, "no reserved DMA memory\n");
131
129
132
130
data->dai.cpus = &dlc[0];
133
131
data->dai.num_cpus = 1;
···
146
152
*/
147
153
data->dai.ignore_pmdown_time = 1;
148
154
155
+
data->dai.cpus->dai_name = pdev->dev.platform_data;
156
+
cpu_dai = snd_soc_find_dai(data->dai.cpus);
157
+
if (!cpu_dai) {
158
+
ret = -EPROBE_DEFER;
159
+
goto fail;
160
+
}
161
+
np = cpu_dai->dev->of_node;
162
+
if (!np) {
163
+
dev_err(&pdev->dev, "failed to parse CPU DAI device node\n");
164
+
ret = -ENODEV;
165
+
goto fail;
166
+
}
167
+
168
+
ret = of_reserved_mem_device_init_by_idx(&pdev->dev, np, 0);
169
+
if (ret)
170
+
dev_warn(&pdev->dev, "no reserved DMA memory\n");
171
+
149
172
/* Optional codec node */
150
173
ret = of_parse_phandle_with_fixed_args(np, "audio-codec", 0, 0, &args);
151
174
if (ret) {
···
181
170
data->sysclk = clk_get_rate(clk);
182
171
}
183
172
184
-
data->dai.cpus->dai_name = dev_name(&rpmsg_pdev->dev);
185
173
if (!of_property_read_string(np, "fsl,rpmsg-channel-name", &platform_name))
186
174
data->dai.platforms->name = platform_name;
187
175
else