drivers/i2c/chips/tlv320aic23.c

   1 /*
   2  *   Texas Instrumens TLV320AIC23 audio codec's i2c interface.
   3  *
   4  *   Copyright (c) by Kai Svahn <kai.svahn@nokia.com>
   5  *   Copyright (c) by Jussi Laako <jussi.laako@nokia.com>
   6  *
   7  *   This program is free software; you can redistribute it and/or modify
   8  *   it under the terms of the GNU General Public License as published by
   9  *   the Free Software Foundation; either version 2 of the License, or
  10  *   (at your option) any later version.
  11  *
  12  *   This program is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  20  *
  21  */
  22
  23 #include <linux/config.h>
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/i2c.h>
  27 #include <linux/slab.h>
  28 #include <linux/device.h>
  29 #include <linux/platform_device.h>
  30 #include <asm/io.h>
  31 #include <asm/arch/aic23.h>
  32 #include <asm/arch/mcbsp.h>
  33
  34 #define TLV320AIC23_VERSION     "1.8"
  35 #define TLV320AIC23_DATE        "10-Feb-2006"
  36 #define MAX_VOL                 100
  37 #define MIN_VOL                 0
  38 #define MAX_GAIN                100
  39 #define MIN_GAIN                0
  40 #define OUTPUT_VOLUME_MIN       LHV_MIN
  41 #define OUTPUT_VOLUME_MAX       LHV_MAX
  42 #define OUTPUT_VOLUME_RANGE     (OUTPUT_VOLUME_MAX - OUTPUT_VOLUME_MIN)
  43 #define INPUT_VOLUME_MIN        LIV_MIN
  44 #define INPUT_VOLUME_MAX        LIV_MAX
  45 #define INPUT_VOLUME_RANGE      (INPUT_VOLUME_MAX - INPUT_VOLUME_MIN)
  46
  47 /* I2C Addresses to scan */
  48 static unsigned short normal_i2c[] = { TLV320AIC23ID1, TLV320AIC23ID2, \
  49                                        I2C_CLIENT_END };
  50 /*static unsigned short normal_i2c_range[] = { I2C_CLIENT_END };*/
  51
  52 /* This makes all addr_data:s */
  53 I2C_CLIENT_INSMOD;
  54
  55 static struct i2c_driver tlv320aic23_driver;
  56 static struct i2c_client *new_client;
  57 static int selftest;
  58
  59 static struct tlv320aic23_info {
  60         u16 volume_reg_left;
  61         u16 volume_reg_right;
  62         u16 input_gain_reg_left;
  63         u16 input_gain_reg_right;
  64         u16 power;                      /* For POWER_DOWN_CONTROL_ADDR */
  65         u16 mask;                       /* For ANALOG_AUDIO_CONTROL_ADDR */
  66         int mic_loopback;
  67         int mic_enable;
  68         int sta;
  69         int power_down;
  70         int initialization;
  71 } tlv320aic23_info_l;
  72
  73 static int _tlv320aic23_write_value(struct i2c_client *client, u8 reg, u16 value)
  74 {
  75         u8 val, wreg;
  76
  77         /* TLV320AIC23 has 7 bit address and 9 bits of data
  78          * so we need to switch one data bit into reg and rest
  79          * of data into val
  80          */
  81
  82         wreg = (reg << 1);
  83         val = (0x01 & (value >> 8));
  84         wreg = (wreg | val);
  85         val = (0x00ff & value);
  86
  87         return i2c_smbus_write_byte_data(client, wreg, val);
  88 }
  89
  90 int tlv320aic23_write_value(u8 reg, u16 value)
  91 {
  92         static struct i2c_client *client;
  93         client = new_client;
  94         _tlv320aic23_write_value(client, reg, value);
  95
  96         return 0;
  97 }
  98
  99 static int tlv320aic23_detect_client(struct i2c_adapter *adapter, int address,
 100                                      int kind)
 101 {
 102         int err = 0;
 103         const char *client_name = "TLV320AIC23 Audio Codec";
 104
 105         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA |
 106                                      I2C_FUNC_SMBUS_WRITE_BYTE)) {
 107                 printk(KERN_WARNING "%s functinality check failed\n",
 108                        client_name);
 109                 return err;
 110         }
 111
 112         if (!(new_client = kmalloc(sizeof(struct i2c_client),
 113                                    GFP_KERNEL))) {
 114                 err = -ENOMEM;
 115                 printk(KERN_WARNING "Couldn't allocate memory for %s\n",
 116                        client_name);
 117                 return err;
 118         }
 119
 120         memset(new_client, 0x00, sizeof(struct i2c_client));
 121         new_client->addr = address;
 122         new_client->adapter = adapter;
 123         new_client->driver = &tlv320aic23_driver;
 124         new_client->flags = 0;
 125         strlcpy(new_client->name, client_name, I2C_NAME_SIZE);
 126
 127         if ((err = i2c_attach_client(new_client))) {
 128                 printk(KERN_WARNING "Couldn't attach %s\n", client_name);
 129                 kfree(new_client);
 130                 return err;
 131         }
 132         return 0;
 133 }
 134
 135 static int tlv320aic23_detach_client(struct i2c_client *client)
 136 {
 137         int err;
 138
 139         if ((err = i2c_detach_client(client))) {
 140                 printk("tlv320aic23.o: Client deregistration failed, \
 141                        client not detached.\n");
 142                 return err;
 143         }
 144         kfree(client);
 145         return 0;
 146 }
 147
 148 static int tlv320aic23_attach_adapter(struct i2c_adapter *adapter)
 149 {
 150         int res;
 151
 152         res = i2c_probe(adapter, &addr_data, &tlv320aic23_detect_client);
 153         return res;
 154 }
 155
 156 static struct i2c_driver tlv320aic23_driver = {
 157         .driver {
 158                 .name   = "OMAP+TLV320AIC23 codec",
 159                 /*.flags        = I2C_DF_NOTIFY,*/
 160         },
 161         .id             = I2C_DRIVERID_MISC, /* Experimental ID */
 162         .attach_adapter = tlv320aic23_attach_adapter,
 163         .detach_client  = tlv320aic23_detach_client,
 164 };
 165
 166 /*
 167  * Configures the McBSP3 which is used to send clock to the AIC23 codec.
 168  * The input clock rate from DSP is 12MHz.
 169  * The DSP clock must be on before this is called.
 170  */
 171 static int omap_mcbsp3_tlv320aic23_clock_init(void)
 172 {
 173         u16 w;
 174
 175         /* enable 12MHz clock to mcbsp 1 & 3 */
 176         __raw_writew(__raw_readw(DSP_IDLECT2) | (1<<1), DSP_IDLECT2);
 177         __raw_writew(__raw_readw(DSP_RSTCT2) | 1 | 1<<1, DSP_RSTCT2);
 178
 179         /* disable sample rate generator */
 180         OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, SPCR1, 0x0000);
 181         OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, SPCR2, 0x0000);
 182
 183         /* pin control register */
 184         OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, PCR0,(CLKXM | CLKXP | CLKRP));
 185
 186         /* configure srg to send 12MHz pulse from dsp peripheral clock */
 187         OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, SRGR1, 0x0000);
 188         OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, SRGR2, CLKSM);
 189
 190         /* enable sample rate generator */
 191         w = OMAP_MCBSP_READ(OMAP1610_MCBSP3_BASE, SPCR2);
 192         OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, SPCR2, (w | FREE | GRST));
 193         printk("Clock enabled to MCBSP1 & 3 \n");
 194
 195         return 0;
 196 }
 197
 198 static void update_volume_left(int volume)
 199 {
 200         u16 val = 0;
 201         val = ((volume * OUTPUT_VOLUME_RANGE) / 100) + OUTPUT_VOLUME_MIN;
 202         tlv320aic23_write_value(LEFT_CHANNEL_VOLUME_ADDR, val);
 203         tlv320aic23_info_l.volume_reg_left = volume;
 204 }
 205
 206 static void update_volume_right(int volume)
 207 {
 208         u16 val = 0;
 209         val = ((volume * OUTPUT_VOLUME_RANGE) / 100) + OUTPUT_VOLUME_MIN;
 210         tlv320aic23_write_value(RIGHT_CHANNEL_VOLUME_ADDR, val);
 211         tlv320aic23_info_l.volume_reg_right = volume;
 212 }
 213
 214 static void set_mic(int mic_en)
 215 {
 216         u16 dg_ctrl;
 217
 218         if (mic_en) {
 219                 tlv320aic23_info_l.power = OSC_OFF | LINE_OFF;
 220                 dg_ctrl = ADCHP_ON;
 221                 tlv320aic23_info_l.mask &= ~MICM_MUTED;
 222                 tlv320aic23_info_l.mask |= MICB_20DB; /* STE_ENABLED */
 223         } else {
 224                 tlv320aic23_info_l.power =
 225                         OSC_OFF | ADC_OFF | MIC_OFF | LINE_OFF;
 226                 dg_ctrl = 0x00;
 227                 tlv320aic23_info_l.mask =
 228                         DAC_SELECTED | INSEL_MIC | MICM_MUTED;
 229         }
 230         tlv320aic23_write_value(POWER_DOWN_CONTROL_ADDR,
 231                                 tlv320aic23_info_l.power);
 232         tlv320aic23_write_value(DIGITAL_AUDIO_CONTROL_ADDR, dg_ctrl);
 233         tlv320aic23_write_value(ANALOG_AUDIO_CONTROL_ADDR,
 234                                 tlv320aic23_info_l.mask);
 235         tlv320aic23_info_l.mic_enable = mic_en;
 236
 237         printk(KERN_INFO "tlv320aic23 mic state: %i\n", mic_en);
 238 }
 239
 240 static void tlv320aic23_init_power(void)
 241 {
 242         tlv320aic23_write_value(RESET_CONTROL_ADDR, 0x00);
 243
 244         if (tlv320aic23_info_l.initialization == 0) {
 245                 tlv320aic23_write_value(LEFT_CHANNEL_VOLUME_ADDR, LHV_MIN);
 246                 tlv320aic23_write_value(RIGHT_CHANNEL_VOLUME_ADDR, LHV_MIN);
 247         }
 248         else {
 249                 update_volume_left(tlv320aic23_info_l.volume_reg_left);
 250                 update_volume_right(tlv320aic23_info_l.volume_reg_right);
 251         }
 252
 253         tlv320aic23_info_l.mask = DAC_SELECTED | INSEL_MIC | MICM_MUTED;
 254         tlv320aic23_write_value(ANALOG_AUDIO_CONTROL_ADDR,
 255                                 tlv320aic23_info_l.mask);
 256         tlv320aic23_write_value(DIGITAL_AUDIO_CONTROL_ADDR, 0x00);
 257         tlv320aic23_write_value(DIGITAL_AUDIO_FORMAT_ADDR, LRP_ON | FOR_DSP);
 258         tlv320aic23_write_value(SAMPLE_RATE_CONTROL_ADDR, USB_CLK_ON);
 259         tlv320aic23_write_value(DIGITAL_INTERFACE_ACT_ADDR, ACT_ON);
 260         tlv320aic23_info_l.power = OSC_OFF | ADC_OFF | MIC_OFF | LINE_OFF;
 261         tlv320aic23_write_value(POWER_DOWN_CONTROL_ADDR,
 262                                 tlv320aic23_info_l.power);
 263
 264         /* enable mic input */
 265         if (tlv320aic23_info_l.mic_enable)
 266                 set_mic(tlv320aic23_info_l.mic_enable);
 267
 268         printk(KERN_INFO "tlv320aic23_init_power() done\n");
 269 }
 270
 271 void tlv320aic23_power_down(void)
 272 {
 273         printk("tlv320aic23 powering down\n");
 274         tlv320aic23_write_value(POWER_DOWN_CONTROL_ADDR, 0xff);
 275         tlv320aic23_info_l.power_down = 1;
 276 }
 277
 278 void tlv320aic23_power_up(void)
 279 {
 280         printk("tlv320aic23 powering up\n");
 281         tlv320aic23_init_power();
 282         tlv320aic23_info_l.power_down = 0;
 283 }
 284
 285 /*----------------------------------------------------------------------*/
 286 /*                      sysfs initializations                           */
 287 /*----------------------------------------------------------------------*/
 288
 289 static ssize_t store_volume_left(struct device *dev,
 290                                  struct device_attribute *attr,
 291                                  const char *buf, size_t count)
 292 {
 293         signed volume;
 294
 295         sscanf(buf, "%i", &volume);
 296
 297         if (volume < MIN_VOL) {
 298                 tlv320aic23_power_down();
 299                 return count;
 300         } else if (volume > MIN_VOL && tlv320aic23_info_l.power_down) {
 301                 tlv320aic23_info_l.volume_reg_left = volume;
 302                 tlv320aic23_power_up();
 303                 return count;
 304         }
 305         if (volume > MAX_VOL)
 306                 volume = MAX_VOL;
 307
 308         update_volume_left(volume);
 309         return count;
 310 }
 311
 312 static ssize_t show_volume_left(struct device *dev,
 313                                 struct device_attribute *attr, char *buf)
 314 {
 315         return sprintf(buf, "%u\n", tlv320aic23_info_l.volume_reg_left);
 316 }
 317
 318 static DEVICE_ATTR(volume_left, S_IRUGO | S_IWUGO,
 319                    show_volume_left, store_volume_left);
 320
 321 static ssize_t store_volume_right(struct device *dev,
 322                                   struct device_attribute *attr,
 323                                   const char *buf, size_t count)
 324 {
 325         signed volume;
 326
 327         sscanf(buf, "%i", &volume);
 328         if (volume < MIN_VOL) {
 329                 tlv320aic23_power_down();
 330                 return count;
 331         } else if (volume > MIN_VOL && tlv320aic23_info_l.power_down) {
 332                 tlv320aic23_info_l.volume_reg_right = volume;
 333                 tlv320aic23_power_up();
 334                 return count;
 335         }
 336         if (volume > MAX_VOL)
 337                 volume = MAX_VOL;
 338
 339         update_volume_right(volume);
 340         return count;
 341 }
 342
 343 static ssize_t show_volume_right(struct device *dev,
 344                                  struct device_attribute *attr, char *buf)
 345 {
 346         return sprintf(buf, "%u\n", tlv320aic23_info_l.volume_reg_right);
 347 }
 348
 349 static DEVICE_ATTR(volume_right, S_IRUGO | S_IWUGO,
 350                    show_volume_right, store_volume_right);
 351
 352 static ssize_t store_gain_left(struct device *dev,
 353                                struct device_attribute *attr,
 354                                const char *buf, size_t count)
 355 {
 356         u16 val = 0;
 357         unsigned gain;
 358
 359         sscanf(buf, "%u", &gain);
 360         if (gain > MAX_VOL)
 361                 gain = MAX_VOL;
 362
 363         val = ((gain * INPUT_VOLUME_RANGE) / 100) + INPUT_VOLUME_MIN;
 364         tlv320aic23_write_value(LEFT_LINE_VOLUME_ADDR, val);
 365         tlv320aic23_info_l.input_gain_reg_left = gain;
 366
 367         return count;
 368 }
 369
 370 static ssize_t show_gain_left(struct device *dev,
 371                               struct device_attribute *attr, char *buf)
 372 {
 373         return sprintf(buf, "%u\n", tlv320aic23_info_l.input_gain_reg_left);
 374 }
 375
 376 static DEVICE_ATTR(gain_left, S_IRUGO | S_IWUSR, show_gain_left,
 377                    store_gain_left);
 378
 379 static ssize_t store_gain_right(struct device *dev,
 380                                 struct device_attribute *attr,
 381                                 const char *buf, size_t count)
 382 {
 383         u16 val = 0;
 384         unsigned gain;
 385
 386         sscanf(buf, "%u", &gain);
 387         if (gain > MAX_VOL)
 388                 gain = MAX_VOL;
 389
 390         val = ((gain * INPUT_VOLUME_RANGE) / 100) + INPUT_VOLUME_MIN;
 391         tlv320aic23_write_value(RIGHT_LINE_VOLUME_ADDR, val);
 392         tlv320aic23_info_l.input_gain_reg_right = gain;
 393
 394         return count;
 395 }
 396
 397 static ssize_t show_gain_right(struct device *dev,
 398                                struct device_attribute *attr, char *buf)
 399 {
 400         return sprintf(buf, "%u\n", tlv320aic23_info_l.input_gain_reg_right);
 401 }
 402
 403 static DEVICE_ATTR(gain_right, S_IRUGO | S_IWUSR, show_gain_right,
 404                    store_gain_right);
 405
 406 static ssize_t store_mic_loopback(struct device *dev,
 407                                   struct device_attribute *attr,
 408                                   const char *buf, size_t count)
 409 {
 410         int mic;
 411
 412         sscanf(buf, "%i", &mic);
 413         if (mic > 0) {
 414                 tlv320aic23_write_value(POWER_DOWN_CONTROL_ADDR, \
 415                                         OSC_OFF | ADC_OFF | LINE_OFF);
 416                 tlv320aic23_info_l.mask = STE_ENABLED | DAC_SELECTED \
 417                                           | INSEL_MIC | MICB_20DB;
 418                 tlv320aic23_write_value(ANALOG_AUDIO_CONTROL_ADDR,
 419                                         tlv320aic23_info_l.mask);
 420                 mic = 1;
 421         }
 422         else {
 423                 tlv320aic23_write_value(POWER_DOWN_CONTROL_ADDR, \
 424                                         OSC_OFF | ADC_OFF | MIC_OFF | LINE_OFF);
 425                 mic = 0;
 426         }
 427         tlv320aic23_info_l.mic_loopback = mic;
 428
 429         return count;
 430 }
 431
 432 static ssize_t show_mic_loopback(struct device *dev,
 433                                  struct device_attribute *attr, char *buf)
 434 {
 435         return sprintf(buf, "%i\n", tlv320aic23_info_l.mic_loopback);
 436 }
 437
 438 static DEVICE_ATTR(mic_loopback, S_IRUGO | S_IWUSR,
 439                    show_mic_loopback, store_mic_loopback);
 440
 441 static ssize_t store_st_attenuation(struct device *dev,
 442                                     struct device_attribute *attr,
 443                                     const char *buf, size_t count)
 444 {
 445         unsigned sta;
 446         u16 tmp;
 447
 448         sscanf(buf, "%u", &sta);
 449         if (sta > 3)
 450                 sta = 3;
 451
 452         tmp = tlv320aic23_info_l.mask;
 453         tmp &= 0x3f;
 454
 455         tlv320aic23_info_l.mask =  tmp | STA_REG(sta);
 456         tlv320aic23_write_value(ANALOG_AUDIO_CONTROL_ADDR,
 457                                 tlv320aic23_info_l.mask);
 458         tlv320aic23_info_l.sta = sta;
 459
 460         return count;
 461 }
 462
 463 static ssize_t show_st_attenuation(struct device *dev,
 464                                    struct device_attribute *attr, char *buf)
 465 {
 466         return sprintf(buf, "%i\n", tlv320aic23_info_l.sta);
 467 }
 468
 469 static DEVICE_ATTR(st_attenuation, S_IRUGO | S_IWUSR,
 470                    show_st_attenuation, store_st_attenuation);
 471
 472 static ssize_t store_mic_enable(struct device *dev,
 473                                 struct device_attribute *attr,
 474                                 const char *buf, size_t count)
 475 {
 476         int mic;
 477
 478         sscanf(buf, "%i", &mic);
 479         set_mic(mic);
 480
 481         return count;
 482 }
 483
 484 static ssize_t show_mic_enable(struct device *dev,
 485                                struct device_attribute *attr, char *buf)
 486 {
 487         return sprintf(buf, "%i\n", tlv320aic23_info_l.mic_enable);
 488 }
 489
 490 static DEVICE_ATTR(mic_enable, S_IRUGO | S_IWUSR,
 491         show_mic_enable, store_mic_enable);
 492
 493 static ssize_t show_audio_selftest(struct device *dev,
 494                                    struct device_attribute *attr, char *buf)
 495 {
 496         return sprintf(buf, "%i\n", selftest);
 497 }
 498
 499 static DEVICE_ATTR(audio_selftest, S_IRUGO | S_IWUSR,
 500                 show_audio_selftest, NULL);
 501
 502 static int audio_i2c_probe(struct platform_device *dev)
 503 {
 504         int r;
 505
 506         if ((r = device_create_file(&dev->dev, &dev_attr_volume_left)) != 0)
 507                 return r;
 508         else if ((r = device_create_file(&dev->dev,
 509                 &dev_attr_volume_right)) != 0)
 510                 goto err_volume_left;
 511         else if ((r = device_create_file(&dev->dev,
 512                 &dev_attr_gain_right)) != 0)
 513                 goto err_volume_right;
 514         else if ((r = device_create_file(&dev->dev,
 515                 &dev_attr_gain_left)) != 0)
 516                 goto err_gain_right;
 517         else if ((r = device_create_file(&dev->dev,
 518                 &dev_attr_mic_loopback)) != 0)
 519                 goto err_gain_left;
 520         else if ((r = device_create_file(&dev->dev,
 521                 &dev_attr_mic_enable)) != 0)
 522                 goto err_mic_loopback;
 523         else if ((r = device_create_file(&dev->dev,
 524                 &dev_attr_st_attenuation)) != 0)
 525                 goto err_mic_enable;
 526         else if ((r = device_create_file(&dev->dev,
 527                 &dev_attr_audio_selftest)) != 0)
 528                 goto err_st_attenuation;
 529         else
 530                 return r;
 531
 532 err_st_attenuation:
 533         device_remove_file(&dev->dev, &dev_attr_st_attenuation);
 534 err_mic_enable:
 535         device_remove_file(&dev->dev, &dev_attr_mic_enable);
 536 err_mic_loopback:
 537         device_remove_file(&dev->dev, &dev_attr_mic_loopback);
 538 err_gain_left:
 539         device_remove_file(&dev->dev, &dev_attr_gain_left);
 540 err_gain_right:
 541         device_remove_file(&dev->dev, &dev_attr_gain_right);
 542 err_volume_right:
 543         device_remove_file(&dev->dev, &dev_attr_volume_right);
 544 err_volume_left:
 545         device_remove_file(&dev->dev, &dev_attr_volume_left);
 546
 547         return r;
 548 }
 549
 550 static int audio_i2c_remove(struct platform_device *dev)
 551 {
 552         device_remove_file(&dev->dev, &dev_attr_st_attenuation);
 553         device_remove_file(&dev->dev, &dev_attr_mic_enable);
 554         device_remove_file(&dev->dev, &dev_attr_mic_loopback);
 555         device_remove_file(&dev->dev, &dev_attr_gain_left);
 556         device_remove_file(&dev->dev, &dev_attr_gain_right);
 557         device_remove_file(&dev->dev, &dev_attr_volume_right);
 558         device_remove_file(&dev->dev, &dev_attr_volume_left);
 559
 560         return 0;
 561 }
 562
 563 /*----------------------------------------------------------------*/
 564 /*                      PM functions                              */
 565 /*----------------------------------------------------------------*/
 566
 567 static void audio_i2c_shutdown(struct platform_device *dev)
 568 {
 569         /* Let's mute the codec before powering off to prevent
 570         * glitch in the sound
 571         */
 572         tlv320aic23_write_value(LEFT_CHANNEL_VOLUME_ADDR, LHV_MIN);
 573         tlv320aic23_write_value(RIGHT_CHANNEL_VOLUME_ADDR, LHV_MIN);
 574         tlv320aic23_power_down();
 575 }
 576
 577 static int audio_i2c_suspend(struct platform_device *dev, pm_message_t state)
 578 {
 579         /* Let's mute the codec before powering off to prevent
 580          * glitch in the sound
 581          */
 582         tlv320aic23_write_value(LEFT_CHANNEL_VOLUME_ADDR, LHV_MIN);
 583         tlv320aic23_write_value(RIGHT_CHANNEL_VOLUME_ADDR, LHV_MIN);
 584         tlv320aic23_power_down();
 585
 586         return 0;
 587 }
 588
 589 static int audio_i2c_resume(struct platform_device *dev)
 590 {
 591         tlv320aic23_power_up();
 592
 593         return 0;
 594 }
 595
 596 static struct platform_driver audio_i2c_driver = {
 597         .driver {
 598                 .owner  = THIS_MODULE,
 599                 .name   = "audio-i2c",
 600         },
 601         .shutdown       = audio_i2c_shutdown,
 602         .probe          = audio_i2c_probe,
 603         .remove         = audio_i2c_remove,
 604         .suspend        = audio_i2c_suspend,
 605         .resume         = audio_i2c_resume,
 606 };
 607
 608 static struct platform_device audio_i2c_device = {
 609         .name           = "audio-i2c",
 610         .id             = -1,
 611 };
 612
 613 /*----------------------------------------------------------------*/
 614
 615 static int __init tlv320aic23_init(void)
 616 {
 617         selftest =  0;
 618         tlv320aic23_info_l.initialization = 0;
 619
 620         if (i2c_add_driver(&tlv320aic23_driver)) {
 621                 printk("tlv320aic23 i2c: Driver registration failed, \
 622                       module not inserted.\n");
 623                 selftest= -ENODEV;
 624                 return selftest;
 625         }
 626
 627         if (platform_driver_register(&audio_i2c_driver)) {
 628                 printk(KERN_WARNING "Failed to register audio i2c driver\n");
 629                 selftest = -ENODEV;
 630                 return selftest;
 631         }
 632
 633         if (platform_device_register(&audio_i2c_device)) {
 634                 printk(KERN_WARNING "Failed to register audio i2c device\n");
 635                 platform_driver_unregister(&audio_i2c_driver);
 636                 selftest = -ENODEV;
 637                 return selftest;
 638         }
 639         omap_mcbsp3_tlv320aic23_clock_init();
 640         tlv320aic23_power_up();
 641         tlv320aic23_info_l.initialization = 1;
 642         printk("TLV320AIC23 I2C version %s (%s)\n",
 643                TLV320AIC23_VERSION, TLV320AIC23_DATE);
 644
 645         return selftest;
 646 }
 647
 648 static void __exit tlv320aic23_exit(void)
 649 {
 650         int res;
 651
 652         tlv320aic23_power_down();
 653         if ((res = i2c_del_driver(&tlv320aic23_driver)))
 654                 printk("tlv320aic23 i2c: Driver remove failed, module not removed.\n");
 655
 656         platform_device_unregister(&audio_i2c_device);
 657         platform_driver_unregister(&audio_i2c_driver);
 658 }
 659
 660 MODULE_AUTHOR("Kai Svahn <kai.svahn@nokia.com>");
 661 MODULE_DESCRIPTION("I2C interface for TLV320AIC23 codec.");
 662 MODULE_LICENSE("GPL");
 663
 664 module_init(tlv320aic23_init)
 665 module_exit(tlv320aic23_exit)
 666
 667 EXPORT_SYMBOL(tlv320aic23_write_value);
 668 EXPORT_SYMBOL(tlv320aic23_power_up);
 669 EXPORT_SYMBOL(tlv320aic23_power_down);