sound/soc/codecs/tas571x.c

   1 /*
   2  * TAS571x amplifier audio driver
   3  *
   4  * Copyright (C) 2015 Google, Inc.
   5  * Copyright (c) 2013 Daniel Mack <zonque@gmail.com>
   6  *
   7  * TAS5721 support:
   8  * Copyright (C) 2016 Petr Kulhavy, Barix AG <petr@barix.com>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  */
  15
  16 #include <linux/clk.h>
  17 #include <linux/delay.h>
  18 #include <linux/device.h>
  19 #include <linux/gpio/consumer.h>
  20 #include <linux/i2c.h>
  21 #include <linux/init.h>
  22 #include <linux/kernel.h>
  23 #include <linux/module.h>
  24 #include <linux/of_device.h>
  25 #include <linux/regmap.h>
  26 #include <linux/regulator/consumer.h>
  27 #include <linux/stddef.h>
  28 #include <sound/pcm_params.h>
  29 #include <sound/soc.h>
  30 #include <sound/tlv.h>
  31
  32 #include "tas571x.h"
  33
  34 #define TAS571X_MAX_SUPPLIES            6
  35
  36 struct 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
  45 struct 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_codec_driver     codec_driver;
  54 };
  55
  56 static 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                 return 4;
  67         default:
  68                 return 1;
  69         }
  70 }
  71
  72 static int tas571x_reg_write(void *context, unsigned int reg,
  73                              unsigned int value)
  74 {
  75         struct i2c_client *client = context;
  76         struct tas571x_private *priv = i2c_get_clientdata(client);
  77         unsigned int i, size;
  78         uint8_t buf[5];
  79         int ret;
  80
  81         size = tas571x_register_size(priv, reg);
  82         buf[0] = reg;
  83
  84         for (i = size; i >= 1; --i) {
  85                 buf[i] = value;
  86                 value >>= 8;
  87         }
  88
  89         ret = i2c_master_send(client, buf, size + 1);
  90         if (ret == size + 1)
  91                 return 0;
  92         else if (ret < 0)
  93                 return ret;
  94         else
  95                 return -EIO;
  96 }
  97
  98 static int tas571x_reg_read(void *context, unsigned int reg,
  99                             unsigned int *value)
 100 {
 101         struct i2c_client *client = context;
 102         struct tas571x_private *priv = i2c_get_clientdata(client);
 103         uint8_t send_buf, recv_buf[4];
 104         struct i2c_msg msgs[2];
 105         unsigned int size;
 106         unsigned int i;
 107         int ret;
 108
 109         size = tas571x_register_size(priv, reg);
 110         send_buf = reg;
 111
 112         msgs[0].addr = client->addr;
 113         msgs[0].len = sizeof(send_buf);
 114         msgs[0].buf = &send_buf;
 115         msgs[0].flags = 0;
 116
 117         msgs[1].addr = client->addr;
 118         msgs[1].len = size;
 119         msgs[1].buf = recv_buf;
 120         msgs[1].flags = I2C_M_RD;
 121
 122         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 123         if (ret < 0)
 124                 return ret;
 125         else if (ret != ARRAY_SIZE(msgs))
 126                 return -EIO;
 127
 128         *value = 0;
 129
 130         for (i = 0; i < size; i++) {
 131                 *value <<= 8;
 132                 *value |= recv_buf[i];
 133         }
 134
 135         return 0;
 136 }
 137
 138 static int tas571x_set_dai_fmt(struct snd_soc_dai *dai, unsigned int format)
 139 {
 140         struct tas571x_private *priv = snd_soc_codec_get_drvdata(dai->codec);
 141
 142         priv->format = format;
 143
 144         return 0;
 145 }
 146
 147 static int tas571x_hw_params(struct snd_pcm_substream *substream,
 148                              struct snd_pcm_hw_params *params,
 149                              struct snd_soc_dai *dai)
 150 {
 151         struct tas571x_private *priv = snd_soc_codec_get_drvdata(dai->codec);
 152         u32 val;
 153
 154         switch (priv->format & SND_SOC_DAIFMT_FORMAT_MASK) {
 155         case SND_SOC_DAIFMT_RIGHT_J:
 156                 val = 0x00;
 157                 break;
 158         case SND_SOC_DAIFMT_I2S:
 159                 val = 0x03;
 160                 break;
 161         case SND_SOC_DAIFMT_LEFT_J:
 162                 val = 0x06;
 163                 break;
 164         default:
 165                 return -EINVAL;
 166         }
 167
 168         if (params_width(params) >= 24)
 169                 val += 2;
 170         else if (params_width(params) >= 20)
 171                 val += 1;
 172
 173         return regmap_update_bits(priv->regmap, TAS571X_SDI_REG,
 174                                   TAS571X_SDI_FMT_MASK, val);
 175 }
 176
 177 static int tas571x_mute(struct snd_soc_dai *dai, int mute)
 178 {
 179         struct snd_soc_codec *codec = dai->codec;
 180         u8 sysctl2;
 181         int ret;
 182
 183         sysctl2 = mute ? TAS571X_SYS_CTRL_2_SDN_MASK : 0;
 184
 185         ret = snd_soc_update_bits(codec,
 186                             TAS571X_SYS_CTRL_2_REG,
 187                      TAS571X_SYS_CTRL_2_SDN_MASK,
 188                      sysctl2);
 189         usleep_range(1000, 2000);
 190
 191         return ret;
 192 }
 193
 194 static int tas571x_set_bias_level(struct snd_soc_codec *codec,
 195                                   enum snd_soc_bias_level level)
 196 {
 197         struct tas571x_private *priv = snd_soc_codec_get_drvdata(codec);
 198         int ret;
 199
 200         switch (level) {
 201         case SND_SOC_BIAS_ON:
 202                 break;
 203         case SND_SOC_BIAS_PREPARE:
 204                 break;
 205         case SND_SOC_BIAS_STANDBY:
 206                 if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) {
 207                         if (!IS_ERR(priv->mclk)) {
 208                                 ret = clk_prepare_enable(priv->mclk);
 209                                 if (ret) {
 210                                         dev_err(codec->dev,
 211                                                 "Failed to enable master clock: %d\n",
 212                                                 ret);
 213                                         return ret;
 214                                 }
 215                         }
 216
 217                         gpiod_set_value(priv->pdn_gpio, 0);
 218                         usleep_range(5000, 6000);
 219
 220                         regcache_cache_only(priv->regmap, false);
 221                         ret = regcache_sync(priv->regmap);
 222                         if (ret)
 223                                 return ret;
 224                 }
 225                 break;
 226         case SND_SOC_BIAS_OFF:
 227                 regcache_cache_only(priv->regmap, true);
 228                 gpiod_set_value(priv->pdn_gpio, 1);
 229
 230                 if (!IS_ERR(priv->mclk))
 231                         clk_disable_unprepare(priv->mclk);
 232                 break;
 233         }
 234
 235         return 0;
 236 }
 237
 238 static const struct snd_soc_dai_ops tas571x_dai_ops = {
 239         .set_fmt        = tas571x_set_dai_fmt,
 240         .hw_params      = tas571x_hw_params,
 241         .digital_mute   = tas571x_mute,
 242 };
 243
 244 static const char *const tas5711_supply_names[] = {
 245         "AVDD",
 246         "DVDD",
 247         "PVDD_A",
 248         "PVDD_B",
 249         "PVDD_C",
 250         "PVDD_D",
 251 };
 252
 253 static const DECLARE_TLV_DB_SCALE(tas5711_volume_tlv, -10350, 50, 1);
 254
 255 static const struct snd_kcontrol_new tas5711_controls[] = {
 256         SOC_SINGLE_TLV("Master Volume",
 257                        TAS571X_MVOL_REG,
 258                        0, 0xff, 1, tas5711_volume_tlv),
 259         SOC_DOUBLE_R_TLV("Speaker Volume",
 260                          TAS571X_CH1_VOL_REG,
 261                          TAS571X_CH2_VOL_REG,
 262                          0, 0xff, 1, tas5711_volume_tlv),
 263         SOC_DOUBLE("Speaker Switch",
 264                    TAS571X_SOFT_MUTE_REG,
 265                    TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT,
 266                    1, 1),
 267 };
 268
 269 static const struct regmap_range tas571x_readonly_regs_range[] = {
 270         regmap_reg_range(TAS571X_CLK_CTRL_REG,  TAS571X_DEV_ID_REG),
 271 };
 272
 273 static const struct regmap_range tas571x_volatile_regs_range[] = {
 274         regmap_reg_range(TAS571X_CLK_CTRL_REG,  TAS571X_ERR_STATUS_REG),
 275         regmap_reg_range(TAS571X_OSC_TRIM_REG,  TAS571X_OSC_TRIM_REG),
 276 };
 277
 278 static const struct regmap_access_table tas571x_write_regs = {
 279         .no_ranges =    tas571x_readonly_regs_range,
 280         .n_no_ranges =  ARRAY_SIZE(tas571x_readonly_regs_range),
 281 };
 282
 283 static const struct regmap_access_table tas571x_volatile_regs = {
 284         .yes_ranges =   tas571x_volatile_regs_range,
 285         .n_yes_ranges = ARRAY_SIZE(tas571x_volatile_regs_range),
 286
 287 };
 288
 289 static const struct reg_default tas5711_reg_defaults[] = {
 290         { 0x04, 0x05 },
 291         { 0x05, 0x40 },
 292         { 0x06, 0x00 },
 293         { 0x07, 0xff },
 294         { 0x08, 0x30 },
 295         { 0x09, 0x30 },
 296         { 0x1b, 0x82 },
 297 };
 298
 299 static const struct regmap_config tas5711_regmap_config = {
 300         .reg_bits                       = 8,
 301         .val_bits                       = 32,
 302         .max_register                   = 0xff,
 303         .reg_read                       = tas571x_reg_read,
 304         .reg_write                      = tas571x_reg_write,
 305         .reg_defaults                   = tas5711_reg_defaults,
 306         .num_reg_defaults               = ARRAY_SIZE(tas5711_reg_defaults),
 307         .cache_type                     = REGCACHE_RBTREE,
 308         .wr_table                       = &tas571x_write_regs,
 309         .volatile_table                 = &tas571x_volatile_regs,
 310 };
 311
 312 static const struct tas571x_chip tas5711_chip = {
 313         .supply_names                   = tas5711_supply_names,
 314         .num_supply_names               = ARRAY_SIZE(tas5711_supply_names),
 315         .controls                       = tas5711_controls,
 316         .num_controls                   = ARRAY_SIZE(tas5711_controls),
 317         .regmap_config                  = &tas5711_regmap_config,
 318         .vol_reg_size                   = 1,
 319 };
 320
 321 static const char *const tas5717_supply_names[] = {
 322         "AVDD",
 323         "DVDD",
 324         "HPVDD",
 325         "PVDD_AB",
 326         "PVDD_CD",
 327 };
 328
 329 static const DECLARE_TLV_DB_SCALE(tas5717_volume_tlv, -10375, 25, 0);
 330
 331 static const struct snd_kcontrol_new tas5717_controls[] = {
 332         /* MVOL LSB is ignored - see comments in tas571x_i2c_probe() */
 333         SOC_SINGLE_TLV("Master Volume",
 334                        TAS571X_MVOL_REG, 1, 0x1ff, 1,
 335                        tas5717_volume_tlv),
 336         SOC_DOUBLE_R_TLV("Speaker Volume",
 337                          TAS571X_CH1_VOL_REG, TAS571X_CH2_VOL_REG,
 338                          1, 0x1ff, 1, tas5717_volume_tlv),
 339         SOC_DOUBLE("Speaker Switch",
 340                    TAS571X_SOFT_MUTE_REG,
 341                    TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT,
 342                    1, 1),
 343 };
 344
 345 static const struct reg_default tas5717_reg_defaults[] = {
 346         { 0x04, 0x05 },
 347         { 0x05, 0x40 },
 348         { 0x06, 0x00 },
 349         { 0x07, 0x03ff },
 350         { 0x08, 0x00c0 },
 351         { 0x09, 0x00c0 },
 352         { 0x1b, 0x82 },
 353 };
 354
 355 static const struct regmap_config tas5717_regmap_config = {
 356         .reg_bits                       = 8,
 357         .val_bits                       = 32,
 358         .max_register                   = 0xff,
 359         .reg_read                       = tas571x_reg_read,
 360         .reg_write                      = tas571x_reg_write,
 361         .reg_defaults                   = tas5717_reg_defaults,
 362         .num_reg_defaults               = ARRAY_SIZE(tas5717_reg_defaults),
 363         .cache_type                     = REGCACHE_RBTREE,
 364         .wr_table                       = &tas571x_write_regs,
 365         .volatile_table                 = &tas571x_volatile_regs,
 366 };
 367
 368 /* This entry is reused for tas5719 as the software interface is identical. */
 369 static const struct tas571x_chip tas5717_chip = {
 370         .supply_names                   = tas5717_supply_names,
 371         .num_supply_names               = ARRAY_SIZE(tas5717_supply_names),
 372         .controls                       = tas5717_controls,
 373         .num_controls                   = ARRAY_SIZE(tas5717_controls),
 374         .regmap_config                  = &tas5717_regmap_config,
 375         .vol_reg_size                   = 2,
 376 };
 377
 378 static const char *const tas5721_supply_names[] = {
 379         "AVDD",
 380         "DVDD",
 381         "DRVDD",
 382         "PVDD",
 383 };
 384
 385 static const struct snd_kcontrol_new tas5721_controls[] = {
 386         SOC_SINGLE_TLV("Master Volume",
 387                        TAS571X_MVOL_REG,
 388                        0, 0xff, 1, tas5711_volume_tlv),
 389         SOC_DOUBLE_R_TLV("Speaker Volume",
 390                          TAS571X_CH1_VOL_REG,
 391                          TAS571X_CH2_VOL_REG,
 392                          0, 0xff, 1, tas5711_volume_tlv),
 393         SOC_DOUBLE("Speaker Switch",
 394                    TAS571X_SOFT_MUTE_REG,
 395                    TAS571X_SOFT_MUTE_CH1_SHIFT, TAS571X_SOFT_MUTE_CH2_SHIFT,
 396                    1, 1),
 397 };
 398
 399 static const struct reg_default tas5721_reg_defaults[] = {
 400         {TAS571X_CLK_CTRL_REG,          0x6c},
 401         {TAS571X_DEV_ID_REG,            0x00},
 402         {TAS571X_ERR_STATUS_REG,        0x00},
 403         {TAS571X_SYS_CTRL_1_REG,        0xa0},
 404         {TAS571X_SDI_REG,               0x05},
 405         {TAS571X_SYS_CTRL_2_REG,        0x40},
 406         {TAS571X_SOFT_MUTE_REG,         0x00},
 407         {TAS571X_MVOL_REG,              0xff},
 408         {TAS571X_CH1_VOL_REG,           0x30},
 409         {TAS571X_CH2_VOL_REG,           0x30},
 410         {TAS571X_CH3_VOL_REG,           0x30},
 411         {TAS571X_VOL_CFG_REG,           0x91},
 412         {TAS571X_MODULATION_LIMIT_REG,  0x02},
 413         {TAS571X_IC_DELAY_CH1_REG,      0xac},
 414         {TAS571X_IC_DELAY_CH2_REG,      0x54},
 415         {TAS571X_IC_DELAY_CH3_REG,      0xac},
 416         {TAS571X_IC_DELAY_CH4_REG,      0x54},
 417         {TAS571X_PWM_CH_SDN_GROUP_REG,  0x30},
 418         {TAS571X_START_STOP_PERIOD_REG, 0x0f},
 419         {TAS571X_OSC_TRIM_REG,          0x82},
 420         {TAS571X_BKND_ERR_REG,          0x02},
 421         {TAS571X_INPUT_MUX_REG,         0x17772},
 422         {TAS571X_CH4_SRC_SELECT_REG,    0x4303},
 423         {TAS571X_PWM_MUX_REG,           0x1021345},
 424 };
 425
 426 static const struct regmap_config tas5721_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                   = tas5721_reg_defaults,
 433         .num_reg_defaults               = ARRAY_SIZE(tas5721_reg_defaults),
 434         .cache_type                     = REGCACHE_RBTREE,
 435         .wr_table                       = &tas571x_write_regs,
 436         .volatile_table                 = &tas571x_volatile_regs,
 437 };
 438
 439
 440 static const struct tas571x_chip tas5721_chip = {
 441         .supply_names                   = tas5721_supply_names,
 442         .num_supply_names               = ARRAY_SIZE(tas5721_supply_names),
 443         .controls                       = tas5711_controls,
 444         .num_controls                   = ARRAY_SIZE(tas5711_controls),
 445         .regmap_config                  = &tas5721_regmap_config,
 446         .vol_reg_size                   = 1,
 447 };
 448
 449 static const struct snd_soc_dapm_widget tas571x_dapm_widgets[] = {
 450         SND_SOC_DAPM_DAC("DACL", NULL, SND_SOC_NOPM, 0, 0),
 451         SND_SOC_DAPM_DAC("DACR", NULL, SND_SOC_NOPM, 0, 0),
 452
 453         SND_SOC_DAPM_OUTPUT("OUT_A"),
 454         SND_SOC_DAPM_OUTPUT("OUT_B"),
 455         SND_SOC_DAPM_OUTPUT("OUT_C"),
 456         SND_SOC_DAPM_OUTPUT("OUT_D"),
 457 };
 458
 459 static const struct snd_soc_dapm_route tas571x_dapm_routes[] = {
 460         { "DACL",  NULL, "Playback" },
 461         { "DACR",  NULL, "Playback" },
 462
 463         { "OUT_A", NULL, "DACL" },
 464         { "OUT_B", NULL, "DACL" },
 465         { "OUT_C", NULL, "DACR" },
 466         { "OUT_D", NULL, "DACR" },
 467 };
 468
 469 static const struct snd_soc_codec_driver tas571x_codec = {
 470         .set_bias_level = tas571x_set_bias_level,
 471         .idle_bias_off = true,
 472
 473         .dapm_widgets = tas571x_dapm_widgets,
 474         .num_dapm_widgets = ARRAY_SIZE(tas571x_dapm_widgets),
 475         .dapm_routes = tas571x_dapm_routes,
 476         .num_dapm_routes = ARRAY_SIZE(tas571x_dapm_routes),
 477 };
 478
 479 static struct snd_soc_dai_driver tas571x_dai = {
 480         .name = "tas571x-hifi",
 481         .playback = {
 482                 .stream_name = "Playback",
 483                 .channels_min = 2,
 484                 .channels_max = 2,
 485                 .rates = SNDRV_PCM_RATE_8000_48000,
 486                 .formats = SNDRV_PCM_FMTBIT_S32_LE |
 487                            SNDRV_PCM_FMTBIT_S24_LE |
 488                            SNDRV_PCM_FMTBIT_S16_LE,
 489         },
 490         .ops = &tas571x_dai_ops,
 491 };
 492
 493 static const struct of_device_id tas571x_of_match[];
 494
 495 static int tas571x_i2c_probe(struct i2c_client *client,
 496                              const struct i2c_device_id *id)
 497 {
 498         struct tas571x_private *priv;
 499         struct device *dev = &client->dev;
 500         const struct of_device_id *of_id;
 501         int i, ret;
 502
 503         priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
 504         if (!priv)
 505                 return -ENOMEM;
 506         i2c_set_clientdata(client, priv);
 507
 508         of_id = of_match_device(tas571x_of_match, dev);
 509         if (of_id)
 510                 priv->chip = of_id->data;
 511         else
 512                 priv->chip = (void *) id->driver_data;
 513
 514         priv->mclk = devm_clk_get(dev, "mclk");
 515         if (IS_ERR(priv->mclk) && PTR_ERR(priv->mclk) != -ENOENT) {
 516                 dev_err(dev, "Failed to request mclk: %ld\n",
 517                         PTR_ERR(priv->mclk));
 518                 return PTR_ERR(priv->mclk);
 519         }
 520
 521         BUG_ON(priv->chip->num_supply_names > TAS571X_MAX_SUPPLIES);
 522         for (i = 0; i < priv->chip->num_supply_names; i++)
 523                 priv->supplies[i].supply = priv->chip->supply_names[i];
 524
 525         ret = devm_regulator_bulk_get(dev, priv->chip->num_supply_names,
 526                                       priv->supplies);
 527         if (ret) {
 528                 dev_err(dev, "Failed to get supplies: %d\n", ret);
 529                 return ret;
 530         }
 531         ret = regulator_bulk_enable(priv->chip->num_supply_names,
 532                                     priv->supplies);
 533         if (ret) {
 534                 dev_err(dev, "Failed to enable supplies: %d\n", ret);
 535                 return ret;
 536         }
 537
 538         priv->regmap = devm_regmap_init(dev, NULL, client,
 539                                         priv->chip->regmap_config);
 540         if (IS_ERR(priv->regmap))
 541                 return PTR_ERR(priv->regmap);
 542
 543         priv->pdn_gpio = devm_gpiod_get_optional(dev, "pdn", GPIOD_OUT_LOW);
 544         if (IS_ERR(priv->pdn_gpio)) {
 545                 dev_err(dev, "error requesting pdn_gpio: %ld\n",
 546                         PTR_ERR(priv->pdn_gpio));
 547                 return PTR_ERR(priv->pdn_gpio);
 548         }
 549
 550         priv->reset_gpio = devm_gpiod_get_optional(dev, "reset",
 551                                                    GPIOD_OUT_HIGH);
 552         if (IS_ERR(priv->reset_gpio)) {
 553                 dev_err(dev, "error requesting reset_gpio: %ld\n",
 554                         PTR_ERR(priv->reset_gpio));
 555                 return PTR_ERR(priv->reset_gpio);
 556         } else if (priv->reset_gpio) {
 557                 /* pulse the active low reset line for ~100us */
 558                 usleep_range(100, 200);
 559                 gpiod_set_value(priv->reset_gpio, 0);
 560                 usleep_range(12000, 20000);
 561         }
 562
 563         ret = regmap_write(priv->regmap, TAS571X_OSC_TRIM_REG, 0);
 564         if (ret)
 565                 return ret;
 566
 567
 568         memcpy(&priv->codec_driver, &tas571x_codec, sizeof(priv->codec_driver));
 569         priv->codec_driver.controls = priv->chip->controls;
 570         priv->codec_driver.num_controls = priv->chip->num_controls;
 571
 572         if (priv->chip->vol_reg_size == 2) {
 573                 /*
 574                  * The master volume defaults to 0x3ff (mute), but we ignore
 575                  * (zero) the LSB because the hardware step size is 0.125 dB
 576                  * and TLV_DB_SCALE_ITEM has a resolution of 0.01 dB.
 577                  */
 578                 ret = regmap_update_bits(priv->regmap, TAS571X_MVOL_REG, 1, 0);
 579                 if (ret)
 580                         return ret;
 581         }
 582
 583         regcache_cache_only(priv->regmap, true);
 584         gpiod_set_value(priv->pdn_gpio, 1);
 585
 586         return snd_soc_register_codec(&client->dev, &priv->codec_driver,
 587                                       &tas571x_dai, 1);
 588 }
 589
 590 static int tas571x_i2c_remove(struct i2c_client *client)
 591 {
 592         struct tas571x_private *priv = i2c_get_clientdata(client);
 593
 594         snd_soc_unregister_codec(&client->dev);
 595         regulator_bulk_disable(priv->chip->num_supply_names, priv->supplies);
 596
 597         return 0;
 598 }
 599
 600 static const struct of_device_id tas571x_of_match[] = {
 601         { .compatible = "ti,tas5711", .data = &tas5711_chip, },
 602         { .compatible = "ti,tas5717", .data = &tas5717_chip, },
 603         { .compatible = "ti,tas5719", .data = &tas5717_chip, },
 604         { .compatible = "ti,tas5721", .data = &tas5721_chip, },
 605         { }
 606 };
 607 MODULE_DEVICE_TABLE(of, tas571x_of_match);
 608
 609 static const struct i2c_device_id tas571x_i2c_id[] = {
 610         { "tas5711", (kernel_ulong_t) &tas5711_chip },
 611         { "tas5717", (kernel_ulong_t) &tas5717_chip },
 612         { "tas5719", (kernel_ulong_t) &tas5717_chip },
 613         { "tas5721", (kernel_ulong_t) &tas5721_chip },
 614         { }
 615 };
 616 MODULE_DEVICE_TABLE(i2c, tas571x_i2c_id);
 617
 618 static struct i2c_driver tas571x_i2c_driver = {
 619         .driver = {
 620                 .name = "tas571x",
 621                 .of_match_table = of_match_ptr(tas571x_of_match),
 622         },
 623         .probe = tas571x_i2c_probe,
 624         .remove = tas571x_i2c_remove,
 625         .id_table = tas571x_i2c_id,
 626 };
 627 module_i2c_driver(tas571x_i2c_driver);
 628
 629 MODULE_DESCRIPTION("ASoC TAS571x driver");
 630 MODULE_AUTHOR("Kevin Cernekee <cernekee@chromium.org>");
 631 MODULE_LICENSE("GPL");