2 * Texas Instrumens TLV320AIC23 audio codec's i2c interface.
4 * Copyright (c) by Kai Svahn <kai.svahn@nokia.com>
5 * Copyright (c) by Jussi Laako <jussi.laako@nokia.com>
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.
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.
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
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>
31 #include <asm/arch/aic23.h>
32 #include <asm/arch/mcbsp.h>
34 #define TLV320AIC23_VERSION "1.8"
35 #define TLV320AIC23_DATE "10-Feb-2006"
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)
47 /* I2C Addresses to scan */
48 static unsigned short normal_i2c[] = { TLV320AIC23ID1, TLV320AIC23ID2, \
50 /*static unsigned short normal_i2c_range[] = { I2C_CLIENT_END };*/
52 /* This makes all addr_data:s */
55 static struct i2c_driver tlv320aic23_driver;
56 static struct i2c_client *new_client;
59 static struct tlv320aic23_info {
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 */
73 static int _tlv320aic23_write_value(struct i2c_client *client, u8 reg, u16 value)
77 /* TLV320AIC23 has 7 bit address and 9 bits of data
78 * so we need to switch one data bit into reg and rest
83 val = (0x01 & (value >> 8));
85 val = (0x00ff & value);
87 return i2c_smbus_write_byte_data(client, wreg, val);
90 int tlv320aic23_write_value(u8 reg, u16 value)
92 static struct i2c_client *client;
94 _tlv320aic23_write_value(client, reg, value);
99 static int tlv320aic23_detect_client(struct i2c_adapter *adapter, int address,
103 const char *client_name = "TLV320AIC23 Audio Codec";
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",
112 if (!(new_client = kmalloc(sizeof(struct i2c_client),
115 printk(KERN_WARNING "Couldn't allocate memory for %s\n",
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);
127 if ((err = i2c_attach_client(new_client))) {
128 printk(KERN_WARNING "Couldn't attach %s\n", client_name);
135 static int tlv320aic23_detach_client(struct i2c_client *client)
139 if ((err = i2c_detach_client(client))) {
140 printk("tlv320aic23.o: Client deregistration failed, \
141 client not detached.\n");
148 static int tlv320aic23_attach_adapter(struct i2c_adapter *adapter)
152 res = i2c_probe(adapter, &addr_data, &tlv320aic23_detect_client);
156 static struct i2c_driver tlv320aic23_driver = {
158 .name = "OMAP+TLV320AIC23 codec",
159 /*.flags = I2C_DF_NOTIFY,*/
161 .id = I2C_DRIVERID_MISC, /* Experimental ID */
162 .attach_adapter = tlv320aic23_attach_adapter,
163 .detach_client = tlv320aic23_detach_client,
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.
171 static int omap_mcbsp3_tlv320aic23_clock_init(void)
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);
179 /* disable sample rate generator */
180 OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, SPCR1, 0x0000);
181 OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, SPCR2, 0x0000);
183 /* pin control register */
184 OMAP_MCBSP_WRITE(OMAP1610_MCBSP3_BASE, PCR0,(CLKXM | CLKXP | CLKRP));
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);
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");
198 static void update_volume_left(int volume)
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;
206 static void update_volume_right(int volume)
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;
214 static void set_mic(int mic_en)
219 tlv320aic23_info_l.power = OSC_OFF | LINE_OFF;
221 tlv320aic23_info_l.mask &= ~MICM_MUTED;
222 tlv320aic23_info_l.mask |= MICB_20DB; /* STE_ENABLED */
224 tlv320aic23_info_l.power =
225 OSC_OFF | ADC_OFF | MIC_OFF | LINE_OFF;
227 tlv320aic23_info_l.mask =
228 DAC_SELECTED | INSEL_MIC | MICM_MUTED;
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;
237 printk(KERN_INFO "tlv320aic23 mic state: %i\n", mic_en);
240 static void tlv320aic23_init_power(void)
242 tlv320aic23_write_value(RESET_CONTROL_ADDR, 0x00);
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);
249 update_volume_left(tlv320aic23_info_l.volume_reg_left);
250 update_volume_right(tlv320aic23_info_l.volume_reg_right);
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);
264 /* enable mic input */
265 if (tlv320aic23_info_l.mic_enable)
266 set_mic(tlv320aic23_info_l.mic_enable);
268 printk(KERN_INFO "tlv320aic23_init_power() done\n");
271 void tlv320aic23_power_down(void)
273 printk("tlv320aic23 powering down\n");
274 tlv320aic23_write_value(POWER_DOWN_CONTROL_ADDR, 0xff);
275 tlv320aic23_info_l.power_down = 1;
278 void tlv320aic23_power_up(void)
280 printk("tlv320aic23 powering up\n");
281 tlv320aic23_init_power();
282 tlv320aic23_info_l.power_down = 0;
285 /*----------------------------------------------------------------------*/
286 /* sysfs initializations */
287 /*----------------------------------------------------------------------*/
289 static ssize_t store_volume_left(struct device *dev,
290 struct device_attribute *attr,
291 const char *buf, size_t count)
295 sscanf(buf, "%i", &volume);
297 if (volume < MIN_VOL) {
298 tlv320aic23_power_down();
300 } else if (volume > MIN_VOL && tlv320aic23_info_l.power_down) {
301 tlv320aic23_info_l.volume_reg_left = volume;
302 tlv320aic23_power_up();
305 if (volume > MAX_VOL)
308 update_volume_left(volume);
312 static ssize_t show_volume_left(struct device *dev,
313 struct device_attribute *attr, char *buf)
315 return sprintf(buf, "%u\n", tlv320aic23_info_l.volume_reg_left);
318 static DEVICE_ATTR(volume_left, S_IRUGO | S_IWUGO,
319 show_volume_left, store_volume_left);
321 static ssize_t store_volume_right(struct device *dev,
322 struct device_attribute *attr,
323 const char *buf, size_t count)
327 sscanf(buf, "%i", &volume);
328 if (volume < MIN_VOL) {
329 tlv320aic23_power_down();
331 } else if (volume > MIN_VOL && tlv320aic23_info_l.power_down) {
332 tlv320aic23_info_l.volume_reg_right = volume;
333 tlv320aic23_power_up();
336 if (volume > MAX_VOL)
339 update_volume_right(volume);
343 static ssize_t show_volume_right(struct device *dev,
344 struct device_attribute *attr, char *buf)
346 return sprintf(buf, "%u\n", tlv320aic23_info_l.volume_reg_right);
349 static DEVICE_ATTR(volume_right, S_IRUGO | S_IWUGO,
350 show_volume_right, store_volume_right);
352 static ssize_t store_gain_left(struct device *dev,
353 struct device_attribute *attr,
354 const char *buf, size_t count)
359 sscanf(buf, "%u", &gain);
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;
370 static ssize_t show_gain_left(struct device *dev,
371 struct device_attribute *attr, char *buf)
373 return sprintf(buf, "%u\n", tlv320aic23_info_l.input_gain_reg_left);
376 static DEVICE_ATTR(gain_left, S_IRUGO | S_IWUSR, show_gain_left,
379 static ssize_t store_gain_right(struct device *dev,
380 struct device_attribute *attr,
381 const char *buf, size_t count)
386 sscanf(buf, "%u", &gain);
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;
397 static ssize_t show_gain_right(struct device *dev,
398 struct device_attribute *attr, char *buf)
400 return sprintf(buf, "%u\n", tlv320aic23_info_l.input_gain_reg_right);
403 static DEVICE_ATTR(gain_right, S_IRUGO | S_IWUSR, show_gain_right,
406 static ssize_t store_mic_loopback(struct device *dev,
407 struct device_attribute *attr,
408 const char *buf, size_t count)
412 sscanf(buf, "%i", &mic);
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);
423 tlv320aic23_write_value(POWER_DOWN_CONTROL_ADDR, \
424 OSC_OFF | ADC_OFF | MIC_OFF | LINE_OFF);
427 tlv320aic23_info_l.mic_loopback = mic;
432 static ssize_t show_mic_loopback(struct device *dev,
433 struct device_attribute *attr, char *buf)
435 return sprintf(buf, "%i\n", tlv320aic23_info_l.mic_loopback);
438 static DEVICE_ATTR(mic_loopback, S_IRUGO | S_IWUSR,
439 show_mic_loopback, store_mic_loopback);
441 static ssize_t store_st_attenuation(struct device *dev,
442 struct device_attribute *attr,
443 const char *buf, size_t count)
448 sscanf(buf, "%u", &sta);
452 tmp = tlv320aic23_info_l.mask;
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;
463 static ssize_t show_st_attenuation(struct device *dev,
464 struct device_attribute *attr, char *buf)
466 return sprintf(buf, "%i\n", tlv320aic23_info_l.sta);
469 static DEVICE_ATTR(st_attenuation, S_IRUGO | S_IWUSR,
470 show_st_attenuation, store_st_attenuation);
472 static ssize_t store_mic_enable(struct device *dev,
473 struct device_attribute *attr,
474 const char *buf, size_t count)
478 sscanf(buf, "%i", &mic);
484 static ssize_t show_mic_enable(struct device *dev,
485 struct device_attribute *attr, char *buf)
487 return sprintf(buf, "%i\n", tlv320aic23_info_l.mic_enable);
490 static DEVICE_ATTR(mic_enable, S_IRUGO | S_IWUSR,
491 show_mic_enable, store_mic_enable);
493 static ssize_t show_audio_selftest(struct device *dev,
494 struct device_attribute *attr, char *buf)
496 return sprintf(buf, "%i\n", selftest);
499 static DEVICE_ATTR(audio_selftest, S_IRUGO | S_IWUSR,
500 show_audio_selftest, NULL);
502 static int audio_i2c_probe(struct platform_device *dev)
506 if ((r = device_create_file(&dev->dev, &dev_attr_volume_left)) != 0)
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)
517 else if ((r = device_create_file(&dev->dev,
518 &dev_attr_mic_loopback)) != 0)
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)
526 else if ((r = device_create_file(&dev->dev,
527 &dev_attr_audio_selftest)) != 0)
528 goto err_st_attenuation;
533 device_remove_file(&dev->dev, &dev_attr_st_attenuation);
535 device_remove_file(&dev->dev, &dev_attr_mic_enable);
537 device_remove_file(&dev->dev, &dev_attr_mic_loopback);
539 device_remove_file(&dev->dev, &dev_attr_gain_left);
541 device_remove_file(&dev->dev, &dev_attr_gain_right);
543 device_remove_file(&dev->dev, &dev_attr_volume_right);
545 device_remove_file(&dev->dev, &dev_attr_volume_left);
550 static int audio_i2c_remove(struct platform_device *dev)
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);
563 /*----------------------------------------------------------------*/
565 /*----------------------------------------------------------------*/
567 static void audio_i2c_shutdown(struct platform_device *dev)
569 /* Let's mute the codec before powering off to prevent
570 * glitch in the sound
572 tlv320aic23_write_value(LEFT_CHANNEL_VOLUME_ADDR, LHV_MIN);
573 tlv320aic23_write_value(RIGHT_CHANNEL_VOLUME_ADDR, LHV_MIN);
574 tlv320aic23_power_down();
577 static int audio_i2c_suspend(struct platform_device *dev, pm_message_t state)
579 /* Let's mute the codec before powering off to prevent
580 * glitch in the sound
582 tlv320aic23_write_value(LEFT_CHANNEL_VOLUME_ADDR, LHV_MIN);
583 tlv320aic23_write_value(RIGHT_CHANNEL_VOLUME_ADDR, LHV_MIN);
584 tlv320aic23_power_down();
589 static int audio_i2c_resume(struct platform_device *dev)
591 tlv320aic23_power_up();
596 static struct platform_driver audio_i2c_driver = {
598 .owner = THIS_MODULE,
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,
608 static struct platform_device audio_i2c_device = {
613 /*----------------------------------------------------------------*/
615 static int __init tlv320aic23_init(void)
618 tlv320aic23_info_l.initialization = 0;
620 if (i2c_add_driver(&tlv320aic23_driver)) {
621 printk("tlv320aic23 i2c: Driver registration failed, \
622 module not inserted.\n");
627 if (platform_driver_register(&audio_i2c_driver)) {
628 printk(KERN_WARNING "Failed to register audio i2c driver\n");
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);
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);
648 static void __exit tlv320aic23_exit(void)
652 tlv320aic23_power_down();
653 if ((res = i2c_del_driver(&tlv320aic23_driver)))
654 printk("tlv320aic23 i2c: Driver remove failed, module not removed.\n");
656 platform_device_unregister(&audio_i2c_device);
657 platform_driver_unregister(&audio_i2c_driver);
660 MODULE_AUTHOR("Kai Svahn <kai.svahn@nokia.com>");
661 MODULE_DESCRIPTION("I2C interface for TLV320AIC23 codec.");
662 MODULE_LICENSE("GPL");
664 module_init(tlv320aic23_init)
665 module_exit(tlv320aic23_exit)
667 EXPORT_SYMBOL(tlv320aic23_write_value);
668 EXPORT_SYMBOL(tlv320aic23_power_up);
669 EXPORT_SYMBOL(tlv320aic23_power_down);