1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * tas5720.c - ALSA SoC Texas Instruments TAS5720 Mono Audio Amplifier 4 * 5 * Copyright (C)2015-2016 Texas Instruments Incorporated - https://www.ti.com 6 * 7 * Author: Andreas Dannenberg <dannenberg@ti.com> 8 */ 9 10 #include <linux/module.h> 11 #include <linux/errno.h> 12 #include <linux/device.h> 13 #include <linux/i2c.h> 14 #include <linux/pm_runtime.h> 15 #include <linux/regmap.h> 16 #include <linux/slab.h> 17 #include <linux/regulator/consumer.h> 18 #include <linux/delay.h> 19 20 #include <sound/pcm.h> 21 #include <sound/pcm_params.h> 22 #include <sound/soc.h> 23 #include <sound/soc-dapm.h> 24 #include <sound/tlv.h> 25 26 #include "tas5720.h" 27 28 /* Define how often to check (and clear) the fault status register (in ms) */ 29 #define TAS5720_FAULT_CHECK_INTERVAL 200 30 31 enum tas572x_type { 32 TAS5720, 33 TAS5720A_Q1, 34 TAS5722, 35 }; 36 37 static const char * const tas5720_supply_names[] = { 38 "dvdd", /* Digital power supply. Connect to 3.3-V supply. */ 39 "pvdd", /* Class-D amp and analog power supply (connected). */ 40 }; 41 42 #define TAS5720_NUM_SUPPLIES ARRAY_SIZE(tas5720_supply_names) 43 44 struct tas5720_data { 45 struct snd_soc_component *component; 46 struct regmap *regmap; 47 struct i2c_client *tas5720_client; 48 enum tas572x_type devtype; 49 struct regulator_bulk_data supplies[TAS5720_NUM_SUPPLIES]; 50 struct delayed_work fault_check_work; 51 unsigned int last_fault; 52 }; 53 54 static int tas5720_hw_params(struct snd_pcm_substream *substream, 55 struct snd_pcm_hw_params *params, 56 struct snd_soc_dai *dai) 57 { 58 struct snd_soc_component *component = dai->component; 59 unsigned int rate = params_rate(params); 60 bool ssz_ds; 61 int ret; 62 63 switch (rate) { 64 case 44100: 65 case 48000: 66 ssz_ds = false; 67 break; 68 case 88200: 69 case 96000: 70 ssz_ds = true; 71 break; 72 default: 73 dev_err(component->dev, "unsupported sample rate: %u\n", rate); 74 return -EINVAL; 75 } 76 77 ret = snd_soc_component_update_bits(component, TAS5720_DIGITAL_CTRL1_REG, 78 TAS5720_SSZ_DS, ssz_ds); 79 if (ret < 0) { 80 dev_err(component->dev, "error setting sample rate: %d\n", ret); 81 return ret; 82 } 83 84 return 0; 85 } 86 87 static int tas5720_set_dai_fmt(struct snd_soc_dai *dai, unsigned int fmt) 88 { 89 struct snd_soc_component *component = dai->component; 90 u8 serial_format; 91 int ret; 92 93 if ((fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) != SND_SOC_DAIFMT_CBC_CFC) { 94 dev_vdbg(component->dev, "DAI clocking invalid\n"); 95 return -EINVAL; 96 } 97 98 switch (fmt & (SND_SOC_DAIFMT_FORMAT_MASK | 99 SND_SOC_DAIFMT_INV_MASK)) { 100 case (SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF): 101 /* 1st data bit occur one BCLK cycle after the frame sync */ 102 serial_format = TAS5720_SAIF_I2S; 103 break; 104 case (SND_SOC_DAIFMT_DSP_A | SND_SOC_DAIFMT_NB_NF): 105 /* 106 * Note that although the TAS5720 does not have a dedicated DSP 107 * mode it doesn't care about the LRCLK duty cycle during TDM 108 * operation. Therefore we can use the device's I2S mode with 109 * its delaying of the 1st data bit to receive DSP_A formatted 110 * data. See device datasheet for additional details. 111 */ 112 serial_format = TAS5720_SAIF_I2S; 113 break; 114 case (SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_NB_NF): 115 /* 116 * Similar to DSP_A, we can use the fact that the TAS5720 does 117 * not care about the LRCLK duty cycle during TDM to receive 118 * DSP_B formatted data in LEFTJ mode (no delaying of the 1st 119 * data bit). 120 */ 121 serial_format = TAS5720_SAIF_LEFTJ; 122 break; 123 case (SND_SOC_DAIFMT_LEFT_J | SND_SOC_DAIFMT_NB_NF): 124 /* No delay after the frame sync */ 125 serial_format = TAS5720_SAIF_LEFTJ; 126 break; 127 default: 128 dev_vdbg(component->dev, "DAI Format is not found\n"); 129 return -EINVAL; 130 } 131 132 ret = snd_soc_component_update_bits(component, TAS5720_DIGITAL_CTRL1_REG, 133 TAS5720_SAIF_FORMAT_MASK, 134 serial_format); 135 if (ret < 0) { 136 dev_err(component->dev, "error setting SAIF format: %d\n", ret); 137 return ret; 138 } 139 140 return 0; 141 } 142 143 static int tas5720_set_dai_tdm_slot(struct snd_soc_dai *dai, 144 unsigned int tx_mask, unsigned int rx_mask, 145 int slots, int slot_width) 146 { 147 struct snd_soc_component *component = dai->component; 148 struct tas5720_data *tas5720 = snd_soc_component_get_drvdata(component); 149 unsigned int first_slot; 150 int ret; 151 152 if (!tx_mask) { 153 dev_err(component->dev, "tx masks must not be 0\n"); 154 return -EINVAL; 155 } 156 157 /* 158 * Determine the first slot that is being requested. We will only 159 * use the first slot that is found since the TAS5720 is a mono 160 * amplifier. 161 */ 162 first_slot = __ffs(tx_mask); 163 164 if (first_slot > 7) { 165 dev_err(component->dev, "slot selection out of bounds (%u)\n", 166 first_slot); 167 return -EINVAL; 168 } 169 170 /* 171 * Enable manual TDM slot selection (instead of I2C ID based). 172 * This is not applicable to TAS5720A-Q1. 173 */ 174 switch (tas5720->devtype) { 175 case TAS5720A_Q1: 176 break; 177 default: 178 ret = snd_soc_component_update_bits(component, TAS5720_DIGITAL_CTRL1_REG, 179 TAS5720_TDM_CFG_SRC, TAS5720_TDM_CFG_SRC); 180 if (ret < 0) 181 goto error_snd_soc_component_update_bits; 182 183 /* Configure the TDM slot to process audio from */ 184 ret = snd_soc_component_update_bits(component, TAS5720_DIGITAL_CTRL2_REG, 185 TAS5720_TDM_SLOT_SEL_MASK, first_slot); 186 if (ret < 0) 187 goto error_snd_soc_component_update_bits; 188 break; 189 } 190 191 /* Configure TDM slot width. This is only applicable to TAS5722. */ 192 switch (tas5720->devtype) { 193 case TAS5722: 194 ret = snd_soc_component_update_bits(component, TAS5722_DIGITAL_CTRL2_REG, 195 TAS5722_TDM_SLOT_16B, 196 slot_width == 16 ? 197 TAS5722_TDM_SLOT_16B : 0); 198 if (ret < 0) 199 goto error_snd_soc_component_update_bits; 200 break; 201 default: 202 break; 203 } 204 205 return 0; 206 207 error_snd_soc_component_update_bits: 208 dev_err(component->dev, "error configuring TDM mode: %d\n", ret); 209 return ret; 210 } 211 212 static int tas5720_mute_soc_component(struct snd_soc_component *component, int mute) 213 { 214 struct tas5720_data *tas5720 = snd_soc_component_get_drvdata(component); 215 unsigned int reg, mask; 216 int ret; 217 218 switch (tas5720->devtype) { 219 case TAS5720A_Q1: 220 reg = TAS5720_Q1_VOLUME_CTRL_CFG_REG; 221 mask = TAS5720_Q1_MUTE; 222 break; 223 default: 224 reg = TAS5720_DIGITAL_CTRL2_REG; 225 mask = TAS5720_MUTE; 226 break; 227 } 228 229 ret = snd_soc_component_update_bits(component, reg, mask, mute ? mask : 0); 230 if (ret < 0) { 231 dev_err(component->dev, "error (un-)muting device: %d\n", ret); 232 return ret; 233 } 234 235 return 0; 236 } 237 238 static int tas5720_mute(struct snd_soc_dai *dai, int mute, int direction) 239 { 240 return tas5720_mute_soc_component(dai->component, mute); 241 } 242 243 static void tas5720_fault_check_work(struct work_struct *work) 244 { 245 struct tas5720_data *tas5720 = container_of(work, struct tas5720_data, 246 fault_check_work.work); 247 struct device *dev = tas5720->component->dev; 248 unsigned int curr_fault; 249 int ret; 250 251 ret = regmap_read(tas5720->regmap, TAS5720_FAULT_REG, &curr_fault); 252 if (ret < 0) { 253 dev_err(dev, "failed to read FAULT register: %d\n", ret); 254 goto out; 255 } 256 257 /* Check/handle all errors except SAIF clock errors */ 258 curr_fault &= TAS5720_OCE | TAS5720_DCE | TAS5720_OTE; 259 260 /* 261 * Only flag errors once for a given occurrence. This is needed as 262 * the TAS5720 will take time clearing the fault condition internally 263 * during which we don't want to bombard the system with the same 264 * error message over and over. 265 */ 266 if ((curr_fault & TAS5720_OCE) && !(tas5720->last_fault & TAS5720_OCE)) 267 dev_crit(dev, "experienced an over current hardware fault\n"); 268 269 if ((curr_fault & TAS5720_DCE) && !(tas5720->last_fault & TAS5720_DCE)) 270 dev_crit(dev, "experienced a DC detection fault\n"); 271 272 if ((curr_fault & TAS5720_OTE) && !(tas5720->last_fault & TAS5720_OTE)) 273 dev_crit(dev, "experienced an over temperature fault\n"); 274 275 /* Store current fault value so we can detect any changes next time */ 276 tas5720->last_fault = curr_fault; 277 278 if (!curr_fault) 279 goto out; 280 281 /* 282 * Periodically toggle SDZ (shutdown bit) H->L->H to clear any latching 283 * faults as long as a fault condition persists. Always going through 284 * the full sequence no matter the first return value to minimizes 285 * chances for the device to end up in shutdown mode. 286 */ 287 ret = regmap_write_bits(tas5720->regmap, TAS5720_POWER_CTRL_REG, 288 TAS5720_SDZ, 0); 289 if (ret < 0) 290 dev_err(dev, "failed to write POWER_CTRL register: %d\n", ret); 291 292 ret = regmap_write_bits(tas5720->regmap, TAS5720_POWER_CTRL_REG, 293 TAS5720_SDZ, TAS5720_SDZ); 294 if (ret < 0) 295 dev_err(dev, "failed to write POWER_CTRL register: %d\n", ret); 296 297 out: 298 /* Schedule the next fault check at the specified interval */ 299 schedule_delayed_work(&tas5720->fault_check_work, 300 msecs_to_jiffies(TAS5720_FAULT_CHECK_INTERVAL)); 301 } 302 303 static int tas5720_codec_probe(struct snd_soc_component *component) 304 { 305 struct tas5720_data *tas5720 = snd_soc_component_get_drvdata(component); 306 unsigned int device_id, expected_device_id; 307 int ret; 308 309 tas5720->component = component; 310 311 ret = regulator_bulk_enable(ARRAY_SIZE(tas5720->supplies), 312 tas5720->supplies); 313 if (ret != 0) { 314 dev_err(component->dev, "failed to enable supplies: %d\n", ret); 315 return ret; 316 } 317 318 /* 319 * Take a liberal approach to checking the device ID to allow the 320 * driver to be used even if the device ID does not match, however 321 * issue a warning if there is a mismatch. 322 */ 323 ret = regmap_read(tas5720->regmap, TAS5720_DEVICE_ID_REG, &device_id); 324 if (ret < 0) { 325 dev_err(component->dev, "failed to read device ID register: %d\n", 326 ret); 327 goto probe_fail; 328 } 329 330 switch (tas5720->devtype) { 331 case TAS5720: 332 expected_device_id = TAS5720_DEVICE_ID; 333 break; 334 case TAS5720A_Q1: 335 expected_device_id = TAS5720A_Q1_DEVICE_ID; 336 break; 337 case TAS5722: 338 expected_device_id = TAS5722_DEVICE_ID; 339 break; 340 default: 341 dev_err(component->dev, "unexpected private driver data\n"); 342 return -EINVAL; 343 } 344 345 if (device_id != expected_device_id) 346 dev_warn(component->dev, "wrong device ID. expected: %u read: %u\n", 347 expected_device_id, device_id); 348 349 /* Set device to mute */ 350 ret = tas5720_mute_soc_component(component, 1); 351 if (ret < 0) 352 goto error_snd_soc_component_update_bits; 353 354 /* Set Bit 7 in TAS5720_ANALOG_CTRL_REG to 1 for TAS5720A_Q1 */ 355 switch (tas5720->devtype) { 356 case TAS5720A_Q1: 357 ret = snd_soc_component_update_bits(component, TAS5720_ANALOG_CTRL_REG, 358 TAS5720_Q1_RESERVED7_BIT, 359 TAS5720_Q1_RESERVED7_BIT); 360 break; 361 default: 362 break; 363 } 364 if (ret < 0) 365 goto error_snd_soc_component_update_bits; 366 367 /* 368 * Enter shutdown mode - our default when not playing audio - to 369 * minimize current consumption. On the TAS5720 there is no real down 370 * side doing so as all device registers are preserved and the wakeup 371 * of the codec is rather quick which we do using a dapm widget. 372 */ 373 ret = snd_soc_component_update_bits(component, TAS5720_POWER_CTRL_REG, 374 TAS5720_SDZ, 0); 375 if (ret < 0) 376 goto error_snd_soc_component_update_bits; 377 378 INIT_DELAYED_WORK(&tas5720->fault_check_work, tas5720_fault_check_work); 379 380 return 0; 381 382 error_snd_soc_component_update_bits: 383 dev_err(component->dev, "error configuring device registers: %d\n", ret); 384 385 probe_fail: 386 regulator_bulk_disable(ARRAY_SIZE(tas5720->supplies), 387 tas5720->supplies); 388 return ret; 389 } 390 391 static void tas5720_codec_remove(struct snd_soc_component *component) 392 { 393 struct tas5720_data *tas5720 = snd_soc_component_get_drvdata(component); 394 int ret; 395 396 cancel_delayed_work_sync(&tas5720->fault_check_work); 397 398 ret = regulator_bulk_disable(ARRAY_SIZE(tas5720->supplies), 399 tas5720->supplies); 400 if (ret < 0) 401 dev_err(component->dev, "failed to disable supplies: %d\n", ret); 402 }; 403 404 static int tas5720_dac_event(struct snd_soc_dapm_widget *w, 405 struct snd_kcontrol *kcontrol, int event) 406 { 407 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); 408 struct tas5720_data *tas5720 = snd_soc_component_get_drvdata(component); 409 int ret; 410 411 if (event & SND_SOC_DAPM_POST_PMU) { 412 /* Take TAS5720 out of shutdown mode */ 413 ret = snd_soc_component_update_bits(component, TAS5720_POWER_CTRL_REG, 414 TAS5720_SDZ, TAS5720_SDZ); 415 if (ret < 0) { 416 dev_err(component->dev, "error waking component: %d\n", ret); 417 return ret; 418 } 419 420 /* 421 * Observe codec shutdown-to-active time. The datasheet only 422 * lists a nominal value however just use-it as-is without 423 * additional padding to minimize the delay introduced in 424 * starting to play audio (actually there is other setup done 425 * by the ASoC framework that will provide additional delays, 426 * so we should always be safe). 427 */ 428 msleep(25); 429 430 /* Turn on TAS5720 periodic fault checking/handling */ 431 tas5720->last_fault = 0; 432 schedule_delayed_work(&tas5720->fault_check_work, 433 msecs_to_jiffies(TAS5720_FAULT_CHECK_INTERVAL)); 434 } else if (event & SND_SOC_DAPM_PRE_PMD) { 435 /* Disable TAS5720 periodic fault checking/handling */ 436 cancel_delayed_work_sync(&tas5720->fault_check_work); 437 438 /* Place TAS5720 in shutdown mode to minimize current draw */ 439 ret = snd_soc_component_update_bits(component, TAS5720_POWER_CTRL_REG, 440 TAS5720_SDZ, 0); 441 if (ret < 0) { 442 dev_err(component->dev, "error shutting down component: %d\n", 443 ret); 444 return ret; 445 } 446 } 447 448 return 0; 449 } 450 451 #ifdef CONFIG_PM 452 static int tas5720_suspend(struct snd_soc_component *component) 453 { 454 struct tas5720_data *tas5720 = snd_soc_component_get_drvdata(component); 455 int ret; 456 457 regcache_cache_only(tas5720->regmap, true); 458 regcache_mark_dirty(tas5720->regmap); 459 460 ret = regulator_bulk_disable(ARRAY_SIZE(tas5720->supplies), 461 tas5720->supplies); 462 if (ret < 0) 463 dev_err(component->dev, "failed to disable supplies: %d\n", ret); 464 465 return ret; 466 } 467 468 static int tas5720_resume(struct snd_soc_component *component) 469 { 470 struct tas5720_data *tas5720 = snd_soc_component_get_drvdata(component); 471 int ret; 472 473 ret = regulator_bulk_enable(ARRAY_SIZE(tas5720->supplies), 474 tas5720->supplies); 475 if (ret < 0) { 476 dev_err(component->dev, "failed to enable supplies: %d\n", ret); 477 return ret; 478 } 479 480 regcache_cache_only(tas5720->regmap, false); 481 482 ret = regcache_sync(tas5720->regmap); 483 if (ret < 0) { 484 dev_err(component->dev, "failed to sync regcache: %d\n", ret); 485 return ret; 486 } 487 488 return 0; 489 } 490 #else 491 #define tas5720_suspend NULL 492 #define tas5720_resume NULL 493 #endif 494 495 static bool tas5720_is_volatile_reg(struct device *dev, unsigned int reg) 496 { 497 switch (reg) { 498 case TAS5720_DEVICE_ID_REG: 499 case TAS5720_FAULT_REG: 500 return true; 501 default: 502 return false; 503 } 504 } 505 506 static const struct regmap_config tas5720_regmap_config = { 507 .reg_bits = 8, 508 .val_bits = 8, 509 510 .max_register = TAS5720_MAX_REG, 511 .cache_type = REGCACHE_RBTREE, 512 .volatile_reg = tas5720_is_volatile_reg, 513 }; 514 515 static const struct regmap_config tas5720a_q1_regmap_config = { 516 .reg_bits = 8, 517 .val_bits = 8, 518 519 .max_register = TAS5720_MAX_REG, 520 .cache_type = REGCACHE_RBTREE, 521 .volatile_reg = tas5720_is_volatile_reg, 522 }; 523 524 static const struct regmap_config tas5722_regmap_config = { 525 .reg_bits = 8, 526 .val_bits = 8, 527 528 .max_register = TAS5722_MAX_REG, 529 .cache_type = REGCACHE_RBTREE, 530 .volatile_reg = tas5720_is_volatile_reg, 531 }; 532 533 /* 534 * DAC analog gain. There are four discrete values to select from, ranging 535 * from 19.2 dB to 26.3dB. 536 */ 537 static const DECLARE_TLV_DB_RANGE(dac_analog_tlv, 538 0x0, 0x0, TLV_DB_SCALE_ITEM(1920, 0, 0), 539 0x1, 0x1, TLV_DB_SCALE_ITEM(2070, 0, 0), 540 0x2, 0x2, TLV_DB_SCALE_ITEM(2350, 0, 0), 541 0x3, 0x3, TLV_DB_SCALE_ITEM(2630, 0, 0), 542 ); 543 544 /* 545 * DAC analog gain for TAS5720A-Q1. There are three discrete values to select from, ranging 546 * from 19.2 dB to 25.0dB. 547 */ 548 static const DECLARE_TLV_DB_RANGE(dac_analog_tlv_a_q1, 549 0x0, 0x0, TLV_DB_SCALE_ITEM(1920, 0, 0), 550 0x1, 0x1, TLV_DB_SCALE_ITEM(2260, 0, 0), 551 0x2, 0x2, TLV_DB_SCALE_ITEM(2500, 0, 0), 552 ); 553 554 /* 555 * DAC digital volumes. From -103.5 to 24 dB in 0.5 dB or 0.25 dB steps 556 * depending on the device. Note that setting the gain below -100 dB 557 * (register value <0x7) is effectively a MUTE as per device datasheet. 558 * 559 * Note that for the TAS5722 the digital volume controls are actually split 560 * over two registers, so we need custom getters/setters for access. 561 */ 562 static DECLARE_TLV_DB_SCALE(tas5720_dac_tlv, -10350, 50, 0); 563 static DECLARE_TLV_DB_SCALE(tas5722_dac_tlv, -10350, 25, 0); 564 565 static int tas5722_volume_get(struct snd_kcontrol *kcontrol, 566 struct snd_ctl_elem_value *ucontrol) 567 { 568 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); 569 unsigned int val; 570 571 val = snd_soc_component_read(component, TAS5720_VOLUME_CTRL_REG); 572 ucontrol->value.integer.value[0] = val << 1; 573 574 val = snd_soc_component_read(component, TAS5722_DIGITAL_CTRL2_REG); 575 ucontrol->value.integer.value[0] |= val & TAS5722_VOL_CONTROL_LSB; 576 577 return 0; 578 } 579 580 static int tas5722_volume_set(struct snd_kcontrol *kcontrol, 581 struct snd_ctl_elem_value *ucontrol) 582 { 583 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol); 584 unsigned int sel = ucontrol->value.integer.value[0]; 585 586 snd_soc_component_write(component, TAS5720_VOLUME_CTRL_REG, sel >> 1); 587 snd_soc_component_update_bits(component, TAS5722_DIGITAL_CTRL2_REG, 588 TAS5722_VOL_CONTROL_LSB, sel); 589 590 return 0; 591 } 592 593 static const struct snd_kcontrol_new tas5720_snd_controls[] = { 594 SOC_SINGLE_TLV("Speaker Driver Playback Volume", 595 TAS5720_VOLUME_CTRL_REG, 0, 0xff, 0, tas5720_dac_tlv), 596 SOC_SINGLE_TLV("Speaker Driver Analog Gain", TAS5720_ANALOG_CTRL_REG, 597 TAS5720_ANALOG_GAIN_SHIFT, 3, 0, dac_analog_tlv), 598 }; 599 600 static const struct snd_kcontrol_new tas5720a_q1_snd_controls[] = { 601 SOC_DOUBLE_R_TLV("Speaker Driver Playback Volume", 602 TAS5720_Q1_VOLUME_CTRL_LEFT_REG, 603 TAS5720_Q1_VOLUME_CTRL_RIGHT_REG, 604 0, 0xff, 0, tas5720_dac_tlv), 605 SOC_SINGLE_TLV("Speaker Driver Analog Gain", TAS5720_ANALOG_CTRL_REG, 606 TAS5720_ANALOG_GAIN_SHIFT, 3, 0, dac_analog_tlv_a_q1), 607 }; 608 609 static const struct snd_kcontrol_new tas5722_snd_controls[] = { 610 SOC_SINGLE_EXT_TLV("Speaker Driver Playback Volume", 611 0, 0, 511, 0, 612 tas5722_volume_get, tas5722_volume_set, 613 tas5722_dac_tlv), 614 SOC_SINGLE_TLV("Speaker Driver Analog Gain", TAS5720_ANALOG_CTRL_REG, 615 TAS5720_ANALOG_GAIN_SHIFT, 3, 0, dac_analog_tlv), 616 }; 617 618 static const struct snd_soc_dapm_widget tas5720_dapm_widgets[] = { 619 SND_SOC_DAPM_AIF_IN("DAC IN", "Playback", 0, SND_SOC_NOPM, 0, 0), 620 SND_SOC_DAPM_DAC_E("DAC", NULL, SND_SOC_NOPM, 0, 0, tas5720_dac_event, 621 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 622 SND_SOC_DAPM_OUTPUT("OUT") 623 }; 624 625 static const struct snd_soc_dapm_route tas5720_audio_map[] = { 626 { "DAC", NULL, "DAC IN" }, 627 { "OUT", NULL, "DAC" }, 628 }; 629 630 static const struct snd_soc_component_driver soc_component_dev_tas5720 = { 631 .probe = tas5720_codec_probe, 632 .remove = tas5720_codec_remove, 633 .suspend = tas5720_suspend, 634 .resume = tas5720_resume, 635 .controls = tas5720_snd_controls, 636 .num_controls = ARRAY_SIZE(tas5720_snd_controls), 637 .dapm_widgets = tas5720_dapm_widgets, 638 .num_dapm_widgets = ARRAY_SIZE(tas5720_dapm_widgets), 639 .dapm_routes = tas5720_audio_map, 640 .num_dapm_routes = ARRAY_SIZE(tas5720_audio_map), 641 .idle_bias_on = 1, 642 .use_pmdown_time = 1, 643 .endianness = 1, 644 }; 645 646 static const struct snd_soc_component_driver soc_component_dev_tas5720_a_q1 = { 647 .probe = tas5720_codec_probe, 648 .remove = tas5720_codec_remove, 649 .suspend = tas5720_suspend, 650 .resume = tas5720_resume, 651 .controls = tas5720a_q1_snd_controls, 652 .num_controls = ARRAY_SIZE(tas5720a_q1_snd_controls), 653 .dapm_widgets = tas5720_dapm_widgets, 654 .num_dapm_widgets = ARRAY_SIZE(tas5720_dapm_widgets), 655 .dapm_routes = tas5720_audio_map, 656 .num_dapm_routes = ARRAY_SIZE(tas5720_audio_map), 657 .idle_bias_on = 1, 658 .use_pmdown_time = 1, 659 .endianness = 1, 660 }; 661 662 static const struct snd_soc_component_driver soc_component_dev_tas5722 = { 663 .probe = tas5720_codec_probe, 664 .remove = tas5720_codec_remove, 665 .suspend = tas5720_suspend, 666 .resume = tas5720_resume, 667 .controls = tas5722_snd_controls, 668 .num_controls = ARRAY_SIZE(tas5722_snd_controls), 669 .dapm_widgets = tas5720_dapm_widgets, 670 .num_dapm_widgets = ARRAY_SIZE(tas5720_dapm_widgets), 671 .dapm_routes = tas5720_audio_map, 672 .num_dapm_routes = ARRAY_SIZE(tas5720_audio_map), 673 .idle_bias_on = 1, 674 .use_pmdown_time = 1, 675 .endianness = 1, 676 }; 677 678 /* PCM rates supported by the TAS5720 driver */ 679 #define TAS5720_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |\ 680 SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000) 681 682 /* Formats supported by TAS5720 driver */ 683 #define TAS5720_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S18_3LE |\ 684 SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE) 685 686 static const struct snd_soc_dai_ops tas5720_speaker_dai_ops = { 687 .hw_params = tas5720_hw_params, 688 .set_fmt = tas5720_set_dai_fmt, 689 .set_tdm_slot = tas5720_set_dai_tdm_slot, 690 .mute_stream = tas5720_mute, 691 .no_capture_mute = 1, 692 }; 693 694 /* 695 * TAS5720 DAI structure 696 * 697 * Note that were are advertising .playback.channels_max = 2 despite this being 698 * a mono amplifier. The reason for that is that some serial ports such as TI's 699 * McASP module have a minimum number of channels (2) that they can output. 700 * Advertising more channels than we have will allow us to interface with such 701 * a serial port without really any negative side effects as the TAS5720 will 702 * simply ignore any extra channel(s) asides from the one channel that is 703 * configured to be played back. 704 */ 705 static struct snd_soc_dai_driver tas5720_dai[] = { 706 { 707 .name = "tas5720-amplifier", 708 .playback = { 709 .stream_name = "Playback", 710 .channels_min = 1, 711 .channels_max = 2, 712 .rates = TAS5720_RATES, 713 .formats = TAS5720_FORMATS, 714 }, 715 .ops = &tas5720_speaker_dai_ops, 716 }, 717 }; 718 719 static const struct i2c_device_id tas5720_id[] = { 720 { "tas5720", TAS5720 }, 721 { "tas5720a-q1", TAS5720A_Q1 }, 722 { "tas5722", TAS5722 }, 723 { } 724 }; 725 MODULE_DEVICE_TABLE(i2c, tas5720_id); 726 727 static int tas5720_probe(struct i2c_client *client) 728 { 729 struct device *dev = &client->dev; 730 struct tas5720_data *data; 731 const struct regmap_config *regmap_config; 732 const struct i2c_device_id *id; 733 int ret; 734 int i; 735 736 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 737 if (!data) 738 return -ENOMEM; 739 740 id = i2c_match_id(tas5720_id, client); 741 data->tas5720_client = client; 742 data->devtype = id->driver_data; 743 744 switch (id->driver_data) { 745 case TAS5720: 746 regmap_config = &tas5720_regmap_config; 747 break; 748 case TAS5720A_Q1: 749 regmap_config = &tas5720a_q1_regmap_config; 750 break; 751 case TAS5722: 752 regmap_config = &tas5722_regmap_config; 753 break; 754 default: 755 dev_err(dev, "unexpected private driver data\n"); 756 return -EINVAL; 757 } 758 data->regmap = devm_regmap_init_i2c(client, regmap_config); 759 if (IS_ERR(data->regmap)) { 760 ret = PTR_ERR(data->regmap); 761 dev_err(dev, "failed to allocate register map: %d\n", ret); 762 return ret; 763 } 764 765 for (i = 0; i < ARRAY_SIZE(data->supplies); i++) 766 data->supplies[i].supply = tas5720_supply_names[i]; 767 768 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies), 769 data->supplies); 770 if (ret != 0) { 771 dev_err(dev, "failed to request supplies: %d\n", ret); 772 return ret; 773 } 774 775 dev_set_drvdata(dev, data); 776 777 switch (id->driver_data) { 778 case TAS5720: 779 ret = devm_snd_soc_register_component(&client->dev, 780 &soc_component_dev_tas5720, 781 tas5720_dai, 782 ARRAY_SIZE(tas5720_dai)); 783 break; 784 case TAS5720A_Q1: 785 ret = devm_snd_soc_register_component(&client->dev, 786 &soc_component_dev_tas5720_a_q1, 787 tas5720_dai, 788 ARRAY_SIZE(tas5720_dai)); 789 break; 790 case TAS5722: 791 ret = devm_snd_soc_register_component(&client->dev, 792 &soc_component_dev_tas5722, 793 tas5720_dai, 794 ARRAY_SIZE(tas5720_dai)); 795 break; 796 default: 797 dev_err(dev, "unexpected private driver data\n"); 798 return -EINVAL; 799 } 800 if (ret < 0) { 801 dev_err(dev, "failed to register component: %d\n", ret); 802 return ret; 803 } 804 805 return 0; 806 } 807 808 #if IS_ENABLED(CONFIG_OF) 809 static const struct of_device_id tas5720_of_match[] = { 810 { .compatible = "ti,tas5720", }, 811 { .compatible = "ti,tas5720a-q1", }, 812 { .compatible = "ti,tas5722", }, 813 { }, 814 }; 815 MODULE_DEVICE_TABLE(of, tas5720_of_match); 816 #endif 817 818 static struct i2c_driver tas5720_i2c_driver = { 819 .driver = { 820 .name = "tas5720", 821 .of_match_table = of_match_ptr(tas5720_of_match), 822 }, 823 .probe_new = tas5720_probe, 824 .id_table = tas5720_id, 825 }; 826 827 module_i2c_driver(tas5720_i2c_driver); 828 829 MODULE_AUTHOR("Andreas Dannenberg <dannenberg@ti.com>"); 830 MODULE_DESCRIPTION("TAS5720 Audio amplifier driver"); 831 MODULE_LICENSE("GPL"); 832