sound/soc/codecs/tpa6130a2.c

   1 /*
   2  * ALSA SoC Texas Instruments TPA6130A2 headset stereo amplifier driver
   3  *
   4  * Copyright (C) Nokia Corporation
   5  *
   6  * Author: Peter Ujfalusi <peter.ujfalusi@nokia.com>
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * version 2 as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  20  * 02110-1301 USA
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/errno.h>
  25 #include <linux/device.h>
  26 #include <linux/i2c.h>
  27 #include <linux/gpio.h>
  28 #include <linux/regulator/consumer.h>
  29 #include <sound/tpa6130a2-plat.h>
  30 #include <sound/soc.h>
  31 #include <sound/soc-dapm.h>
  32 #include <sound/tlv.h>
  33
  34 #include "tpa6130a2.h"
  35
  36 static struct i2c_client *tpa6130a2_client;
  37
  38 #define TPA6130A2_NUM_SUPPLIES 2
  39 static const char *tpa6130a2_supply_names[TPA6130A2_NUM_SUPPLIES] = {
  40         "CPVSS",
  41         "Vdd",
  42 };
  43
  44 static const char *tpa6140a2_supply_names[TPA6130A2_NUM_SUPPLIES] = {
  45         "HPVdd",
  46         "AVdd",
  47 };
  48
  49 #define TPA6130A2_GAIN_MAX      0x3f
  50 #define TPA6140A2_GAIN_MAX      0x1f
  51
  52 /* This struct is used to save the context */
  53 struct tpa6130a2_data {
  54         struct mutex mutex;
  55         unsigned char regs[TPA6130A2_CACHEREGNUM];
  56         struct regulator_bulk_data supplies[TPA6130A2_NUM_SUPPLIES];
  57         int power_gpio;
  58         unsigned char power_state;
  59         enum tpa_model id;
  60         int gain_limit;
  61 };
  62
  63 static int tpa6130a2_i2c_read(int reg)
  64 {
  65         struct tpa6130a2_data *data;
  66         int val;
  67
  68         BUG_ON(tpa6130a2_client == NULL);
  69         data = i2c_get_clientdata(tpa6130a2_client);
  70
  71         /* If powered off, return the cached value */
  72         if (data->power_state) {
  73                 val = i2c_smbus_read_byte_data(tpa6130a2_client, reg);
  74                 if (val < 0)
  75                         dev_err(&tpa6130a2_client->dev, "Read failed\n");
  76                 else
  77                         data->regs[reg] = val;
  78         } else {
  79                 val = data->regs[reg];
  80         }
  81
  82         return val;
  83 }
  84
  85 static int tpa6130a2_i2c_write(int reg, u8 value)
  86 {
  87         struct tpa6130a2_data *data;
  88         int val = 0;
  89
  90         BUG_ON(tpa6130a2_client == NULL);
  91         data = i2c_get_clientdata(tpa6130a2_client);
  92
  93         if (data->power_state) {
  94                 val = i2c_smbus_write_byte_data(tpa6130a2_client, reg, value);
  95                 if (val < 0)
  96                         dev_err(&tpa6130a2_client->dev, "Write failed\n");
  97         }
  98
  99         /* Either powered on or off, we save the context */
 100         data->regs[reg] = value;
 101
 102         return val;
 103 }
 104
 105 static u8 tpa6130a2_read(int reg)
 106 {
 107         struct tpa6130a2_data *data;
 108
 109         BUG_ON(tpa6130a2_client == NULL);
 110         data = i2c_get_clientdata(tpa6130a2_client);
 111
 112         return data->regs[reg];
 113 }
 114
 115 static void tpa6130a2_initialize(void)
 116 {
 117         struct tpa6130a2_data *data;
 118         int i;
 119
 120         BUG_ON(tpa6130a2_client == NULL);
 121         data = i2c_get_clientdata(tpa6130a2_client);
 122
 123         for (i = 1; i < TPA6130A2_REG_VERSION; i++)
 124                 tpa6130a2_i2c_write(i, data->regs[i]);
 125 }
 126
 127 static int tpa6130a2_power(int power)
 128 {
 129         struct  tpa6130a2_data *data;
 130         u8      val;
 131         int     ret;
 132
 133         BUG_ON(tpa6130a2_client == NULL);
 134         data = i2c_get_clientdata(tpa6130a2_client);
 135
 136         mutex_lock(&data->mutex);
 137         if (power) {
 138                 /* Power on */
 139                 if (data->power_gpio >= 0)
 140                         gpio_set_value(data->power_gpio, 1);
 141
 142                 ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies),
 143                                             data->supplies);
 144                 if (ret != 0) {
 145                         dev_err(&tpa6130a2_client->dev,
 146                                 "Failed to enable supplies: %d\n", ret);
 147                         goto exit;
 148                 }
 149
 150                 data->power_state = 1;
 151                 tpa6130a2_initialize();
 152
 153                 /* Clear SWS */
 154                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
 155                 val &= ~TPA6130A2_SWS;
 156                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
 157         } else {
 158                 /* set SWS */
 159                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
 160                 val |= TPA6130A2_SWS;
 161                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
 162
 163                 /* Power off */
 164                 if (data->power_gpio >= 0)
 165                         gpio_set_value(data->power_gpio, 0);
 166
 167                 ret = regulator_bulk_disable(ARRAY_SIZE(data->supplies),
 168                                              data->supplies);
 169                 if (ret != 0) {
 170                         dev_err(&tpa6130a2_client->dev,
 171                                 "Failed to disable supplies: %d\n", ret);
 172                         goto exit;
 173                 }
 174
 175                 data->power_state = 0;
 176         }
 177
 178 exit:
 179         mutex_unlock(&data->mutex);
 180         return ret;
 181 }
 182
 183 static int tpa6130a2_info_volsw(struct snd_kcontrol *kcontrol,
 184                 struct snd_ctl_elem_info *uinfo)
 185 {
 186         struct soc_mixer_control *mc =
 187                 (struct soc_mixer_control *)kcontrol->private_value;
 188         struct tpa6130a2_data *data;
 189
 190         BUG_ON(tpa6130a2_client == NULL);
 191         data = i2c_get_clientdata(tpa6130a2_client);
 192
 193         mutex_lock(&data->mutex);
 194         switch (mc->reg) {
 195         case TPA6130A2_REG_VOL_MUTE:
 196                 if (data->gain_limit != mc->max)
 197                         mc->max = data->gain_limit;
 198                 break;
 199         default:
 200                 dev_err(&tpa6130a2_client->dev,
 201                         "Invalid register: 0x02%x\n", mc->reg);
 202                 goto out;
 203         }
 204         if (unlikely(mc->max == 1))
 205                 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 206         else
 207                 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 208
 209         uinfo->count = 1;
 210         uinfo->value.integer.min = 0;
 211         uinfo->value.integer.max = mc->max;
 212 out:
 213         mutex_unlock(&data->mutex);
 214         return 0;
 215 }
 216
 217 static int tpa6130a2_get_reg(struct snd_kcontrol *kcontrol,
 218                 struct snd_ctl_elem_value *ucontrol)
 219 {
 220         struct soc_mixer_control *mc =
 221                 (struct soc_mixer_control *)kcontrol->private_value;
 222         struct tpa6130a2_data *data;
 223         unsigned int reg = mc->reg;
 224         unsigned int shift = mc->shift;
 225         unsigned int mask = mc->max;
 226         unsigned int invert = mc->invert;
 227
 228         BUG_ON(tpa6130a2_client == NULL);
 229         data = i2c_get_clientdata(tpa6130a2_client);
 230
 231         mutex_lock(&data->mutex);
 232
 233         ucontrol->value.integer.value[0] =
 234                 (tpa6130a2_read(reg) >> shift) & mask;
 235
 236         if (invert)
 237                 ucontrol->value.integer.value[0] =
 238                         mask - ucontrol->value.integer.value[0];
 239
 240         mutex_unlock(&data->mutex);
 241         return 0;
 242 }
 243
 244 static int tpa6130a2_set_reg(struct snd_kcontrol *kcontrol,
 245                 struct snd_ctl_elem_value *ucontrol)
 246 {
 247         struct soc_mixer_control *mc =
 248                 (struct soc_mixer_control *)kcontrol->private_value;
 249         struct tpa6130a2_data *data;
 250         unsigned int reg = mc->reg;
 251         unsigned int shift = mc->shift;
 252         unsigned int mask = mc->max;
 253         unsigned int invert = mc->invert;
 254         unsigned int val = (ucontrol->value.integer.value[0] & mask);
 255         unsigned int val_reg;
 256
 257         BUG_ON(tpa6130a2_client == NULL);
 258         data = i2c_get_clientdata(tpa6130a2_client);
 259
 260         if (invert)
 261                 val = mask - val;
 262
 263         mutex_lock(&data->mutex);
 264
 265         val_reg = tpa6130a2_read(reg);
 266         if (((val_reg >> shift) & mask) == val) {
 267                 mutex_unlock(&data->mutex);
 268                 return 0;
 269         }
 270
 271         val_reg &= ~(mask << shift);
 272         val_reg |= val << shift;
 273         tpa6130a2_i2c_write(reg, val_reg);
 274
 275         mutex_unlock(&data->mutex);
 276
 277         return 1;
 278 }
 279
 280 #define SOC_SINGLE_EXT_TLV_TPA(xname, xreg, xshift, xmax, xinvert, tlv_array) \
 281 {       .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, \
 282         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
 283                  SNDRV_CTL_ELEM_ACCESS_READWRITE,\
 284         .tlv.p = (tlv_array), \
 285         .info = tpa6130a2_info_volsw, \
 286         .get = tpa6130a2_get_reg, .put = tpa6130a2_set_reg, \
 287         .private_value = SOC_SINGLE_VALUE(xreg, xshift, xmax, xinvert) }
 288
 289 /*
 290  * TPA6130 volume. From -59.5 to 4 dB with increasing step size when going
 291  * down in gain.
 292  */
 293 static const unsigned int tpa6130_tlv[] = {
 294         TLV_DB_RANGE_HEAD(10),
 295         0, 1, TLV_DB_SCALE_ITEM(-5950, 600, 0),
 296         2, 3, TLV_DB_SCALE_ITEM(-5000, 250, 0),
 297         4, 5, TLV_DB_SCALE_ITEM(-4550, 160, 0),
 298         6, 7, TLV_DB_SCALE_ITEM(-4140, 190, 0),
 299         8, 9, TLV_DB_SCALE_ITEM(-3650, 120, 0),
 300         10, 11, TLV_DB_SCALE_ITEM(-3330, 160, 0),
 301         12, 13, TLV_DB_SCALE_ITEM(-3040, 180, 0),
 302         14, 20, TLV_DB_SCALE_ITEM(-2710, 110, 0),
 303         21, 37, TLV_DB_SCALE_ITEM(-1960, 74, 0),
 304         38, 63, TLV_DB_SCALE_ITEM(-720, 45, 0),
 305 };
 306
 307 static const struct snd_kcontrol_new tpa6130a2_controls[] = {
 308         SOC_SINGLE_EXT_TLV_TPA("TPA6130A2 Headphone Playback Volume",
 309                         TPA6130A2_REG_VOL_MUTE, 0, TPA6130A2_GAIN_MAX, 0,
 310                         tpa6130_tlv),
 311 };
 312
 313 static const unsigned int tpa6140_tlv[] = {
 314         TLV_DB_RANGE_HEAD(3),
 315         0, 8, TLV_DB_SCALE_ITEM(-5900, 400, 0),
 316         9, 16, TLV_DB_SCALE_ITEM(-2500, 200, 0),
 317         17, 31, TLV_DB_SCALE_ITEM(-1000, 100, 0),
 318 };
 319
 320 static const struct snd_kcontrol_new tpa6140a2_controls[] = {
 321         SOC_SINGLE_EXT_TLV_TPA("TPA6140A2 Headphone Playback Volume",
 322                         TPA6130A2_REG_VOL_MUTE, 1, TPA6140A2_GAIN_MAX, 0,
 323                         tpa6140_tlv),
 324 };
 325
 326 /*
 327  * Enable or disable channel (left or right)
 328  * The bit number for mute and amplifier are the same per channel:
 329  * bit 6: Right channel
 330  * bit 7: Left channel
 331  * in both registers.
 332  */
 333 static void tpa6130a2_channel_enable(u8 channel, int enable)
 334 {
 335         u8      val;
 336
 337         if (enable) {
 338                 /* Enable channel */
 339                 /* Enable amplifier */
 340                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
 341                 val |= channel;
 342                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
 343
 344                 /* Unmute channel */
 345                 val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
 346                 val &= ~channel;
 347                 tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
 348         } else {
 349                 /* Disable channel */
 350                 /* Mute channel */
 351                 val = tpa6130a2_read(TPA6130A2_REG_VOL_MUTE);
 352                 val |= channel;
 353                 tpa6130a2_i2c_write(TPA6130A2_REG_VOL_MUTE, val);
 354
 355                 /* Disable amplifier */
 356                 val = tpa6130a2_read(TPA6130A2_REG_CONTROL);
 357                 val &= ~channel;
 358                 tpa6130a2_i2c_write(TPA6130A2_REG_CONTROL, val);
 359         }
 360 }
 361
 362 static int tpa6130a2_left_event(struct snd_soc_dapm_widget *w,
 363                 struct snd_kcontrol *kcontrol, int event)
 364 {
 365         switch (event) {
 366         case SND_SOC_DAPM_POST_PMU:
 367                 tpa6130a2_channel_enable(TPA6130A2_HP_EN_L, 1);
 368                 break;
 369         case SND_SOC_DAPM_POST_PMD:
 370                 tpa6130a2_channel_enable(TPA6130A2_HP_EN_L, 0);
 371                 break;
 372         }
 373         return 0;
 374 }
 375
 376 static int tpa6130a2_right_event(struct snd_soc_dapm_widget *w,
 377                 struct snd_kcontrol *kcontrol, int event)
 378 {
 379         switch (event) {
 380         case SND_SOC_DAPM_POST_PMU:
 381                 tpa6130a2_channel_enable(TPA6130A2_HP_EN_R, 1);
 382                 break;
 383         case SND_SOC_DAPM_POST_PMD:
 384                 tpa6130a2_channel_enable(TPA6130A2_HP_EN_R, 0);
 385                 break;
 386         }
 387         return 0;
 388 }
 389
 390 static int tpa6130a2_supply_event(struct snd_soc_dapm_widget *w,
 391                 struct snd_kcontrol *kcontrol, int event)
 392 {
 393         int ret = 0;
 394
 395         switch (event) {
 396         case SND_SOC_DAPM_POST_PMU:
 397                 ret = tpa6130a2_power(1);
 398                 break;
 399         case SND_SOC_DAPM_POST_PMD:
 400                 ret = tpa6130a2_power(0);
 401                 break;
 402         }
 403         return ret;
 404 }
 405
 406 static const struct snd_soc_dapm_widget tpa6130a2_dapm_widgets[] = {
 407         SND_SOC_DAPM_PGA_E("TPA6130A2 Left", SND_SOC_NOPM,
 408                         0, 0, NULL, 0, tpa6130a2_left_event,
 409                         SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
 410         SND_SOC_DAPM_PGA_E("TPA6130A2 Right", SND_SOC_NOPM,
 411                         0, 0, NULL, 0, tpa6130a2_right_event,
 412                         SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
 413         SND_SOC_DAPM_SUPPLY("TPA6130A2 Enable", SND_SOC_NOPM,
 414                         0, 0, tpa6130a2_supply_event,
 415                         SND_SOC_DAPM_POST_PMU|SND_SOC_DAPM_POST_PMD),
 416         /* Outputs */
 417         SND_SOC_DAPM_HP("TPA6130A2 Headphone Left", NULL),
 418         SND_SOC_DAPM_HP("TPA6130A2 Headphone Right", NULL),
 419 };
 420
 421 static const struct snd_soc_dapm_route audio_map[] = {
 422         {"TPA6130A2 Headphone Left", NULL, "TPA6130A2 Left"},
 423         {"TPA6130A2 Headphone Right", NULL, "TPA6130A2 Right"},
 424
 425         {"TPA6130A2 Headphone Left", NULL, "TPA6130A2 Enable"},
 426         {"TPA6130A2 Headphone Right", NULL, "TPA6130A2 Enable"},
 427 };
 428
 429 int tpa6130a2_add_controls(struct snd_soc_codec *codec)
 430 {
 431         struct  tpa6130a2_data *data;
 432
 433         BUG_ON(tpa6130a2_client == NULL);
 434         data = i2c_get_clientdata(tpa6130a2_client);
 435
 436         snd_soc_dapm_new_controls(codec, tpa6130a2_dapm_widgets,
 437                                 ARRAY_SIZE(tpa6130a2_dapm_widgets));
 438
 439         snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map));
 440
 441         if (data->id == TPA6140A2)
 442                 return snd_soc_add_controls(codec, tpa6140a2_controls,
 443                                                 ARRAY_SIZE(tpa6140a2_controls));
 444         else
 445                 return snd_soc_add_controls(codec, tpa6130a2_controls,
 446                                                 ARRAY_SIZE(tpa6130a2_controls));
 447
 448 }
 449 EXPORT_SYMBOL_GPL(tpa6130a2_add_controls);
 450
 451 static int __devinit tpa6130a2_probe(struct i2c_client *client,
 452                                      const struct i2c_device_id *id)
 453 {
 454         struct device *dev;
 455         struct tpa6130a2_data *data;
 456         struct tpa6130a2_platform_data *pdata;
 457         int i, ret;
 458
 459         dev = &client->dev;
 460
 461         if (client->dev.platform_data == NULL) {
 462                 dev_err(dev, "Platform data not set\n");
 463                 dump_stack();
 464                 return -ENODEV;
 465         }
 466
 467         data = kzalloc(sizeof(*data), GFP_KERNEL);
 468         if (data == NULL) {
 469                 dev_err(dev, "Can not allocate memory\n");
 470                 return -ENOMEM;
 471         }
 472
 473         tpa6130a2_client = client;
 474
 475         i2c_set_clientdata(tpa6130a2_client, data);
 476
 477         pdata = client->dev.platform_data;
 478         data->power_gpio = pdata->power_gpio;
 479         data->id = pdata->id;
 480
 481         mutex_init(&data->mutex);
 482
 483         /* Set default register values */
 484         data->regs[TPA6130A2_REG_CONTROL] =     TPA6130A2_SWS;
 485         data->regs[TPA6130A2_REG_VOL_MUTE] =    TPA6130A2_MUTE_R |
 486                                                 TPA6130A2_MUTE_L;
 487
 488         if (data->power_gpio >= 0) {
 489                 ret = gpio_request(data->power_gpio, "tpa6130a2 enable");
 490                 if (ret < 0) {
 491                         dev_err(dev, "Failed to request power GPIO (%d)\n",
 492                                 data->power_gpio);
 493                         goto err_gpio;
 494                 }
 495                 gpio_direction_output(data->power_gpio, 0);
 496         }
 497
 498         switch (data->id) {
 499         case TPA6130A2:
 500                 for (i = 0; i < ARRAY_SIZE(data->supplies); i++)
 501                         data->supplies[i].supply = tpa6130a2_supply_names[i];
 502                 if (pdata->limit_gain > 0 &&
 503                     pdata->limit_gain < TPA6130A2_GAIN_MAX)
 504                         data->gain_limit = pdata->limit_gain;
 505                 else
 506                         data->gain_limit = TPA6130A2_GAIN_MAX;
 507                 break;
 508         case TPA6140A2:
 509                 for (i = 0; i < ARRAY_SIZE(data->supplies); i++)
 510                         data->supplies[i].supply = tpa6140a2_supply_names[i];;
 511                 if (pdata->limit_gain > 0 &&
 512                     pdata->limit_gain < TPA6140A2_GAIN_MAX)
 513                         data->gain_limit = pdata->limit_gain;
 514                 else
 515                         data->gain_limit = TPA6140A2_GAIN_MAX;
 516                 break;
 517         default:
 518                 dev_warn(dev, "Unknown TPA model (%d). Assuming 6130A2\n",
 519                          pdata->id);
 520                 for (i = 0; i < ARRAY_SIZE(data->supplies); i++)
 521                         data->supplies[i].supply = tpa6130a2_supply_names[i];
 522                 if (pdata->limit_gain > 0 &&
 523                     pdata->limit_gain < TPA6130A2_GAIN_MAX)
 524                         data->gain_limit = pdata->limit_gain;
 525                 else
 526                         data->gain_limit = TPA6130A2_GAIN_MAX;
 527         }
 528
 529         ret = regulator_bulk_get(dev, ARRAY_SIZE(data->supplies),
 530                                  data->supplies);
 531         if (ret != 0) {
 532                 dev_err(dev, "Failed to request supplies: %d\n", ret);
 533                 goto err_regulator;
 534         }
 535
 536         ret = tpa6130a2_power(1);
 537         if (ret != 0)
 538                 goto err_power;
 539
 540
 541         /* Read version */
 542         ret = tpa6130a2_i2c_read(TPA6130A2_REG_VERSION) &
 543                                  TPA6130A2_VERSION_MASK;
 544         if ((ret != 1) && (ret != 2))
 545                 dev_warn(dev, "UNTESTED version detected (%d)\n", ret);
 546
 547         /* Disable the chip */
 548         ret = tpa6130a2_power(0);
 549         if (ret != 0)
 550                 goto err_power;
 551
 552         return 0;
 553
 554 err_power:
 555         regulator_bulk_free(ARRAY_SIZE(data->supplies), data->supplies);
 556 err_regulator:
 557         if (data->power_gpio >= 0)
 558                 gpio_free(data->power_gpio);
 559 err_gpio:
 560         kfree(data);
 561         i2c_set_clientdata(tpa6130a2_client, NULL);
 562         tpa6130a2_client = NULL;
 563
 564         return ret;
 565 }
 566
 567 static int __devexit tpa6130a2_remove(struct i2c_client *client)
 568 {
 569         struct tpa6130a2_data *data = i2c_get_clientdata(client);
 570
 571         tpa6130a2_power(0);
 572
 573         if (data->power_gpio >= 0)
 574                 gpio_free(data->power_gpio);
 575
 576         regulator_bulk_free(ARRAY_SIZE(data->supplies), data->supplies);
 577
 578         kfree(data);
 579         tpa6130a2_client = NULL;
 580
 581         return 0;
 582 }
 583
 584 static const struct i2c_device_id tpa6130a2_id[] = {
 585         { "tpa6130a2", 0 },
 586         { }
 587 };
 588 MODULE_DEVICE_TABLE(i2c, tpa6130a2_id);
 589
 590 static struct i2c_driver tpa6130a2_i2c_driver = {
 591         .driver = {
 592                 .name = "tpa6130a2",
 593                 .owner = THIS_MODULE,
 594         },
 595         .probe = tpa6130a2_probe,
 596         .remove = __devexit_p(tpa6130a2_remove),
 597         .id_table = tpa6130a2_id,
 598 };
 599
 600 static int __init tpa6130a2_init(void)
 601 {
 602         return i2c_add_driver(&tpa6130a2_i2c_driver);
 603 }
 604
 605 static void __exit tpa6130a2_exit(void)
 606 {
 607         i2c_del_driver(&tpa6130a2_i2c_driver);
 608 }
 609
 610 MODULE_AUTHOR("Peter Ujfalusi");
 611 MODULE_DESCRIPTION("TPA6130A2 Headphone amplifier driver");
 612 MODULE_LICENSE("GPL");
 613
 614 module_init(tpa6130a2_init);
 615 module_exit(tpa6130a2_exit);