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