1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // CS35l41 ALSA HDA audio driver 4 // 5 // Copyright 2021 Cirrus Logic, Inc. 6 // 7 // Author: Lucas Tanure <tanureal@opensource.cirrus.com> 8 9 #include <linux/acpi.h> 10 #include <linux/module.h> 11 #include <sound/hda_codec.h> 12 #include "hda_local.h" 13 #include "hda_auto_parser.h" 14 #include "hda_jack.h" 15 #include "hda_generic.h" 16 #include "hda_component.h" 17 #include "cs35l41_hda.h" 18 19 static const struct reg_sequence cs35l41_hda_config[] = { 20 { CS35L41_PLL_CLK_CTRL, 0x00000430 }, // 3072000Hz, BCLK Input, PLL_REFCLK_EN = 1 21 { CS35L41_GLOBAL_CLK_CTRL, 0x00000003 }, // GLOBAL_FS = 48 kHz 22 { CS35L41_SP_ENABLES, 0x00010000 }, // ASP_RX1_EN = 1 23 { CS35L41_SP_RATE_CTRL, 0x00000021 }, // ASP_BCLK_FREQ = 3.072 MHz 24 { CS35L41_SP_FORMAT, 0x20200200 }, // 32 bits RX/TX slots, I2S, clk consumer 25 { CS35L41_DAC_PCM1_SRC, 0x00000008 }, // DACPCM1_SRC = ASPRX1 26 { CS35L41_AMP_DIG_VOL_CTRL, 0x00000000 }, // AMP_VOL_PCM 0.0 dB 27 { CS35L41_AMP_GAIN_CTRL, 0x00000084 }, // AMP_GAIN_PCM 4.5 dB 28 }; 29 30 static const struct reg_sequence cs35l41_hda_mute[] = { 31 { CS35L41_AMP_GAIN_CTRL, 0x00000000 }, // AMP_GAIN_PCM 0.5 dB 32 { CS35L41_AMP_DIG_VOL_CTRL, 0x0000A678 }, // AMP_VOL_PCM Mute 33 }; 34 35 static const struct reg_sequence cs35l41_safe_to_reset[] = { 36 { 0x00000040, 0x00000055 }, 37 { 0x00000040, 0x000000AA }, 38 { 0x0000393C, 0x000000C0, 6000}, 39 { 0x0000393C, 0x00000000 }, 40 { 0x00007414, 0x00C82222 }, 41 { 0x0000742C, 0x00000000 }, 42 { 0x00000040, 0x000000CC }, 43 { 0x00000040, 0x00000033 }, 44 }; 45 46 static const struct reg_sequence cs35l41_safe_to_active[] = { 47 { 0x00000040, 0x00000055 }, 48 { 0x00000040, 0x000000AA }, 49 { 0x0000742C, 0x0000000F }, 50 { 0x0000742C, 0x00000079 }, 51 { 0x00007438, 0x00585941 }, 52 { CS35L41_PWR_CTRL1, 0x00000001, 3000 }, // GLOBAL_EN = 1 53 { 0x0000742C, 0x000000F9 }, 54 { 0x00007438, 0x00580941 }, 55 { 0x00000040, 0x000000CC }, 56 { 0x00000040, 0x00000033 }, 57 }; 58 59 static const struct reg_sequence cs35l41_active_to_safe[] = { 60 { 0x00000040, 0x00000055 }, 61 { 0x00000040, 0x000000AA }, 62 { 0x00007438, 0x00585941 }, 63 { CS35L41_PWR_CTRL1, 0x00000000 }, 64 { 0x0000742C, 0x00000009, 3000 }, 65 { 0x00007438, 0x00580941 }, 66 { 0x00000040, 0x000000CC }, 67 { 0x00000040, 0x00000033 }, 68 }; 69 70 static const struct reg_sequence cs35l41_reset_to_safe[] = { 71 { 0x00000040, 0x00000055 }, 72 { 0x00000040, 0x000000AA }, 73 { 0x00007438, 0x00585941 }, 74 { 0x00007414, 0x08C82222 }, 75 { 0x0000742C, 0x00000009 }, 76 { 0x00000040, 0x000000CC }, 77 { 0x00000040, 0x00000033 }, 78 }; 79 80 static bool cs35l41_hda_safe_reset(struct cs35l41_hda *cs35l41) 81 { 82 switch (cs35l41->hw_cfg.bst_type) { 83 case CS35L41_EXT_BOOST: 84 regmap_write(cs35l41->regmap, CS35L41_GPIO1_CTRL1, 0x00000001); 85 regmap_multi_reg_write(cs35l41->regmap, cs35l41_safe_to_reset, 86 ARRAY_SIZE(cs35l41_safe_to_reset)); 87 return true; 88 case CS35L41_EXT_BOOST_NO_VSPK_SWITCH: 89 return false; 90 default: 91 return true; 92 } 93 }; 94 95 static int cs35l41_hda_global_enable(struct cs35l41_hda *cs35l41, int enable) 96 { 97 int ret; 98 99 switch (cs35l41->hw_cfg.bst_type) { 100 case CS35L41_INT_BOOST: 101 ret = regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL1, 102 CS35L41_GLOBAL_EN_MASK, 103 enable << CS35L41_GLOBAL_EN_SHIFT); 104 usleep_range(3000, 3100); 105 break; 106 case CS35L41_EXT_BOOST: 107 case CS35L41_EXT_BOOST_NO_VSPK_SWITCH: 108 if (enable) 109 ret = regmap_multi_reg_write(cs35l41->regmap, cs35l41_safe_to_active, 110 ARRAY_SIZE(cs35l41_safe_to_active)); 111 else 112 ret = regmap_multi_reg_write(cs35l41->regmap, cs35l41_active_to_safe, 113 ARRAY_SIZE(cs35l41_active_to_safe)); 114 break; 115 default: 116 ret = -EINVAL; 117 break; 118 } 119 120 return ret; 121 }; 122 123 static void cs35l41_hda_playback_hook(struct device *dev, int action) 124 { 125 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 126 struct regmap *reg = cs35l41->regmap; 127 int ret = 0; 128 129 switch (action) { 130 case HDA_GEN_PCM_ACT_OPEN: 131 regmap_multi_reg_write(reg, cs35l41_hda_config, ARRAY_SIZE(cs35l41_hda_config)); 132 ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2, 133 CS35L41_AMP_EN_MASK, 1 << CS35L41_AMP_EN_SHIFT); 134 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 135 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00008001); 136 break; 137 case HDA_GEN_PCM_ACT_PREPARE: 138 ret = cs35l41_hda_global_enable(cs35l41, 1); 139 break; 140 case HDA_GEN_PCM_ACT_CLEANUP: 141 regmap_multi_reg_write(reg, cs35l41_hda_mute, ARRAY_SIZE(cs35l41_hda_mute)); 142 ret = cs35l41_hda_global_enable(cs35l41, 0); 143 break; 144 case HDA_GEN_PCM_ACT_CLOSE: 145 ret = regmap_update_bits(reg, CS35L41_PWR_CTRL2, 146 CS35L41_AMP_EN_MASK, 0 << CS35L41_AMP_EN_SHIFT); 147 if (cs35l41->hw_cfg.bst_type == CS35L41_EXT_BOOST) 148 regmap_write(reg, CS35L41_GPIO1_CTRL1, 0x00000001); 149 break; 150 default: 151 dev_warn(cs35l41->dev, "Playback action not supported: %d\n", action); 152 break; 153 } 154 155 if (ret) 156 dev_err(cs35l41->dev, "Regmap access fail: %d\n", ret); 157 } 158 159 static int cs35l41_hda_channel_map(struct device *dev, unsigned int tx_num, unsigned int *tx_slot, 160 unsigned int rx_num, unsigned int *rx_slot) 161 { 162 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 163 164 return cs35l41_set_channels(cs35l41->dev, cs35l41->regmap, tx_num, tx_slot, rx_num, 165 rx_slot); 166 } 167 168 static int cs35l41_hda_bind(struct device *dev, struct device *master, void *master_data) 169 { 170 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 171 struct hda_component *comps = master_data; 172 173 if (!comps || cs35l41->index < 0 || cs35l41->index >= HDA_MAX_COMPONENTS) 174 return -EINVAL; 175 176 comps = &comps[cs35l41->index]; 177 if (comps->dev) 178 return -EBUSY; 179 180 comps->dev = dev; 181 strscpy(comps->name, dev_name(dev), sizeof(comps->name)); 182 comps->playback_hook = cs35l41_hda_playback_hook; 183 comps->set_channel_map = cs35l41_hda_channel_map; 184 185 return 0; 186 } 187 188 static void cs35l41_hda_unbind(struct device *dev, struct device *master, void *master_data) 189 { 190 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 191 struct hda_component *comps = master_data; 192 193 if (comps[cs35l41->index].dev == dev) 194 memset(&comps[cs35l41->index], 0, sizeof(*comps)); 195 } 196 197 static const struct component_ops cs35l41_hda_comp_ops = { 198 .bind = cs35l41_hda_bind, 199 .unbind = cs35l41_hda_unbind, 200 }; 201 202 static int cs35l41_hda_apply_properties(struct cs35l41_hda *cs35l41) 203 { 204 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 205 int ret; 206 207 if (!cs35l41->hw_cfg.valid) 208 return -EINVAL; 209 210 switch (hw_cfg->bst_type) { 211 case CS35L41_INT_BOOST: 212 ret = cs35l41_boost_config(cs35l41->dev, cs35l41->regmap, 213 hw_cfg->bst_ind, hw_cfg->bst_cap, hw_cfg->bst_ipk); 214 if (ret) 215 return ret; 216 break; 217 case CS35L41_EXT_BOOST: 218 case CS35L41_EXT_BOOST_NO_VSPK_SWITCH: 219 regmap_multi_reg_write(cs35l41->regmap, cs35l41_reset_to_safe, 220 ARRAY_SIZE(cs35l41_reset_to_safe)); 221 ret = regmap_update_bits(cs35l41->regmap, CS35L41_PWR_CTRL2, CS35L41_BST_EN_MASK, 222 CS35L41_BST_DIS_FET_OFF << CS35L41_BST_EN_SHIFT); 223 if (ret) 224 return ret; 225 break; 226 default: 227 dev_err(cs35l41->dev, "Boost type %d not supported\n", hw_cfg->bst_type); 228 return -EINVAL; 229 } 230 231 if (hw_cfg->gpio1.valid) { 232 switch (hw_cfg->gpio1.func) { 233 case CS35L41_NOT_USED: 234 break; 235 case CS35l41_VSPK_SWITCH: 236 hw_cfg->gpio1.func = CS35L41_GPIO1_GPIO; 237 hw_cfg->gpio1.out_en = true; 238 break; 239 case CS35l41_SYNC: 240 hw_cfg->gpio1.func = CS35L41_GPIO1_MDSYNC; 241 break; 242 default: 243 dev_err(cs35l41->dev, "Invalid function %d for GPIO1\n", 244 hw_cfg->gpio1.func); 245 return -EINVAL; 246 } 247 } 248 249 if (hw_cfg->gpio2.valid) { 250 switch (hw_cfg->gpio2.func) { 251 case CS35L41_NOT_USED: 252 break; 253 case CS35L41_INTERRUPT: 254 break; 255 default: 256 dev_err(cs35l41->dev, "Invalid GPIO2 function %d\n", hw_cfg->gpio2.func); 257 return -EINVAL; 258 } 259 } 260 261 cs35l41_gpio_config(cs35l41->regmap, hw_cfg); 262 263 return cs35l41_hda_channel_map(cs35l41->dev, 0, NULL, 1, &hw_cfg->spk_pos); 264 } 265 266 static int cs35l41_hda_read_acpi(struct cs35l41_hda *cs35l41, const char *hid, int id) 267 { 268 struct cs35l41_hw_cfg *hw_cfg = &cs35l41->hw_cfg; 269 u32 values[HDA_MAX_COMPONENTS]; 270 struct acpi_device *adev; 271 struct device *physdev; 272 char *property; 273 size_t nval; 274 int i, ret; 275 276 adev = acpi_dev_get_first_match_dev(hid, NULL, -1); 277 if (!adev) { 278 dev_err(cs35l41->dev, "Failed to find an ACPI device for %s\n", hid); 279 return -ENODEV; 280 } 281 282 physdev = get_device(acpi_get_first_physical_node(adev)); 283 acpi_dev_put(adev); 284 285 property = "cirrus,dev-index"; 286 ret = device_property_count_u32(physdev, property); 287 if (ret <= 0) 288 goto no_acpi_dsd; 289 290 if (ret > ARRAY_SIZE(values)) { 291 ret = -EINVAL; 292 goto err; 293 } 294 nval = ret; 295 296 ret = device_property_read_u32_array(physdev, property, values, nval); 297 if (ret) 298 goto err; 299 300 cs35l41->index = -1; 301 for (i = 0; i < nval; i++) { 302 if (values[i] == id) { 303 cs35l41->index = i; 304 break; 305 } 306 } 307 if (cs35l41->index == -1) { 308 dev_err(cs35l41->dev, "No index found in %s\n", property); 309 ret = -ENODEV; 310 goto err; 311 } 312 313 /* To use the same release code for all laptop variants we can't use devm_ version of 314 * gpiod_get here, as CLSA010* don't have a fully functional bios with an _DSD node 315 */ 316 cs35l41->reset_gpio = fwnode_gpiod_get_index(&adev->fwnode, "reset", cs35l41->index, 317 GPIOD_OUT_LOW, "cs35l41-reset"); 318 319 property = "cirrus,speaker-position"; 320 ret = device_property_read_u32_array(physdev, property, values, nval); 321 if (ret) 322 goto err; 323 hw_cfg->spk_pos = values[cs35l41->index]; 324 325 property = "cirrus,gpio1-func"; 326 ret = device_property_read_u32_array(physdev, property, values, nval); 327 if (ret) 328 goto err; 329 hw_cfg->gpio1.func = values[cs35l41->index]; 330 hw_cfg->gpio1.valid = true; 331 332 property = "cirrus,gpio2-func"; 333 ret = device_property_read_u32_array(physdev, property, values, nval); 334 if (ret) 335 goto err; 336 hw_cfg->gpio2.func = values[cs35l41->index]; 337 hw_cfg->gpio2.valid = true; 338 339 property = "cirrus,boost-peak-milliamp"; 340 ret = device_property_read_u32_array(physdev, property, values, nval); 341 if (ret == 0) 342 hw_cfg->bst_ipk = values[cs35l41->index]; 343 else 344 hw_cfg->bst_ipk = -1; 345 346 property = "cirrus,boost-ind-nanohenry"; 347 ret = device_property_read_u32_array(physdev, property, values, nval); 348 if (ret == 0) 349 hw_cfg->bst_ind = values[cs35l41->index]; 350 else 351 hw_cfg->bst_ind = -1; 352 353 property = "cirrus,boost-cap-microfarad"; 354 ret = device_property_read_u32_array(physdev, property, values, nval); 355 if (ret == 0) 356 hw_cfg->bst_cap = values[cs35l41->index]; 357 else 358 hw_cfg->bst_cap = -1; 359 360 if (hw_cfg->bst_ind > 0 || hw_cfg->bst_cap > 0 || hw_cfg->bst_ipk > 0) 361 hw_cfg->bst_type = CS35L41_INT_BOOST; 362 else 363 hw_cfg->bst_type = CS35L41_EXT_BOOST; 364 365 hw_cfg->valid = true; 366 put_device(physdev); 367 368 return 0; 369 370 err: 371 put_device(physdev); 372 dev_err(cs35l41->dev, "Failed property %s: %d\n", property, ret); 373 374 return ret; 375 376 no_acpi_dsd: 377 /* 378 * Device CLSA0100 doesn't have _DSD so a gpiod_get by the label reset won't work. 379 * And devices created by i2c-multi-instantiate don't have their device struct pointing to 380 * the correct fwnode, so acpi_dev must be used here. 381 * And devm functions expect that the device requesting the resource has the correct 382 * fwnode. 383 */ 384 if (strncmp(hid, "CLSA0100", 8) != 0) 385 return -EINVAL; 386 387 /* check I2C address to assign the index */ 388 cs35l41->index = id == 0x40 ? 0 : 1; 389 cs35l41->reset_gpio = gpiod_get_index(physdev, NULL, 0, GPIOD_OUT_HIGH); 390 cs35l41->hw_cfg.bst_type = CS35L41_EXT_BOOST_NO_VSPK_SWITCH; 391 cs35l41->hw_cfg.valid = true; 392 put_device(physdev); 393 394 return 0; 395 } 396 397 int cs35l41_hda_probe(struct device *dev, const char *device_name, int id, int irq, 398 struct regmap *regmap) 399 { 400 unsigned int int_sts, regid, reg_revid, mtl_revid, chipid, int_status; 401 struct cs35l41_hda *cs35l41; 402 int ret; 403 404 if (IS_ERR(regmap)) 405 return PTR_ERR(regmap); 406 407 cs35l41 = devm_kzalloc(dev, sizeof(*cs35l41), GFP_KERNEL); 408 if (!cs35l41) 409 return -ENOMEM; 410 411 cs35l41->dev = dev; 412 cs35l41->irq = irq; 413 cs35l41->regmap = regmap; 414 dev_set_drvdata(dev, cs35l41); 415 416 ret = cs35l41_hda_read_acpi(cs35l41, device_name, id); 417 if (ret) { 418 dev_err_probe(cs35l41->dev, ret, "Platform not supported %d\n", ret); 419 return ret; 420 } 421 422 if (IS_ERR(cs35l41->reset_gpio)) { 423 ret = PTR_ERR(cs35l41->reset_gpio); 424 cs35l41->reset_gpio = NULL; 425 if (ret == -EBUSY) { 426 dev_info(cs35l41->dev, "Reset line busy, assuming shared reset\n"); 427 } else { 428 dev_err_probe(cs35l41->dev, ret, "Failed to get reset GPIO: %d\n", ret); 429 goto err; 430 } 431 } 432 if (cs35l41->reset_gpio) { 433 usleep_range(2000, 2100); 434 gpiod_set_value_cansleep(cs35l41->reset_gpio, 1); 435 } 436 437 usleep_range(2000, 2100); 438 439 ret = regmap_read_poll_timeout(cs35l41->regmap, CS35L41_IRQ1_STATUS4, int_status, 440 int_status & CS35L41_OTP_BOOT_DONE, 1000, 100000); 441 if (ret) { 442 dev_err(cs35l41->dev, "Failed waiting for OTP_BOOT_DONE: %d\n", ret); 443 goto err; 444 } 445 446 ret = regmap_read(cs35l41->regmap, CS35L41_IRQ1_STATUS3, &int_sts); 447 if (ret || (int_sts & CS35L41_OTP_BOOT_ERR)) { 448 dev_err(cs35l41->dev, "OTP Boot status %x error: %d\n", 449 int_sts & CS35L41_OTP_BOOT_ERR, ret); 450 ret = -EIO; 451 goto err; 452 } 453 454 ret = regmap_read(cs35l41->regmap, CS35L41_DEVID, ®id); 455 if (ret) { 456 dev_err(cs35l41->dev, "Get Device ID failed: %d\n", ret); 457 goto err; 458 } 459 460 ret = regmap_read(cs35l41->regmap, CS35L41_REVID, ®_revid); 461 if (ret) { 462 dev_err(cs35l41->dev, "Get Revision ID failed: %d\n", ret); 463 goto err; 464 } 465 466 mtl_revid = reg_revid & CS35L41_MTLREVID_MASK; 467 468 chipid = (mtl_revid % 2) ? CS35L41R_CHIP_ID : CS35L41_CHIP_ID; 469 if (regid != chipid) { 470 dev_err(cs35l41->dev, "CS35L41 Device ID (%X). Expected ID %X\n", regid, chipid); 471 ret = -ENODEV; 472 goto err; 473 } 474 475 ret = cs35l41_test_key_unlock(cs35l41->dev, cs35l41->regmap); 476 if (ret) 477 goto err; 478 479 ret = cs35l41_register_errata_patch(cs35l41->dev, cs35l41->regmap, reg_revid); 480 if (ret) 481 goto err; 482 483 ret = cs35l41_otp_unpack(cs35l41->dev, cs35l41->regmap); 484 if (ret) { 485 dev_err(cs35l41->dev, "OTP Unpack failed: %d\n", ret); 486 goto err; 487 } 488 489 ret = cs35l41_test_key_lock(cs35l41->dev, cs35l41->regmap); 490 if (ret) 491 goto err; 492 493 ret = cs35l41_hda_apply_properties(cs35l41); 494 if (ret) 495 goto err; 496 497 ret = component_add(cs35l41->dev, &cs35l41_hda_comp_ops); 498 if (ret) { 499 dev_err(cs35l41->dev, "Register component failed: %d\n", ret); 500 goto err; 501 } 502 503 dev_info(cs35l41->dev, "Cirrus Logic CS35L41 (%x), Revision: %02X\n", regid, reg_revid); 504 505 return 0; 506 507 err: 508 if (cs35l41_hda_safe_reset(cs35l41)) 509 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 510 gpiod_put(cs35l41->reset_gpio); 511 512 return ret; 513 } 514 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_probe, SND_HDA_SCODEC_CS35L41); 515 516 void cs35l41_hda_remove(struct device *dev) 517 { 518 struct cs35l41_hda *cs35l41 = dev_get_drvdata(dev); 519 520 component_del(cs35l41->dev, &cs35l41_hda_comp_ops); 521 522 if (cs35l41_hda_safe_reset(cs35l41)) 523 gpiod_set_value_cansleep(cs35l41->reset_gpio, 0); 524 gpiod_put(cs35l41->reset_gpio); 525 } 526 EXPORT_SYMBOL_NS_GPL(cs35l41_hda_remove, SND_HDA_SCODEC_CS35L41); 527 528 MODULE_DESCRIPTION("CS35L41 HDA Driver"); 529 MODULE_AUTHOR("Lucas Tanure, Cirrus Logic Inc, <tanureal@opensource.cirrus.com>"); 530 MODULE_LICENSE("GPL"); 531