Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Improve CS35l41-based audio codec drivers
Merge series from Cristian Ciocaltea <cristian.ciocaltea@collabora.com>:
This patch series contains several fixes and improvements to drivers
based on the CS35l41 audio codec.
It has been verified on Valve's Steam Deck, except the HDA related patches.
+112
-91
+2
-2
include/sound/cs35l41.h
+2
-2
include/sound/cs35l41.h
···
11
11
#define __CS35L41_H
12
12
13
13
#include <linux/regmap.h>
14
-
#include <linux/completion.h>
15
14
#include <linux/firmware/cirrus/cs_dsp.h>
16
15
17
16
#define CS35L41_FIRSTREG 0x00000000
···
901
902
int cs35l41_init_boost(struct device *dev, struct regmap *regmap,
902
903
struct cs35l41_hw_cfg *hw_cfg);
903
904
bool cs35l41_safe_reset(struct regmap *regmap, enum cs35l41_boost_type b_type);
905
+
int cs35l41_mdsync_up(struct regmap *regmap);
904
906
int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l41_boost_type b_type,
905
-
int enable, struct completion *pll_lock, bool firmware_running);
907
+
int enable, bool firmware_running);
906
908
907
909
#endif /* __CS35L41_H */
+12
-11
sound/pci/hda/cs35l41_hda.c
+12
-11
sound/pci/hda/cs35l41_hda.c
···
527
527
528
528
dev_dbg(dev, "Play (Complete)\n");
529
529
530
-
cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1, NULL,
530
+
cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 1,
531
531
cs35l41->firmware_running);
532
532
if (cs35l41->firmware_running) {
533
533
regmap_multi_reg_write(reg, cs35l41_hda_unmute_dsp,
···
546
546
dev_dbg(dev, "Pause (Start)\n");
547
547
548
548
regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute));
549
-
cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0, NULL,
549
+
cs35l41_global_enable(dev, reg, cs35l41->hw_cfg.bst_type, 0,
550
550
cs35l41->firmware_running);
551
551
}
552
552
···
1550
1550
ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status,
1551
1551
int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000);
1552
1552
if (ret) {
1553
-
dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE: %d\n", ret);
1553
+
dev_err_probe(cs35l41->dev, ret, "Failed waiting for OTP_BOOT_DONE\n");
1554
1554
goto err;
1555
1555
}
1556
1556
1557
1557
ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_sts);
1558
1558
if (ret || (int_sts & CS35L41_OTP_BOOT_ERR)) {
1559
-
dev_err(cs35l41->dev, "OTP Boot status %x error: %d\n",
1560
-
int_sts & CS35L41_OTP_BOOT_ERR, ret);
1559
+
dev_err_probe(cs35l41->dev, ret, "OTP Boot status %x error\n",
1560
+
int_sts & CS35L41_OTP_BOOT_ERR);
1561
1561
ret = -EIO;
1562
1562
goto err;
1563
1563
}
1564
1564
1565
1565
ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, ®id);
1566
1566
if (ret) {
1567
-
dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret);
1567
+
dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n");
1568
1568
goto err;
1569
1569
}
1570
1570
1571
1571
ret = regmap_read(cs35l41->regmap, CS35L41_REVID, ®_revid);
1572
1572
if (ret) {
1573
-
dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret);
1573
+
dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n");
1574
1574
goto err;
1575
1575
}
1576
1576
···
1593
1593
1594
1594
ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1595
1595
if (ret) {
1596
-
dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret);
1596
+
dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n");
1597
1597
goto err;
1598
1598
}
1599
1599
···
1624
1624
1625
1625
ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops);
1626
1626
if (ret) {
1627
-
dev_err(cs35l41->dev, "Register component failed: %d\n", ret);
1628
-
pm_runtime_disable(cs35l41->dev);
1629
-
goto err;
1627
+
dev_err_probe(cs35l41->dev, ret, "Register component failed\n");
1628
+
goto err_pm;
1630
1629
}
1631
1630
1632
1631
dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid);
···
1633
1634
return 0;
1634
1635
1635
1636
err_pm:
1637
+
pm_runtime_dont_use_autosuspend(cs35l41->dev);
1636
1638
pm_runtime_disable(cs35l41->dev);
1637
1639
pm_runtime_put_noidle(cs35l41->dev);
1638
1640
···
1652
1652
struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev);
1653
1653
1654
1654
pm_runtime_get_sync(cs35l41->dev);
1655
+
pm_runtime_dont_use_autosuspend(cs35l41->dev);
1655
1656
pm_runtime_disable(cs35l41->dev);
1656
1657
1657
1658
if (cs35l41->halo_initialized)
+4
-7
sound/soc/codecs/cs35l41-i2c.c
+4
-7
sound/soc/codecs/cs35l41-i2c.c
···
35
35
struct device *dev = &client->dev;
36
36
struct cs35l41_hw_cfg *hw_cfg = dev_get_platdata(dev);
37
37
const struct regmap_config *regmap_config = &cs35l41_regmap_i2c;
38
-
int ret;
39
38
40
39
cs35l41 = devm_kzalloc(dev, sizeof(struct cs35l41_private), GFP_KERNEL);
41
40
···
46
47
47
48
i2c_set_clientdata(client, cs35l41);
48
49
cs35l41->regmap = devm_regmap_init_i2c(client, regmap_config);
49
-
if (IS_ERR(cs35l41->regmap)) {
50
-
ret = PTR_ERR(cs35l41->regmap);
51
-
dev_err(cs35l41->dev, "Failed to allocate register map: %d\n", ret);
52
-
return ret;
53
-
}
50
+
if (IS_ERR(cs35l41->regmap))
51
+
return dev_err_probe(cs35l41->dev, PTR_ERR(cs35l41->regmap),
52
+
"Failed to allocate register map\n");
54
53
55
54
return cs35l41_probe(cs35l41, hw_cfg);
56
55
}
···
80
83
static struct i2c_driver cs35l41_i2c_driver = {
81
84
.driver = {
82
85
.name = "cs35l41",
83
-
.pm = &cs35l41_pm_ops,
86
+
.pm = pm_ptr(&cs35l41_pm_ops),
84
87
.of_match_table = of_match_ptr(cs35l41_of_match),
85
88
.acpi_match_table = ACPI_PTR(cs35l41_acpi_match),
86
89
},
+37
-23
sound/soc/codecs/cs35l41-lib.c
+37
-23
sound/soc/codecs/cs35l41-lib.c
···
1192
1192
}
1193
1193
EXPORT_SYMBOL_GPL(cs35l41_safe_reset);
1194
1194
1195
+
/*
1196
+
* Enabling the CS35L41_SHD_BOOST_ACTV and CS35L41_SHD_BOOST_PASS shared boosts
1197
+
* does also require a call to cs35l41_mdsync_up(), but not before getting the
1198
+
* PLL Lock signal.
1199
+
*
1200
+
* PLL Lock seems to be triggered soon after snd_pcm_start() is executed and
1201
+
* SNDRV_PCM_TRIGGER_START command is processed, which happens (long) after the
1202
+
* SND_SOC_DAPM_PRE_PMU event handler is invoked as part of snd_pcm_prepare().
1203
+
*
1204
+
* This event handler is where cs35l41_global_enable() is normally called from,
1205
+
* but waiting for PLL Lock here will time out. Increasing the wait duration
1206
+
* will not help, as the only consequence of it would be to add an unnecessary
1207
+
* delay in the invocation of snd_pcm_start().
1208
+
*
1209
+
* Trying to move the wait in the SNDRV_PCM_TRIGGER_START callback is not a
1210
+
* solution either, as the trigger is executed in an IRQ-off atomic context.
1211
+
*
1212
+
* The current approach is to invoke cs35l41_mdsync_up() right after receiving
1213
+
* the PLL Lock interrupt, in the IRQ handler.
1214
+
*/
1195
1215
int cs35l41_global_enable(struct device *dev, struct regmap *regmap, enum cs35l41_boost_type b_type,
1196
-
int enable, struct completion *pll_lock, bool firmware_running)
1216
+
int enable, bool firmware_running)
1197
1217
{
1198
1218
int ret;
1199
1219
unsigned int gpio1_func, pad_control, pwr_ctrl1, pwr_ctrl3, int_status, pup_pdn_mask;
···
1222
1202
{CS35L41_PWR_CTRL3, 0},
1223
1203
{CS35L41_GPIO_PAD_CONTROL, 0},
1224
1204
{CS35L41_PWR_CTRL1, 0, 3000},
1225
-
};
1226
-
struct reg_sequence cs35l41_mdsync_up_seq[] = {
1227
-
{CS35L41_PWR_CTRL3, 0},
1228
-
{CS35L41_PWR_CTRL1, 0x00000000, 3000},
1229
-
{CS35L41_PWR_CTRL1, 0x00000001, 3000},
1230
1205
};
1231
1206
1232
1207
pup_pdn_mask = enable ? CS35L41_PUP_DONE_MASK : CS35L41_PDN_DONE_MASK;
···
1256
1241
cs35l41_mdsync_down_seq[0].def = pwr_ctrl3;
1257
1242
cs35l41_mdsync_down_seq[1].def = pad_control;
1258
1243
cs35l41_mdsync_down_seq[2].def = pwr_ctrl1;
1244
+
1259
1245
ret = regmap_multi_reg_write(regmap, cs35l41_mdsync_down_seq,
1260
1246
ARRAY_SIZE(cs35l41_mdsync_down_seq));
1261
-
if (!enable)
1262
-
break;
1263
-
1264
-
if (!pll_lock)
1265
-
return -EINVAL;
1266
-
1267
-
ret = wait_for_completion_timeout(pll_lock, msecs_to_jiffies(1000));
1268
-
if (ret == 0) {
1269
-
ret = -ETIMEDOUT;
1270
-
} else {
1271
-
regmap_read(regmap, CS35L41_PWR_CTRL3, &pwr_ctrl3);
1272
-
pwr_ctrl3 |= CS35L41_SYNC_EN_MASK;
1273
-
cs35l41_mdsync_up_seq[0].def = pwr_ctrl3;
1274
-
ret = regmap_multi_reg_write(regmap, cs35l41_mdsync_up_seq,
1275
-
ARRAY_SIZE(cs35l41_mdsync_up_seq));
1276
-
}
1247
+
/* Activation to be completed later via cs35l41_mdsync_up() */
1248
+
if (ret || enable)
1249
+
return ret;
1277
1250
1278
1251
ret = regmap_read_poll_timeout(regmap, CS35L41_IRQ1_STATUS1,
1279
1252
int_status, int_status & pup_pdn_mask,
···
1269
1266
if (ret)
1270
1267
dev_err(dev, "Enable(%d) failed: %d\n", enable, ret);
1271
1268
1272
-
// Clear PUP/PDN status
1269
+
/* Clear PUP/PDN status */
1273
1270
regmap_write(regmap, CS35L41_IRQ1_STATUS1, pup_pdn_mask);
1274
1271
break;
1275
1272
case CS35L41_INT_BOOST:
···
1350
1347
return ret;
1351
1348
}
1352
1349
EXPORT_SYMBOL_GPL(cs35l41_global_enable);
1350
+
1351
+
/*
1352
+
* To be called after receiving the IRQ Lock interrupt, in order to complete
1353
+
* any shared boost activation initiated by cs35l41_global_enable().
1354
+
*/
1355
+
int cs35l41_mdsync_up(struct regmap *regmap)
1356
+
{
1357
+
return regmap_update_bits(regmap, CS35L41_PWR_CTRL3,
1358
+
CS35L41_SYNC_EN_MASK, CS35L41_SYNC_EN_MASK);
1359
+
}
1360
+
EXPORT_SYMBOL_GPL(cs35l41_mdsync_up);
1353
1361
1354
1362
int cs35l41_gpio_config(struct regmap *regmap, struct cs35l41_hw_cfg *hw_cfg)
1355
1363
{
+4
-7
sound/soc/codecs/cs35l41-spi.c
+4
-7
sound/soc/codecs/cs35l41-spi.c
···
32
32
const struct regmap_config *regmap_config = &cs35l41_regmap_spi;
33
33
struct cs35l41_hw_cfg *hw_cfg = dev_get_platdata(&spi->dev);
34
34
struct cs35l41_private *cs35l41;
35
-
int ret;
36
35
37
36
cs35l41 = devm_kzalloc(&spi->dev, sizeof(struct cs35l41_private), GFP_KERNEL);
38
37
if (!cs35l41)
···
42
43
43
44
spi_set_drvdata(spi, cs35l41);
44
45
cs35l41->regmap = devm_regmap_init_spi(spi, regmap_config);
45
-
if (IS_ERR(cs35l41->regmap)) {
46
-
ret = PTR_ERR(cs35l41->regmap);
47
-
dev_err(&spi->dev, "Failed to allocate register map: %d\n", ret);
48
-
return ret;
49
-
}
46
+
if (IS_ERR(cs35l41->regmap))
47
+
return dev_err_probe(cs35l41->dev, PTR_ERR(cs35l41->regmap),
48
+
"Failed to allocate register map\n");
50
49
51
50
cs35l41->dev = &spi->dev;
52
51
cs35l41->irq = spi->irq;
···
80
83
static struct spi_driver cs35l41_spi_driver = {
81
84
.driver = {
82
85
.name = "cs35l41",
83
-
.pm = &cs35l41_pm_ops,
86
+
.pm = pm_ptr(&cs35l41_pm_ops),
84
87
.of_match_table = of_match_ptr(cs35l41_of_match),
85
88
.acpi_match_table = ACPI_PTR(cs35l41_acpi_match),
86
89
},
+53
-40
sound/soc/codecs/cs35l41.c
+53
-40
sound/soc/codecs/cs35l41.c
···
386
386
struct cs35l41_private *cs35l41 = data;
387
387
unsigned int status[4] = { 0, 0, 0, 0 };
388
388
unsigned int masks[4] = { 0, 0, 0, 0 };
389
-
int ret = IRQ_NONE;
390
389
unsigned int i;
390
+
int ret;
391
391
392
-
pm_runtime_get_sync(cs35l41->dev);
392
+
ret = pm_runtime_resume_and_get(cs35l41->dev);
393
+
if (ret < 0) {
394
+
dev_err(cs35l41->dev,
395
+
"pm_runtime_resume_and_get failed in %s: %d\n",
396
+
__func__, ret);
397
+
return IRQ_NONE;
398
+
}
399
+
400
+
ret = IRQ_NONE;
393
401
394
402
for (i = 0; i < ARRAY_SIZE(status); i++) {
395
403
regmap_read(cs35l41->regmap,
···
467
459
468
460
if (status[2] & CS35L41_PLL_LOCK) {
469
461
regmap_write(cs35l41->regmap, CS35L41_IRQ1_STATUS3, CS35L41_PLL_LOCK);
470
-
complete(&cs35l41->pll_lock);
462
+
463
+
if (cs35l41->hw_cfg.bst_type == CS35L41_SHD_BOOST_ACTV ||
464
+
cs35l41->hw_cfg.bst_type == CS35L41_SHD_BOOST_PASS) {
465
+
ret = cs35l41_mdsync_up(cs35l41->regmap);
466
+
if (ret)
467
+
dev_err(cs35l41->dev, "MDSYNC-up failed: %d\n", ret);
468
+
else
469
+
dev_dbg(cs35l41->dev, "MDSYNC-up done\n");
470
+
471
+
dev_dbg(cs35l41->dev, "PUP-done status: %d\n",
472
+
!!(status[0] & CS35L41_PUP_DONE_MASK));
473
+
}
474
+
471
475
ret = IRQ_HANDLED;
472
476
}
473
477
···
520
500
ARRAY_SIZE(cs35l41_pup_patch));
521
501
522
502
ret = cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type,
523
-
1, &cs35l41->pll_lock, cs35l41->dsp.cs_dsp.running);
503
+
1, cs35l41->dsp.cs_dsp.running);
524
504
break;
525
505
case SND_SOC_DAPM_POST_PMD:
526
506
ret = cs35l41_global_enable(cs35l41->dev, cs35l41->regmap, cs35l41->hw_cfg.bst_type,
527
-
0, &cs35l41->pll_lock, cs35l41->dsp.cs_dsp.running);
507
+
0, cs35l41->dsp.cs_dsp.running);
528
508
529
509
regmap_multi_reg_write_bypassed(cs35l41->regmap,
530
510
cs35l41_pdn_patch,
···
822
802
static int cs35l41_pcm_startup(struct snd_pcm_substream *substream,
823
803
struct snd_soc_dai *dai)
824
804
{
825
-
struct cs35l41_private *cs35l41 = snd_soc_component_get_drvdata(dai->component);
826
-
827
-
reinit_completion(&cs35l41->pll_lock);
828
-
829
805
if (substream->runtime)
830
806
return snd_pcm_hw_constraint_list(substream->runtime, 0,
831
807
SNDRV_PCM_HW_PARAM_RATE,
···
1190
1174
1191
1175
ret = devm_regulator_bulk_get(cs35l41->dev, CS35L41_NUM_SUPPLIES,
1192
1176
cs35l41->supplies);
1193
-
if (ret != 0) {
1194
-
dev_err(cs35l41->dev, "Failed to request core supplies: %d\n", ret);
1195
-
return ret;
1196
-
}
1177
+
if (ret != 0)
1178
+
return dev_err_probe(cs35l41->dev, ret,
1179
+
"Failed to request core supplies\n");
1197
1180
1198
1181
ret = regulator_bulk_enable(CS35L41_NUM_SUPPLIES, cs35l41->supplies);
1199
-
if (ret != 0) {
1200
-
dev_err(cs35l41->dev, "Failed to enable core supplies: %d\n", ret);
1201
-
return ret;
1202
-
}
1182
+
if (ret != 0)
1183
+
return dev_err_probe(cs35l41->dev, ret,
1184
+
"Failed to enable core supplies\n");
1203
1185
1204
1186
/* returning NULL can be an option if in stereo mode */
1205
1187
cs35l41->reset_gpio = devm_gpiod_get_optional(cs35l41->dev, "reset",
···
1209
1195
dev_info(cs35l41->dev,
1210
1196
"Reset line busy, assuming shared reset\n");
1211
1197
} else {
1212
-
dev_err(cs35l41->dev,
1213
-
"Failed to get reset GPIO: %d\n", ret);
1198
+
dev_err_probe(cs35l41->dev, ret,
1199
+
"Failed to get reset GPIO\n");
1214
1200
goto err;
1215
1201
}
1216
1202
}
···
1226
1212
int_status, int_status & CS35L41_OTP_BOOT_DONE,
1227
1213
1000, 100000);
1228
1214
if (ret) {
1229
-
dev_err(cs35l41->dev,
1230
-
"Failed waiting for OTP_BOOT_DONE: %d\n", ret);
1215
+
dev_err_probe(cs35l41->dev, ret,
1216
+
"Failed waiting for OTP_BOOT_DONE\n");
1231
1217
goto err;
1232
1218
}
1233
1219
···
1240
1226
1241
1227
ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, ®id);
1242
1228
if (ret < 0) {
1243
-
dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret);
1229
+
dev_err_probe(cs35l41->dev, ret, "Get Device ID failed\n");
1244
1230
goto err;
1245
1231
}
1246
1232
1247
1233
ret = regmap_read(cs35l41->regmap, CS35L41_REVID, ®_revid);
1248
1234
if (ret < 0) {
1249
-
dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret);
1235
+
dev_err_probe(cs35l41->dev, ret, "Get Revision ID failed\n");
1250
1236
goto err;
1251
1237
}
1252
1238
···
1271
1257
1272
1258
ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap);
1273
1259
if (ret < 0) {
1274
-
dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret);
1260
+
dev_err_probe(cs35l41->dev, ret, "OTP Unpack failed\n");
1275
1261
goto err;
1276
1262
}
1277
1263
···
1291
1277
IRQF_ONESHOT | IRQF_SHARED | irq_pol,
1292
1278
"cs35l41", cs35l41);
1293
1279
if (ret != 0) {
1294
-
dev_err(cs35l41->dev, "Failed to request IRQ: %d\n", ret);
1280
+
dev_err_probe(cs35l41->dev, ret, "Failed to request IRQ\n");
1295
1281
goto err;
1296
1282
}
1297
1283
1298
1284
ret = cs35l41_set_pdata(cs35l41);
1299
1285
if (ret < 0) {
1300
-
dev_err(cs35l41->dev, "Set pdata failed: %d\n", ret);
1286
+
dev_err_probe(cs35l41->dev, ret, "Set pdata failed\n");
1301
1287
goto err;
1302
1288
}
1303
1289
···
1308
1294
ret = cs35l41_dsp_init(cs35l41);
1309
1295
if (ret < 0)
1310
1296
goto err;
1311
-
1312
-
init_completion(&cs35l41->pll_lock);
1313
1297
1314
1298
pm_runtime_set_autosuspend_delay(cs35l41->dev, 3000);
1315
1299
pm_runtime_use_autosuspend(cs35l41->dev);
···
1320
1308
&soc_component_dev_cs35l41,
1321
1309
cs35l41_dai, ARRAY_SIZE(cs35l41_dai));
1322
1310
if (ret < 0) {
1323
-
dev_err(cs35l41->dev, "Register codec failed: %d\n", ret);
1311
+
dev_err_probe(cs35l41->dev, ret, "Register codec failed\n");
1324
1312
goto err_pm;
1325
1313
}
1326
1314
···
1332
1320
return 0;
1333
1321
1334
1322
err_pm:
1323
+
pm_runtime_dont_use_autosuspend(cs35l41->dev);
1335
1324
pm_runtime_disable(cs35l41->dev);
1336
1325
pm_runtime_put_noidle(cs35l41->dev);
1337
1326
···
1349
1336
void cs35l41_remove(struct cs35l41_private *cs35l41)
1350
1337
{
1351
1338
pm_runtime_get_sync(cs35l41->dev);
1339
+
pm_runtime_dont_use_autosuspend(cs35l41->dev);
1352
1340
pm_runtime_disable(cs35l41->dev);
1353
1341
1354
1342
regmap_write(cs35l41->regmap, CS35L41_IRQ1_MASK1, 0xFFFFFFFF);
···
1368
1354
}
1369
1355
EXPORT_SYMBOL_GPL(cs35l41_remove);
1370
1356
1371
-
static int __maybe_unused cs35l41_runtime_suspend(struct device *dev)
1357
+
static int cs35l41_runtime_suspend(struct device *dev)
1372
1358
{
1373
1359
struct cs35l41_private *cs35l41 = dev_get_drvdata(dev);
1374
1360
···
1385
1371
return 0;
1386
1372
}
1387
1373
1388
-
static int __maybe_unused cs35l41_runtime_resume(struct device *dev)
1374
+
static int cs35l41_runtime_resume(struct device *dev)
1389
1375
{
1390
1376
struct cs35l41_private *cs35l41 = dev_get_drvdata(dev);
1391
1377
int ret;
···
1414
1400
return 0;
1415
1401
}
1416
1402
1417
-
static int __maybe_unused cs35l41_sys_suspend(struct device *dev)
1403
+
static int cs35l41_sys_suspend(struct device *dev)
1418
1404
{
1419
1405
struct cs35l41_private *cs35l41 = dev_get_drvdata(dev);
1420
1406
···
1424
1410
return 0;
1425
1411
}
1426
1412
1427
-
static int __maybe_unused cs35l41_sys_suspend_noirq(struct device *dev)
1413
+
static int cs35l41_sys_suspend_noirq(struct device *dev)
1428
1414
{
1429
1415
struct cs35l41_private *cs35l41 = dev_get_drvdata(dev);
1430
1416
···
1434
1420
return 0;
1435
1421
}
1436
1422
1437
-
static int __maybe_unused cs35l41_sys_resume_noirq(struct device *dev)
1423
+
static int cs35l41_sys_resume_noirq(struct device *dev)
1438
1424
{
1439
1425
struct cs35l41_private *cs35l41 = dev_get_drvdata(dev);
1440
1426
···
1444
1430
return 0;
1445
1431
}
1446
1432
1447
-
static int __maybe_unused cs35l41_sys_resume(struct device *dev)
1433
+
static int cs35l41_sys_resume(struct device *dev)
1448
1434
{
1449
1435
struct cs35l41_private *cs35l41 = dev_get_drvdata(dev);
1450
1436
···
1454
1440
return 0;
1455
1441
}
1456
1442
1457
-
const struct dev_pm_ops cs35l41_pm_ops = {
1458
-
SET_RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, NULL)
1443
+
EXPORT_GPL_DEV_PM_OPS(cs35l41_pm_ops) = {
1444
+
RUNTIME_PM_OPS(cs35l41_runtime_suspend, cs35l41_runtime_resume, NULL)
1459
1445
1460
-
SET_SYSTEM_SLEEP_PM_OPS(cs35l41_sys_suspend, cs35l41_sys_resume)
1461
-
SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l41_sys_suspend_noirq, cs35l41_sys_resume_noirq)
1446
+
SYSTEM_SLEEP_PM_OPS(cs35l41_sys_suspend, cs35l41_sys_resume)
1447
+
NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l41_sys_suspend_noirq, cs35l41_sys_resume_noirq)
1462
1448
};
1463
-
EXPORT_SYMBOL_GPL(cs35l41_pm_ops);
1464
1449
1465
1450
MODULE_DESCRIPTION("ASoC CS35L41 driver");
1466
1451
MODULE_AUTHOR("David Rhodes, Cirrus Logic Inc, <david.rhodes@cirrus.com>");