1 /* 2 * alc5632.c -- ALC5632 ALSA SoC Audio Codec 3 * 4 * Copyright (C) 2011 The AC100 Kernel Team <ac100@lists.lauchpad.net> 5 * 6 * Authors: Leon Romanovsky <leon@leon.nu> 7 * Andrey Danin <danindrey@mail.ru> 8 * Ilya Petrov <ilya.muromec@gmail.com> 9 * Marc Dietrich <marvin24@gmx.de> 10 * 11 * Based on alc5623.c by Arnaud Patard 12 * 13 * This program is free software; you can redistribute it and/or modify 14 * it under the terms of the GNU General Public License version 2 as 15 * published by the Free Software Foundation. 16 */ 17 18 #include <linux/module.h> 19 #include <linux/kernel.h> 20 #include <linux/init.h> 21 #include <linux/delay.h> 22 #include <linux/pm.h> 23 #include <linux/i2c.h> 24 #include <linux/slab.h> 25 #include <linux/regmap.h> 26 #include <sound/core.h> 27 #include <sound/pcm.h> 28 #include <sound/pcm_params.h> 29 #include <sound/tlv.h> 30 #include <sound/soc.h> 31 #include <sound/initval.h> 32 33 #include "alc5632.h" 34 35 /* 36 * ALC5632 register cache 37 */ 38 static struct reg_default alc5632_reg_defaults[] = { 39 { 0, 0x59B4 }, 40 { 1, 0x0000 }, 41 { 2, 0x8080 }, 42 { 3, 0x0000 }, 43 { 4, 0x8080 }, 44 { 5, 0x0000 }, 45 { 6, 0x8080 }, 46 { 7, 0x0000 }, 47 { 8, 0xC800 }, 48 { 9, 0x0000 }, 49 { 10, 0xE808 }, 50 { 11, 0x0000 }, 51 { 12, 0x1010 }, 52 { 13, 0x0000 }, 53 { 14, 0x0808 }, 54 { 15, 0x0000 }, 55 { 16, 0xEE0F }, 56 { 17, 0x0000 }, 57 { 18, 0xCBCB }, 58 { 19, 0x0000 }, 59 { 20, 0x7F7F }, 60 { 21, 0x0000 }, 61 { 22, 0x0000 }, 62 { 23, 0x0000 }, 63 { 24, 0xE010 }, 64 { 25, 0x0000 }, 65 { 26, 0x0000 }, 66 { 27, 0x0000 }, 67 { 28, 0x8008 }, 68 { 29, 0x0000 }, 69 { 30, 0x0000 }, 70 { 31, 0x0000 }, 71 { 32, 0x0000 }, 72 { 33, 0x0000 }, 73 { 34, 0x0000 }, 74 { 35, 0x0000 }, 75 { 36, 0x00C0 }, 76 { 37, 0x0000 }, 77 { 38, 0xEF00 }, 78 { 39, 0x0000 }, 79 { 40, 0x0000 }, 80 { 41, 0x0000 }, 81 { 42, 0x0000 }, 82 { 43, 0x0000 }, 83 { 44, 0x0000 }, 84 { 45, 0x0000 }, 85 { 46, 0x0000 }, 86 { 47, 0x0000 }, 87 { 48, 0x0000 }, 88 { 49, 0x0000 }, 89 { 50, 0x0000 }, 90 { 51, 0x0000 }, 91 { 52, 0x8000 }, 92 { 53, 0x0000 }, 93 { 54, 0x0000 }, 94 { 55, 0x0000 }, 95 { 56, 0x0000 }, 96 { 57, 0x0000 }, 97 { 58, 0x0000 }, 98 { 59, 0x0000 }, 99 { 60, 0x0000 }, 100 { 61, 0x0000 }, 101 { 62, 0x8000 }, 102 { 63, 0x0000 }, 103 { 64, 0x0C0A }, 104 { 65, 0x0000 }, 105 { 66, 0x0000 }, 106 { 67, 0x0000 }, 107 { 68, 0x0000 }, 108 { 69, 0x0000 }, 109 { 70, 0x0000 }, 110 { 71, 0x0000 }, 111 { 72, 0x0000 }, 112 { 73, 0x0000 }, 113 { 74, 0x0000 }, 114 { 75, 0x0000 }, 115 { 76, 0xBE3E }, 116 { 77, 0x0000 }, 117 { 78, 0xBE3E }, 118 { 79, 0x0000 }, 119 { 80, 0x0000 }, 120 { 81, 0x0000 }, 121 { 82, 0x0000 }, 122 { 83, 0x0000 }, 123 { 84, 0x803A }, 124 { 85, 0x0000 }, 125 { 86, 0x0000 }, 126 { 87, 0x0000 }, 127 { 88, 0x0000 }, 128 { 89, 0x0000 }, 129 { 90, 0x0009 }, 130 { 91, 0x0000 }, 131 { 92, 0x0000 }, 132 { 93, 0x0000 }, 133 { 94, 0x3000 }, 134 { 95, 0x0000 }, 135 { 96, 0x3075 }, 136 { 97, 0x0000 }, 137 { 98, 0x1010 }, 138 { 99, 0x0000 }, 139 { 100, 0x3110 }, 140 { 101, 0x0000 }, 141 { 102, 0x0000 }, 142 { 103, 0x0000 }, 143 { 104, 0x0553 }, 144 { 105, 0x0000 }, 145 { 106, 0x0000 }, 146 { 107, 0x0000 }, 147 { 108, 0x0000 }, 148 { 109, 0x0000 }, 149 { 110, 0x0000 }, 150 { 111, 0x0000 }, 151 }; 152 153 /* codec private data */ 154 struct alc5632_priv { 155 struct regmap *regmap; 156 u8 id; 157 unsigned int sysclk; 158 }; 159 160 static bool alc5632_volatile_register(struct device *dev, 161 unsigned int reg) 162 { 163 switch (reg) { 164 case ALC5632_RESET: 165 case ALC5632_PWR_DOWN_CTRL_STATUS: 166 case ALC5632_GPIO_PIN_STATUS: 167 case ALC5632_OVER_CURR_STATUS: 168 case ALC5632_HID_CTRL_DATA: 169 case ALC5632_EQ_CTRL: 170 return true; 171 172 default: 173 break; 174 } 175 176 return false; 177 } 178 179 static inline int alc5632_reset(struct regmap *map) 180 { 181 return regmap_write(map, ALC5632_RESET, 0x59B4); 182 } 183 184 static int amp_mixer_event(struct snd_soc_dapm_widget *w, 185 struct snd_kcontrol *kcontrol, int event) 186 { 187 /* to power-on/off class-d amp generators/speaker */ 188 /* need to write to 'index-46h' register : */ 189 /* so write index num (here 0x46) to reg 0x6a */ 190 /* and then 0xffff/0 to reg 0x6c */ 191 snd_soc_write(w->codec, ALC5632_HID_CTRL_INDEX, 0x46); 192 193 switch (event) { 194 case SND_SOC_DAPM_PRE_PMU: 195 snd_soc_write(w->codec, ALC5632_HID_CTRL_DATA, 0xFFFF); 196 break; 197 case SND_SOC_DAPM_POST_PMD: 198 snd_soc_write(w->codec, ALC5632_HID_CTRL_DATA, 0); 199 break; 200 } 201 202 return 0; 203 } 204 205 /* 206 * ALC5632 Controls 207 */ 208 209 /* -34.5db min scale, 1.5db steps, no mute */ 210 static const DECLARE_TLV_DB_SCALE(vol_tlv, -3450, 150, 0); 211 /* -46.5db min scale, 1.5db steps, no mute */ 212 static const DECLARE_TLV_DB_SCALE(hp_tlv, -4650, 150, 0); 213 /* -16.5db min scale, 1.5db steps, no mute */ 214 static const DECLARE_TLV_DB_SCALE(adc_rec_tlv, -1650, 150, 0); 215 static const unsigned int boost_tlv[] = { 216 TLV_DB_RANGE_HEAD(3), 217 0, 0, TLV_DB_SCALE_ITEM(0, 0, 0), 218 1, 1, TLV_DB_SCALE_ITEM(2000, 0, 0), 219 2, 2, TLV_DB_SCALE_ITEM(3000, 0, 0), 220 }; 221 /* 0db min scale, 6 db steps, no mute */ 222 static const DECLARE_TLV_DB_SCALE(dig_tlv, 0, 600, 0); 223 /* 0db min scalem 0.75db steps, no mute */ 224 static const DECLARE_TLV_DB_SCALE(vdac_tlv, -3525, 075, 0); 225 226 static const struct snd_kcontrol_new alc5632_vol_snd_controls[] = { 227 /* left starts at bit 8, right at bit 0 */ 228 /* 31 steps (5 bit), -46.5db scale */ 229 SOC_DOUBLE_TLV("Line Playback Volume", 230 ALC5632_SPK_OUT_VOL, 8, 0, 31, 1, hp_tlv), 231 /* bit 15 mutes left, bit 7 right */ 232 SOC_DOUBLE("Line Playback Switch", 233 ALC5632_SPK_OUT_VOL, 15, 7, 1, 1), 234 SOC_DOUBLE_TLV("Headphone Playback Volume", 235 ALC5632_HP_OUT_VOL, 8, 0, 31, 1, hp_tlv), 236 SOC_DOUBLE("Headphone Playback Switch", 237 ALC5632_HP_OUT_VOL, 15, 7, 1, 1), 238 }; 239 240 static const struct snd_kcontrol_new alc5632_snd_controls[] = { 241 SOC_DOUBLE_TLV("Auxout Playback Volume", 242 ALC5632_AUX_OUT_VOL, 8, 0, 31, 1, hp_tlv), 243 SOC_DOUBLE("Auxout Playback Switch", 244 ALC5632_AUX_OUT_VOL, 15, 7, 1, 1), 245 SOC_SINGLE_TLV("Voice DAC Playback Volume", 246 ALC5632_VOICE_DAC_VOL, 0, 63, 0, vdac_tlv), 247 SOC_SINGLE_TLV("Phone Capture Volume", 248 ALC5632_PHONE_IN_VOL, 8, 31, 1, vol_tlv), 249 SOC_DOUBLE_TLV("LineIn Capture Volume", 250 ALC5632_LINE_IN_VOL, 8, 0, 31, 1, vol_tlv), 251 SOC_DOUBLE_TLV("Stereo DAC Playback Volume", 252 ALC5632_STEREO_DAC_IN_VOL, 8, 0, 63, 1, vdac_tlv), 253 SOC_DOUBLE("Stereo DAC Playback Switch", 254 ALC5632_STEREO_DAC_IN_VOL, 15, 7, 1, 1), 255 SOC_SINGLE_TLV("Mic1 Capture Volume", 256 ALC5632_MIC_VOL, 8, 31, 1, vol_tlv), 257 SOC_SINGLE_TLV("Mic2 Capture Volume", 258 ALC5632_MIC_VOL, 0, 31, 1, vol_tlv), 259 SOC_DOUBLE_TLV("Rec Capture Volume", 260 ALC5632_ADC_REC_GAIN, 8, 0, 31, 0, adc_rec_tlv), 261 SOC_SINGLE_TLV("Mic 1 Boost Volume", 262 ALC5632_MIC_CTRL, 10, 2, 0, boost_tlv), 263 SOC_SINGLE_TLV("Mic 2 Boost Volume", 264 ALC5632_MIC_CTRL, 8, 2, 0, boost_tlv), 265 SOC_SINGLE_TLV("Digital Boost Volume", 266 ALC5632_DIGI_BOOST_CTRL, 0, 7, 0, dig_tlv), 267 }; 268 269 /* 270 * DAPM Controls 271 */ 272 static const struct snd_kcontrol_new alc5632_hp_mixer_controls[] = { 273 SOC_DAPM_SINGLE("LI2HP Playback Switch", ALC5632_LINE_IN_VOL, 15, 1, 1), 274 SOC_DAPM_SINGLE("PHONE2HP Playback Switch", ALC5632_PHONE_IN_VOL, 15, 1, 1), 275 SOC_DAPM_SINGLE("MIC12HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 15, 1, 1), 276 SOC_DAPM_SINGLE("MIC22HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 11, 1, 1), 277 SOC_DAPM_SINGLE("VOICE2HP Playback Switch", ALC5632_VOICE_DAC_VOL, 15, 1, 1), 278 }; 279 280 static const struct snd_kcontrol_new alc5632_hpl_mixer_controls[] = { 281 SOC_DAPM_SINGLE("ADC2HP_L Playback Switch", ALC5632_ADC_REC_GAIN, 15, 1, 1), 282 SOC_DAPM_SINGLE("DACL2HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 3, 1, 1), 283 }; 284 285 static const struct snd_kcontrol_new alc5632_hpr_mixer_controls[] = { 286 SOC_DAPM_SINGLE("ADC2HP_R Playback Switch", ALC5632_ADC_REC_GAIN, 7, 1, 1), 287 SOC_DAPM_SINGLE("DACR2HP Playback Switch", ALC5632_MIC_ROUTING_CTRL, 2, 1, 1), 288 }; 289 290 static const struct snd_kcontrol_new alc5632_mono_mixer_controls[] = { 291 SOC_DAPM_SINGLE("ADC2MONO_L Playback Switch", ALC5632_ADC_REC_GAIN, 14, 1, 1), 292 SOC_DAPM_SINGLE("ADC2MONO_R Playback Switch", ALC5632_ADC_REC_GAIN, 6, 1, 1), 293 SOC_DAPM_SINGLE("LI2MONO Playback Switch", ALC5632_LINE_IN_VOL, 13, 1, 1), 294 SOC_DAPM_SINGLE("MIC12MONO Playback Switch", 295 ALC5632_MIC_ROUTING_CTRL, 13, 1, 1), 296 SOC_DAPM_SINGLE("MIC22MONO Playback Switch", 297 ALC5632_MIC_ROUTING_CTRL, 9, 1, 1), 298 SOC_DAPM_SINGLE("DAC2MONO Playback Switch", ALC5632_MIC_ROUTING_CTRL, 0, 1, 1), 299 SOC_DAPM_SINGLE("VOICE2MONO Playback Switch", ALC5632_VOICE_DAC_VOL, 13, 1, 1), 300 }; 301 302 static const struct snd_kcontrol_new alc5632_speaker_mixer_controls[] = { 303 SOC_DAPM_SINGLE("LI2SPK Playback Switch", ALC5632_LINE_IN_VOL, 14, 1, 1), 304 SOC_DAPM_SINGLE("PHONE2SPK Playback Switch", ALC5632_PHONE_IN_VOL, 14, 1, 1), 305 SOC_DAPM_SINGLE("MIC12SPK Playback Switch", 306 ALC5632_MIC_ROUTING_CTRL, 14, 1, 1), 307 SOC_DAPM_SINGLE("MIC22SPK Playback Switch", 308 ALC5632_MIC_ROUTING_CTRL, 10, 1, 1), 309 SOC_DAPM_SINGLE("DAC2SPK Playback Switch", ALC5632_MIC_ROUTING_CTRL, 1, 1, 1), 310 SOC_DAPM_SINGLE("VOICE2SPK Playback Switch", ALC5632_VOICE_DAC_VOL, 14, 1, 1), 311 }; 312 313 /* Left Record Mixer */ 314 static const struct snd_kcontrol_new alc5632_captureL_mixer_controls[] = { 315 SOC_DAPM_SINGLE("Mic1 Capture Switch", ALC5632_ADC_REC_MIXER, 14, 1, 1), 316 SOC_DAPM_SINGLE("Mic2 Capture Switch", ALC5632_ADC_REC_MIXER, 13, 1, 1), 317 SOC_DAPM_SINGLE("LineInL Capture Switch", ALC5632_ADC_REC_MIXER, 12, 1, 1), 318 SOC_DAPM_SINGLE("Left Phone Capture Switch", ALC5632_ADC_REC_MIXER, 11, 1, 1), 319 SOC_DAPM_SINGLE("HPMixerL Capture Switch", ALC5632_ADC_REC_MIXER, 10, 1, 1), 320 SOC_DAPM_SINGLE("SPKMixer Capture Switch", ALC5632_ADC_REC_MIXER, 9, 1, 1), 321 SOC_DAPM_SINGLE("MonoMixer Capture Switch", ALC5632_ADC_REC_MIXER, 8, 1, 1), 322 }; 323 324 /* Right Record Mixer */ 325 static const struct snd_kcontrol_new alc5632_captureR_mixer_controls[] = { 326 SOC_DAPM_SINGLE("Mic1 Capture Switch", ALC5632_ADC_REC_MIXER, 6, 1, 1), 327 SOC_DAPM_SINGLE("Mic2 Capture Switch", ALC5632_ADC_REC_MIXER, 5, 1, 1), 328 SOC_DAPM_SINGLE("LineInR Capture Switch", ALC5632_ADC_REC_MIXER, 4, 1, 1), 329 SOC_DAPM_SINGLE("Right Phone Capture Switch", ALC5632_ADC_REC_MIXER, 3, 1, 1), 330 SOC_DAPM_SINGLE("HPMixerR Capture Switch", ALC5632_ADC_REC_MIXER, 2, 1, 1), 331 SOC_DAPM_SINGLE("SPKMixer Capture Switch", ALC5632_ADC_REC_MIXER, 1, 1, 1), 332 SOC_DAPM_SINGLE("MonoMixer Capture Switch", ALC5632_ADC_REC_MIXER, 0, 1, 1), 333 }; 334 335 static const char *alc5632_spk_n_sour_sel[] = { 336 "RN/-R", "RP/+R", "LN/-R", "Mute"}; 337 static const char *alc5632_hpl_out_input_sel[] = { 338 "Vmid", "HP Left Mix"}; 339 static const char *alc5632_hpr_out_input_sel[] = { 340 "Vmid", "HP Right Mix"}; 341 static const char *alc5632_spkout_input_sel[] = { 342 "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"}; 343 static const char *alc5632_aux_out_input_sel[] = { 344 "Vmid", "HPOut Mix", "Speaker Mix", "Mono Mix"}; 345 346 /* auxout output mux */ 347 static const struct soc_enum alc5632_aux_out_input_enum = 348 SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 6, 4, alc5632_aux_out_input_sel); 349 static const struct snd_kcontrol_new alc5632_auxout_mux_controls = 350 SOC_DAPM_ENUM("AuxOut Mux", alc5632_aux_out_input_enum); 351 352 /* speaker output mux */ 353 static const struct soc_enum alc5632_spkout_input_enum = 354 SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 10, 4, alc5632_spkout_input_sel); 355 static const struct snd_kcontrol_new alc5632_spkout_mux_controls = 356 SOC_DAPM_ENUM("SpeakerOut Mux", alc5632_spkout_input_enum); 357 358 /* headphone left output mux */ 359 static const struct soc_enum alc5632_hpl_out_input_enum = 360 SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 9, 2, alc5632_hpl_out_input_sel); 361 static const struct snd_kcontrol_new alc5632_hpl_out_mux_controls = 362 SOC_DAPM_ENUM("Left Headphone Mux", alc5632_hpl_out_input_enum); 363 364 /* headphone right output mux */ 365 static const struct soc_enum alc5632_hpr_out_input_enum = 366 SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 8, 2, alc5632_hpr_out_input_sel); 367 static const struct snd_kcontrol_new alc5632_hpr_out_mux_controls = 368 SOC_DAPM_ENUM("Right Headphone Mux", alc5632_hpr_out_input_enum); 369 370 /* speaker output N select */ 371 static const struct soc_enum alc5632_spk_n_sour_enum = 372 SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 14, 4, alc5632_spk_n_sour_sel); 373 static const struct snd_kcontrol_new alc5632_spkoutn_mux_controls = 374 SOC_DAPM_ENUM("SpeakerOut N Mux", alc5632_spk_n_sour_enum); 375 376 /* speaker amplifier */ 377 static const char *alc5632_amp_names[] = {"AB Amp", "D Amp"}; 378 static const struct soc_enum alc5632_amp_enum = 379 SOC_ENUM_SINGLE(ALC5632_OUTPUT_MIXER_CTRL, 13, 2, alc5632_amp_names); 380 static const struct snd_kcontrol_new alc5632_amp_mux_controls = 381 SOC_DAPM_ENUM("AB-D Amp Mux", alc5632_amp_enum); 382 383 384 static const struct snd_soc_dapm_widget alc5632_dapm_widgets[] = { 385 /* Muxes */ 386 SND_SOC_DAPM_MUX("AuxOut Mux", SND_SOC_NOPM, 0, 0, 387 &alc5632_auxout_mux_controls), 388 SND_SOC_DAPM_MUX("SpeakerOut Mux", SND_SOC_NOPM, 0, 0, 389 &alc5632_spkout_mux_controls), 390 SND_SOC_DAPM_MUX("Left Headphone Mux", SND_SOC_NOPM, 0, 0, 391 &alc5632_hpl_out_mux_controls), 392 SND_SOC_DAPM_MUX("Right Headphone Mux", SND_SOC_NOPM, 0, 0, 393 &alc5632_hpr_out_mux_controls), 394 SND_SOC_DAPM_MUX("SpeakerOut N Mux", SND_SOC_NOPM, 0, 0, 395 &alc5632_spkoutn_mux_controls), 396 397 /* output mixers */ 398 SND_SOC_DAPM_MIXER("HP Mix", SND_SOC_NOPM, 0, 0, 399 &alc5632_hp_mixer_controls[0], 400 ARRAY_SIZE(alc5632_hp_mixer_controls)), 401 SND_SOC_DAPM_MIXER("HPR Mix", ALC5632_PWR_MANAG_ADD2, 4, 0, 402 &alc5632_hpr_mixer_controls[0], 403 ARRAY_SIZE(alc5632_hpr_mixer_controls)), 404 SND_SOC_DAPM_MIXER("HPL Mix", ALC5632_PWR_MANAG_ADD2, 5, 0, 405 &alc5632_hpl_mixer_controls[0], 406 ARRAY_SIZE(alc5632_hpl_mixer_controls)), 407 SND_SOC_DAPM_MIXER("HPOut Mix", SND_SOC_NOPM, 0, 0, NULL, 0), 408 SND_SOC_DAPM_MIXER("Mono Mix", ALC5632_PWR_MANAG_ADD2, 2, 0, 409 &alc5632_mono_mixer_controls[0], 410 ARRAY_SIZE(alc5632_mono_mixer_controls)), 411 SND_SOC_DAPM_MIXER("Speaker Mix", ALC5632_PWR_MANAG_ADD2, 3, 0, 412 &alc5632_speaker_mixer_controls[0], 413 ARRAY_SIZE(alc5632_speaker_mixer_controls)), 414 415 /* input mixers */ 416 SND_SOC_DAPM_MIXER("Left Capture Mix", ALC5632_PWR_MANAG_ADD2, 1, 0, 417 &alc5632_captureL_mixer_controls[0], 418 ARRAY_SIZE(alc5632_captureL_mixer_controls)), 419 SND_SOC_DAPM_MIXER("Right Capture Mix", ALC5632_PWR_MANAG_ADD2, 0, 0, 420 &alc5632_captureR_mixer_controls[0], 421 ARRAY_SIZE(alc5632_captureR_mixer_controls)), 422 423 SND_SOC_DAPM_DAC("Left DAC", "HiFi Playback", 424 ALC5632_PWR_MANAG_ADD2, 9, 0), 425 SND_SOC_DAPM_DAC("Right DAC", "HiFi Playback", 426 ALC5632_PWR_MANAG_ADD2, 8, 0), 427 SND_SOC_DAPM_MIXER("DAC Left Channel", ALC5632_PWR_MANAG_ADD1, 15, 0, NULL, 0), 428 SND_SOC_DAPM_MIXER("DAC Right Channel", 429 ALC5632_PWR_MANAG_ADD1, 14, 0, NULL, 0), 430 SND_SOC_DAPM_MIXER("I2S Mix", ALC5632_PWR_MANAG_ADD1, 11, 0, NULL, 0), 431 SND_SOC_DAPM_MIXER("Phone Mix", SND_SOC_NOPM, 0, 0, NULL, 0), 432 SND_SOC_DAPM_MIXER("Line Mix", SND_SOC_NOPM, 0, 0, NULL, 0), 433 SND_SOC_DAPM_ADC("Left ADC", "HiFi Capture", 434 ALC5632_PWR_MANAG_ADD2, 7, 0), 435 SND_SOC_DAPM_ADC("Right ADC", "HiFi Capture", 436 ALC5632_PWR_MANAG_ADD2, 6, 0), 437 SND_SOC_DAPM_PGA("Left Headphone", ALC5632_PWR_MANAG_ADD3, 11, 0, NULL, 0), 438 SND_SOC_DAPM_PGA("Right Headphone", ALC5632_PWR_MANAG_ADD3, 10, 0, NULL, 0), 439 SND_SOC_DAPM_PGA("Left Speaker", ALC5632_PWR_MANAG_ADD3, 13, 0, NULL, 0), 440 SND_SOC_DAPM_PGA("Right Speaker", ALC5632_PWR_MANAG_ADD3, 12, 0, NULL, 0), 441 SND_SOC_DAPM_PGA("Aux Out", ALC5632_PWR_MANAG_ADD3, 14, 0, NULL, 0), 442 SND_SOC_DAPM_PGA("Left LineIn", ALC5632_PWR_MANAG_ADD3, 7, 0, NULL, 0), 443 SND_SOC_DAPM_PGA("Right LineIn", ALC5632_PWR_MANAG_ADD3, 6, 0, NULL, 0), 444 SND_SOC_DAPM_PGA("Phone", ALC5632_PWR_MANAG_ADD3, 5, 0, NULL, 0), 445 SND_SOC_DAPM_PGA("Phone ADMix", ALC5632_PWR_MANAG_ADD3, 4, 0, NULL, 0), 446 SND_SOC_DAPM_PGA("MIC1 PGA", ALC5632_PWR_MANAG_ADD3, 3, 0, NULL, 0), 447 SND_SOC_DAPM_PGA("MIC2 PGA", ALC5632_PWR_MANAG_ADD3, 2, 0, NULL, 0), 448 SND_SOC_DAPM_PGA("MIC1 Pre Amp", ALC5632_PWR_MANAG_ADD3, 1, 0, NULL, 0), 449 SND_SOC_DAPM_PGA("MIC2 Pre Amp", ALC5632_PWR_MANAG_ADD3, 0, 0, NULL, 0), 450 SND_SOC_DAPM_SUPPLY("Mic Bias1", ALC5632_PWR_MANAG_ADD1, 3, 0, NULL, 0), 451 SND_SOC_DAPM_SUPPLY("Mic Bias2", ALC5632_PWR_MANAG_ADD1, 2, 0, NULL, 0), 452 453 SND_SOC_DAPM_PGA_E("D Amp", ALC5632_PWR_MANAG_ADD2, 14, 0, NULL, 0, 454 amp_mixer_event, SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD), 455 SND_SOC_DAPM_PGA("AB Amp", ALC5632_PWR_MANAG_ADD2, 15, 0, NULL, 0), 456 SND_SOC_DAPM_MUX("AB-D Amp Mux", ALC5632_PWR_MANAG_ADD1, 10, 0, 457 &alc5632_amp_mux_controls), 458 459 SND_SOC_DAPM_OUTPUT("AUXOUT"), 460 SND_SOC_DAPM_OUTPUT("HPL"), 461 SND_SOC_DAPM_OUTPUT("HPR"), 462 SND_SOC_DAPM_OUTPUT("SPKOUT"), 463 SND_SOC_DAPM_OUTPUT("SPKOUTN"), 464 SND_SOC_DAPM_INPUT("LINEINL"), 465 SND_SOC_DAPM_INPUT("LINEINR"), 466 SND_SOC_DAPM_INPUT("PHONEP"), 467 SND_SOC_DAPM_INPUT("PHONEN"), 468 SND_SOC_DAPM_INPUT("MIC1"), 469 SND_SOC_DAPM_INPUT("MIC2"), 470 SND_SOC_DAPM_VMID("Vmid"), 471 }; 472 473 474 static const struct snd_soc_dapm_route alc5632_dapm_routes[] = { 475 /* virtual mixer - mixes left & right channels */ 476 {"I2S Mix", NULL, "Left DAC"}, 477 {"I2S Mix", NULL, "Right DAC"}, 478 {"Line Mix", NULL, "Right LineIn"}, 479 {"Line Mix", NULL, "Left LineIn"}, 480 {"Phone Mix", NULL, "Phone"}, 481 {"Phone Mix", NULL, "Phone ADMix"}, 482 {"AUXOUT", NULL, "Aux Out"}, 483 484 /* DAC */ 485 {"DAC Right Channel", NULL, "I2S Mix"}, 486 {"DAC Left Channel", NULL, "I2S Mix"}, 487 488 /* HP mixer */ 489 {"HPL Mix", "ADC2HP_L Playback Switch", "Left Capture Mix"}, 490 {"HPL Mix", NULL, "HP Mix"}, 491 {"HPR Mix", "ADC2HP_R Playback Switch", "Right Capture Mix"}, 492 {"HPR Mix", NULL, "HP Mix"}, 493 {"HP Mix", "LI2HP Playback Switch", "Line Mix"}, 494 {"HP Mix", "PHONE2HP Playback Switch", "Phone Mix"}, 495 {"HP Mix", "MIC12HP Playback Switch", "MIC1 PGA"}, 496 {"HP Mix", "MIC22HP Playback Switch", "MIC2 PGA"}, 497 498 {"HPR Mix", "DACR2HP Playback Switch", "DAC Right Channel"}, 499 {"HPL Mix", "DACL2HP Playback Switch", "DAC Left Channel"}, 500 501 /* speaker mixer */ 502 {"Speaker Mix", "LI2SPK Playback Switch", "Line Mix"}, 503 {"Speaker Mix", "PHONE2SPK Playback Switch", "Phone Mix"}, 504 {"Speaker Mix", "MIC12SPK Playback Switch", "MIC1 PGA"}, 505 {"Speaker Mix", "MIC22SPK Playback Switch", "MIC2 PGA"}, 506 {"Speaker Mix", "DAC2SPK Playback Switch", "DAC Left Channel"}, 507 508 509 510 /* mono mixer */ 511 {"Mono Mix", "ADC2MONO_L Playback Switch", "Left Capture Mix"}, 512 {"Mono Mix", "ADC2MONO_R Playback Switch", "Right Capture Mix"}, 513 {"Mono Mix", "LI2MONO Playback Switch", "Line Mix"}, 514 {"Mono Mix", "VOICE2MONO Playback Switch", "Phone Mix"}, 515 {"Mono Mix", "MIC12MONO Playback Switch", "MIC1 PGA"}, 516 {"Mono Mix", "MIC22MONO Playback Switch", "MIC2 PGA"}, 517 {"Mono Mix", "DAC2MONO Playback Switch", "DAC Left Channel"}, 518 519 /* Left record mixer */ 520 {"Left Capture Mix", "LineInL Capture Switch", "LINEINL"}, 521 {"Left Capture Mix", "Left Phone Capture Switch", "PHONEN"}, 522 {"Left Capture Mix", "Mic1 Capture Switch", "MIC1 Pre Amp"}, 523 {"Left Capture Mix", "Mic2 Capture Switch", "MIC2 Pre Amp"}, 524 {"Left Capture Mix", "HPMixerL Capture Switch", "HPL Mix"}, 525 {"Left Capture Mix", "SPKMixer Capture Switch", "Speaker Mix"}, 526 {"Left Capture Mix", "MonoMixer Capture Switch", "Mono Mix"}, 527 528 /*Right record mixer */ 529 {"Right Capture Mix", "LineInR Capture Switch", "LINEINR"}, 530 {"Right Capture Mix", "Right Phone Capture Switch", "PHONEP"}, 531 {"Right Capture Mix", "Mic1 Capture Switch", "MIC1 Pre Amp"}, 532 {"Right Capture Mix", "Mic2 Capture Switch", "MIC2 Pre Amp"}, 533 {"Right Capture Mix", "HPMixerR Capture Switch", "HPR Mix"}, 534 {"Right Capture Mix", "SPKMixer Capture Switch", "Speaker Mix"}, 535 {"Right Capture Mix", "MonoMixer Capture Switch", "Mono Mix"}, 536 537 /* headphone left mux */ 538 {"Left Headphone Mux", "HP Left Mix", "HPL Mix"}, 539 {"Left Headphone Mux", "Vmid", "Vmid"}, 540 541 /* headphone right mux */ 542 {"Right Headphone Mux", "HP Right Mix", "HPR Mix"}, 543 {"Right Headphone Mux", "Vmid", "Vmid"}, 544 545 /* speaker out mux */ 546 {"SpeakerOut Mux", "Vmid", "Vmid"}, 547 {"SpeakerOut Mux", "HPOut Mix", "HPOut Mix"}, 548 {"SpeakerOut Mux", "Speaker Mix", "Speaker Mix"}, 549 {"SpeakerOut Mux", "Mono Mix", "Mono Mix"}, 550 551 /* Mono/Aux Out mux */ 552 {"AuxOut Mux", "Vmid", "Vmid"}, 553 {"AuxOut Mux", "HPOut Mix", "HPOut Mix"}, 554 {"AuxOut Mux", "Speaker Mix", "Speaker Mix"}, 555 {"AuxOut Mux", "Mono Mix", "Mono Mix"}, 556 557 /* output pga */ 558 {"HPL", NULL, "Left Headphone"}, 559 {"Left Headphone", NULL, "Left Headphone Mux"}, 560 {"HPR", NULL, "Right Headphone"}, 561 {"Right Headphone", NULL, "Right Headphone Mux"}, 562 {"Aux Out", NULL, "AuxOut Mux"}, 563 564 /* input pga */ 565 {"Left LineIn", NULL, "LINEINL"}, 566 {"Right LineIn", NULL, "LINEINR"}, 567 {"Phone", NULL, "PHONEP"}, 568 {"MIC1 Pre Amp", NULL, "MIC1"}, 569 {"MIC2 Pre Amp", NULL, "MIC2"}, 570 {"MIC1 PGA", NULL, "MIC1 Pre Amp"}, 571 {"MIC2 PGA", NULL, "MIC2 Pre Amp"}, 572 573 /* left ADC */ 574 {"Left ADC", NULL, "Left Capture Mix"}, 575 576 /* right ADC */ 577 {"Right ADC", NULL, "Right Capture Mix"}, 578 579 {"SpeakerOut N Mux", "RN/-R", "Left Speaker"}, 580 {"SpeakerOut N Mux", "RP/+R", "Left Speaker"}, 581 {"SpeakerOut N Mux", "LN/-R", "Left Speaker"}, 582 {"SpeakerOut N Mux", "Mute", "Vmid"}, 583 584 {"SpeakerOut N Mux", "RN/-R", "Right Speaker"}, 585 {"SpeakerOut N Mux", "RP/+R", "Right Speaker"}, 586 {"SpeakerOut N Mux", "LN/-R", "Right Speaker"}, 587 {"SpeakerOut N Mux", "Mute", "Vmid"}, 588 589 {"AB Amp", NULL, "SpeakerOut Mux"}, 590 {"D Amp", NULL, "SpeakerOut Mux"}, 591 {"AB-D Amp Mux", "AB Amp", "AB Amp"}, 592 {"AB-D Amp Mux", "D Amp", "D Amp"}, 593 {"Left Speaker", NULL, "AB-D Amp Mux"}, 594 {"Right Speaker", NULL, "AB-D Amp Mux"}, 595 596 {"SPKOUT", NULL, "Left Speaker"}, 597 {"SPKOUT", NULL, "Right Speaker"}, 598 599 {"SPKOUTN", NULL, "SpeakerOut N Mux"}, 600 601 }; 602 603 /* PLL divisors */ 604 struct _pll_div { 605 u32 pll_in; 606 u32 pll_out; 607 u16 regvalue; 608 }; 609 610 /* Note : pll code from original alc5632 driver. Not sure of how good it is */ 611 /* usefull only for master mode */ 612 static const struct _pll_div codec_master_pll_div[] = { 613 614 { 2048000, 8192000, 0x0ea0}, 615 { 3686400, 8192000, 0x4e27}, 616 { 12000000, 8192000, 0x456b}, 617 { 13000000, 8192000, 0x495f}, 618 { 13100000, 8192000, 0x0320}, 619 { 2048000, 11289600, 0xf637}, 620 { 3686400, 11289600, 0x2f22}, 621 { 12000000, 11289600, 0x3e2f}, 622 { 13000000, 11289600, 0x4d5b}, 623 { 13100000, 11289600, 0x363b}, 624 { 2048000, 16384000, 0x1ea0}, 625 { 3686400, 16384000, 0x9e27}, 626 { 12000000, 16384000, 0x452b}, 627 { 13000000, 16384000, 0x542f}, 628 { 13100000, 16384000, 0x03a0}, 629 { 2048000, 16934400, 0xe625}, 630 { 3686400, 16934400, 0x9126}, 631 { 12000000, 16934400, 0x4d2c}, 632 { 13000000, 16934400, 0x742f}, 633 { 13100000, 16934400, 0x3c27}, 634 { 2048000, 22579200, 0x2aa0}, 635 { 3686400, 22579200, 0x2f20}, 636 { 12000000, 22579200, 0x7e2f}, 637 { 13000000, 22579200, 0x742f}, 638 { 13100000, 22579200, 0x3c27}, 639 { 2048000, 24576000, 0x2ea0}, 640 { 3686400, 24576000, 0xee27}, 641 { 12000000, 24576000, 0x2915}, 642 { 13000000, 24576000, 0x772e}, 643 { 13100000, 24576000, 0x0d20}, 644 }; 645 646 /* FOUT = MCLK*(N+2)/((M+2)*(K+2)) 647 N: bit 15:8 (div 2 .. div 257) 648 K: bit 6:4 typical 2 649 M: bit 3:0 (div 2 .. div 17) 650 651 same as for 5623 - thanks! 652 */ 653 654 static const struct _pll_div codec_slave_pll_div[] = { 655 656 { 1024000, 16384000, 0x3ea0}, 657 { 1411200, 22579200, 0x3ea0}, 658 { 1536000, 24576000, 0x3ea0}, 659 { 2048000, 16384000, 0x1ea0}, 660 { 2822400, 22579200, 0x1ea0}, 661 { 3072000, 24576000, 0x1ea0}, 662 663 }; 664 665 static int alc5632_set_dai_pll(struct snd_soc_dai *codec_dai, int pll_id, 666 int source, unsigned int freq_in, unsigned int freq_out) 667 { 668 int i; 669 struct snd_soc_codec *codec = codec_dai->codec; 670 int gbl_clk = 0, pll_div = 0; 671 u16 reg; 672 673 if (pll_id < ALC5632_PLL_FR_MCLK || pll_id > ALC5632_PLL_FR_VBCLK) 674 return -EINVAL; 675 676 /* Disable PLL power */ 677 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2, 678 ALC5632_PWR_ADD2_PLL1, 679 0); 680 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2, 681 ALC5632_PWR_ADD2_PLL2, 682 0); 683 684 /* pll is not used in slave mode */ 685 reg = snd_soc_read(codec, ALC5632_DAI_CONTROL); 686 if (reg & ALC5632_DAI_SDP_SLAVE_MODE) 687 return 0; 688 689 if (!freq_in || !freq_out) 690 return 0; 691 692 switch (pll_id) { 693 case ALC5632_PLL_FR_MCLK: 694 for (i = 0; i < ARRAY_SIZE(codec_master_pll_div); i++) { 695 if (codec_master_pll_div[i].pll_in == freq_in 696 && codec_master_pll_div[i].pll_out == freq_out) { 697 /* PLL source from MCLK */ 698 pll_div = codec_master_pll_div[i].regvalue; 699 break; 700 } 701 } 702 break; 703 case ALC5632_PLL_FR_BCLK: 704 for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) { 705 if (codec_slave_pll_div[i].pll_in == freq_in 706 && codec_slave_pll_div[i].pll_out == freq_out) { 707 /* PLL source from Bitclk */ 708 gbl_clk = ALC5632_PLL_FR_BCLK; 709 pll_div = codec_slave_pll_div[i].regvalue; 710 break; 711 } 712 } 713 break; 714 case ALC5632_PLL_FR_VBCLK: 715 for (i = 0; i < ARRAY_SIZE(codec_slave_pll_div); i++) { 716 if (codec_slave_pll_div[i].pll_in == freq_in 717 && codec_slave_pll_div[i].pll_out == freq_out) { 718 /* PLL source from voice clock */ 719 gbl_clk = ALC5632_PLL_FR_VBCLK; 720 pll_div = codec_slave_pll_div[i].regvalue; 721 break; 722 } 723 } 724 break; 725 default: 726 return -EINVAL; 727 } 728 729 if (!pll_div) 730 return -EINVAL; 731 732 /* choose MCLK/BCLK/VBCLK */ 733 snd_soc_write(codec, ALC5632_GPCR2, gbl_clk); 734 /* choose PLL1 clock rate */ 735 snd_soc_write(codec, ALC5632_PLL1_CTRL, pll_div); 736 /* enable PLL1 */ 737 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2, 738 ALC5632_PWR_ADD2_PLL1, 739 ALC5632_PWR_ADD2_PLL1); 740 /* enable PLL2 */ 741 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2, 742 ALC5632_PWR_ADD2_PLL2, 743 ALC5632_PWR_ADD2_PLL2); 744 /* use PLL1 as main SYSCLK */ 745 snd_soc_update_bits(codec, ALC5632_GPCR1, 746 ALC5632_GPCR1_CLK_SYS_SRC_SEL_PLL1, 747 ALC5632_GPCR1_CLK_SYS_SRC_SEL_PLL1); 748 749 return 0; 750 } 751 752 struct _coeff_div { 753 u16 fs; 754 u16 regvalue; 755 }; 756 757 /* codec hifi mclk (after PLL) clock divider coefficients */ 758 /* values inspired from column BCLK=32Fs of Appendix A table */ 759 static const struct _coeff_div coeff_div[] = { 760 {512*1, 0x3075}, 761 }; 762 763 static int get_coeff(struct snd_soc_codec *codec, int rate) 764 { 765 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec); 766 int i; 767 768 for (i = 0; i < ARRAY_SIZE(coeff_div); i++) { 769 if (coeff_div[i].fs * rate == alc5632->sysclk) 770 return i; 771 } 772 return -EINVAL; 773 } 774 775 /* 776 * Clock after PLL and dividers 777 */ 778 static int alc5632_set_dai_sysclk(struct snd_soc_dai *codec_dai, 779 int clk_id, unsigned int freq, int dir) 780 { 781 struct snd_soc_codec *codec = codec_dai->codec; 782 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec); 783 784 switch (freq) { 785 case 8192000: 786 case 11289600: 787 case 12288000: 788 case 16384000: 789 case 16934400: 790 case 18432000: 791 case 22579200: 792 case 24576000: 793 alc5632->sysclk = freq; 794 return 0; 795 } 796 return -EINVAL; 797 } 798 799 static int alc5632_set_dai_fmt(struct snd_soc_dai *codec_dai, 800 unsigned int fmt) 801 { 802 struct snd_soc_codec *codec = codec_dai->codec; 803 u16 iface = 0; 804 805 /* set master/slave audio interface */ 806 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 807 case SND_SOC_DAIFMT_CBM_CFM: 808 iface = ALC5632_DAI_SDP_MASTER_MODE; 809 break; 810 case SND_SOC_DAIFMT_CBS_CFS: 811 iface = ALC5632_DAI_SDP_SLAVE_MODE; 812 break; 813 default: 814 return -EINVAL; 815 } 816 817 /* interface format */ 818 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 819 case SND_SOC_DAIFMT_I2S: 820 iface |= ALC5632_DAI_I2S_DF_I2S; 821 break; 822 case SND_SOC_DAIFMT_LEFT_J: 823 iface |= ALC5632_DAI_I2S_DF_LEFT; 824 break; 825 case SND_SOC_DAIFMT_DSP_A: 826 iface |= ALC5632_DAI_I2S_DF_PCM_A; 827 break; 828 case SND_SOC_DAIFMT_DSP_B: 829 iface |= ALC5632_DAI_I2S_DF_PCM_B; 830 break; 831 default: 832 return -EINVAL; 833 } 834 835 /* clock inversion */ 836 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 837 case SND_SOC_DAIFMT_NB_NF: 838 break; 839 case SND_SOC_DAIFMT_IB_IF: 840 iface |= ALC5632_DAI_MAIN_I2S_BCLK_POL_CTRL; 841 break; 842 case SND_SOC_DAIFMT_IB_NF: 843 iface |= ALC5632_DAI_MAIN_I2S_BCLK_POL_CTRL; 844 break; 845 case SND_SOC_DAIFMT_NB_IF: 846 break; 847 default: 848 return -EINVAL; 849 } 850 851 return snd_soc_write(codec, ALC5632_DAI_CONTROL, iface); 852 } 853 854 static int alc5632_pcm_hw_params(struct snd_pcm_substream *substream, 855 struct snd_pcm_hw_params *params, struct snd_soc_dai *dai) 856 { 857 struct snd_soc_pcm_runtime *rtd = substream->private_data; 858 struct snd_soc_codec *codec = rtd->codec; 859 int coeff, rate; 860 u16 iface; 861 862 iface = snd_soc_read(codec, ALC5632_DAI_CONTROL); 863 iface &= ~ALC5632_DAI_I2S_DL_MASK; 864 865 /* bit size */ 866 switch (params_format(params)) { 867 case SNDRV_PCM_FORMAT_S16_LE: 868 iface |= ALC5632_DAI_I2S_DL_16; 869 break; 870 case SNDRV_PCM_FORMAT_S20_3LE: 871 iface |= ALC5632_DAI_I2S_DL_20; 872 break; 873 case SNDRV_PCM_FORMAT_S24_LE: 874 iface |= ALC5632_DAI_I2S_DL_24; 875 break; 876 default: 877 return -EINVAL; 878 } 879 880 /* set iface & srate */ 881 snd_soc_write(codec, ALC5632_DAI_CONTROL, iface); 882 rate = params_rate(params); 883 coeff = get_coeff(codec, rate); 884 if (coeff < 0) 885 return -EINVAL; 886 887 coeff = coeff_div[coeff].regvalue; 888 snd_soc_write(codec, ALC5632_DAC_CLK_CTRL1, coeff); 889 890 return 0; 891 } 892 893 static int alc5632_mute(struct snd_soc_dai *dai, int mute) 894 { 895 struct snd_soc_codec *codec = dai->codec; 896 u16 hp_mute = ALC5632_MISC_HP_DEPOP_MUTE_L 897 |ALC5632_MISC_HP_DEPOP_MUTE_R; 898 u16 mute_reg = snd_soc_read(codec, ALC5632_MISC_CTRL) & ~hp_mute; 899 900 if (mute) 901 mute_reg |= hp_mute; 902 903 return snd_soc_write(codec, ALC5632_MISC_CTRL, mute_reg); 904 } 905 906 #define ALC5632_ADD2_POWER_EN (ALC5632_PWR_ADD2_VREF) 907 908 #define ALC5632_ADD3_POWER_EN (ALC5632_PWR_ADD3_MIC1_BOOST_AD) 909 910 #define ALC5632_ADD1_POWER_EN \ 911 (ALC5632_PWR_ADD1_DAC_REF \ 912 | ALC5632_PWR_ADD1_SOFTGEN_EN \ 913 | ALC5632_PWR_ADD1_HP_OUT_AMP \ 914 | ALC5632_PWR_ADD1_HP_OUT_ENH_AMP \ 915 | ALC5632_PWR_ADD1_MAIN_BIAS) 916 917 static void enable_power_depop(struct snd_soc_codec *codec) 918 { 919 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1, 920 ALC5632_PWR_ADD1_SOFTGEN_EN, 921 ALC5632_PWR_ADD1_SOFTGEN_EN); 922 923 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD3, 924 ALC5632_ADD3_POWER_EN, 925 ALC5632_ADD3_POWER_EN); 926 927 snd_soc_update_bits(codec, ALC5632_MISC_CTRL, 928 ALC5632_MISC_HP_DEPOP_MODE2_EN, 929 ALC5632_MISC_HP_DEPOP_MODE2_EN); 930 931 /* "normal" mode: 0 @ 26 */ 932 /* set all PR0-7 mixers to 0 */ 933 snd_soc_update_bits(codec, ALC5632_PWR_DOWN_CTRL_STATUS, 934 ALC5632_PWR_DOWN_CTRL_STATUS_MASK, 935 0); 936 937 msleep(500); 938 939 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2, 940 ALC5632_ADD2_POWER_EN, 941 ALC5632_ADD2_POWER_EN); 942 943 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1, 944 ALC5632_ADD1_POWER_EN, 945 ALC5632_ADD1_POWER_EN); 946 947 /* disable HP Depop2 */ 948 snd_soc_update_bits(codec, ALC5632_MISC_CTRL, 949 ALC5632_MISC_HP_DEPOP_MODE2_EN, 950 0); 951 952 } 953 954 static int alc5632_set_bias_level(struct snd_soc_codec *codec, 955 enum snd_soc_bias_level level) 956 { 957 switch (level) { 958 case SND_SOC_BIAS_ON: 959 enable_power_depop(codec); 960 break; 961 case SND_SOC_BIAS_PREPARE: 962 break; 963 case SND_SOC_BIAS_STANDBY: 964 /* everything off except vref/vmid, */ 965 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1, 966 ALC5632_PWR_MANAG_ADD1_MASK, 967 ALC5632_PWR_ADD1_MAIN_BIAS); 968 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2, 969 ALC5632_PWR_MANAG_ADD2_MASK, 970 ALC5632_PWR_ADD2_VREF); 971 /* "normal" mode: 0 @ 26 */ 972 snd_soc_update_bits(codec, ALC5632_PWR_DOWN_CTRL_STATUS, 973 ALC5632_PWR_DOWN_CTRL_STATUS_MASK, 974 0xffff ^ (ALC5632_PWR_VREF_PR3 975 | ALC5632_PWR_VREF_PR2)); 976 break; 977 case SND_SOC_BIAS_OFF: 978 /* everything off, dac mute, inactive */ 979 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD2, 980 ALC5632_PWR_MANAG_ADD2_MASK, 0); 981 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD3, 982 ALC5632_PWR_MANAG_ADD3_MASK, 0); 983 snd_soc_update_bits(codec, ALC5632_PWR_MANAG_ADD1, 984 ALC5632_PWR_MANAG_ADD1_MASK, 0); 985 break; 986 } 987 codec->dapm.bias_level = level; 988 return 0; 989 } 990 991 #define ALC5632_FORMATS (SNDRV_PCM_FMTBIT_S16_LE \ 992 | SNDRV_PCM_FMTBIT_S24_LE \ 993 | SNDRV_PCM_FMTBIT_S32_LE) 994 995 static struct snd_soc_dai_ops alc5632_dai_ops = { 996 .hw_params = alc5632_pcm_hw_params, 997 .digital_mute = alc5632_mute, 998 .set_fmt = alc5632_set_dai_fmt, 999 .set_sysclk = alc5632_set_dai_sysclk, 1000 .set_pll = alc5632_set_dai_pll, 1001 }; 1002 1003 static struct snd_soc_dai_driver alc5632_dai = { 1004 .name = "alc5632-hifi", 1005 .playback = { 1006 .stream_name = "HiFi Playback", 1007 .channels_min = 1, 1008 .channels_max = 2, 1009 .rate_min = 8000, 1010 .rate_max = 48000, 1011 .rates = SNDRV_PCM_RATE_8000_48000, 1012 .formats = ALC5632_FORMATS,}, 1013 .capture = { 1014 .stream_name = "HiFi Capture", 1015 .channels_min = 1, 1016 .channels_max = 2, 1017 .rate_min = 8000, 1018 .rate_max = 48000, 1019 .rates = SNDRV_PCM_RATE_8000_48000, 1020 .formats = ALC5632_FORMATS,}, 1021 1022 .ops = &alc5632_dai_ops, 1023 .symmetric_rates = 1, 1024 }; 1025 1026 #ifdef CONFIG_PM 1027 static int alc5632_suspend(struct snd_soc_codec *codec, pm_message_t mesg) 1028 { 1029 alc5632_set_bias_level(codec, SND_SOC_BIAS_OFF); 1030 return 0; 1031 } 1032 1033 static int alc5632_resume(struct snd_soc_codec *codec) 1034 { 1035 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec); 1036 1037 regcache_sync(alc5632->regmap); 1038 1039 alc5632_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 1040 return 0; 1041 } 1042 #else 1043 #define alc5632_suspend NULL 1044 #define alc5632_resume NULL 1045 #endif 1046 1047 static int alc5632_probe(struct snd_soc_codec *codec) 1048 { 1049 struct alc5632_priv *alc5632 = snd_soc_codec_get_drvdata(codec); 1050 int ret; 1051 1052 codec->control_data = alc5632->regmap; 1053 1054 ret = snd_soc_codec_set_cache_io(codec, 8, 16, SND_SOC_REGMAP); 1055 if (ret != 0) { 1056 dev_err(codec->dev, "Failed to set cache I/O: %d\n", ret); 1057 return ret; 1058 } 1059 1060 /* power on device */ 1061 alc5632_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 1062 1063 switch (alc5632->id) { 1064 case 0x5c: 1065 snd_soc_add_controls(codec, alc5632_vol_snd_controls, 1066 ARRAY_SIZE(alc5632_vol_snd_controls)); 1067 break; 1068 default: 1069 return -EINVAL; 1070 } 1071 1072 return ret; 1073 } 1074 1075 /* power down chip */ 1076 static int alc5632_remove(struct snd_soc_codec *codec) 1077 { 1078 alc5632_set_bias_level(codec, SND_SOC_BIAS_OFF); 1079 return 0; 1080 } 1081 1082 static struct snd_soc_codec_driver soc_codec_device_alc5632 = { 1083 .probe = alc5632_probe, 1084 .remove = alc5632_remove, 1085 .suspend = alc5632_suspend, 1086 .resume = alc5632_resume, 1087 .set_bias_level = alc5632_set_bias_level, 1088 .controls = alc5632_snd_controls, 1089 .num_controls = ARRAY_SIZE(alc5632_snd_controls), 1090 .dapm_widgets = alc5632_dapm_widgets, 1091 .num_dapm_widgets = ARRAY_SIZE(alc5632_dapm_widgets), 1092 .dapm_routes = alc5632_dapm_routes, 1093 .num_dapm_routes = ARRAY_SIZE(alc5632_dapm_routes), 1094 }; 1095 1096 static struct regmap_config alc5632_regmap = { 1097 .reg_bits = 8, 1098 .val_bits = 16, 1099 1100 .max_register = ALC5632_MAX_REGISTER, 1101 .reg_defaults = alc5632_reg_defaults, 1102 .num_reg_defaults = ARRAY_SIZE(alc5632_reg_defaults), 1103 .volatile_reg = alc5632_volatile_register, 1104 .cache_type = REGCACHE_RBTREE, 1105 }; 1106 1107 /* 1108 * alc5632 2 wire address is determined by A1 pin 1109 * state during powerup. 1110 * low = 0x1a 1111 * high = 0x1b 1112 */ 1113 static __devinit int alc5632_i2c_probe(struct i2c_client *client, 1114 const struct i2c_device_id *id) 1115 { 1116 struct alc5632_priv *alc5632; 1117 int ret, vid1, vid2; 1118 1119 vid1 = i2c_smbus_read_word_data(client, ALC5632_VENDOR_ID1); 1120 if (vid1 < 0) { 1121 dev_err(&client->dev, "failed to read I2C\n"); 1122 return -EIO; 1123 } else { 1124 dev_info(&client->dev, "got vid1: %x\n", vid1); 1125 } 1126 vid1 = ((vid1 & 0xff) << 8) | (vid1 >> 8); 1127 1128 vid2 = i2c_smbus_read_word_data(client, ALC5632_VENDOR_ID2); 1129 if (vid2 < 0) { 1130 dev_err(&client->dev, "failed to read I2C\n"); 1131 return -EIO; 1132 } else { 1133 dev_info(&client->dev, "got vid2: %x\n", vid2); 1134 } 1135 vid2 = (vid2 & 0xff); 1136 1137 if ((vid1 != 0x10ec) || (vid2 != id->driver_data)) { 1138 dev_err(&client->dev, "unknown or wrong codec\n"); 1139 dev_err(&client->dev, "Expected %x:%lx, got %x:%x\n", 1140 0x10ec, id->driver_data, 1141 vid1, vid2); 1142 return -ENODEV; 1143 } 1144 1145 alc5632 = devm_kzalloc(&client->dev, 1146 sizeof(struct alc5632_priv), GFP_KERNEL); 1147 if (alc5632 == NULL) 1148 return -ENOMEM; 1149 1150 alc5632->id = vid2; 1151 switch (alc5632->id) { 1152 case 0x5c: 1153 alc5632_dai.name = "alc5632-hifi"; 1154 break; 1155 default: 1156 return -EINVAL; 1157 } 1158 1159 i2c_set_clientdata(client, alc5632); 1160 1161 alc5632->regmap = regmap_init_i2c(client, &alc5632_regmap); 1162 if (IS_ERR(alc5632->regmap)) { 1163 ret = PTR_ERR(alc5632->regmap); 1164 dev_err(&client->dev, "regmap_init() failed: %d\n", ret); 1165 return ret; 1166 } 1167 1168 ret = alc5632_reset(alc5632->regmap); 1169 if (ret < 0) { 1170 dev_err(&client->dev, "Failed to issue reset\n"); 1171 regmap_exit(alc5632->regmap); 1172 return ret; 1173 } 1174 1175 ret = snd_soc_register_codec(&client->dev, 1176 &soc_codec_device_alc5632, &alc5632_dai, 1); 1177 1178 if (ret < 0) { 1179 dev_err(&client->dev, "Failed to register codec: %d\n", ret); 1180 regmap_exit(alc5632->regmap); 1181 return ret; 1182 } 1183 1184 return ret; 1185 } 1186 1187 static int alc5632_i2c_remove(struct i2c_client *client) 1188 { 1189 struct alc5632_priv *alc5632 = i2c_get_clientdata(client); 1190 snd_soc_unregister_codec(&client->dev); 1191 regmap_exit(alc5632->regmap); 1192 return 0; 1193 } 1194 1195 static const struct i2c_device_id alc5632_i2c_table[] = { 1196 {"alc5632", 0x5c}, 1197 {} 1198 }; 1199 MODULE_DEVICE_TABLE(i2c, alc5632_i2c_table); 1200 1201 /* i2c codec control layer */ 1202 static struct i2c_driver alc5632_i2c_driver = { 1203 .driver = { 1204 .name = "alc5632", 1205 .owner = THIS_MODULE, 1206 }, 1207 .probe = alc5632_i2c_probe, 1208 .remove = __devexit_p(alc5632_i2c_remove), 1209 .id_table = alc5632_i2c_table, 1210 }; 1211 1212 static int __init alc5632_modinit(void) 1213 { 1214 int ret; 1215 1216 ret = i2c_add_driver(&alc5632_i2c_driver); 1217 if (ret != 0) { 1218 printk(KERN_ERR "%s: can't add i2c driver", __func__); 1219 return ret; 1220 } 1221 1222 return ret; 1223 } 1224 module_init(alc5632_modinit); 1225 1226 static void __exit alc5632_modexit(void) 1227 { 1228 i2c_del_driver(&alc5632_i2c_driver); 1229 } 1230 module_exit(alc5632_modexit); 1231 1232 MODULE_DESCRIPTION("ASoC ALC5632 driver"); 1233 MODULE_AUTHOR("Leon Romanovsky <leon@leon.nu>"); 1234 MODULE_LICENSE("GPL"); 1235