1 /* 2 * ak4535.c -- AK4535 ALSA Soc Audio driver 3 * 4 * Copyright 2005 Openedhand Ltd. 5 * 6 * Author: Richard Purdie <richard@openedhand.com> 7 * 8 * Based on wm8753.c by Liam Girdwood 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 version 2 as 12 * published by the Free Software Foundation. 13 */ 14 15 #include <linux/module.h> 16 #include <linux/moduleparam.h> 17 #include <linux/init.h> 18 #include <linux/delay.h> 19 #include <linux/pm.h> 20 #include <linux/i2c.h> 21 #include <linux/regmap.h> 22 #include <linux/slab.h> 23 #include <sound/core.h> 24 #include <sound/pcm.h> 25 #include <sound/pcm_params.h> 26 #include <sound/soc.h> 27 #include <sound/initval.h> 28 29 #include "ak4535.h" 30 31 /* codec private data */ 32 struct ak4535_priv { 33 struct regmap *regmap; 34 unsigned int sysclk; 35 }; 36 37 /* 38 * ak4535 register cache 39 */ 40 static const struct reg_default ak4535_reg_defaults[] = { 41 { 0, 0x00 }, 42 { 1, 0x80 }, 43 { 2, 0x00 }, 44 { 3, 0x03 }, 45 { 4, 0x02 }, 46 { 5, 0x00 }, 47 { 6, 0x11 }, 48 { 7, 0x01 }, 49 { 8, 0x00 }, 50 { 9, 0x40 }, 51 { 10, 0x36 }, 52 { 11, 0x10 }, 53 { 12, 0x00 }, 54 { 13, 0x00 }, 55 { 14, 0x57 }, 56 }; 57 58 static bool ak4535_volatile(struct device *dev, unsigned int reg) 59 { 60 switch (reg) { 61 case AK4535_STATUS: 62 return true; 63 default: 64 return false; 65 } 66 } 67 68 static const char *ak4535_mono_gain[] = {"+6dB", "-17dB"}; 69 static const char *ak4535_mono_out[] = {"(L + R)/2", "Hi-Z"}; 70 static const char *ak4535_hp_out[] = {"Stereo", "Mono"}; 71 static const char *ak4535_deemp[] = {"44.1kHz", "Off", "48kHz", "32kHz"}; 72 static const char *ak4535_mic_select[] = {"Internal", "External"}; 73 74 static const struct soc_enum ak4535_enum[] = { 75 SOC_ENUM_SINGLE(AK4535_SIG1, 7, 2, ak4535_mono_gain), 76 SOC_ENUM_SINGLE(AK4535_SIG1, 6, 2, ak4535_mono_out), 77 SOC_ENUM_SINGLE(AK4535_MODE2, 2, 2, ak4535_hp_out), 78 SOC_ENUM_SINGLE(AK4535_DAC, 0, 4, ak4535_deemp), 79 SOC_ENUM_SINGLE(AK4535_MIC, 1, 2, ak4535_mic_select), 80 }; 81 82 static const struct snd_kcontrol_new ak4535_snd_controls[] = { 83 SOC_SINGLE("ALC2 Switch", AK4535_SIG1, 1, 1, 0), 84 SOC_ENUM("Mono 1 Output", ak4535_enum[1]), 85 SOC_ENUM("Mono 1 Gain", ak4535_enum[0]), 86 SOC_ENUM("Headphone Output", ak4535_enum[2]), 87 SOC_ENUM("Playback Deemphasis", ak4535_enum[3]), 88 SOC_SINGLE("Bass Volume", AK4535_DAC, 2, 3, 0), 89 SOC_SINGLE("Mic Boost (+20dB) Switch", AK4535_MIC, 0, 1, 0), 90 SOC_ENUM("Mic Select", ak4535_enum[4]), 91 SOC_SINGLE("ALC Operation Time", AK4535_TIMER, 0, 3, 0), 92 SOC_SINGLE("ALC Recovery Time", AK4535_TIMER, 2, 3, 0), 93 SOC_SINGLE("ALC ZC Time", AK4535_TIMER, 4, 3, 0), 94 SOC_SINGLE("ALC 1 Switch", AK4535_ALC1, 5, 1, 0), 95 SOC_SINGLE("ALC 2 Switch", AK4535_ALC1, 6, 1, 0), 96 SOC_SINGLE("ALC Volume", AK4535_ALC2, 0, 127, 0), 97 SOC_SINGLE("Capture Volume", AK4535_PGA, 0, 127, 0), 98 SOC_SINGLE("Left Playback Volume", AK4535_LATT, 0, 127, 1), 99 SOC_SINGLE("Right Playback Volume", AK4535_RATT, 0, 127, 1), 100 SOC_SINGLE("AUX Bypass Volume", AK4535_VOL, 0, 15, 0), 101 SOC_SINGLE("Mic Sidetone Volume", AK4535_VOL, 4, 7, 0), 102 }; 103 104 /* Mono 1 Mixer */ 105 static const struct snd_kcontrol_new ak4535_mono1_mixer_controls[] = { 106 SOC_DAPM_SINGLE("Mic Sidetone Switch", AK4535_SIG1, 4, 1, 0), 107 SOC_DAPM_SINGLE("Mono Playback Switch", AK4535_SIG1, 5, 1, 0), 108 }; 109 110 /* Stereo Mixer */ 111 static const struct snd_kcontrol_new ak4535_stereo_mixer_controls[] = { 112 SOC_DAPM_SINGLE("Mic Sidetone Switch", AK4535_SIG2, 4, 1, 0), 113 SOC_DAPM_SINGLE("Playback Switch", AK4535_SIG2, 7, 1, 0), 114 SOC_DAPM_SINGLE("Aux Bypass Switch", AK4535_SIG2, 5, 1, 0), 115 }; 116 117 /* Input Mixer */ 118 static const struct snd_kcontrol_new ak4535_input_mixer_controls[] = { 119 SOC_DAPM_SINGLE("Mic Capture Switch", AK4535_MIC, 2, 1, 0), 120 SOC_DAPM_SINGLE("Aux Capture Switch", AK4535_MIC, 5, 1, 0), 121 }; 122 123 /* Input mux */ 124 static const struct snd_kcontrol_new ak4535_input_mux_control = 125 SOC_DAPM_ENUM("Input Select", ak4535_enum[4]); 126 127 /* HP L switch */ 128 static const struct snd_kcontrol_new ak4535_hpl_control = 129 SOC_DAPM_SINGLE("Switch", AK4535_SIG2, 1, 1, 1); 130 131 /* HP R switch */ 132 static const struct snd_kcontrol_new ak4535_hpr_control = 133 SOC_DAPM_SINGLE("Switch", AK4535_SIG2, 0, 1, 1); 134 135 /* mono 2 switch */ 136 static const struct snd_kcontrol_new ak4535_mono2_control = 137 SOC_DAPM_SINGLE("Switch", AK4535_SIG1, 0, 1, 0); 138 139 /* Line out switch */ 140 static const struct snd_kcontrol_new ak4535_line_control = 141 SOC_DAPM_SINGLE("Switch", AK4535_SIG2, 6, 1, 0); 142 143 /* ak4535 dapm widgets */ 144 static const struct snd_soc_dapm_widget ak4535_dapm_widgets[] = { 145 SND_SOC_DAPM_MIXER("Stereo Mixer", SND_SOC_NOPM, 0, 0, 146 &ak4535_stereo_mixer_controls[0], 147 ARRAY_SIZE(ak4535_stereo_mixer_controls)), 148 SND_SOC_DAPM_MIXER("Mono1 Mixer", SND_SOC_NOPM, 0, 0, 149 &ak4535_mono1_mixer_controls[0], 150 ARRAY_SIZE(ak4535_mono1_mixer_controls)), 151 SND_SOC_DAPM_MIXER("Input Mixer", SND_SOC_NOPM, 0, 0, 152 &ak4535_input_mixer_controls[0], 153 ARRAY_SIZE(ak4535_input_mixer_controls)), 154 SND_SOC_DAPM_MUX("Input Mux", SND_SOC_NOPM, 0, 0, 155 &ak4535_input_mux_control), 156 SND_SOC_DAPM_DAC("DAC", "Playback", AK4535_PM2, 0, 0), 157 SND_SOC_DAPM_SWITCH("Mono 2 Enable", SND_SOC_NOPM, 0, 0, 158 &ak4535_mono2_control), 159 /* speaker powersave bit */ 160 SND_SOC_DAPM_PGA("Speaker Enable", AK4535_MODE2, 0, 0, NULL, 0), 161 SND_SOC_DAPM_SWITCH("Line Out Enable", SND_SOC_NOPM, 0, 0, 162 &ak4535_line_control), 163 SND_SOC_DAPM_SWITCH("Left HP Enable", SND_SOC_NOPM, 0, 0, 164 &ak4535_hpl_control), 165 SND_SOC_DAPM_SWITCH("Right HP Enable", SND_SOC_NOPM, 0, 0, 166 &ak4535_hpr_control), 167 SND_SOC_DAPM_OUTPUT("LOUT"), 168 SND_SOC_DAPM_OUTPUT("HPL"), 169 SND_SOC_DAPM_OUTPUT("ROUT"), 170 SND_SOC_DAPM_OUTPUT("HPR"), 171 SND_SOC_DAPM_OUTPUT("SPP"), 172 SND_SOC_DAPM_OUTPUT("SPN"), 173 SND_SOC_DAPM_OUTPUT("MOUT1"), 174 SND_SOC_DAPM_OUTPUT("MOUT2"), 175 SND_SOC_DAPM_OUTPUT("MICOUT"), 176 SND_SOC_DAPM_ADC("ADC", "Capture", AK4535_PM1, 0, 0), 177 SND_SOC_DAPM_PGA("Spk Amp", AK4535_PM2, 3, 0, NULL, 0), 178 SND_SOC_DAPM_PGA("HP R Amp", AK4535_PM2, 1, 0, NULL, 0), 179 SND_SOC_DAPM_PGA("HP L Amp", AK4535_PM2, 2, 0, NULL, 0), 180 SND_SOC_DAPM_PGA("Mic", AK4535_PM1, 1, 0, NULL, 0), 181 SND_SOC_DAPM_PGA("Line Out", AK4535_PM1, 4, 0, NULL, 0), 182 SND_SOC_DAPM_PGA("Mono Out", AK4535_PM1, 3, 0, NULL, 0), 183 SND_SOC_DAPM_PGA("AUX In", AK4535_PM1, 2, 0, NULL, 0), 184 185 SND_SOC_DAPM_MICBIAS("Mic Int Bias", AK4535_MIC, 3, 0), 186 SND_SOC_DAPM_MICBIAS("Mic Ext Bias", AK4535_MIC, 4, 0), 187 SND_SOC_DAPM_INPUT("MICIN"), 188 SND_SOC_DAPM_INPUT("MICEXT"), 189 SND_SOC_DAPM_INPUT("AUX"), 190 SND_SOC_DAPM_INPUT("MIN"), 191 SND_SOC_DAPM_INPUT("AIN"), 192 }; 193 194 static const struct snd_soc_dapm_route ak4535_audio_map[] = { 195 /*stereo mixer */ 196 {"Stereo Mixer", "Playback Switch", "DAC"}, 197 {"Stereo Mixer", "Mic Sidetone Switch", "Mic"}, 198 {"Stereo Mixer", "Aux Bypass Switch", "AUX In"}, 199 200 /* mono1 mixer */ 201 {"Mono1 Mixer", "Mic Sidetone Switch", "Mic"}, 202 {"Mono1 Mixer", "Mono Playback Switch", "DAC"}, 203 204 /* Mic */ 205 {"Mic", NULL, "AIN"}, 206 {"Input Mux", "Internal", "Mic Int Bias"}, 207 {"Input Mux", "External", "Mic Ext Bias"}, 208 {"Mic Int Bias", NULL, "MICIN"}, 209 {"Mic Ext Bias", NULL, "MICEXT"}, 210 {"MICOUT", NULL, "Input Mux"}, 211 212 /* line out */ 213 {"LOUT", NULL, "Line Out Enable"}, 214 {"ROUT", NULL, "Line Out Enable"}, 215 {"Line Out Enable", "Switch", "Line Out"}, 216 {"Line Out", NULL, "Stereo Mixer"}, 217 218 /* mono1 out */ 219 {"MOUT1", NULL, "Mono Out"}, 220 {"Mono Out", NULL, "Mono1 Mixer"}, 221 222 /* left HP */ 223 {"HPL", NULL, "Left HP Enable"}, 224 {"Left HP Enable", "Switch", "HP L Amp"}, 225 {"HP L Amp", NULL, "Stereo Mixer"}, 226 227 /* right HP */ 228 {"HPR", NULL, "Right HP Enable"}, 229 {"Right HP Enable", "Switch", "HP R Amp"}, 230 {"HP R Amp", NULL, "Stereo Mixer"}, 231 232 /* speaker */ 233 {"SPP", NULL, "Speaker Enable"}, 234 {"SPN", NULL, "Speaker Enable"}, 235 {"Speaker Enable", "Switch", "Spk Amp"}, 236 {"Spk Amp", NULL, "MIN"}, 237 238 /* mono 2 */ 239 {"MOUT2", NULL, "Mono 2 Enable"}, 240 {"Mono 2 Enable", "Switch", "Stereo Mixer"}, 241 242 /* Aux In */ 243 {"Aux In", NULL, "AUX"}, 244 245 /* ADC */ 246 {"ADC", NULL, "Input Mixer"}, 247 {"Input Mixer", "Mic Capture Switch", "Mic"}, 248 {"Input Mixer", "Aux Capture Switch", "Aux In"}, 249 }; 250 251 static int ak4535_set_dai_sysclk(struct snd_soc_dai *codec_dai, 252 int clk_id, unsigned int freq, int dir) 253 { 254 struct snd_soc_codec *codec = codec_dai->codec; 255 struct ak4535_priv *ak4535 = snd_soc_codec_get_drvdata(codec); 256 257 ak4535->sysclk = freq; 258 return 0; 259 } 260 261 static int ak4535_hw_params(struct snd_pcm_substream *substream, 262 struct snd_pcm_hw_params *params, 263 struct snd_soc_dai *dai) 264 { 265 struct snd_soc_pcm_runtime *rtd = substream->private_data; 266 struct snd_soc_codec *codec = rtd->codec; 267 struct ak4535_priv *ak4535 = snd_soc_codec_get_drvdata(codec); 268 u8 mode2 = snd_soc_read(codec, AK4535_MODE2) & ~(0x3 << 5); 269 int rate = params_rate(params), fs = 256; 270 271 if (rate) 272 fs = ak4535->sysclk / rate; 273 274 /* set fs */ 275 switch (fs) { 276 case 1024: 277 mode2 |= (0x2 << 5); 278 break; 279 case 512: 280 mode2 |= (0x1 << 5); 281 break; 282 case 256: 283 break; 284 } 285 286 /* set rate */ 287 snd_soc_write(codec, AK4535_MODE2, mode2); 288 return 0; 289 } 290 291 static int ak4535_set_dai_fmt(struct snd_soc_dai *codec_dai, 292 unsigned int fmt) 293 { 294 struct snd_soc_codec *codec = codec_dai->codec; 295 u8 mode1 = 0; 296 297 /* interface format */ 298 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 299 case SND_SOC_DAIFMT_I2S: 300 mode1 = 0x0002; 301 break; 302 case SND_SOC_DAIFMT_LEFT_J: 303 mode1 = 0x0001; 304 break; 305 default: 306 return -EINVAL; 307 } 308 309 /* use 32 fs for BCLK to save power */ 310 mode1 |= 0x4; 311 312 snd_soc_write(codec, AK4535_MODE1, mode1); 313 return 0; 314 } 315 316 static int ak4535_mute(struct snd_soc_dai *dai, int mute) 317 { 318 struct snd_soc_codec *codec = dai->codec; 319 u16 mute_reg = snd_soc_read(codec, AK4535_DAC); 320 if (!mute) 321 snd_soc_write(codec, AK4535_DAC, mute_reg & ~0x20); 322 else 323 snd_soc_write(codec, AK4535_DAC, mute_reg | 0x20); 324 return 0; 325 } 326 327 static int ak4535_set_bias_level(struct snd_soc_codec *codec, 328 enum snd_soc_bias_level level) 329 { 330 switch (level) { 331 case SND_SOC_BIAS_ON: 332 snd_soc_update_bits(codec, AK4535_DAC, 0x20, 0); 333 break; 334 case SND_SOC_BIAS_PREPARE: 335 snd_soc_update_bits(codec, AK4535_DAC, 0x20, 0x20); 336 break; 337 case SND_SOC_BIAS_STANDBY: 338 snd_soc_update_bits(codec, AK4535_PM1, 0x80, 0x80); 339 snd_soc_update_bits(codec, AK4535_PM2, 0x80, 0); 340 break; 341 case SND_SOC_BIAS_OFF: 342 snd_soc_update_bits(codec, AK4535_PM1, 0x80, 0); 343 break; 344 } 345 codec->dapm.bias_level = level; 346 return 0; 347 } 348 349 #define AK4535_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\ 350 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\ 351 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000) 352 353 static const struct snd_soc_dai_ops ak4535_dai_ops = { 354 .hw_params = ak4535_hw_params, 355 .set_fmt = ak4535_set_dai_fmt, 356 .digital_mute = ak4535_mute, 357 .set_sysclk = ak4535_set_dai_sysclk, 358 }; 359 360 static struct snd_soc_dai_driver ak4535_dai = { 361 .name = "ak4535-hifi", 362 .playback = { 363 .stream_name = "Playback", 364 .channels_min = 1, 365 .channels_max = 2, 366 .rates = AK4535_RATES, 367 .formats = SNDRV_PCM_FMTBIT_S16_LE,}, 368 .capture = { 369 .stream_name = "Capture", 370 .channels_min = 1, 371 .channels_max = 2, 372 .rates = AK4535_RATES, 373 .formats = SNDRV_PCM_FMTBIT_S16_LE,}, 374 .ops = &ak4535_dai_ops, 375 }; 376 377 static int ak4535_suspend(struct snd_soc_codec *codec) 378 { 379 ak4535_set_bias_level(codec, SND_SOC_BIAS_OFF); 380 return 0; 381 } 382 383 static int ak4535_resume(struct snd_soc_codec *codec) 384 { 385 snd_soc_cache_sync(codec); 386 ak4535_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 387 return 0; 388 } 389 390 static int ak4535_probe(struct snd_soc_codec *codec) 391 { 392 struct ak4535_priv *ak4535 = snd_soc_codec_get_drvdata(codec); 393 int ret; 394 395 codec->control_data = ak4535->regmap; 396 ret = snd_soc_codec_set_cache_io(codec, 8, 8, SND_SOC_REGMAP); 397 if (ret < 0) { 398 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); 399 return ret; 400 } 401 /* power on device */ 402 ak4535_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 403 404 snd_soc_add_codec_controls(codec, ak4535_snd_controls, 405 ARRAY_SIZE(ak4535_snd_controls)); 406 return 0; 407 } 408 409 /* power down chip */ 410 static int ak4535_remove(struct snd_soc_codec *codec) 411 { 412 ak4535_set_bias_level(codec, SND_SOC_BIAS_OFF); 413 return 0; 414 } 415 416 static const struct regmap_config ak4535_regmap = { 417 .reg_bits = 8, 418 .val_bits = 8, 419 420 .max_register = AK4535_STATUS, 421 .volatile_reg = ak4535_volatile, 422 423 .cache_type = REGCACHE_RBTREE, 424 .reg_defaults = ak4535_reg_defaults, 425 .num_reg_defaults = ARRAY_SIZE(ak4535_reg_defaults), 426 }; 427 428 static struct snd_soc_codec_driver soc_codec_dev_ak4535 = { 429 .probe = ak4535_probe, 430 .remove = ak4535_remove, 431 .suspend = ak4535_suspend, 432 .resume = ak4535_resume, 433 .set_bias_level = ak4535_set_bias_level, 434 .dapm_widgets = ak4535_dapm_widgets, 435 .num_dapm_widgets = ARRAY_SIZE(ak4535_dapm_widgets), 436 .dapm_routes = ak4535_audio_map, 437 .num_dapm_routes = ARRAY_SIZE(ak4535_audio_map), 438 }; 439 440 static __devinit int ak4535_i2c_probe(struct i2c_client *i2c, 441 const struct i2c_device_id *id) 442 { 443 struct ak4535_priv *ak4535; 444 int ret; 445 446 ak4535 = devm_kzalloc(&i2c->dev, sizeof(struct ak4535_priv), 447 GFP_KERNEL); 448 if (ak4535 == NULL) 449 return -ENOMEM; 450 451 ak4535->regmap = regmap_init_i2c(i2c, &ak4535_regmap); 452 if (IS_ERR(ak4535->regmap)) { 453 ret = PTR_ERR(ak4535->regmap); 454 dev_err(&i2c->dev, "Failed to init regmap: %d\n", ret); 455 return ret; 456 } 457 458 i2c_set_clientdata(i2c, ak4535); 459 460 ret = snd_soc_register_codec(&i2c->dev, 461 &soc_codec_dev_ak4535, &ak4535_dai, 1); 462 if (ret != 0) 463 regmap_exit(ak4535->regmap); 464 465 return ret; 466 } 467 468 static __devexit int ak4535_i2c_remove(struct i2c_client *client) 469 { 470 struct ak4535_priv *ak4535 = i2c_get_clientdata(client); 471 472 snd_soc_unregister_codec(&client->dev); 473 regmap_exit(ak4535->regmap); 474 return 0; 475 } 476 477 static const struct i2c_device_id ak4535_i2c_id[] = { 478 { "ak4535", 0 }, 479 { } 480 }; 481 MODULE_DEVICE_TABLE(i2c, ak4535_i2c_id); 482 483 static struct i2c_driver ak4535_i2c_driver = { 484 .driver = { 485 .name = "ak4535", 486 .owner = THIS_MODULE, 487 }, 488 .probe = ak4535_i2c_probe, 489 .remove = __devexit_p(ak4535_i2c_remove), 490 .id_table = ak4535_i2c_id, 491 }; 492 493 module_i2c_driver(ak4535_i2c_driver); 494 495 MODULE_DESCRIPTION("Soc AK4535 driver"); 496 MODULE_AUTHOR("Richard Purdie"); 497 MODULE_LICENSE("GPL"); 498