Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
ASoC: Intel: avs: Properly identify boards
Merge series from Amadeusz Sławiński <amadeuszx.slawinski@linux.intel.com>:
Instead of using MODULE_ALIAS() to load boards, add proper device id
table and use MODULE_DEVICE_TABLE() macro to create board alias.
+153
-17
+9
-1
sound/soc/intel/avs/boards/da7219.c
+9
-1
sound/soc/intel/avs/boards/da7219.c
···
277
277
return devm_snd_soc_register_card(dev, card);
278
278
}
279
279
280
+
static const struct platform_device_id avs_da7219_driver_ids[] = {
281
+
{
282
+
.name = "avs_da7219",
283
+
},
284
+
{},
285
+
};
286
+
MODULE_DEVICE_TABLE(platform, avs_da7219_driver_ids);
287
+
280
288
static struct platform_driver avs_da7219_driver = {
281
289
.probe = avs_da7219_probe,
282
290
.driver = {
283
291
.name = "avs_da7219",
284
292
.pm = &snd_soc_pm_ops,
285
293
},
294
+
.id_table = avs_da7219_driver_ids,
286
295
};
287
296
288
297
module_platform_driver(avs_da7219_driver);
289
298
290
299
MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>");
291
300
MODULE_LICENSE("GPL");
292
-
MODULE_ALIAS("platform:avs_da7219");
+9
-1
sound/soc/intel/avs/boards/dmic.c
+9
-1
sound/soc/intel/avs/boards/dmic.c
···
77
77
return devm_snd_soc_register_card(dev, card);
78
78
}
79
79
80
+
static const struct platform_device_id avs_dmic_driver_ids[] = {
81
+
{
82
+
.name = "avs_dmic",
83
+
},
84
+
{},
85
+
};
86
+
MODULE_DEVICE_TABLE(platform, avs_dmic_driver_ids);
87
+
80
88
static struct platform_driver avs_dmic_driver = {
81
89
.probe = avs_dmic_probe,
82
90
.driver = {
83
91
.name = "avs_dmic",
84
92
.pm = &snd_soc_pm_ops,
85
93
},
94
+
.id_table = avs_dmic_driver_ids,
86
95
};
87
96
88
97
module_platform_driver(avs_dmic_driver);
89
98
90
99
MODULE_LICENSE("GPL");
91
-
MODULE_ALIAS("platform:avs_dmic");
+9
-1
sound/soc/intel/avs/boards/es8336.c
+9
-1
sound/soc/intel/avs/boards/es8336.c
···
307
307
return devm_snd_soc_register_card(dev, card);
308
308
}
309
309
310
+
static const struct platform_device_id avs_es8336_driver_ids[] = {
311
+
{
312
+
.name = "avs_es8336",
313
+
},
314
+
{},
315
+
};
316
+
MODULE_DEVICE_TABLE(platform, avs_es8336_driver_ids);
317
+
310
318
static struct platform_driver avs_es8336_driver = {
311
319
.probe = avs_es8336_probe,
312
320
.driver = {
313
321
.name = "avs_es8336",
314
322
.pm = &snd_soc_pm_ops,
315
323
},
324
+
.id_table = avs_es8336_driver_ids,
316
325
};
317
326
318
327
module_platform_driver(avs_es8336_driver);
319
328
320
329
MODULE_LICENSE("GPL");
321
-
MODULE_ALIAS("platform:avs_es8336");
+9
-1
sound/soc/intel/avs/boards/hdaudio.c
+9
-1
sound/soc/intel/avs/boards/hdaudio.c
···
218
218
return devm_snd_soc_register_card(dev, card);
219
219
}
220
220
221
+
static const struct platform_device_id avs_hdaudio_driver_ids[] = {
222
+
{
223
+
.name = "avs_hdaudio",
224
+
},
225
+
{},
226
+
};
227
+
MODULE_DEVICE_TABLE(platform, avs_hdaudio_driver_ids);
228
+
221
229
static struct platform_driver avs_hdaudio_driver = {
222
230
.probe = avs_hdaudio_probe,
223
231
.driver = {
224
232
.name = "avs_hdaudio",
225
233
.pm = &snd_soc_pm_ops,
226
234
},
235
+
.id_table = avs_hdaudio_driver_ids,
227
236
};
228
237
229
238
module_platform_driver(avs_hdaudio_driver)
···
240
231
MODULE_DESCRIPTION("Intel HD-Audio machine driver");
241
232
MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>");
242
233
MODULE_LICENSE("GPL");
243
-
MODULE_ALIAS("platform:avs_hdaudio");
+9
-1
sound/soc/intel/avs/boards/i2s_test.c
+9
-1
sound/soc/intel/avs/boards/i2s_test.c
···
185
185
return devm_snd_soc_register_card(dev, card);
186
186
}
187
187
188
+
static const struct platform_device_id avs_i2s_test_driver_ids[] = {
189
+
{
190
+
.name = "avs_i2s_test",
191
+
},
192
+
{},
193
+
};
194
+
MODULE_DEVICE_TABLE(platform, avs_i2s_test_driver_ids);
195
+
188
196
static struct platform_driver avs_i2s_test_driver = {
189
197
.probe = avs_i2s_test_probe,
190
198
.driver = {
191
199
.name = "avs_i2s_test",
192
200
.pm = &snd_soc_pm_ops,
193
201
},
202
+
.id_table = avs_i2s_test_driver_ids,
194
203
};
195
204
196
205
module_platform_driver(avs_i2s_test_driver);
197
206
198
207
MODULE_LICENSE("GPL");
199
-
MODULE_ALIAS("platform:avs_i2s_test");
+9
-1
sound/soc/intel/avs/boards/max98357a.c
+9
-1
sound/soc/intel/avs/boards/max98357a.c
···
135
135
return devm_snd_soc_register_card(dev, card);
136
136
}
137
137
138
+
static const struct platform_device_id avs_max98357a_driver_ids[] = {
139
+
{
140
+
.name = "avs_max98357a",
141
+
},
142
+
{},
143
+
};
144
+
MODULE_DEVICE_TABLE(platform, avs_max98357a_driver_ids);
145
+
138
146
static struct platform_driver avs_max98357a_driver = {
139
147
.probe = avs_max98357a_probe,
140
148
.driver = {
141
149
.name = "avs_max98357a",
142
150
.pm = &snd_soc_pm_ops,
143
151
},
152
+
.id_table = avs_max98357a_driver_ids,
144
153
};
145
154
146
155
module_platform_driver(avs_max98357a_driver)
147
156
148
157
MODULE_LICENSE("GPL");
149
-
MODULE_ALIAS("platform:avs_max98357a");
+9
-1
sound/soc/intel/avs/boards/max98373.c
+9
-1
sound/soc/intel/avs/boards/max98373.c
···
192
192
return devm_snd_soc_register_card(dev, card);
193
193
}
194
194
195
+
static const struct platform_device_id avs_max98373_driver_ids[] = {
196
+
{
197
+
.name = "avs_max98373",
198
+
},
199
+
{},
200
+
};
201
+
MODULE_DEVICE_TABLE(platform, avs_max98373_driver_ids);
202
+
195
203
static struct platform_driver avs_max98373_driver = {
196
204
.probe = avs_max98373_probe,
197
205
.driver = {
198
206
.name = "avs_max98373",
199
207
.pm = &snd_soc_pm_ops,
200
208
},
209
+
.id_table = avs_max98373_driver_ids,
201
210
};
202
211
203
212
module_platform_driver(avs_max98373_driver)
204
213
205
214
MODULE_LICENSE("GPL");
206
-
MODULE_ALIAS("platform:avs_max98373");
+9
-1
sound/soc/intel/avs/boards/max98927.c
+9
-1
sound/soc/intel/avs/boards/max98927.c
···
189
189
return devm_snd_soc_register_card(dev, card);
190
190
}
191
191
192
+
static const struct platform_device_id avs_max98927_driver_ids[] = {
193
+
{
194
+
.name = "avs_max98927",
195
+
},
196
+
{},
197
+
};
198
+
MODULE_DEVICE_TABLE(platform, avs_max98927_driver_ids);
199
+
192
200
static struct platform_driver avs_max98927_driver = {
193
201
.probe = avs_max98927_probe,
194
202
.driver = {
195
203
.name = "avs_max98927",
196
204
.pm = &snd_soc_pm_ops,
197
205
},
206
+
.id_table = avs_max98927_driver_ids,
198
207
};
199
208
200
209
module_platform_driver(avs_max98927_driver)
201
210
202
211
MODULE_LICENSE("GPL");
203
-
MODULE_ALIAS("platform:avs_max98927");
+9
-1
sound/soc/intel/avs/boards/nau8825.c
+9
-1
sound/soc/intel/avs/boards/nau8825.c
···
294
294
return devm_snd_soc_register_card(dev, card);
295
295
}
296
296
297
+
static const struct platform_device_id avs_nau8825_driver_ids[] = {
298
+
{
299
+
.name = "avs_nau8825",
300
+
},
301
+
{},
302
+
};
303
+
MODULE_DEVICE_TABLE(platform, avs_nau8825_driver_ids);
304
+
297
305
static struct platform_driver avs_nau8825_driver = {
298
306
.probe = avs_nau8825_probe,
299
307
.driver = {
300
308
.name = "avs_nau8825",
301
309
.pm = &snd_soc_pm_ops,
302
310
},
311
+
.id_table = avs_nau8825_driver_ids,
303
312
};
304
313
305
314
module_platform_driver(avs_nau8825_driver)
306
315
307
316
MODULE_LICENSE("GPL");
308
-
MODULE_ALIAS("platform:avs_nau8825");
+9
-1
sound/soc/intel/avs/boards/probe.c
+9
-1
sound/soc/intel/avs/boards/probe.c
···
50
50
return devm_snd_soc_register_card(dev, card);
51
51
}
52
52
53
+
static const struct platform_device_id avs_probe_mb_driver_ids[] = {
54
+
{
55
+
.name = "avs_probe_mb",
56
+
},
57
+
{},
58
+
};
59
+
MODULE_DEVICE_TABLE(platform, avs_probe_mb_driver_ids);
60
+
53
61
static struct platform_driver avs_probe_mb_driver = {
54
62
.probe = avs_probe_mb_probe,
55
63
.driver = {
56
64
.name = "avs_probe_mb",
57
65
.pm = &snd_soc_pm_ops,
58
66
},
67
+
.id_table = avs_probe_mb_driver_ids,
59
68
};
60
69
61
70
module_platform_driver(avs_probe_mb_driver);
62
71
63
72
MODULE_LICENSE("GPL");
64
-
MODULE_ALIAS("platform:avs_probe_mb");
+9
-1
sound/soc/intel/avs/boards/rt274.c
+9
-1
sound/soc/intel/avs/boards/rt274.c
···
257
257
return devm_snd_soc_register_card(dev, card);
258
258
}
259
259
260
+
static const struct platform_device_id avs_rt274_driver_ids[] = {
261
+
{
262
+
.name = "avs_rt274",
263
+
},
264
+
{},
265
+
};
266
+
MODULE_DEVICE_TABLE(platform, avs_rt274_driver_ids);
267
+
260
268
static struct platform_driver avs_rt274_driver = {
261
269
.probe = avs_rt274_probe,
262
270
.driver = {
263
271
.name = "avs_rt274",
264
272
.pm = &snd_soc_pm_ops,
265
273
},
274
+
.id_table = avs_rt274_driver_ids,
266
275
};
267
276
268
277
module_platform_driver(avs_rt274_driver);
269
278
270
279
MODULE_LICENSE("GPL");
271
-
MODULE_ALIAS("platform:avs_rt274");
+9
-1
sound/soc/intel/avs/boards/rt286.c
+9
-1
sound/soc/intel/avs/boards/rt286.c
···
228
228
return devm_snd_soc_register_card(dev, card);
229
229
}
230
230
231
+
static const struct platform_device_id avs_rt286_driver_ids[] = {
232
+
{
233
+
.name = "avs_rt286",
234
+
},
235
+
{},
236
+
};
237
+
MODULE_DEVICE_TABLE(platform, avs_rt286_driver_ids);
238
+
231
239
static struct platform_driver avs_rt286_driver = {
232
240
.probe = avs_rt286_probe,
233
241
.driver = {
234
242
.name = "avs_rt286",
235
243
.pm = &snd_soc_pm_ops,
236
244
},
245
+
.id_table = avs_rt286_driver_ids,
237
246
};
238
247
239
248
module_platform_driver(avs_rt286_driver);
240
249
241
250
MODULE_LICENSE("GPL");
242
-
MODULE_ALIAS("platform:avs_rt286");
+9
-1
sound/soc/intel/avs/boards/rt298.c
+9
-1
sound/soc/intel/avs/boards/rt298.c
···
247
247
return devm_snd_soc_register_card(dev, card);
248
248
}
249
249
250
+
static const struct platform_device_id avs_rt298_driver_ids[] = {
251
+
{
252
+
.name = "avs_rt298",
253
+
},
254
+
{},
255
+
};
256
+
MODULE_DEVICE_TABLE(platform, avs_rt298_driver_ids);
257
+
250
258
static struct platform_driver avs_rt298_driver = {
251
259
.probe = avs_rt298_probe,
252
260
.driver = {
253
261
.name = "avs_rt298",
254
262
.pm = &snd_soc_pm_ops,
255
263
},
264
+
.id_table = avs_rt298_driver_ids,
256
265
};
257
266
258
267
module_platform_driver(avs_rt298_driver);
259
268
260
269
MODULE_LICENSE("GPL");
261
-
MODULE_ALIAS("platform:avs_rt298");
+9
-1
sound/soc/intel/avs/boards/rt5514.c
+9
-1
sound/soc/intel/avs/boards/rt5514.c
···
173
173
return devm_snd_soc_register_card(dev, card);
174
174
}
175
175
176
+
static const struct platform_device_id avs_rt5514_driver_ids[] = {
177
+
{
178
+
.name = "avs_rt5514",
179
+
},
180
+
{},
181
+
};
182
+
MODULE_DEVICE_TABLE(platform, avs_rt5514_driver_ids);
183
+
176
184
static struct platform_driver avs_rt5514_driver = {
177
185
.probe = avs_rt5514_probe,
178
186
.driver = {
179
187
.name = "avs_rt5514",
180
188
.pm = &snd_soc_pm_ops,
181
189
},
190
+
.id_table = avs_rt5514_driver_ids,
182
191
};
183
192
184
193
module_platform_driver(avs_rt5514_driver);
185
194
186
195
MODULE_LICENSE("GPL");
187
-
MODULE_ALIAS("platform:avs_rt5514");
+9
-1
sound/soc/intel/avs/boards/rt5663.c
+9
-1
sound/soc/intel/avs/boards/rt5663.c
···
246
246
return devm_snd_soc_register_card(dev, card);
247
247
}
248
248
249
+
static const struct platform_device_id avs_rt5663_driver_ids[] = {
250
+
{
251
+
.name = "avs_rt5663",
252
+
},
253
+
{},
254
+
};
255
+
MODULE_DEVICE_TABLE(platform, avs_rt5663_driver_ids);
256
+
249
257
static struct platform_driver avs_rt5663_driver = {
250
258
.probe = avs_rt5663_probe,
251
259
.driver = {
252
260
.name = "avs_rt5663",
253
261
.pm = &snd_soc_pm_ops,
254
262
},
263
+
.id_table = avs_rt5663_driver_ids,
255
264
};
256
265
257
266
module_platform_driver(avs_rt5663_driver);
258
267
259
268
MODULE_LICENSE("GPL");
260
-
MODULE_ALIAS("platform:avs_rt5663");
+9
-1
sound/soc/intel/avs/boards/rt5682.c
+9
-1
sound/soc/intel/avs/boards/rt5682.c
···
322
322
return devm_snd_soc_register_card(dev, card);
323
323
}
324
324
325
+
static const struct platform_device_id avs_rt5682_driver_ids[] = {
326
+
{
327
+
.name = "avs_rt5682",
328
+
},
329
+
{},
330
+
};
331
+
MODULE_DEVICE_TABLE(platform, avs_rt5682_driver_ids);
332
+
325
333
static struct platform_driver avs_rt5682_driver = {
326
334
.probe = avs_rt5682_probe,
327
335
.driver = {
328
336
.name = "avs_rt5682",
329
337
.pm = &snd_soc_pm_ops,
330
338
},
339
+
.id_table = avs_rt5682_driver_ids,
331
340
};
332
341
333
342
module_platform_driver(avs_rt5682_driver)
334
343
335
344
MODULE_AUTHOR("Cezary Rojewski <cezary.rojewski@intel.com>");
336
345
MODULE_LICENSE("GPL");
337
-
MODULE_ALIAS("platform:avs_rt5682");
+9
-1
sound/soc/intel/avs/boards/ssm4567.c
+9
-1
sound/soc/intel/avs/boards/ssm4567.c
···
181
181
return devm_snd_soc_register_card(dev, card);
182
182
}
183
183
184
+
static const struct platform_device_id avs_ssm4567_driver_ids[] = {
185
+
{
186
+
.name = "avs_ssm4567",
187
+
},
188
+
{},
189
+
};
190
+
MODULE_DEVICE_TABLE(platform, avs_ssm4567_driver_ids);
191
+
184
192
static struct platform_driver avs_ssm4567_driver = {
185
193
.probe = avs_ssm4567_probe,
186
194
.driver = {
187
195
.name = "avs_ssm4567",
188
196
.pm = &snd_soc_pm_ops,
189
197
},
198
+
.id_table = avs_ssm4567_driver_ids,
190
199
};
191
200
192
201
module_platform_driver(avs_ssm4567_driver)
193
202
194
203
MODULE_LICENSE("GPL");
195
-
MODULE_ALIAS("platform:avs_ssm4567");