1 // SPDX-License-Identifier: GPL-2.0 // 2 3 // Copyright (c) 2019 MediaTek Inc. 4 5 #include <linux/module.h> 6 #include <linux/kernel.h> 7 #include <linux/version.h> 8 #include <linux/err.h> 9 #include <linux/i2c.h> 10 #include <linux/pm_runtime.h> 11 #include <linux/delay.h> 12 #include <linux/debugfs.h> 13 #include <sound/soc.h> 14 #include <sound/tlv.h> 15 #include <sound/pcm_params.h> 16 17 #include "mt6660.h" 18 19 struct reg_size_table { 20 u32 addr; 21 u8 size; 22 }; 23 24 static const struct reg_size_table mt6660_reg_size_table[] = { 25 { MT6660_REG_HPF1_COEF, 4 }, 26 { MT6660_REG_HPF2_COEF, 4 }, 27 { MT6660_REG_TDM_CFG3, 2 }, 28 { MT6660_REG_RESV17, 2 }, 29 { MT6660_REG_RESV23, 2 }, 30 { MT6660_REG_SIGMAX, 2 }, 31 { MT6660_REG_DEVID, 2 }, 32 { MT6660_REG_HCLIP_CTRL, 2 }, 33 { MT6660_REG_DA_GAIN, 2 }, 34 }; 35 36 static int mt6660_get_reg_size(uint32_t addr) 37 { 38 int i; 39 40 for (i = 0; i < ARRAY_SIZE(mt6660_reg_size_table); i++) { 41 if (mt6660_reg_size_table[i].addr == addr) 42 return mt6660_reg_size_table[i].size; 43 } 44 return 1; 45 } 46 47 static int mt6660_reg_write(void *context, unsigned int reg, unsigned int val) 48 { 49 struct mt6660_chip *chip = context; 50 int size = mt6660_get_reg_size(reg); 51 u8 reg_data[4]; 52 int i, ret; 53 54 for (i = 0; i < size; i++) 55 reg_data[size - i - 1] = (val >> (8 * i)) & 0xff; 56 57 ret = i2c_smbus_write_i2c_block_data(chip->i2c, reg, size, reg_data); 58 return ret; 59 } 60 61 static int mt6660_reg_read(void *context, unsigned int reg, unsigned int *val) 62 { 63 struct mt6660_chip *chip = context; 64 int size = mt6660_get_reg_size(reg); 65 int i, ret; 66 u8 data[4]; 67 u32 reg_data = 0; 68 69 ret = i2c_smbus_read_i2c_block_data(chip->i2c, reg, size, data); 70 if (ret < 0) 71 return ret; 72 for (i = 0; i < size; i++) { 73 reg_data <<= 8; 74 reg_data |= data[i]; 75 } 76 *val = reg_data; 77 return 0; 78 } 79 80 static const struct regmap_config mt6660_regmap_config = { 81 .reg_bits = 8, 82 .val_bits = 32, 83 .reg_write = mt6660_reg_write, 84 .reg_read = mt6660_reg_read, 85 }; 86 87 static int mt6660_codec_dac_event(struct snd_soc_dapm_widget *w, 88 struct snd_kcontrol *kcontrol, int event) 89 { 90 if (event == SND_SOC_DAPM_POST_PMU) 91 usleep_range(1000, 1100); 92 return 0; 93 } 94 95 static int mt6660_codec_classd_event(struct snd_soc_dapm_widget *w, 96 struct snd_kcontrol *kcontrol, int event) 97 { 98 struct snd_soc_component *component = 99 snd_soc_dapm_to_component(w->dapm); 100 int ret; 101 102 switch (event) { 103 case SND_SOC_DAPM_PRE_PMU: 104 dev_dbg(component->dev, 105 "%s: before classd turn on\n", __func__); 106 /* config to adaptive mode */ 107 ret = snd_soc_component_update_bits(component, 108 MT6660_REG_BST_CTRL, 0x03, 0x03); 109 if (ret < 0) { 110 dev_err(component->dev, "config mode adaptive fail\n"); 111 return ret; 112 } 113 break; 114 case SND_SOC_DAPM_POST_PMU: 115 /* voltage sensing enable */ 116 ret = snd_soc_component_update_bits(component, 117 MT6660_REG_RESV7, 0x04, 0x04); 118 if (ret < 0) { 119 dev_err(component->dev, 120 "enable voltage sensing fail\n"); 121 return ret; 122 } 123 dev_dbg(component->dev, "Amp on\n"); 124 break; 125 case SND_SOC_DAPM_PRE_PMD: 126 dev_dbg(component->dev, "Amp off\n"); 127 /* voltage sensing disable */ 128 ret = snd_soc_component_update_bits(component, 129 MT6660_REG_RESV7, 0x04, 0x00); 130 if (ret < 0) { 131 dev_err(component->dev, 132 "disable voltage sensing fail\n"); 133 return ret; 134 } 135 /* pop-noise improvement 1 */ 136 ret = snd_soc_component_update_bits(component, 137 MT6660_REG_RESV10, 0x10, 0x10); 138 if (ret < 0) { 139 dev_err(component->dev, 140 "pop-noise improvement 1 fail\n"); 141 return ret; 142 } 143 break; 144 case SND_SOC_DAPM_POST_PMD: 145 dev_dbg(component->dev, 146 "%s: after classd turn off\n", __func__); 147 /* pop-noise improvement 2 */ 148 ret = snd_soc_component_update_bits(component, 149 MT6660_REG_RESV10, 0x10, 0x00); 150 if (ret < 0) { 151 dev_err(component->dev, 152 "pop-noise improvement 2 fail\n"); 153 return ret; 154 } 155 /* config to off mode */ 156 ret = snd_soc_component_update_bits(component, 157 MT6660_REG_BST_CTRL, 0x03, 0x00); 158 if (ret < 0) { 159 dev_err(component->dev, "config mode off fail\n"); 160 return ret; 161 } 162 break; 163 } 164 return 0; 165 } 166 167 static const struct snd_soc_dapm_widget mt6660_component_dapm_widgets[] = { 168 SND_SOC_DAPM_DAC_E("DAC", NULL, MT6660_REG_PLL_CFG1, 169 0, 1, mt6660_codec_dac_event, SND_SOC_DAPM_POST_PMU), 170 SND_SOC_DAPM_ADC("VI ADC", NULL, SND_SOC_NOPM, 0, 0), 171 SND_SOC_DAPM_PGA("PGA", SND_SOC_NOPM, 0, 0, NULL, 0), 172 SND_SOC_DAPM_OUT_DRV_E("ClassD", MT6660_REG_SYSTEM_CTRL, 2, 0, 173 NULL, 0, mt6660_codec_classd_event, 174 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU | 175 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD), 176 SND_SOC_DAPM_OUTPUT("OUTP"), 177 SND_SOC_DAPM_OUTPUT("OUTN"), 178 }; 179 180 static const struct snd_soc_dapm_route mt6660_component_dapm_routes[] = { 181 { "DAC", NULL, "aif_playback" }, 182 { "PGA", NULL, "DAC" }, 183 { "ClassD", NULL, "PGA" }, 184 { "OUTP", NULL, "ClassD" }, 185 { "OUTN", NULL, "ClassD" }, 186 { "VI ADC", NULL, "ClassD" }, 187 { "aif_capture", NULL, "VI ADC" }, 188 }; 189 190 static int mt6660_component_get_volsw(struct snd_kcontrol *kcontrol, 191 struct snd_ctl_elem_value *ucontrol) 192 { 193 struct snd_soc_component *component = 194 snd_soc_kcontrol_component(kcontrol); 195 struct mt6660_chip *chip = (struct mt6660_chip *) 196 snd_soc_component_get_drvdata(component); 197 198 ucontrol->value.integer.value[0] = chip->chip_rev & 0x0f; 199 return 0; 200 } 201 202 static const DECLARE_TLV_DB_SCALE(vol_ctl_tlv, -1155, 5, 0); 203 204 static const struct snd_kcontrol_new mt6660_component_snd_controls[] = { 205 SOC_SINGLE_TLV("Digital Volume", MT6660_REG_VOL_CTRL, 0, 255, 206 1, vol_ctl_tlv), 207 SOC_SINGLE("Hard Clip Switch", MT6660_REG_HCLIP_CTRL, 8, 1, 0), 208 SOC_SINGLE("Clip Switch", MT6660_REG_SPS_CTRL, 0, 1, 0), 209 SOC_SINGLE("Boost Mode", MT6660_REG_BST_CTRL, 0, 3, 0), 210 SOC_SINGLE("DRE Switch", MT6660_REG_DRE_CTRL, 0, 1, 0), 211 SOC_SINGLE("DC Protect Switch", MT6660_REG_DC_PROTECT_CTRL, 3, 1, 0), 212 SOC_SINGLE("Data Output Left Channel Selection", 213 MT6660_REG_DATAO_SEL, 3, 7, 0), 214 SOC_SINGLE("Data Output Right Channel Selection", 215 MT6660_REG_DATAO_SEL, 0, 7, 0), 216 SOC_SINGLE_EXT("T0 SEL", MT6660_REG_CALI_T0, 0, 7, 0, 217 snd_soc_get_volsw, NULL), 218 SOC_SINGLE_EXT("Chip Rev", MT6660_REG_DEVID, 8, 15, 0, 219 mt6660_component_get_volsw, NULL), 220 }; 221 222 static int _mt6660_chip_power_on(struct mt6660_chip *chip, int on_off) 223 { 224 return regmap_write_bits(chip->regmap, MT6660_REG_SYSTEM_CTRL, 225 0x01, on_off ? 0x00 : 0x01); 226 } 227 228 static int mt6660_component_probe(struct snd_soc_component *component) 229 { 230 struct mt6660_chip *chip = snd_soc_component_get_drvdata(component); 231 232 dev_dbg(component->dev, "%s\n", __func__); 233 snd_soc_component_init_regmap(component, chip->regmap); 234 235 return 0; 236 } 237 238 static void mt6660_component_remove(struct snd_soc_component *component) 239 { 240 dev_dbg(component->dev, "%s\n", __func__); 241 snd_soc_component_exit_regmap(component); 242 } 243 244 static const struct snd_soc_component_driver mt6660_component_driver = { 245 .probe = mt6660_component_probe, 246 .remove = mt6660_component_remove, 247 248 .controls = mt6660_component_snd_controls, 249 .num_controls = ARRAY_SIZE(mt6660_component_snd_controls), 250 .dapm_widgets = mt6660_component_dapm_widgets, 251 .num_dapm_widgets = ARRAY_SIZE(mt6660_component_dapm_widgets), 252 .dapm_routes = mt6660_component_dapm_routes, 253 .num_dapm_routes = ARRAY_SIZE(mt6660_component_dapm_routes), 254 255 .idle_bias_on = false, /* idle_bias_off = true */ 256 }; 257 258 static int mt6660_component_aif_hw_params(struct snd_pcm_substream *substream, 259 struct snd_pcm_hw_params *hw_params, struct snd_soc_dai *dai) 260 { 261 int word_len = params_physical_width(hw_params); 262 int aud_bit = params_width(hw_params); 263 u16 reg_data = 0; 264 int ret; 265 266 dev_dbg(dai->dev, "%s: ++\n", __func__); 267 dev_dbg(dai->dev, "format: 0x%08x\n", params_format(hw_params)); 268 dev_dbg(dai->dev, "rate: 0x%08x\n", params_rate(hw_params)); 269 dev_dbg(dai->dev, "word_len: %d, aud_bit: %d\n", word_len, aud_bit); 270 if (word_len > 32 || word_len < 16) { 271 dev_err(dai->dev, "not supported word length\n"); 272 return -ENOTSUPP; 273 } 274 switch (aud_bit) { 275 case 16: 276 reg_data = 3; 277 break; 278 case 18: 279 reg_data = 2; 280 break; 281 case 20: 282 reg_data = 1; 283 break; 284 case 24: 285 case 32: 286 reg_data = 0; 287 break; 288 default: 289 return -ENOTSUPP; 290 } 291 ret = snd_soc_component_update_bits(dai->component, 292 MT6660_REG_SERIAL_CFG1, 0xc0, (reg_data << 6)); 293 if (ret < 0) { 294 dev_err(dai->dev, "config aud bit fail\n"); 295 return ret; 296 } 297 ret = snd_soc_component_update_bits(dai->component, 298 MT6660_REG_TDM_CFG3, 0x3f0, word_len << 4); 299 if (ret < 0) { 300 dev_err(dai->dev, "config word len fail\n"); 301 return ret; 302 } 303 dev_dbg(dai->dev, "%s: --\n", __func__); 304 return 0; 305 } 306 307 static const struct snd_soc_dai_ops mt6660_component_aif_ops = { 308 .hw_params = mt6660_component_aif_hw_params, 309 }; 310 311 #define STUB_RATES SNDRV_PCM_RATE_8000_192000 312 #define STUB_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \ 313 SNDRV_PCM_FMTBIT_U16_LE | \ 314 SNDRV_PCM_FMTBIT_S24_LE | \ 315 SNDRV_PCM_FMTBIT_U24_LE | \ 316 SNDRV_PCM_FMTBIT_S32_LE | \ 317 SNDRV_PCM_FMTBIT_U32_LE) 318 319 static struct snd_soc_dai_driver mt6660_codec_dai = { 320 .name = "mt6660-aif", 321 .playback = { 322 .stream_name = "aif_playback", 323 .channels_min = 1, 324 .channels_max = 2, 325 .rates = STUB_RATES, 326 .formats = STUB_FORMATS, 327 }, 328 .capture = { 329 .stream_name = "aif_capture", 330 .channels_min = 1, 331 .channels_max = 2, 332 .rates = STUB_RATES, 333 .formats = STUB_FORMATS, 334 }, 335 /* dai properties */ 336 .symmetric_rates = 1, 337 .symmetric_channels = 1, 338 .symmetric_samplebits = 1, 339 /* dai operations */ 340 .ops = &mt6660_component_aif_ops, 341 }; 342 343 static int _mt6660_chip_id_check(struct mt6660_chip *chip) 344 { 345 int ret; 346 unsigned int val; 347 348 ret = regmap_read(chip->regmap, MT6660_REG_DEVID, &val); 349 if (ret < 0) 350 return ret; 351 val &= 0x0ff0; 352 if (val != 0x00e0 && val != 0x01e0) { 353 dev_err(chip->dev, "%s id(%x) not match\n", __func__, val); 354 return -ENODEV; 355 } 356 return 0; 357 } 358 359 static int _mt6660_chip_sw_reset(struct mt6660_chip *chip) 360 { 361 int ret; 362 363 /* turn on main pll first, then trigger reset */ 364 ret = regmap_write(chip->regmap, MT6660_REG_SYSTEM_CTRL, 0x00); 365 if (ret < 0) 366 return ret; 367 ret = regmap_write(chip->regmap, MT6660_REG_SYSTEM_CTRL, 0x80); 368 if (ret < 0) 369 return ret; 370 msleep(30); 371 return 0; 372 } 373 374 static int _mt6660_read_chip_revision(struct mt6660_chip *chip) 375 { 376 int ret; 377 unsigned int val; 378 379 ret = regmap_read(chip->regmap, MT6660_REG_DEVID, &val); 380 if (ret < 0) { 381 dev_err(chip->dev, "get chip revision fail\n"); 382 return ret; 383 } 384 chip->chip_rev = val&0xff; 385 dev_info(chip->dev, "%s chip_rev = %x\n", __func__, chip->chip_rev); 386 return 0; 387 } 388 389 static int mt6660_i2c_probe(struct i2c_client *client, 390 const struct i2c_device_id *id) 391 { 392 struct mt6660_chip *chip = NULL; 393 int ret; 394 395 dev_dbg(&client->dev, "%s\n", __func__); 396 chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL); 397 if (!chip) 398 return -ENOMEM; 399 chip->i2c = client; 400 chip->dev = &client->dev; 401 mutex_init(&chip->io_lock); 402 i2c_set_clientdata(client, chip); 403 404 chip->regmap = devm_regmap_init(&client->dev, 405 NULL, chip, &mt6660_regmap_config); 406 if (IS_ERR(chip->regmap)) { 407 ret = PTR_ERR(chip->regmap); 408 dev_err(&client->dev, "failed to initialise regmap: %d\n", ret); 409 return ret; 410 } 411 412 /* chip reset first */ 413 ret = _mt6660_chip_sw_reset(chip); 414 if (ret < 0) { 415 dev_err(chip->dev, "chip reset fail\n"); 416 goto probe_fail; 417 } 418 /* chip power on */ 419 ret = _mt6660_chip_power_on(chip, 1); 420 if (ret < 0) { 421 dev_err(chip->dev, "chip power on 2 fail\n"); 422 goto probe_fail; 423 } 424 /* chip devid check */ 425 ret = _mt6660_chip_id_check(chip); 426 if (ret < 0) { 427 dev_err(chip->dev, "chip id check fail\n"); 428 goto probe_fail; 429 } 430 /* chip revision get */ 431 ret = _mt6660_read_chip_revision(chip); 432 if (ret < 0) { 433 dev_err(chip->dev, "read chip revision fail\n"); 434 goto probe_fail; 435 } 436 pm_runtime_set_active(chip->dev); 437 pm_runtime_enable(chip->dev); 438 439 ret = devm_snd_soc_register_component(chip->dev, 440 &mt6660_component_driver, 441 &mt6660_codec_dai, 1); 442 return ret; 443 probe_fail: 444 _mt6660_chip_power_on(chip, 0); 445 mutex_destroy(&chip->io_lock); 446 return ret; 447 } 448 449 static int mt6660_i2c_remove(struct i2c_client *client) 450 { 451 struct mt6660_chip *chip = i2c_get_clientdata(client); 452 453 pm_runtime_disable(chip->dev); 454 pm_runtime_set_suspended(chip->dev); 455 mutex_destroy(&chip->io_lock); 456 return 0; 457 } 458 459 static int __maybe_unused mt6660_i2c_runtime_suspend(struct device *dev) 460 { 461 struct mt6660_chip *chip = dev_get_drvdata(dev); 462 463 dev_dbg(dev, "enter low power mode\n"); 464 return regmap_update_bits(chip->regmap, 465 MT6660_REG_SYSTEM_CTRL, 0x01, 0x01); 466 } 467 468 static int __maybe_unused mt6660_i2c_runtime_resume(struct device *dev) 469 { 470 struct mt6660_chip *chip = dev_get_drvdata(dev); 471 472 dev_dbg(dev, "exit low power mode\n"); 473 return regmap_update_bits(chip->regmap, 474 MT6660_REG_SYSTEM_CTRL, 0x01, 0x00); 475 } 476 477 static const struct dev_pm_ops mt6660_dev_pm_ops = { 478 SET_RUNTIME_PM_OPS(mt6660_i2c_runtime_suspend, 479 mt6660_i2c_runtime_resume, NULL) 480 }; 481 482 static const struct of_device_id __maybe_unused mt6660_of_id[] = { 483 { .compatible = "mediatek,mt6660",}, 484 {}, 485 }; 486 MODULE_DEVICE_TABLE(of, mt6660_of_id); 487 488 static const struct i2c_device_id mt6660_i2c_id[] = { 489 {"mt6660", 0 }, 490 {}, 491 }; 492 MODULE_DEVICE_TABLE(i2c, mt6660_i2c_id); 493 494 static struct i2c_driver mt6660_i2c_driver = { 495 .driver = { 496 .name = "mt6660", 497 .of_match_table = of_match_ptr(mt6660_of_id), 498 .pm = &mt6660_dev_pm_ops, 499 }, 500 .probe = mt6660_i2c_probe, 501 .remove = mt6660_i2c_remove, 502 .id_table = mt6660_i2c_id, 503 }; 504 module_i2c_driver(mt6660_i2c_driver); 505 506 MODULE_AUTHOR("Jeff Chang <jeff_chang@richtek.com>"); 507 MODULE_DESCRIPTION("MT6660 SPKAMP Driver"); 508 MODULE_LICENSE("GPL"); 509 MODULE_VERSION("1.0.7_G"); 510