Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

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
··· 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
··· 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, &regid); 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, &reg_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
··· 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
··· 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
··· 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
··· 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, &regid); 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, &reg_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>");
-1
sound/soc/codecs/cs35l41.h
··· 33 33 int irq; 34 34 /* GPIO for /RST */ 35 35 struct gpio_desc *reset_gpio; 36 - struct completion pll_lock; 37 36 }; 38 37 39 38 int cs35l41_probe(struct cs35l41_private *cs35l41, const struct cs35l41_hw_cfg *hw_cfg);