FILE
tas571x.c
File preview with syntax highlighting.
linux-6.19.14/sound/soc/codecs/tas571x.c
1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * TAS571x amplifier audio driver 4 * 5 * Copyright (C) 2015 Google, Inc. 6 * Copyright (c) 2013 Daniel Mack <zonque@gmail.com> 7 * 8 * TAS5721 support: 9 * Copyright (C) 2016 Petr Kulhavy, Barix AG <petr@barix.com> 10 * 11 * TAS5707 support: 12 * Copyright (C) 2018 Jerome Brunet, Baylibre SAS <jbrunet@baylibre.com> 13 */ 14 15#include <linux/clk.h> 16#include <linux/delay.h> 17#include <linux/device.h> 18#include <linux/gpio/consumer.h> 19#include <linux/i2c.h> 20#include <linux/init.h> 21#include <linux/kernel.h> 22#include <linux/module.h> 23#include <linux/of.h> 24#include <linux/regmap.h> 25#include <linux/regulator/consumer.h> 26#include <linux/stddef.h> 27#include <sound/pcm_params.h> 28#include <sound/soc.h> 29#include <sound/tlv.h> 30#include <linux/unaligned.h> 31 32#include "tas571x.h" 33 34#define TAS571X_MAX_SUPPLIES 6 35 36struct tas571x_chip { 37 const char *const *supply_names; 38 int num_supply_names; 39 const struct snd_kcontrol_new *controls; 40 int num_controls; 41 const struct regmap_config *regmap_config; 42 int vol_reg_size; 43}; 44 45struct tas571x_private { 46 const struct tas571x_chip *chip; 47 struct regmap *regmap; 48 struct regulator_bulk_data supplies[TAS571X_MAX_SUPPLIES]; 49 struct clk *mclk; 50 unsigned int format; 51 struct gpio_desc *reset_gpio; 52 struct gpio_desc *pdn_gpio; 53 struct snd_soc_component_driver component_driver; 54}; 55 56static int tas571x_register_size(struct tas571x_private *priv, unsigned int reg) 57{ 58 switch (reg) { 59 case TAS571X_MVOL_REG: 60 case TAS571X_CH1_VOL_REG: 61 case TAS571X_CH2_VOL_REG: 62 return priv->chip->vol_reg_size; 63 case TAS571X_INPUT_MUX_REG: 64 case TAS571X_CH4_SRC_SELECT_REG: 65 case TAS571X_PWM_MUX_REG: 66 case TAS5717_CH1_RIGHT_CH_MIX_REG: 67 case TAS5717_CH1_LEFT_CH_MIX_REG: 68 case TAS5717_CH2_LEFT_CH_MIX_REG: 69 case TAS5717_CH2_RIGHT_CH_MIX_REG: 70 return 4; 71 default: 72 return 1; 73 } 74} 75 76static int tas571x_reg_write(void *context, unsigned int reg, 77 unsigned int value) 78{ 79 struct i2c_client *client = context; 80 struct tas571x_private *priv = i2c_get_clientdata(client); 81 unsigned int i, size; 82 uint8_t buf[5]; 83 int ret; 84 85 size = tas571x_register_size(priv, reg); 86 buf[0] = reg; 87 88 for (i = size; i >= 1; --i) { 89 buf[i] = value; 90 value >>= 8; 91 } 92 93 ret = i2c_master_send(client, buf, size + 1); 94 if (ret == size + 1) 95 return 0; 96 else if (ret < 0) 97 return ret; 98 else 99 return -EIO; 100} 101 102static int tas571x_reg_read(void *context, unsigned int reg, 103 unsigned int *value) 104{ 105 struct i2c_client *client = context; 106 struct tas571x_private *priv = i2c_get_clientdata(client); 107 uint8_t send_buf, recv_buf[4]; 108 struct i2c_msg msgs[2]; 109 unsigned int size; 110 unsigned int i; 111 int ret; 112 113 size = tas571x_register_size(priv, reg); 114 send_buf = reg; 115 116 msgs[0].addr = client->addr; 117 msgs[0].len = sizeof(send_buf); 118 msgs[0].buf = &send_buf; 119 msgs[0].flags = 0; 120 121 msgs[1].addr = client->addr; 122 msgs[1].len = size; 123 msgs[1].buf = recv_buf; 124 msgs[1].flags = I2C_M_RD; 125 126 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 127 if (ret < 0) 128 return ret; 129 else if (ret != ARRAY_SIZE(msgs)) 130 return -EIO; 131 132 *value = 0; 133 134 for (i = 0; i < size; i++) { 135 *value <<= 8; 136 *value |= recv_buf[i]; 137 } 138 139 return 0; 140} 141 142/* 143 * register write for 8- and 20-byte registers 144 */ 145static int tas571x_reg_write_multiword(struct i2c_client *client, 146 unsigned int reg, const long values[], size_t len) 147{ 148 size_t i; 149 uint8_t *buf, *p; 150 int ret; 151 size_t send_size = 1 + len * sizeof(uint32_t); 152 153 buf = kzalloc(send_size, GFP_KERNEL | GFP_DMA); 154 if (!buf) 155 return -ENOMEM; 156 buf[0] = reg; 157 158 for (i = 0, p = buf + 1; i < len; i++, p += sizeof(uint32_t)) 159 put_unaligned_be32(values[i], p); 160 161 ret = i2c_master_send(client, buf, send_size); 162 163 kfree(buf); 164 165 if (ret == send_size) 166 return 0; 167 else if (ret < 0) 168 return ret; 169 else 170 return -EIO; 171} 172 173/* 174 * register read for 8- and 20-byte registers 175 */ 176static int tas571x_reg_read_multiword(struct i2c_client *client, 177 unsigned int reg, long values[], size_t len) 178{ 179 unsigned int i; 180 uint8_t send_buf; 181 uint8_t *recv_buf, *p; 182 struct i2c_msg msgs[2]; 183 unsigned int recv_size = len * sizeof(uint32_t); 184 int ret; 185 186 recv_buf = kzalloc(recv_size, GFP_KERNEL | GFP_DMA); 187 if (!recv_buf) 188 return -ENOMEM; 189 190 send_buf = reg; 191 192 msgs[0].addr = client->addr; 193 msgs[0].len = sizeof(send_buf); 194 msgs[0].buf = &send_buf; 195 msgs[0].flags = 0; 196 197 msgs[1].addr = client->addr; 198 msgs[1].len = recv_size; 199 msgs[1].buf = recv_buf; 200 msgs[1].flags = I2C_M_RD; 201 202 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs)); 203 if (ret < 0) 204 goto err_ret; 205 else if (ret != ARRAY_SIZE(msgs)) { 206 ret = -EIO; 207 goto err_ret; 208 } 209 210 for (i = 0, p = recv_buf; i < len; i++, p += sizeof(uint32_t)) 211 values[i] = get_unaligned_be32(p); 212 213err_ret: 214 kfree(recv_buf); 215 return ret; 216} 217 218/* 219 * Integer array controls for setting biquad, mixer, DRC coefficients. 220 * According to the datasheet each coefficient is effectively 26bits, 221 * i.e. stored as 32bits, where bits [31:26] are ignored. 222 * TI's TAS57xx Graphical Development Environment tool however produces 223 * coefficients with more than 26 bits. For this reason we allow values 224 * in the full 32-bits reange. 225 * The coefficients are ordered as given in the TAS571x data sheet: 226 * b0, b1, b2, a1, a2 227 */ 228 229static int tas571x_coefficient_info(struct snd_kcontrol *kcontrol, 230 struct snd_ctl_elem_info *uinfo) 231{ 232 int numcoef = kcontrol->private_value >> 16; 233 234 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 235 uinfo->count = numcoef; 236 uinfo->value.integer.min = 0; 237 uinfo->value.integer.max = 0xffffffff; 238 return 0; 239} 240 241static int tas571x_coefficient_get(struct snd_kcontrol *kcontrol, 242 struct snd_ctl_elem_value *ucontrol) 243{ 244 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 245 struct i2c_client *i2c = to_i2c_client(component->dev); 246 int numcoef = kcontrol->private_value >> 16; 247 int index = kcontrol->private_value & 0xffff; 248 249 return tas571x_reg_read_multiword(i2c, index, 250 ucontrol->value.integer.value, numcoef); 251} 252 253static int tas571x_coefficient_put(struct snd_kcontrol *kcontrol, 254 struct snd_ctl_elem_value *ucontrol) 255{ 256 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 257 struct i2c_client *i2c = to_i2c_client(component->dev); 258 int numcoef = kcontrol->private_value >> 16; 259 int index = kcontrol->private_value & 0xffff; 260 261 return tas571x_reg_write_multiword(i2c, index, 262 ucontrol->value.integer.value, numcoef); 263} 264 265static int tas571x_set_dai_fmt(struct snd_soc_dai *dai, unsigned int format) 266{ 267 struct tas571x_private *priv = snd_soc_component_get_drvdata(dai->component); 268 269 priv->format = format; 270 271 return 0; 272} 273 274static int tas571x_hw_params(struct snd_pcm_substream *substream, 275 struct snd_pcm_hw_params *params, 276 struct snd_soc_dai *dai) 277{ 278 struct tas571x_private *priv = snd_soc_component_get_drvdata(dai->component); 279 u32 val; 280 281 switch (priv->format & SND_SOC_DAIFMT_FORMAT_MASK) { 282 case SND_SOC_DAIFMT_RIGHT_J: 283 val = 0x00; 284 break; 285 case SND_SOC_DAIFMT_I2S: 286 val = 0x03; 287 break; 288 case SND_SOC_DAIFMT_LEFT_J: 289 val = 0x06; 290 break; 291 default: 292 return -EINVAL; 293 } 294 295 if (params_width(params) >= 24) 296 val += 2; 297 else if (params_width(params) >= 20) 298 val += 1; 299 300 return regmap_update_bits(priv->regmap, TAS571X_SDI_REG, 301 TAS571X_SDI_FMT_MASK, val); 302} 303 304static int tas571x_mute(struct snd_soc_dai *dai, int mute, int direction) 305{ 306 struct snd_soc_component *component = dai->component; 307 u8 sysctl2; 308 int ret; 309 310 sysctl2 = mute ? TAS571X_SYS_CTRL_2_SDN_MASK : 0; 311 312 ret = snd_soc_component_update_bits(component, 313 TAS571X_SYS_CTRL_2_REG, 314 TAS571X_SYS_CTRL_2_SDN_MASK, 315 sysctl2); 316 usleep_range(1000, 2000); 317 318 return ret; 319} 320 321static int tas571x_set_bias_level(struct snd_soc_component *component, 322 enum snd_soc_bias_level level) 323{ 324 struct tas571x_private *priv = snd_soc_component_get_drvdata(component); 325 struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component); 326 int ret; 327 328 switch (level) { 329 case SND_SOC_BIAS_ON: 330 break; 331 case SND_SOC_BIAS_PREPARE: 332 break; 333 case SND_SOC_BIAS_STANDBY: 334 if (snd_soc_dapm_get_bias_level(dapm) == SND_SOC_BIAS_OFF) { 335 if (!IS_ERR(priv->mclk)) { 336 ret = clk_prepare_enable(priv->mclk); 337 if (ret) { 338 dev_err(component->dev, 339 "Failed to enable master clock: %d\n", 340 ret); 341 return ret; 342 } 343 } 344 } 345 break; 346 case SND_SOC_BIAS_OFF: 347 if (!IS_ERR(priv->mclk)) 348 clk_disable_unprepare(priv->mclk); 349 break; 350 } 351 352 return 0; 353} 354 355static const struct snd_soc_dai_ops tas571x_dai_ops = { 356 .set_fmt = tas571x_set_dai_fmt, 357 .hw_params = tas571x_hw_params, 358 .mute_stream = tas571x_mute, 359 .no_capture_mute = 1, 360}; 361 362 363#define BIQUAD_COEFS(xname, reg) \ 364{ .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \ 365 .info = tas571x_coefficient_info, \ 366 .get = tas571x_coefficient_get,\ 367 .put = tas571x_coefficient_put, \ 368 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \ 369 .private_value = reg | (5 << 16) } 370 371static const char *const tas5711_supply_names[] = { 372 "AVDD", 373 "DVDD", 374 "PVDD_A", 375 "PVDD_B", 376 "PVDD_C", 377 "PVDD_D", 378}; 379 380static const DECLARE_TLV_DB_SCALE(tas5711_volume_tlv, -10350, 50, 1); 381 382static const struct snd_kcontrol_new tas5711_controls[] = { 383 SOC_SINGLE_TLV("Master Volume", 384 TAS571X_MVOL_REG, 385 0, 0xff, 1, tas5711_volume_tlv), 386 SOC_DOUBLE_R_TLV("Speaker Volume", 387 TAS571X_CH1_VOL_REG, 388 TAS571X_CH2_VOL_REG, 389 0, 0xff, 1, tas5711_volume_tlv), 390 SOC_DOUBLE("Speaker Switch", 391 TAS571X_SOFT_MUTE_REG, 392 TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT, 393 1, 1), 394}; 395 396static const struct regmap_range tas571x_readonly_regs_range[] = { 397 regmap_reg_range(TAS571X_CLK_CTRL_REG, TAS571X_DEV_ID_REG), 398}; 399 400static const struct regmap_range tas571x_volatile_regs_range[] = { 401 regmap_reg_range(TAS571X_CLK_CTRL_REG, TAS571X_ERR_STATUS_REG), 402 regmap_reg_range(TAS571X_OSC_TRIM_REG, TAS571X_OSC_TRIM_REG), 403}; 404 405static const struct regmap_access_table tas571x_write_regs = { 406 .no_ranges = tas571x_readonly_regs_range, 407 .n_no_ranges = ARRAY_SIZE(tas571x_readonly_regs_range), 408}; 409 410static const struct regmap_access_table tas571x_volatile_regs = { 411 .yes_ranges = tas571x_volatile_regs_range, 412 .n_yes_ranges = ARRAY_SIZE(tas571x_volatile_regs_range), 413 414}; 415 416static const struct reg_default tas5711_reg_defaults[] = { 417 { 0x04, 0x05 }, 418 { 0x05, 0x40 }, 419 { 0x06, 0x00 }, 420 { 0x07, 0xff }, 421 { 0x08, 0x30 }, 422 { 0x09, 0x30 }, 423 { 0x1b, 0x82 }, 424}; 425 426static const struct regmap_config tas5711_regmap_config = { 427 .reg_bits = 8, 428 .val_bits = 32, 429 .max_register = 0xff, 430 .reg_read = tas571x_reg_read, 431 .reg_write = tas571x_reg_write, 432 .reg_defaults = tas5711_reg_defaults, 433 .num_reg_defaults = ARRAY_SIZE(tas5711_reg_defaults), 434 .cache_type = REGCACHE_RBTREE, 435 .wr_table = &tas571x_write_regs, 436 .volatile_table = &tas571x_volatile_regs, 437}; 438 439static const struct tas571x_chip tas5711_chip = { 440 .supply_names = tas5711_supply_names, 441 .num_supply_names = ARRAY_SIZE(tas5711_supply_names), 442 .controls = tas5711_controls, 443 .num_controls = ARRAY_SIZE(tas5711_controls), 444 .regmap_config = &tas5711_regmap_config, 445 .vol_reg_size = 1, 446}; 447 448static const struct regmap_range tas5707_volatile_regs_range[] = { 449 regmap_reg_range(TAS571X_CLK_CTRL_REG, TAS571X_ERR_STATUS_REG), 450 regmap_reg_range(TAS571X_OSC_TRIM_REG, TAS571X_OSC_TRIM_REG), 451 regmap_reg_range(TAS5707_CH1_BQ0_REG, TAS5707_CH2_BQ6_REG), 452}; 453 454static const struct regmap_access_table tas5707_volatile_regs = { 455 .yes_ranges = tas5707_volatile_regs_range, 456 .n_yes_ranges = ARRAY_SIZE(tas5707_volatile_regs_range), 457 458}; 459 460static const DECLARE_TLV_DB_SCALE(tas5707_volume_tlv, -7900, 50, 1); 461 462static const char * const tas5707_volume_slew_step_txt[] = { 463 "256", "512", "1024", "2048", 464}; 465 466static const unsigned int tas5707_volume_slew_step_values[] = { 467 3, 0, 1, 2, 468}; 469 470static SOC_VALUE_ENUM_SINGLE_DECL(tas5707_volume_slew_step_enum, 471 TAS571X_VOL_CFG_REG, 0, 0x3, 472 tas5707_volume_slew_step_txt, 473 tas5707_volume_slew_step_values); 474 475static const struct snd_kcontrol_new tas5707_controls[] = { 476 SOC_SINGLE_TLV("Master Volume", 477 TAS571X_MVOL_REG, 478 0, 0xff, 1, tas5707_volume_tlv), 479 SOC_DOUBLE_R_TLV("Speaker Volume", 480 TAS571X_CH1_VOL_REG, 481 TAS571X_CH2_VOL_REG, 482 0, 0xff, 1, tas5707_volume_tlv), 483 SOC_DOUBLE("Speaker Switch", 484 TAS571X_SOFT_MUTE_REG, 485 TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT, 486 1, 1), 487 488 SOC_ENUM("Slew Rate Steps", tas5707_volume_slew_step_enum), 489 490 BIQUAD_COEFS("CH1 - Biquad 0", TAS5707_CH1_BQ0_REG), 491 BIQUAD_COEFS("CH1 - Biquad 1", TAS5707_CH1_BQ1_REG), 492 BIQUAD_COEFS("CH1 - Biquad 2", TAS5707_CH1_BQ2_REG), 493 BIQUAD_COEFS("CH1 - Biquad 3", TAS5707_CH1_BQ3_REG), 494 BIQUAD_COEFS("CH1 - Biquad 4", TAS5707_CH1_BQ4_REG), 495 BIQUAD_COEFS("CH1 - Biquad 5", TAS5707_CH1_BQ5_REG), 496 BIQUAD_COEFS("CH1 - Biquad 6", TAS5707_CH1_BQ6_REG), 497 498 BIQUAD_COEFS("CH2 - Biquad 0", TAS5707_CH2_BQ0_REG), 499 BIQUAD_COEFS("CH2 - Biquad 1", TAS5707_CH2_BQ1_REG), 500 BIQUAD_COEFS("CH2 - Biquad 2", TAS5707_CH2_BQ2_REG), 501 BIQUAD_COEFS("CH2 - Biquad 3", TAS5707_CH2_BQ3_REG), 502 BIQUAD_COEFS("CH2 - Biquad 4", TAS5707_CH2_BQ4_REG), 503 BIQUAD_COEFS("CH2 - Biquad 5", TAS5707_CH2_BQ5_REG), 504 BIQUAD_COEFS("CH2 - Biquad 6", TAS5707_CH2_BQ6_REG), 505}; 506 507static const struct reg_default tas5707_reg_defaults[] = { 508 {TAS571X_CLK_CTRL_REG, 0x6c}, 509 {TAS571X_DEV_ID_REG, 0x70}, 510 {TAS571X_ERR_STATUS_REG, 0x00}, 511 {TAS571X_SYS_CTRL_1_REG, 0xa0}, 512 {TAS571X_SDI_REG, 0x05}, 513 {TAS571X_SYS_CTRL_2_REG, 0x40}, 514 {TAS571X_SOFT_MUTE_REG, 0x00}, 515 {TAS571X_MVOL_REG, 0xff}, 516 {TAS571X_CH1_VOL_REG, 0x30}, 517 {TAS571X_CH2_VOL_REG, 0x30}, 518 {TAS571X_VOL_CFG_REG, 0x91}, 519 {TAS571X_MODULATION_LIMIT_REG, 0x02}, 520 {TAS571X_IC_DELAY_CH1_REG, 0xac}, 521 {TAS571X_IC_DELAY_CH2_REG, 0x54}, 522 {TAS571X_IC_DELAY_CH3_REG, 0xac}, 523 {TAS571X_IC_DELAY_CH4_REG, 0x54}, 524 {TAS571X_START_STOP_PERIOD_REG, 0x0f}, 525 {TAS571X_OSC_TRIM_REG, 0x82}, 526 {TAS571X_BKND_ERR_REG, 0x02}, 527 {TAS571X_INPUT_MUX_REG, 0x17772}, 528 {TAS571X_PWM_MUX_REG, 0x1021345}, 529}; 530 531static const struct regmap_config tas5707_regmap_config = { 532 .reg_bits = 8, 533 .val_bits = 32, 534 .max_register = 0xff, 535 .reg_read = tas571x_reg_read, 536 .reg_write = tas571x_reg_write, 537 .reg_defaults = tas5707_reg_defaults, 538 .num_reg_defaults = ARRAY_SIZE(tas5707_reg_defaults), 539 .cache_type = REGCACHE_RBTREE, 540 .wr_table = &tas571x_write_regs, 541 .volatile_table = &tas5707_volatile_regs, 542}; 543 544static const struct tas571x_chip tas5707_chip = { 545 .supply_names = tas5711_supply_names, 546 .num_supply_names = ARRAY_SIZE(tas5711_supply_names), 547 .controls = tas5707_controls, 548 .num_controls = ARRAY_SIZE(tas5707_controls), 549 .regmap_config = &tas5707_regmap_config, 550 .vol_reg_size = 1, 551}; 552 553static const char *const tas5717_supply_names[] = { 554 "AVDD", 555 "DVDD", 556 "HPVDD", 557 "PVDD_AB", 558 "PVDD_CD", 559}; 560 561static const DECLARE_TLV_DB_SCALE(tas5717_volume_tlv, -10375, 25, 0); 562 563static const struct snd_kcontrol_new tas5717_controls[] = { 564 /* MVOL LSB is ignored - see comments in tas571x_i2c_probe() */ 565 SOC_SINGLE_TLV("Master Volume", 566 TAS571X_MVOL_REG, 1, 0x1ff, 1, 567 tas5717_volume_tlv), 568 SOC_DOUBLE_R_TLV("Speaker Volume", 569 TAS571X_CH1_VOL_REG, TAS571X_CH2_VOL_REG, 570 1, 0x1ff, 1, tas5717_volume_tlv), 571 SOC_DOUBLE("Speaker Switch", 572 TAS571X_SOFT_MUTE_REG, 573 TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT, 574 1, 1), 575 576 SOC_DOUBLE_R_RANGE("CH1 Mixer Volume", 577 TAS5717_CH1_LEFT_CH_MIX_REG, 578 TAS5717_CH1_RIGHT_CH_MIX_REG, 579 16, 0, 0x80, 0), 580 581 SOC_DOUBLE_R_RANGE("CH2 Mixer Volume", 582 TAS5717_CH2_LEFT_CH_MIX_REG, 583 TAS5717_CH2_RIGHT_CH_MIX_REG, 584 16, 0, 0x80, 0), 585 586 /* 587 * The biquads are named according to the register names. 588 * Please note that TI's TAS57xx Graphical Development Environment 589 * tool names them different. 590 */ 591 BIQUAD_COEFS("CH1 - Biquad 0", TAS5717_CH1_BQ0_REG), 592 BIQUAD_COEFS("CH1 - Biquad 1", TAS5717_CH1_BQ1_REG), 593 BIQUAD_COEFS("CH1 - Biquad 2", TAS5717_CH1_BQ2_REG), 594 BIQUAD_COEFS("CH1 - Biquad 3", TAS5717_CH1_BQ3_REG), 595 BIQUAD_COEFS("CH1 - Biquad 4", TAS5717_CH1_BQ4_REG), 596 BIQUAD_COEFS("CH1 - Biquad 5", TAS5717_CH1_BQ5_REG), 597 BIQUAD_COEFS("CH1 - Biquad 6", TAS5717_CH1_BQ6_REG), 598 BIQUAD_COEFS("CH1 - Biquad 7", TAS5717_CH1_BQ7_REG), 599 BIQUAD_COEFS("CH1 - Biquad 8", TAS5717_CH1_BQ8_REG), 600 BIQUAD_COEFS("CH1 - Biquad 9", TAS5717_CH1_BQ9_REG), 601 BIQUAD_COEFS("CH1 - Biquad 10", TAS5717_CH1_BQ10_REG), 602 BIQUAD_COEFS("CH1 - Biquad 11", TAS5717_CH1_BQ11_REG), 603 604 BIQUAD_COEFS("CH2 - Biquad 0", TAS5717_CH2_BQ0_REG), 605 BIQUAD_COEFS("CH2 - Biquad 1", TAS5717_CH2_BQ1_REG), 606 BIQUAD_COEFS("CH2 - Biquad 2", TAS5717_CH2_BQ2_REG), 607 BIQUAD_COEFS("CH2 - Biquad 3", TAS5717_CH2_BQ3_REG), 608 BIQUAD_COEFS("CH2 - Biquad 4", TAS5717_CH2_BQ4_REG), 609 BIQUAD_COEFS("CH2 - Biquad 5", TAS5717_CH2_BQ5_REG), 610 BIQUAD_COEFS("CH2 - Biquad 6", TAS5717_CH2_BQ6_REG), 611 BIQUAD_COEFS("CH2 - Biquad 7", TAS5717_CH2_BQ7_REG), 612 BIQUAD_COEFS("CH2 - Biquad 8", TAS5717_CH2_BQ8_REG), 613 BIQUAD_COEFS("CH2 - Biquad 9", TAS5717_CH2_BQ9_REG), 614 BIQUAD_COEFS("CH2 - Biquad 10", TAS5717_CH2_BQ10_REG), 615 BIQUAD_COEFS("CH2 - Biquad 11", TAS5717_CH2_BQ11_REG), 616 617 BIQUAD_COEFS("CH3 - Biquad 0", TAS5717_CH3_BQ0_REG), 618 BIQUAD_COEFS("CH3 - Biquad 1", TAS5717_CH3_BQ1_REG), 619 620 BIQUAD_COEFS("CH4 - Biquad 0", TAS5717_CH4_BQ0_REG), 621 BIQUAD_COEFS("CH4 - Biquad 1", TAS5717_CH4_BQ1_REG), 622}; 623 624static const struct reg_default tas5717_reg_defaults[] = { 625 { 0x04, 0x05 }, 626 { 0x05, 0x40 }, 627 { 0x06, 0x00 }, 628 { 0x07, 0x03ff }, 629 { 0x08, 0x00c0 }, 630 { 0x09, 0x00c0 }, 631 { 0x1b, 0x82 }, 632 { TAS5717_CH1_RIGHT_CH_MIX_REG, 0x0 }, 633 { TAS5717_CH1_LEFT_CH_MIX_REG, 0x800000}, 634 { TAS5717_CH2_LEFT_CH_MIX_REG, 0x0 }, 635 { TAS5717_CH2_RIGHT_CH_MIX_REG, 0x800000}, 636}; 637 638static const struct regmap_config tas5717_regmap_config = { 639 .reg_bits = 8, 640 .val_bits = 32, 641 .max_register = 0xff, 642 .reg_read = tas571x_reg_read, 643 .reg_write = tas571x_reg_write, 644 .reg_defaults = tas5717_reg_defaults, 645 .num_reg_defaults = ARRAY_SIZE(tas5717_reg_defaults), 646 .cache_type = REGCACHE_RBTREE, 647 .wr_table = &tas571x_write_regs, 648 .volatile_table = &tas571x_volatile_regs, 649}; 650 651/* This entry is reused for tas5719 as the software interface is identical. */ 652static const struct tas571x_chip tas5717_chip = { 653 .supply_names = tas5717_supply_names, 654 .num_supply_names = ARRAY_SIZE(tas5717_supply_names), 655 .controls = tas5717_controls, 656 .num_controls = ARRAY_SIZE(tas5717_controls), 657 .regmap_config = &tas5717_regmap_config, 658 .vol_reg_size = 2, 659}; 660 661static const char *const tas5721_supply_names[] = { 662 "AVDD", 663 "DVDD", 664 "DRVDD", 665 "PVDD", 666}; 667 668static const struct snd_kcontrol_new tas5721_controls[] = { 669 SOC_SINGLE_TLV("Master Volume", 670 TAS571X_MVOL_REG, 671 0, 0xff, 1, tas5711_volume_tlv), 672 SOC_DOUBLE_R_TLV("Speaker Volume", 673 TAS571X_CH1_VOL_REG, 674 TAS571X_CH2_VOL_REG, 675 0, 0xff, 1, tas5711_volume_tlv), 676 SOC_DOUBLE("Speaker Switch", 677 TAS571X_SOFT_MUTE_REG, 678 TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT, 679 1, 1), 680}; 681 682static const struct reg_default tas5721_reg_defaults[] = { 683 {TAS571X_CLK_CTRL_REG, 0x6c}, 684 {TAS571X_DEV_ID_REG, 0x00}, 685 {TAS571X_ERR_STATUS_REG, 0x00}, 686 {TAS571X_SYS_CTRL_1_REG, 0xa0}, 687 {TAS571X_SDI_REG, 0x05}, 688 {TAS571X_SYS_CTRL_2_REG, 0x40}, 689 {TAS571X_SOFT_MUTE_REG, 0x00}, 690 {TAS571X_MVOL_REG, 0xff}, 691 {TAS571X_CH1_VOL_REG, 0x30}, 692 {TAS571X_CH2_VOL_REG, 0x30}, 693 {TAS571X_CH3_VOL_REG, 0x30}, 694 {TAS571X_VOL_CFG_REG, 0x91}, 695 {TAS571X_MODULATION_LIMIT_REG, 0x02}, 696 {TAS571X_IC_DELAY_CH1_REG, 0xac}, 697 {TAS571X_IC_DELAY_CH2_REG, 0x54}, 698 {TAS571X_IC_DELAY_CH3_REG, 0xac}, 699 {TAS571X_IC_DELAY_CH4_REG, 0x54}, 700 {TAS571X_PWM_CH_SDN_GROUP_REG, 0x30}, 701 {TAS571X_START_STOP_PERIOD_REG, 0x0f}, 702 {TAS571X_OSC_TRIM_REG, 0x82}, 703 {TAS571X_BKND_ERR_REG, 0x02}, 704 {TAS571X_INPUT_MUX_REG, 0x17772}, 705 {TAS571X_CH4_SRC_SELECT_REG, 0x4303}, 706 {TAS571X_PWM_MUX_REG, 0x1021345}, 707}; 708 709static const struct regmap_config tas5721_regmap_config = { 710 .reg_bits = 8, 711 .val_bits = 32, 712 .max_register = 0xff, 713 .reg_read = tas571x_reg_read, 714 .reg_write = tas571x_reg_write, 715 .reg_defaults = tas5721_reg_defaults, 716 .num_reg_defaults = ARRAY_SIZE(tas5721_reg_defaults), 717 .cache_type = REGCACHE_RBTREE, 718 .wr_table = &tas571x_write_regs, 719 .volatile_table = &tas571x_volatile_regs, 720}; 721 722static const struct snd_kcontrol_new tas5733_controls[] = { 723 /* MVOL LSB is ignored - see comments in tas571x_i2c_probe() */ 724 SOC_SINGLE_TLV("Master Volume", 725 TAS571X_MVOL_REG, 1, 0x1ff, 1, 726 tas5717_volume_tlv), 727 SOC_DOUBLE_R_TLV("Speaker Volume", 728 TAS571X_CH1_VOL_REG, TAS571X_CH2_VOL_REG, 729 1, 0x1ff, 1, tas5717_volume_tlv), 730 SOC_DOUBLE("Speaker Switch", 731 TAS571X_SOFT_MUTE_REG, 732 TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT, 733 1, 1), 734 735 SOC_DOUBLE_R_RANGE("CH1 Mixer Volume", 736 TAS5717_CH1_LEFT_CH_MIX_REG, 737 TAS5717_CH1_RIGHT_CH_MIX_REG, 738 16, 0, 0x80, 0), 739 740 SOC_DOUBLE_R_RANGE("CH2 Mixer Volume", 741 TAS5717_CH2_LEFT_CH_MIX_REG, 742 TAS5717_CH2_RIGHT_CH_MIX_REG, 743 16, 0, 0x80, 0), 744 745 /* 746 * The biquads are named according to the register names. 747 * Please note that TI's TAS57xx Graphical Development Environment 748 * tool names them different. 749 */ 750 BIQUAD_COEFS("CH1 - Biquad 0", TAS5733_CH1_BQ0_REG), 751 BIQUAD_COEFS("CH1 - Biquad 1", TAS5733_CH1_BQ1_REG), 752 BIQUAD_COEFS("CH1 - Biquad 2", TAS5733_CH1_BQ2_REG), 753 BIQUAD_COEFS("CH1 - Biquad 3", TAS5733_CH1_BQ3_REG), 754 BIQUAD_COEFS("CH1 - Biquad 4", TAS5733_CH1_BQ4_REG), 755 BIQUAD_COEFS("CH1 - Biquad 5", TAS5733_CH1_BQ5_REG), 756 BIQUAD_COEFS("CH1 - Biquad 6", TAS5733_CH1_BQ6_REG), 757 BIQUAD_COEFS("CH1 - Biquad 7", TAS5733_CH1_BQ7_REG), 758 BIQUAD_COEFS("CH1 - Biquad 8", TAS5733_CH1_BQ8_REG), 759 BIQUAD_COEFS("CH1 - Biquad 9", TAS5733_CH1_BQ9_REG), 760 BIQUAD_COEFS("CH1 - Biquad 10", TAS5733_CH1_BQ10_REG), 761 762 BIQUAD_COEFS("CH2 - Biquad 0", TAS5733_CH2_BQ0_REG), 763 BIQUAD_COEFS("CH2 - Biquad 1", TAS5733_CH2_BQ1_REG), 764 BIQUAD_COEFS("CH2 - Biquad 2", TAS5733_CH2_BQ2_REG), 765 BIQUAD_COEFS("CH2 - Biquad 3", TAS5733_CH2_BQ3_REG), 766 BIQUAD_COEFS("CH2 - Biquad 4", TAS5733_CH2_BQ4_REG), 767 BIQUAD_COEFS("CH2 - Biquad 5", TAS5733_CH2_BQ5_REG), 768 BIQUAD_COEFS("CH2 - Biquad 6", TAS5733_CH2_BQ6_REG), 769 BIQUAD_COEFS("CH2 - Biquad 7", TAS5733_CH2_BQ7_REG), 770 BIQUAD_COEFS("CH2 - Biquad 8", TAS5733_CH2_BQ8_REG), 771 BIQUAD_COEFS("CH2 - Biquad 9", TAS5733_CH2_BQ9_REG), 772 BIQUAD_COEFS("CH2 - Biquad 10", TAS5733_CH2_BQ10_REG), 773 774 BIQUAD_COEFS("CH1 - Cross Biquad 0", TAS5733_CH1_CBQ0_REG), 775 BIQUAD_COEFS("CH1 - Cross Biquad 1", TAS5733_CH1_CBQ1_REG), 776 BIQUAD_COEFS("CH1 - Cross Biquad 2", TAS5733_CH1_CBQ2_REG), 777 BIQUAD_COEFS("CH1 - Cross Biquad 3", TAS5733_CH1_CBQ3_REG), 778 779 BIQUAD_COEFS("CH2 - Cross Biquad 0", TAS5733_CH2_CBQ0_REG), 780 BIQUAD_COEFS("CH2 - Cross Biquad 1", TAS5733_CH2_CBQ1_REG), 781 BIQUAD_COEFS("CH2 - Cross Biquad 2", TAS5733_CH2_CBQ2_REG), 782 BIQUAD_COEFS("CH2 - Cross Biquad 3", TAS5733_CH2_CBQ3_REG), 783}; 784 785static const char *const tas5733_supply_names[] = { 786 "AVDD", 787 "DVDD", 788 "PVDD", 789}; 790 791static const struct reg_default tas5733_reg_defaults[] = { 792 {TAS571X_CLK_CTRL_REG, 0x6c}, 793 {TAS571X_DEV_ID_REG, 0x00}, 794 {TAS571X_ERR_STATUS_REG, 0x00}, 795 {TAS571X_SYS_CTRL_1_REG, 0xa0}, 796 {TAS571X_SDI_REG, 0x05}, 797 {TAS571X_SYS_CTRL_2_REG, 0x40}, 798 {TAS571X_SOFT_MUTE_REG, 0x07}, 799 {TAS571X_MVOL_REG, 0x03ff}, 800 {TAS571X_CH1_VOL_REG, 0x00c0}, 801 {TAS571X_CH2_VOL_REG, 0x00c0}, 802 {TAS571X_CH3_VOL_REG, 0x00c0}, 803 {TAS571X_VOL_CFG_REG, 0xf0}, 804 {TAS571X_MODULATION_LIMIT_REG, 0x07}, 805 {TAS571X_IC_DELAY_CH1_REG, 0xb8}, 806 {TAS571X_IC_DELAY_CH2_REG, 0x60}, 807 {TAS571X_IC_DELAY_CH3_REG, 0xa0}, 808 {TAS571X_IC_DELAY_CH4_REG, 0x48}, 809 {TAS571X_PWM_CH_SDN_GROUP_REG, 0x30}, 810 {TAS571X_START_STOP_PERIOD_REG, 0x68}, 811 {TAS571X_OSC_TRIM_REG, 0x82}, 812 {TAS571X_BKND_ERR_REG, 0x02}, 813 {TAS571X_INPUT_MUX_REG, 0x00897772}, 814 {TAS571X_PWM_MUX_REG, 0x01021345}, 815 {TAS5717_CH1_RIGHT_CH_MIX_REG, 0x00}, 816 {TAS5717_CH1_LEFT_CH_MIX_REG, 0x800000}, 817 {TAS5717_CH2_LEFT_CH_MIX_REG, 0x00}, 818 {TAS5717_CH2_RIGHT_CH_MIX_REG, 0x800000}, 819}; 820 821static const struct regmap_config tas5733_regmap_config = { 822 .reg_bits = 8, 823 .val_bits = 32, 824 .max_register = 0xff, 825 .reg_read = tas571x_reg_read, 826 .reg_write = tas571x_reg_write, 827 .reg_defaults = tas5733_reg_defaults, 828 .num_reg_defaults = ARRAY_SIZE(tas5733_reg_defaults), 829 .cache_type = REGCACHE_RBTREE, 830 .wr_table = &tas571x_write_regs, 831 .volatile_table = &tas571x_volatile_regs, 832}; 833 834static const struct tas571x_chip tas5733_chip = { 835 .supply_names = tas5733_supply_names, 836 .num_supply_names = ARRAY_SIZE(tas5733_supply_names), 837 .controls = tas5733_controls, 838 .num_controls = ARRAY_SIZE(tas5733_controls), 839 .regmap_config = &tas5733_regmap_config, 840 .vol_reg_size = 2, 841}; 842 843static const struct reg_default tas5753_reg_defaults[] = { 844 {TAS571X_CLK_CTRL_REG, 0x6c}, 845 {TAS571X_DEV_ID_REG, 0x41}, 846 {TAS571X_ERR_STATUS_REG, 0x00}, 847 {TAS571X_SYS_CTRL_1_REG, 0xa0}, 848 {TAS571X_SDI_REG, 0x05}, 849 {TAS571X_SYS_CTRL_2_REG, 0x40}, 850 {TAS571X_SOFT_MUTE_REG, 0x00}, 851 {TAS571X_MVOL_REG, 0x03ff}, 852 {TAS571X_CH1_VOL_REG, 0x00c0}, 853 {TAS571X_CH2_VOL_REG, 0x00c0}, 854 {TAS571X_CH3_VOL_REG, 0x00c0}, 855 {TAS571X_VOL_CFG_REG, 0xf0}, 856 {TAS571X_MODULATION_LIMIT_REG, 0x01}, 857 {TAS571X_IC_DELAY_CH1_REG, 0xac}, 858 {TAS571X_IC_DELAY_CH2_REG, 0x54}, 859 {TAS571X_IC_DELAY_CH3_REG, 0xac}, 860 {TAS571X_IC_DELAY_CH4_REG, 0x54}, 861 {TAS571X_OSC_TRIM_REG, 0x82}, 862 {TAS571X_BKND_ERR_REG, 0x57}, 863 {TAS571X_INPUT_MUX_REG, 0x00017772}, 864 {TAS571X_PWM_MUX_REG, 0x01021345}, 865 {TAS5717_CH1_RIGHT_CH_MIX_REG, 0x00}, 866 {TAS5717_CH1_LEFT_CH_MIX_REG, 0x800000}, 867 {TAS5717_CH2_LEFT_CH_MIX_REG, 0x00}, 868 {TAS5717_CH2_RIGHT_CH_MIX_REG, 0x800000}, 869}; 870 871static const struct regmap_config tas5753_regmap_config = { 872 .reg_bits = 8, 873 .val_bits = 32, 874 .max_register = 0xff, 875 .reg_read = tas571x_reg_read, 876 .reg_write = tas571x_reg_write, 877 .reg_defaults = tas5753_reg_defaults, 878 .num_reg_defaults = ARRAY_SIZE(tas5753_reg_defaults), 879 .cache_type = REGCACHE_RBTREE, 880 .wr_table = &tas571x_write_regs, 881 .volatile_table = &tas571x_volatile_regs, 882}; 883 884static const struct tas571x_chip tas5753_chip = { 885 .supply_names = tas5721_supply_names, 886 .num_supply_names = ARRAY_SIZE(tas5721_supply_names), 887 .controls = tas5733_controls, 888 .num_controls = ARRAY_SIZE(tas5733_controls), 889 .regmap_config = &tas5753_regmap_config, 890 .vol_reg_size = 2, 891}; 892 893static const struct tas571x_chip tas5721_chip = { 894 .supply_names = tas5721_supply_names, 895 .num_supply_names = ARRAY_SIZE(tas5721_supply_names), 896 .controls = tas5721_controls, 897 .num_controls = ARRAY_SIZE(tas5721_controls), 898 .regmap_config = &tas5721_regmap_config, 899 .vol_reg_size = 1, 900}; 901 902static const struct snd_soc_dapm_widget tas571x_dapm_widgets[] = { 903 SND_SOC_DAPM_DAC("DACL", NULL, SND_SOC_NOPM, 0, 0), 904 SND_SOC_DAPM_DAC("DACR", NULL, SND_SOC_NOPM, 0, 0), 905 906 SND_SOC_DAPM_OUTPUT("OUT_A"), 907 SND_SOC_DAPM_OUTPUT("OUT_B"), 908 SND_SOC_DAPM_OUTPUT("OUT_C"), 909 SND_SOC_DAPM_OUTPUT("OUT_D"), 910}; 911 912static const struct snd_soc_dapm_route tas571x_dapm_routes[] = { 913 { "DACL", NULL, "Playback" }, 914 { "DACR", NULL, "Playback" }, 915 916 { "OUT_A", NULL, "DACL" }, 917 { "OUT_B", NULL, "DACL" }, 918 { "OUT_C", NULL, "DACR" }, 919 { "OUT_D", NULL, "DACR" }, 920}; 921 922static const struct snd_soc_component_driver tas571x_component = { 923 .set_bias_level = tas571x_set_bias_level, 924 .dapm_widgets = tas571x_dapm_widgets, 925 .num_dapm_widgets = ARRAY_SIZE(tas571x_dapm_widgets), 926 .dapm_routes = tas571x_dapm_routes, 927 .num_dapm_routes = ARRAY_SIZE(tas571x_dapm_routes), 928 .use_pmdown_time = 1, 929 .endianness = 1, 930}; 931 932static struct snd_soc_dai_driver tas571x_dai = { 933 .name = "tas571x-hifi", 934 .playback = { 935 .stream_name = "Playback", 936 .channels_min = 2, 937 .channels_max = 2, 938 .rates = SNDRV_PCM_RATE_8000_48000, 939 .formats = SNDRV_PCM_FMTBIT_S32_LE | 940 SNDRV_PCM_FMTBIT_S24_LE | 941 SNDRV_PCM_FMTBIT_S16_LE, 942 }, 943 .ops = &tas571x_dai_ops, 944}; 945 946static int tas571x_i2c_probe(struct i2c_client *client) 947{ 948 struct tas571x_private *priv; 949 struct device *dev = &client->dev; 950 int i, ret; 951 952 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 953 if (!priv) 954 return -ENOMEM; 955 i2c_set_clientdata(client, priv); 956 957 priv->chip = i2c_get_match_data(client); 958 959 priv->mclk = devm_clk_get(dev, "mclk"); 960 if (IS_ERR(priv->mclk) && PTR_ERR(priv->mclk) != -ENOENT) { 961 dev_err(dev, "Failed to request mclk: %ld\n", 962 PTR_ERR(priv->mclk)); 963 return PTR_ERR(priv->mclk); 964 } 965 966 if (WARN_ON(priv->chip->num_supply_names > TAS571X_MAX_SUPPLIES)) 967 return -EINVAL; 968 for (i = 0; i < priv->chip->num_supply_names; i++) 969 priv->supplies[i].supply = priv->chip->supply_names[i]; 970 971 ret = devm_regulator_bulk_get(dev, priv->chip->num_supply_names, 972 priv->supplies); 973 if (ret) { 974 dev_err(dev, "Failed to get supplies: %d\n", ret); 975 return ret; 976 } 977 ret = regulator_bulk_enable(priv->chip->num_supply_names, 978 priv->supplies); 979 if (ret) { 980 dev_err(dev, "Failed to enable supplies: %d\n", ret); 981 return ret; 982 } 983 984 priv->regmap = devm_regmap_init(dev, NULL, client, 985 priv->chip->regmap_config); 986 if (IS_ERR(priv->regmap)) { 987 ret = PTR_ERR(priv->regmap); 988 goto disable_regs; 989 } 990 991 priv->pdn_gpio = devm_gpiod_get_optional(dev, "pdn", GPIOD_OUT_LOW); 992 if (IS_ERR(priv->pdn_gpio)) { 993 dev_err(dev, "error requesting pdn_gpio: %ld\n", 994 PTR_ERR(priv->pdn_gpio)); 995 ret = PTR_ERR(priv->pdn_gpio); 996 goto disable_regs; 997 } 998 999 priv->reset_gpio = devm_gpiod_get_optional(dev, "reset", 1000 GPIOD_OUT_HIGH); 1001 if (IS_ERR(priv->reset_gpio)) { 1002 dev_err(dev, "error requesting reset_gpio: %ld\n", 1003 PTR_ERR(priv->reset_gpio)); 1004 ret = PTR_ERR(priv->reset_gpio); 1005 goto disable_regs; 1006 } else if (priv->reset_gpio) { 1007 /* pulse the active low reset line for ~100us */ 1008 usleep_range(100, 200); 1009 gpiod_set_value(priv->reset_gpio, 0); 1010 usleep_range(13500, 20000); 1011 } 1012 1013 ret = regmap_write(priv->regmap, TAS571X_OSC_TRIM_REG, 0); 1014 if (ret) 1015 goto disable_regs; 1016 1017 usleep_range(50000, 60000); 1018 1019 memcpy(&priv->component_driver, &tas571x_component, sizeof(priv->component_driver)); 1020 priv->component_driver.controls = priv->chip->controls; 1021 priv->component_driver.num_controls = priv->chip->num_controls; 1022 1023 if (priv->chip->vol_reg_size == 2) { 1024 /* 1025 * The master volume defaults to 0x3ff (mute), but we ignore 1026 * (zero) the LSB because the hardware step size is 0.125 dB 1027 * and TLV_DB_SCALE_ITEM has a resolution of 0.01 dB. 1028 */ 1029 ret = regmap_update_bits(priv->regmap, TAS571X_MVOL_REG, 1, 0); 1030 if (ret) 1031 goto disable_regs; 1032 } 1033 1034 ret = devm_snd_soc_register_component(&client->dev, 1035 &priv->component_driver, 1036 &tas571x_dai, 1); 1037 if (ret) 1038 goto disable_regs; 1039 1040 return ret; 1041 1042disable_regs: 1043 regulator_bulk_disable(priv->chip->num_supply_names, priv->supplies); 1044 return ret; 1045} 1046 1047static void tas571x_i2c_remove(struct i2c_client *client) 1048{ 1049 struct tas571x_private *priv = i2c_get_clientdata(client); 1050 1051 regulator_bulk_disable(priv->chip->num_supply_names, priv->supplies); 1052} 1053 1054static const struct of_device_id tas571x_of_match[] __maybe_unused = { 1055 { .compatible = "ti,tas5707", .data = &tas5707_chip, }, 1056 { .compatible = "ti,tas5711", .data = &tas5711_chip, }, 1057 { .compatible = "ti,tas5717", .data = &tas5717_chip, }, 1058 { .compatible = "ti,tas5719", .data = &tas5717_chip, }, 1059 { .compatible = "ti,tas5721", .data = &tas5721_chip, }, 1060 { .compatible = "ti,tas5733", .data = &tas5733_chip, }, 1061 { .compatible = "ti,tas5753", .data = &tas5753_chip, }, 1062 { } 1063}; 1064MODULE_DEVICE_TABLE(of, tas571x_of_match); 1065 1066static const struct i2c_device_id tas571x_i2c_id[] = { 1067 { "tas5707", (kernel_ulong_t) &tas5707_chip }, 1068 { "tas5711", (kernel_ulong_t) &tas5711_chip }, 1069 { "tas5717", (kernel_ulong_t) &tas5717_chip }, 1070 { "tas5719", (kernel_ulong_t) &tas5717_chip }, 1071 { "tas5721", (kernel_ulong_t) &tas5721_chip }, 1072 { "tas5733", (kernel_ulong_t) &tas5733_chip }, 1073 { "tas5753", (kernel_ulong_t) &tas5753_chip }, 1074 { } 1075}; 1076MODULE_DEVICE_TABLE(i2c, tas571x_i2c_id); 1077 1078static struct i2c_driver tas571x_i2c_driver = { 1079 .driver = { 1080 .name = "tas571x", 1081 .of_match_table = of_match_ptr(tas571x_of_match), 1082 }, 1083 .probe = tas571x_i2c_probe, 1084 .remove = tas571x_i2c_remove, 1085 .id_table = tas571x_i2c_id, 1086}; 1087module_i2c_driver(tas571x_i2c_driver); 1088 1089MODULE_DESCRIPTION("ASoC TAS571x driver"); 1090MODULE_AUTHOR("Kevin Cernekee <cernekee@chromium.org>"); 1091MODULE_LICENSE("GPL");
~/
Read-only file preview.