1 /* 2 * wm8900.c -- WM8900 ALSA Soc Audio driver 3 * 4 * Copyright 2007, 2008 Wolfson Microelectronics PLC. 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License version 2 as 10 * published by the Free Software Foundation. 11 * 12 * TODO: 13 * - Tristating. 14 * - TDM. 15 * - Jack detect. 16 * - FLL source configuration, currently only MCLK is supported. 17 */ 18 19 #include <linux/module.h> 20 #include <linux/moduleparam.h> 21 #include <linux/kernel.h> 22 #include <linux/init.h> 23 #include <linux/delay.h> 24 #include <linux/pm.h> 25 #include <linux/i2c.h> 26 #include <linux/platform_device.h> 27 #include <sound/core.h> 28 #include <sound/pcm.h> 29 #include <sound/pcm_params.h> 30 #include <sound/soc.h> 31 #include <sound/soc-dapm.h> 32 #include <sound/initval.h> 33 #include <sound/tlv.h> 34 35 #include "wm8900.h" 36 37 /* WM8900 register space */ 38 #define WM8900_REG_RESET 0x0 39 #define WM8900_REG_ID 0x0 40 #define WM8900_REG_POWER1 0x1 41 #define WM8900_REG_POWER2 0x2 42 #define WM8900_REG_POWER3 0x3 43 #define WM8900_REG_AUDIO1 0x4 44 #define WM8900_REG_AUDIO2 0x5 45 #define WM8900_REG_CLOCKING1 0x6 46 #define WM8900_REG_CLOCKING2 0x7 47 #define WM8900_REG_AUDIO3 0x8 48 #define WM8900_REG_AUDIO4 0x9 49 #define WM8900_REG_DACCTRL 0xa 50 #define WM8900_REG_LDAC_DV 0xb 51 #define WM8900_REG_RDAC_DV 0xc 52 #define WM8900_REG_SIDETONE 0xd 53 #define WM8900_REG_ADCCTRL 0xe 54 #define WM8900_REG_LADC_DV 0xf 55 #define WM8900_REG_RADC_DV 0x10 56 #define WM8900_REG_GPIO 0x12 57 #define WM8900_REG_INCTL 0x15 58 #define WM8900_REG_LINVOL 0x16 59 #define WM8900_REG_RINVOL 0x17 60 #define WM8900_REG_INBOOSTMIX1 0x18 61 #define WM8900_REG_INBOOSTMIX2 0x19 62 #define WM8900_REG_ADCPATH 0x1a 63 #define WM8900_REG_AUXBOOST 0x1b 64 #define WM8900_REG_ADDCTL 0x1e 65 #define WM8900_REG_FLLCTL1 0x24 66 #define WM8900_REG_FLLCTL2 0x25 67 #define WM8900_REG_FLLCTL3 0x26 68 #define WM8900_REG_FLLCTL4 0x27 69 #define WM8900_REG_FLLCTL5 0x28 70 #define WM8900_REG_FLLCTL6 0x29 71 #define WM8900_REG_LOUTMIXCTL1 0x2c 72 #define WM8900_REG_ROUTMIXCTL1 0x2d 73 #define WM8900_REG_BYPASS1 0x2e 74 #define WM8900_REG_BYPASS2 0x2f 75 #define WM8900_REG_AUXOUT_CTL 0x30 76 #define WM8900_REG_LOUT1CTL 0x33 77 #define WM8900_REG_ROUT1CTL 0x34 78 #define WM8900_REG_LOUT2CTL 0x35 79 #define WM8900_REG_ROUT2CTL 0x36 80 #define WM8900_REG_HPCTL1 0x3a 81 #define WM8900_REG_OUTBIASCTL 0x73 82 83 #define WM8900_MAXREG 0x80 84 85 #define WM8900_REG_ADDCTL_OUT1_DIS 0x80 86 #define WM8900_REG_ADDCTL_OUT2_DIS 0x40 87 #define WM8900_REG_ADDCTL_VMID_DIS 0x20 88 #define WM8900_REG_ADDCTL_BIAS_SRC 0x10 89 #define WM8900_REG_ADDCTL_VMID_SOFTST 0x04 90 #define WM8900_REG_ADDCTL_TEMP_SD 0x02 91 92 #define WM8900_REG_GPIO_TEMP_ENA 0x2 93 94 #define WM8900_REG_POWER1_STARTUP_BIAS_ENA 0x0100 95 #define WM8900_REG_POWER1_BIAS_ENA 0x0008 96 #define WM8900_REG_POWER1_VMID_BUF_ENA 0x0004 97 #define WM8900_REG_POWER1_FLL_ENA 0x0040 98 99 #define WM8900_REG_POWER2_SYSCLK_ENA 0x8000 100 #define WM8900_REG_POWER2_ADCL_ENA 0x0002 101 #define WM8900_REG_POWER2_ADCR_ENA 0x0001 102 103 #define WM8900_REG_POWER3_DACL_ENA 0x0002 104 #define WM8900_REG_POWER3_DACR_ENA 0x0001 105 106 #define WM8900_REG_AUDIO1_AIF_FMT_MASK 0x0018 107 #define WM8900_REG_AUDIO1_LRCLK_INV 0x0080 108 #define WM8900_REG_AUDIO1_BCLK_INV 0x0100 109 110 #define WM8900_REG_CLOCKING1_BCLK_DIR 0x1 111 #define WM8900_REG_CLOCKING1_MCLK_SRC 0x100 112 #define WM8900_REG_CLOCKING1_BCLK_MASK (~0x01e) 113 #define WM8900_REG_CLOCKING1_OPCLK_MASK (~0x7000) 114 115 #define WM8900_REG_CLOCKING2_ADC_CLKDIV 0xe0 116 #define WM8900_REG_CLOCKING2_DAC_CLKDIV 0x1c 117 118 #define WM8900_REG_DACCTRL_MUTE 0x004 119 #define WM8900_REG_DACCTRL_AIF_LRCLKRATE 0x400 120 121 #define WM8900_REG_AUDIO3_ADCLRC_DIR 0x0800 122 123 #define WM8900_REG_AUDIO4_DACLRC_DIR 0x0800 124 125 #define WM8900_REG_FLLCTL1_OSC_ENA 0x100 126 127 #define WM8900_REG_FLLCTL6_FLL_SLOW_LOCK_REF 0x100 128 129 #define WM8900_REG_HPCTL1_HP_IPSTAGE_ENA 0x80 130 #define WM8900_REG_HPCTL1_HP_OPSTAGE_ENA 0x40 131 #define WM8900_REG_HPCTL1_HP_CLAMP_IP 0x20 132 #define WM8900_REG_HPCTL1_HP_CLAMP_OP 0x10 133 #define WM8900_REG_HPCTL1_HP_SHORT 0x08 134 #define WM8900_REG_HPCTL1_HP_SHORT2 0x04 135 136 #define WM8900_LRC_MASK 0xfc00 137 138 struct snd_soc_codec_device soc_codec_dev_wm8900; 139 140 struct wm8900_priv { 141 struct snd_soc_codec codec; 142 143 u16 reg_cache[WM8900_MAXREG]; 144 145 u32 fll_in; /* FLL input frequency */ 146 u32 fll_out; /* FLL output frequency */ 147 }; 148 149 /* 150 * wm8900 register cache. We can't read the entire register space and we 151 * have slow control buses so we cache the registers. 152 */ 153 static const u16 wm8900_reg_defaults[WM8900_MAXREG] = { 154 0x8900, 0x0000, 155 0xc000, 0x0000, 156 0x4050, 0x4000, 157 0x0008, 0x0000, 158 0x0040, 0x0040, 159 0x1004, 0x00c0, 160 0x00c0, 0x0000, 161 0x0100, 0x00c0, 162 0x00c0, 0x0000, 163 0xb001, 0x0000, 164 0x0000, 0x0044, 165 0x004c, 0x004c, 166 0x0044, 0x0044, 167 0x0000, 0x0044, 168 0x0000, 0x0000, 169 0x0002, 0x0000, 170 0x0000, 0x0000, 171 0x0000, 0x0000, 172 0x0008, 0x0000, 173 0x0000, 0x0008, 174 0x0097, 0x0100, 175 0x0000, 0x0000, 176 0x0050, 0x0050, 177 0x0055, 0x0055, 178 0x0055, 0x0000, 179 0x0000, 0x0079, 180 0x0079, 0x0079, 181 0x0079, 0x0000, 182 /* Remaining registers all zero */ 183 }; 184 185 /* 186 * read wm8900 register cache 187 */ 188 static inline unsigned int wm8900_read_reg_cache(struct snd_soc_codec *codec, 189 unsigned int reg) 190 { 191 u16 *cache = codec->reg_cache; 192 193 BUG_ON(reg >= WM8900_MAXREG); 194 195 if (reg == WM8900_REG_ID) 196 return 0; 197 198 return cache[reg]; 199 } 200 201 /* 202 * write wm8900 register cache 203 */ 204 static inline void wm8900_write_reg_cache(struct snd_soc_codec *codec, 205 u16 reg, unsigned int value) 206 { 207 u16 *cache = codec->reg_cache; 208 209 BUG_ON(reg >= WM8900_MAXREG); 210 211 cache[reg] = value; 212 } 213 214 /* 215 * write to the WM8900 register space 216 */ 217 static int wm8900_write(struct snd_soc_codec *codec, unsigned int reg, 218 unsigned int value) 219 { 220 u8 data[3]; 221 222 if (value == wm8900_read_reg_cache(codec, reg)) 223 return 0; 224 225 /* data is 226 * D15..D9 WM8900 register offset 227 * D8...D0 register data 228 */ 229 data[0] = reg; 230 data[1] = value >> 8; 231 data[2] = value & 0x00ff; 232 233 wm8900_write_reg_cache(codec, reg, value); 234 if (codec->hw_write(codec->control_data, data, 3) == 3) 235 return 0; 236 else 237 return -EIO; 238 } 239 240 /* 241 * Read from the wm8900. 242 */ 243 static unsigned int wm8900_chip_read(struct snd_soc_codec *codec, u8 reg) 244 { 245 struct i2c_msg xfer[2]; 246 u16 data; 247 int ret; 248 struct i2c_client *client = codec->control_data; 249 250 BUG_ON(reg != WM8900_REG_ID && reg != WM8900_REG_POWER1); 251 252 /* Write register */ 253 xfer[0].addr = client->addr; 254 xfer[0].flags = 0; 255 xfer[0].len = 1; 256 xfer[0].buf = ® 257 258 /* Read data */ 259 xfer[1].addr = client->addr; 260 xfer[1].flags = I2C_M_RD; 261 xfer[1].len = 2; 262 xfer[1].buf = (u8 *)&data; 263 264 ret = i2c_transfer(client->adapter, xfer, 2); 265 if (ret != 2) { 266 printk(KERN_CRIT "i2c_transfer returned %d\n", ret); 267 return 0; 268 } 269 270 return (data >> 8) | ((data & 0xff) << 8); 271 } 272 273 /* 274 * Read from the WM8900 register space. Most registers can't be read 275 * and are therefore supplied from cache. 276 */ 277 static unsigned int wm8900_read(struct snd_soc_codec *codec, unsigned int reg) 278 { 279 switch (reg) { 280 case WM8900_REG_ID: 281 return wm8900_chip_read(codec, reg); 282 default: 283 return wm8900_read_reg_cache(codec, reg); 284 } 285 } 286 287 static void wm8900_reset(struct snd_soc_codec *codec) 288 { 289 wm8900_write(codec, WM8900_REG_RESET, 0); 290 291 memcpy(codec->reg_cache, wm8900_reg_defaults, 292 sizeof(codec->reg_cache)); 293 } 294 295 static int wm8900_hp_event(struct snd_soc_dapm_widget *w, 296 struct snd_kcontrol *kcontrol, int event) 297 { 298 struct snd_soc_codec *codec = w->codec; 299 u16 hpctl1 = wm8900_read(codec, WM8900_REG_HPCTL1); 300 301 switch (event) { 302 case SND_SOC_DAPM_PRE_PMU: 303 /* Clamp headphone outputs */ 304 hpctl1 = WM8900_REG_HPCTL1_HP_CLAMP_IP | 305 WM8900_REG_HPCTL1_HP_CLAMP_OP; 306 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 307 break; 308 309 case SND_SOC_DAPM_POST_PMU: 310 /* Enable the input stage */ 311 hpctl1 &= ~WM8900_REG_HPCTL1_HP_CLAMP_IP; 312 hpctl1 |= WM8900_REG_HPCTL1_HP_SHORT | 313 WM8900_REG_HPCTL1_HP_SHORT2 | 314 WM8900_REG_HPCTL1_HP_IPSTAGE_ENA; 315 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 316 317 msleep(400); 318 319 /* Enable the output stage */ 320 hpctl1 &= ~WM8900_REG_HPCTL1_HP_CLAMP_OP; 321 hpctl1 |= WM8900_REG_HPCTL1_HP_OPSTAGE_ENA; 322 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 323 324 /* Remove the shorts */ 325 hpctl1 &= ~WM8900_REG_HPCTL1_HP_SHORT2; 326 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 327 hpctl1 &= ~WM8900_REG_HPCTL1_HP_SHORT; 328 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 329 break; 330 331 case SND_SOC_DAPM_PRE_PMD: 332 /* Short the output */ 333 hpctl1 |= WM8900_REG_HPCTL1_HP_SHORT; 334 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 335 336 /* Disable the output stage */ 337 hpctl1 &= ~WM8900_REG_HPCTL1_HP_OPSTAGE_ENA; 338 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 339 340 /* Clamp the outputs and power down input */ 341 hpctl1 |= WM8900_REG_HPCTL1_HP_CLAMP_IP | 342 WM8900_REG_HPCTL1_HP_CLAMP_OP; 343 hpctl1 &= ~WM8900_REG_HPCTL1_HP_IPSTAGE_ENA; 344 wm8900_write(codec, WM8900_REG_HPCTL1, hpctl1); 345 break; 346 347 case SND_SOC_DAPM_POST_PMD: 348 /* Disable everything */ 349 wm8900_write(codec, WM8900_REG_HPCTL1, 0); 350 break; 351 352 default: 353 BUG(); 354 } 355 356 return 0; 357 } 358 359 static const DECLARE_TLV_DB_SCALE(out_pga_tlv, -5700, 100, 0); 360 361 static const DECLARE_TLV_DB_SCALE(out_mix_tlv, -1500, 300, 0); 362 363 static const DECLARE_TLV_DB_SCALE(in_boost_tlv, -1200, 600, 0); 364 365 static const DECLARE_TLV_DB_SCALE(in_pga_tlv, -1200, 100, 0); 366 367 static const DECLARE_TLV_DB_SCALE(dac_boost_tlv, 0, 600, 0); 368 369 static const DECLARE_TLV_DB_SCALE(dac_tlv, -7200, 75, 1); 370 371 static const DECLARE_TLV_DB_SCALE(adc_svol_tlv, -3600, 300, 0); 372 373 static const DECLARE_TLV_DB_SCALE(adc_tlv, -7200, 75, 1); 374 375 static const char *mic_bias_level_txt[] = { "0.9*AVDD", "0.65*AVDD" }; 376 377 static const struct soc_enum mic_bias_level = 378 SOC_ENUM_SINGLE(WM8900_REG_INCTL, 8, 2, mic_bias_level_txt); 379 380 static const char *dac_mute_rate_txt[] = { "Fast", "Slow" }; 381 382 static const struct soc_enum dac_mute_rate = 383 SOC_ENUM_SINGLE(WM8900_REG_DACCTRL, 7, 2, dac_mute_rate_txt); 384 385 static const char *dac_deemphasis_txt[] = { 386 "Disabled", "32kHz", "44.1kHz", "48kHz" 387 }; 388 389 static const struct soc_enum dac_deemphasis = 390 SOC_ENUM_SINGLE(WM8900_REG_DACCTRL, 4, 4, dac_deemphasis_txt); 391 392 static const char *adc_hpf_cut_txt[] = { 393 "Hi-fi mode", "Voice mode 1", "Voice mode 2", "Voice mode 3" 394 }; 395 396 static const struct soc_enum adc_hpf_cut = 397 SOC_ENUM_SINGLE(WM8900_REG_ADCCTRL, 5, 4, adc_hpf_cut_txt); 398 399 static const char *lr_txt[] = { 400 "Left", "Right" 401 }; 402 403 static const struct soc_enum aifl_src = 404 SOC_ENUM_SINGLE(WM8900_REG_AUDIO1, 15, 2, lr_txt); 405 406 static const struct soc_enum aifr_src = 407 SOC_ENUM_SINGLE(WM8900_REG_AUDIO1, 14, 2, lr_txt); 408 409 static const struct soc_enum dacl_src = 410 SOC_ENUM_SINGLE(WM8900_REG_AUDIO2, 15, 2, lr_txt); 411 412 static const struct soc_enum dacr_src = 413 SOC_ENUM_SINGLE(WM8900_REG_AUDIO2, 14, 2, lr_txt); 414 415 static const char *sidetone_txt[] = { 416 "Disabled", "Left ADC", "Right ADC" 417 }; 418 419 static const struct soc_enum dacl_sidetone = 420 SOC_ENUM_SINGLE(WM8900_REG_SIDETONE, 2, 3, sidetone_txt); 421 422 static const struct soc_enum dacr_sidetone = 423 SOC_ENUM_SINGLE(WM8900_REG_SIDETONE, 0, 3, sidetone_txt); 424 425 static const struct snd_kcontrol_new wm8900_snd_controls[] = { 426 SOC_ENUM("Mic Bias Level", mic_bias_level), 427 428 SOC_SINGLE_TLV("Left Input PGA Volume", WM8900_REG_LINVOL, 0, 31, 0, 429 in_pga_tlv), 430 SOC_SINGLE("Left Input PGA Switch", WM8900_REG_LINVOL, 6, 1, 1), 431 SOC_SINGLE("Left Input PGA ZC Switch", WM8900_REG_LINVOL, 7, 1, 0), 432 433 SOC_SINGLE_TLV("Right Input PGA Volume", WM8900_REG_RINVOL, 0, 31, 0, 434 in_pga_tlv), 435 SOC_SINGLE("Right Input PGA Switch", WM8900_REG_RINVOL, 6, 1, 1), 436 SOC_SINGLE("Right Input PGA ZC Switch", WM8900_REG_RINVOL, 7, 1, 0), 437 438 SOC_SINGLE("DAC Soft Mute Switch", WM8900_REG_DACCTRL, 6, 1, 1), 439 SOC_ENUM("DAC Mute Rate", dac_mute_rate), 440 SOC_SINGLE("DAC Mono Switch", WM8900_REG_DACCTRL, 9, 1, 0), 441 SOC_ENUM("DAC Deemphasis", dac_deemphasis), 442 SOC_SINGLE("DAC Sloping Stopband Filter Switch", WM8900_REG_DACCTRL, 8, 1, 0), 443 SOC_SINGLE("DAC Sigma-Delta Modulator Clock Switch", WM8900_REG_DACCTRL, 444 12, 1, 0), 445 446 SOC_SINGLE("ADC HPF Switch", WM8900_REG_ADCCTRL, 8, 1, 0), 447 SOC_ENUM("ADC HPF Cut-Off", adc_hpf_cut), 448 SOC_DOUBLE("ADC Invert Switch", WM8900_REG_ADCCTRL, 1, 0, 1, 0), 449 SOC_SINGLE_TLV("Left ADC Sidetone Volume", WM8900_REG_SIDETONE, 9, 12, 0, 450 adc_svol_tlv), 451 SOC_SINGLE_TLV("Right ADC Sidetone Volume", WM8900_REG_SIDETONE, 5, 12, 0, 452 adc_svol_tlv), 453 SOC_ENUM("Left Digital Audio Source", aifl_src), 454 SOC_ENUM("Right Digital Audio Source", aifr_src), 455 456 SOC_SINGLE_TLV("DAC Input Boost Volume", WM8900_REG_AUDIO2, 10, 4, 0, 457 dac_boost_tlv), 458 SOC_ENUM("Left DAC Source", dacl_src), 459 SOC_ENUM("Right DAC Source", dacr_src), 460 SOC_ENUM("Left DAC Sidetone", dacl_sidetone), 461 SOC_ENUM("Right DAC Sidetone", dacr_sidetone), 462 SOC_DOUBLE("DAC Invert Switch", WM8900_REG_DACCTRL, 1, 0, 1, 0), 463 464 SOC_DOUBLE_R_TLV("Digital Playback Volume", 465 WM8900_REG_LDAC_DV, WM8900_REG_RDAC_DV, 466 1, 96, 0, dac_tlv), 467 SOC_DOUBLE_R_TLV("Digital Capture Volume", 468 WM8900_REG_LADC_DV, WM8900_REG_RADC_DV, 1, 119, 0, adc_tlv), 469 470 SOC_SINGLE_TLV("LINPUT3 Bypass Volume", WM8900_REG_LOUTMIXCTL1, 4, 7, 0, 471 out_mix_tlv), 472 SOC_SINGLE_TLV("RINPUT3 Bypass Volume", WM8900_REG_ROUTMIXCTL1, 4, 7, 0, 473 out_mix_tlv), 474 SOC_SINGLE_TLV("Left AUX Bypass Volume", WM8900_REG_AUXOUT_CTL, 4, 7, 0, 475 out_mix_tlv), 476 SOC_SINGLE_TLV("Right AUX Bypass Volume", WM8900_REG_AUXOUT_CTL, 0, 7, 0, 477 out_mix_tlv), 478 479 SOC_SINGLE_TLV("LeftIn to RightOut Mixer Volume", WM8900_REG_BYPASS1, 0, 7, 0, 480 out_mix_tlv), 481 SOC_SINGLE_TLV("LeftIn to LeftOut Mixer Volume", WM8900_REG_BYPASS1, 4, 7, 0, 482 out_mix_tlv), 483 SOC_SINGLE_TLV("RightIn to LeftOut Mixer Volume", WM8900_REG_BYPASS2, 0, 7, 0, 484 out_mix_tlv), 485 SOC_SINGLE_TLV("RightIn to RightOut Mixer Volume", WM8900_REG_BYPASS2, 4, 7, 0, 486 out_mix_tlv), 487 488 SOC_SINGLE_TLV("IN2L Boost Volume", WM8900_REG_INBOOSTMIX1, 0, 3, 0, 489 in_boost_tlv), 490 SOC_SINGLE_TLV("IN3L Boost Volume", WM8900_REG_INBOOSTMIX1, 4, 3, 0, 491 in_boost_tlv), 492 SOC_SINGLE_TLV("IN2R Boost Volume", WM8900_REG_INBOOSTMIX2, 0, 3, 0, 493 in_boost_tlv), 494 SOC_SINGLE_TLV("IN3R Boost Volume", WM8900_REG_INBOOSTMIX2, 4, 3, 0, 495 in_boost_tlv), 496 SOC_SINGLE_TLV("Left AUX Boost Volume", WM8900_REG_AUXBOOST, 4, 3, 0, 497 in_boost_tlv), 498 SOC_SINGLE_TLV("Right AUX Boost Volume", WM8900_REG_AUXBOOST, 0, 3, 0, 499 in_boost_tlv), 500 501 SOC_DOUBLE_R_TLV("LINEOUT1 Volume", WM8900_REG_LOUT1CTL, WM8900_REG_ROUT1CTL, 502 0, 63, 0, out_pga_tlv), 503 SOC_DOUBLE_R("LINEOUT1 Switch", WM8900_REG_LOUT1CTL, WM8900_REG_ROUT1CTL, 504 6, 1, 1), 505 SOC_DOUBLE_R("LINEOUT1 ZC Switch", WM8900_REG_LOUT1CTL, WM8900_REG_ROUT1CTL, 506 7, 1, 0), 507 508 SOC_DOUBLE_R_TLV("LINEOUT2 Volume", 509 WM8900_REG_LOUT2CTL, WM8900_REG_ROUT2CTL, 510 0, 63, 0, out_pga_tlv), 511 SOC_DOUBLE_R("LINEOUT2 Switch", 512 WM8900_REG_LOUT2CTL, WM8900_REG_ROUT2CTL, 6, 1, 1), 513 SOC_DOUBLE_R("LINEOUT2 ZC Switch", 514 WM8900_REG_LOUT2CTL, WM8900_REG_ROUT2CTL, 7, 1, 0), 515 SOC_SINGLE("LINEOUT2 LP -12dB", WM8900_REG_LOUTMIXCTL1, 516 0, 1, 1), 517 518 }; 519 520 static const struct snd_kcontrol_new wm8900_dapm_loutput2_control = 521 SOC_DAPM_SINGLE("LINEOUT2L Switch", WM8900_REG_POWER3, 6, 1, 0); 522 523 static const struct snd_kcontrol_new wm8900_dapm_routput2_control = 524 SOC_DAPM_SINGLE("LINEOUT2R Switch", WM8900_REG_POWER3, 5, 1, 0); 525 526 static const struct snd_kcontrol_new wm8900_loutmix_controls[] = { 527 SOC_DAPM_SINGLE("LINPUT3 Bypass Switch", WM8900_REG_LOUTMIXCTL1, 7, 1, 0), 528 SOC_DAPM_SINGLE("AUX Bypass Switch", WM8900_REG_AUXOUT_CTL, 7, 1, 0), 529 SOC_DAPM_SINGLE("Left Input Mixer Switch", WM8900_REG_BYPASS1, 7, 1, 0), 530 SOC_DAPM_SINGLE("Right Input Mixer Switch", WM8900_REG_BYPASS2, 3, 1, 0), 531 SOC_DAPM_SINGLE("DACL Switch", WM8900_REG_LOUTMIXCTL1, 8, 1, 0), 532 }; 533 534 static const struct snd_kcontrol_new wm8900_routmix_controls[] = { 535 SOC_DAPM_SINGLE("RINPUT3 Bypass Switch", WM8900_REG_ROUTMIXCTL1, 7, 1, 0), 536 SOC_DAPM_SINGLE("AUX Bypass Switch", WM8900_REG_AUXOUT_CTL, 3, 1, 0), 537 SOC_DAPM_SINGLE("Left Input Mixer Switch", WM8900_REG_BYPASS1, 3, 1, 0), 538 SOC_DAPM_SINGLE("Right Input Mixer Switch", WM8900_REG_BYPASS2, 7, 1, 0), 539 SOC_DAPM_SINGLE("DACR Switch", WM8900_REG_ROUTMIXCTL1, 8, 1, 0), 540 }; 541 542 static const struct snd_kcontrol_new wm8900_linmix_controls[] = { 543 SOC_DAPM_SINGLE("LINPUT2 Switch", WM8900_REG_INBOOSTMIX1, 2, 1, 1), 544 SOC_DAPM_SINGLE("LINPUT3 Switch", WM8900_REG_INBOOSTMIX1, 6, 1, 1), 545 SOC_DAPM_SINGLE("AUX Switch", WM8900_REG_AUXBOOST, 6, 1, 1), 546 SOC_DAPM_SINGLE("Input PGA Switch", WM8900_REG_ADCPATH, 6, 1, 0), 547 }; 548 549 static const struct snd_kcontrol_new wm8900_rinmix_controls[] = { 550 SOC_DAPM_SINGLE("RINPUT2 Switch", WM8900_REG_INBOOSTMIX2, 2, 1, 1), 551 SOC_DAPM_SINGLE("RINPUT3 Switch", WM8900_REG_INBOOSTMIX2, 6, 1, 1), 552 SOC_DAPM_SINGLE("AUX Switch", WM8900_REG_AUXBOOST, 2, 1, 1), 553 SOC_DAPM_SINGLE("Input PGA Switch", WM8900_REG_ADCPATH, 2, 1, 0), 554 }; 555 556 static const struct snd_kcontrol_new wm8900_linpga_controls[] = { 557 SOC_DAPM_SINGLE("LINPUT1 Switch", WM8900_REG_INCTL, 6, 1, 0), 558 SOC_DAPM_SINGLE("LINPUT2 Switch", WM8900_REG_INCTL, 5, 1, 0), 559 SOC_DAPM_SINGLE("LINPUT3 Switch", WM8900_REG_INCTL, 4, 1, 0), 560 }; 561 562 static const struct snd_kcontrol_new wm8900_rinpga_controls[] = { 563 SOC_DAPM_SINGLE("RINPUT1 Switch", WM8900_REG_INCTL, 2, 1, 0), 564 SOC_DAPM_SINGLE("RINPUT2 Switch", WM8900_REG_INCTL, 1, 1, 0), 565 SOC_DAPM_SINGLE("RINPUT3 Switch", WM8900_REG_INCTL, 0, 1, 0), 566 }; 567 568 static const char *wm9700_lp_mux[] = { "Disabled", "Enabled" }; 569 570 static const struct soc_enum wm8900_lineout2_lp_mux = 571 SOC_ENUM_SINGLE(WM8900_REG_LOUTMIXCTL1, 1, 2, wm9700_lp_mux); 572 573 static const struct snd_kcontrol_new wm8900_lineout2_lp = 574 SOC_DAPM_ENUM("Route", wm8900_lineout2_lp_mux); 575 576 static const struct snd_soc_dapm_widget wm8900_dapm_widgets[] = { 577 578 /* Externally visible pins */ 579 SND_SOC_DAPM_OUTPUT("LINEOUT1L"), 580 SND_SOC_DAPM_OUTPUT("LINEOUT1R"), 581 SND_SOC_DAPM_OUTPUT("LINEOUT2L"), 582 SND_SOC_DAPM_OUTPUT("LINEOUT2R"), 583 SND_SOC_DAPM_OUTPUT("HP_L"), 584 SND_SOC_DAPM_OUTPUT("HP_R"), 585 586 SND_SOC_DAPM_INPUT("RINPUT1"), 587 SND_SOC_DAPM_INPUT("LINPUT1"), 588 SND_SOC_DAPM_INPUT("RINPUT2"), 589 SND_SOC_DAPM_INPUT("LINPUT2"), 590 SND_SOC_DAPM_INPUT("RINPUT3"), 591 SND_SOC_DAPM_INPUT("LINPUT3"), 592 SND_SOC_DAPM_INPUT("AUX"), 593 594 SND_SOC_DAPM_VMID("VMID"), 595 596 /* Input */ 597 SND_SOC_DAPM_MIXER("Left Input PGA", WM8900_REG_POWER2, 3, 0, 598 wm8900_linpga_controls, 599 ARRAY_SIZE(wm8900_linpga_controls)), 600 SND_SOC_DAPM_MIXER("Right Input PGA", WM8900_REG_POWER2, 2, 0, 601 wm8900_rinpga_controls, 602 ARRAY_SIZE(wm8900_rinpga_controls)), 603 604 SND_SOC_DAPM_MIXER("Left Input Mixer", WM8900_REG_POWER2, 5, 0, 605 wm8900_linmix_controls, 606 ARRAY_SIZE(wm8900_linmix_controls)), 607 SND_SOC_DAPM_MIXER("Right Input Mixer", WM8900_REG_POWER2, 4, 0, 608 wm8900_rinmix_controls, 609 ARRAY_SIZE(wm8900_rinmix_controls)), 610 611 SND_SOC_DAPM_MICBIAS("Mic Bias", WM8900_REG_POWER1, 4, 0), 612 613 SND_SOC_DAPM_ADC("ADCL", "Left HiFi Capture", WM8900_REG_POWER2, 1, 0), 614 SND_SOC_DAPM_ADC("ADCR", "Right HiFi Capture", WM8900_REG_POWER2, 0, 0), 615 616 /* Output */ 617 SND_SOC_DAPM_DAC("DACL", "Left HiFi Playback", WM8900_REG_POWER3, 1, 0), 618 SND_SOC_DAPM_DAC("DACR", "Right HiFi Playback", WM8900_REG_POWER3, 0, 0), 619 620 SND_SOC_DAPM_PGA_E("Headphone Amplifier", WM8900_REG_POWER3, 7, 0, NULL, 0, 621 wm8900_hp_event, 622 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMU | 623 SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMD), 624 625 SND_SOC_DAPM_PGA("LINEOUT1L PGA", WM8900_REG_POWER2, 8, 0, NULL, 0), 626 SND_SOC_DAPM_PGA("LINEOUT1R PGA", WM8900_REG_POWER2, 7, 0, NULL, 0), 627 628 SND_SOC_DAPM_MUX("LINEOUT2 LP", SND_SOC_NOPM, 0, 0, &wm8900_lineout2_lp), 629 SND_SOC_DAPM_PGA("LINEOUT2L PGA", WM8900_REG_POWER3, 6, 0, NULL, 0), 630 SND_SOC_DAPM_PGA("LINEOUT2R PGA", WM8900_REG_POWER3, 5, 0, NULL, 0), 631 632 SND_SOC_DAPM_MIXER("Left Output Mixer", WM8900_REG_POWER3, 3, 0, 633 wm8900_loutmix_controls, 634 ARRAY_SIZE(wm8900_loutmix_controls)), 635 SND_SOC_DAPM_MIXER("Right Output Mixer", WM8900_REG_POWER3, 2, 0, 636 wm8900_routmix_controls, 637 ARRAY_SIZE(wm8900_routmix_controls)), 638 }; 639 640 /* Target, Path, Source */ 641 static const struct snd_soc_dapm_route audio_map[] = { 642 /* Inputs */ 643 {"Left Input PGA", "LINPUT1 Switch", "LINPUT1"}, 644 {"Left Input PGA", "LINPUT2 Switch", "LINPUT2"}, 645 {"Left Input PGA", "LINPUT3 Switch", "LINPUT3"}, 646 647 {"Right Input PGA", "RINPUT1 Switch", "RINPUT1"}, 648 {"Right Input PGA", "RINPUT2 Switch", "RINPUT2"}, 649 {"Right Input PGA", "RINPUT3 Switch", "RINPUT3"}, 650 651 {"Left Input Mixer", "LINPUT2 Switch", "LINPUT2"}, 652 {"Left Input Mixer", "LINPUT3 Switch", "LINPUT3"}, 653 {"Left Input Mixer", "AUX Switch", "AUX"}, 654 {"Left Input Mixer", "Input PGA Switch", "Left Input PGA"}, 655 656 {"Right Input Mixer", "RINPUT2 Switch", "RINPUT2"}, 657 {"Right Input Mixer", "RINPUT3 Switch", "RINPUT3"}, 658 {"Right Input Mixer", "AUX Switch", "AUX"}, 659 {"Right Input Mixer", "Input PGA Switch", "Right Input PGA"}, 660 661 {"ADCL", NULL, "Left Input Mixer"}, 662 {"ADCR", NULL, "Right Input Mixer"}, 663 664 /* Outputs */ 665 {"LINEOUT1L", NULL, "LINEOUT1L PGA"}, 666 {"LINEOUT1L PGA", NULL, "Left Output Mixer"}, 667 {"LINEOUT1R", NULL, "LINEOUT1R PGA"}, 668 {"LINEOUT1R PGA", NULL, "Right Output Mixer"}, 669 670 {"LINEOUT2L PGA", NULL, "Left Output Mixer"}, 671 {"LINEOUT2 LP", "Disabled", "LINEOUT2L PGA"}, 672 {"LINEOUT2 LP", "Enabled", "Left Output Mixer"}, 673 {"LINEOUT2L", NULL, "LINEOUT2 LP"}, 674 675 {"LINEOUT2R PGA", NULL, "Right Output Mixer"}, 676 {"LINEOUT2 LP", "Disabled", "LINEOUT2R PGA"}, 677 {"LINEOUT2 LP", "Enabled", "Right Output Mixer"}, 678 {"LINEOUT2R", NULL, "LINEOUT2 LP"}, 679 680 {"Left Output Mixer", "LINPUT3 Bypass Switch", "LINPUT3"}, 681 {"Left Output Mixer", "AUX Bypass Switch", "AUX"}, 682 {"Left Output Mixer", "Left Input Mixer Switch", "Left Input Mixer"}, 683 {"Left Output Mixer", "Right Input Mixer Switch", "Right Input Mixer"}, 684 {"Left Output Mixer", "DACL Switch", "DACL"}, 685 686 {"Right Output Mixer", "RINPUT3 Bypass Switch", "RINPUT3"}, 687 {"Right Output Mixer", "AUX Bypass Switch", "AUX"}, 688 {"Right Output Mixer", "Left Input Mixer Switch", "Left Input Mixer"}, 689 {"Right Output Mixer", "Right Input Mixer Switch", "Right Input Mixer"}, 690 {"Right Output Mixer", "DACR Switch", "DACR"}, 691 692 /* Note that the headphone output stage needs to be connected 693 * externally to LINEOUT2 via DC blocking capacitors. Other 694 * configurations are not supported. 695 * 696 * Note also that left and right headphone paths are treated as a 697 * mono path. 698 */ 699 {"Headphone Amplifier", NULL, "LINEOUT2 LP"}, 700 {"Headphone Amplifier", NULL, "LINEOUT2 LP"}, 701 {"HP_L", NULL, "Headphone Amplifier"}, 702 {"HP_R", NULL, "Headphone Amplifier"}, 703 }; 704 705 static int wm8900_add_widgets(struct snd_soc_codec *codec) 706 { 707 snd_soc_dapm_new_controls(codec, wm8900_dapm_widgets, 708 ARRAY_SIZE(wm8900_dapm_widgets)); 709 710 snd_soc_dapm_add_routes(codec, audio_map, ARRAY_SIZE(audio_map)); 711 712 snd_soc_dapm_new_widgets(codec); 713 714 return 0; 715 } 716 717 static int wm8900_hw_params(struct snd_pcm_substream *substream, 718 struct snd_pcm_hw_params *params, 719 struct snd_soc_dai *dai) 720 { 721 struct snd_soc_pcm_runtime *rtd = substream->private_data; 722 struct snd_soc_device *socdev = rtd->socdev; 723 struct snd_soc_codec *codec = socdev->card->codec; 724 u16 reg; 725 726 reg = wm8900_read(codec, WM8900_REG_AUDIO1) & ~0x60; 727 728 switch (params_format(params)) { 729 case SNDRV_PCM_FORMAT_S16_LE: 730 break; 731 case SNDRV_PCM_FORMAT_S20_3LE: 732 reg |= 0x20; 733 break; 734 case SNDRV_PCM_FORMAT_S24_LE: 735 reg |= 0x40; 736 break; 737 case SNDRV_PCM_FORMAT_S32_LE: 738 reg |= 0x60; 739 break; 740 default: 741 return -EINVAL; 742 } 743 744 wm8900_write(codec, WM8900_REG_AUDIO1, reg); 745 746 return 0; 747 } 748 749 /* FLL divisors */ 750 struct _fll_div { 751 u16 fll_ratio; 752 u16 fllclk_div; 753 u16 fll_slow_lock_ref; 754 u16 n; 755 u16 k; 756 }; 757 758 /* The size in bits of the FLL divide multiplied by 10 759 * to allow rounding later */ 760 #define FIXED_FLL_SIZE ((1 << 16) * 10) 761 762 static int fll_factors(struct _fll_div *fll_div, unsigned int Fref, 763 unsigned int Fout) 764 { 765 u64 Kpart; 766 unsigned int K, Ndiv, Nmod, target; 767 unsigned int div; 768 769 BUG_ON(!Fout); 770 771 /* The FLL must run at 90-100MHz which is then scaled down to 772 * the output value by FLLCLK_DIV. */ 773 target = Fout; 774 div = 1; 775 while (target < 90000000) { 776 div *= 2; 777 target *= 2; 778 } 779 780 if (target > 100000000) 781 printk(KERN_WARNING "wm8900: FLL rate %d out of range, Fref=%d" 782 " Fout=%d\n", target, Fref, Fout); 783 if (div > 32) { 784 printk(KERN_ERR "wm8900: Invalid FLL division rate %u, " 785 "Fref=%d, Fout=%d, target=%d\n", 786 div, Fref, Fout, target); 787 return -EINVAL; 788 } 789 790 fll_div->fllclk_div = div >> 2; 791 792 if (Fref < 48000) 793 fll_div->fll_slow_lock_ref = 1; 794 else 795 fll_div->fll_slow_lock_ref = 0; 796 797 Ndiv = target / Fref; 798 799 if (Fref < 1000000) 800 fll_div->fll_ratio = 8; 801 else 802 fll_div->fll_ratio = 1; 803 804 fll_div->n = Ndiv / fll_div->fll_ratio; 805 Nmod = (target / fll_div->fll_ratio) % Fref; 806 807 /* Calculate fractional part - scale up so we can round. */ 808 Kpart = FIXED_FLL_SIZE * (long long)Nmod; 809 810 do_div(Kpart, Fref); 811 812 K = Kpart & 0xFFFFFFFF; 813 814 if ((K % 10) >= 5) 815 K += 5; 816 817 /* Move down to proper range now rounding is done */ 818 fll_div->k = K / 10; 819 820 BUG_ON(target != Fout * (fll_div->fllclk_div << 2)); 821 BUG_ON(!K && target != Fref * fll_div->fll_ratio * fll_div->n); 822 823 return 0; 824 } 825 826 static int wm8900_set_fll(struct snd_soc_codec *codec, 827 int fll_id, unsigned int freq_in, unsigned int freq_out) 828 { 829 struct wm8900_priv *wm8900 = codec->private_data; 830 struct _fll_div fll_div; 831 unsigned int reg; 832 833 if (wm8900->fll_in == freq_in && wm8900->fll_out == freq_out) 834 return 0; 835 836 /* The digital side should be disabled during any change. */ 837 reg = wm8900_read(codec, WM8900_REG_POWER1); 838 wm8900_write(codec, WM8900_REG_POWER1, 839 reg & (~WM8900_REG_POWER1_FLL_ENA)); 840 841 /* Disable the FLL? */ 842 if (!freq_in || !freq_out) { 843 reg = wm8900_read(codec, WM8900_REG_CLOCKING1); 844 wm8900_write(codec, WM8900_REG_CLOCKING1, 845 reg & (~WM8900_REG_CLOCKING1_MCLK_SRC)); 846 847 reg = wm8900_read(codec, WM8900_REG_FLLCTL1); 848 wm8900_write(codec, WM8900_REG_FLLCTL1, 849 reg & (~WM8900_REG_FLLCTL1_OSC_ENA)); 850 851 wm8900->fll_in = freq_in; 852 wm8900->fll_out = freq_out; 853 854 return 0; 855 } 856 857 if (fll_factors(&fll_div, freq_in, freq_out) != 0) 858 goto reenable; 859 860 wm8900->fll_in = freq_in; 861 wm8900->fll_out = freq_out; 862 863 /* The osclilator *MUST* be enabled before we enable the 864 * digital circuit. */ 865 wm8900_write(codec, WM8900_REG_FLLCTL1, 866 fll_div.fll_ratio | WM8900_REG_FLLCTL1_OSC_ENA); 867 868 wm8900_write(codec, WM8900_REG_FLLCTL4, fll_div.n >> 5); 869 wm8900_write(codec, WM8900_REG_FLLCTL5, 870 (fll_div.fllclk_div << 6) | (fll_div.n & 0x1f)); 871 872 if (fll_div.k) { 873 wm8900_write(codec, WM8900_REG_FLLCTL2, 874 (fll_div.k >> 8) | 0x100); 875 wm8900_write(codec, WM8900_REG_FLLCTL3, fll_div.k & 0xff); 876 } else 877 wm8900_write(codec, WM8900_REG_FLLCTL2, 0); 878 879 if (fll_div.fll_slow_lock_ref) 880 wm8900_write(codec, WM8900_REG_FLLCTL6, 881 WM8900_REG_FLLCTL6_FLL_SLOW_LOCK_REF); 882 else 883 wm8900_write(codec, WM8900_REG_FLLCTL6, 0); 884 885 reg = wm8900_read(codec, WM8900_REG_POWER1); 886 wm8900_write(codec, WM8900_REG_POWER1, 887 reg | WM8900_REG_POWER1_FLL_ENA); 888 889 reenable: 890 reg = wm8900_read(codec, WM8900_REG_CLOCKING1); 891 wm8900_write(codec, WM8900_REG_CLOCKING1, 892 reg | WM8900_REG_CLOCKING1_MCLK_SRC); 893 894 return 0; 895 } 896 897 static int wm8900_set_dai_pll(struct snd_soc_dai *codec_dai, 898 int pll_id, unsigned int freq_in, unsigned int freq_out) 899 { 900 return wm8900_set_fll(codec_dai->codec, pll_id, freq_in, freq_out); 901 } 902 903 static int wm8900_set_dai_clkdiv(struct snd_soc_dai *codec_dai, 904 int div_id, int div) 905 { 906 struct snd_soc_codec *codec = codec_dai->codec; 907 unsigned int reg; 908 909 switch (div_id) { 910 case WM8900_BCLK_DIV: 911 reg = wm8900_read(codec, WM8900_REG_CLOCKING1); 912 wm8900_write(codec, WM8900_REG_CLOCKING1, 913 div | (reg & WM8900_REG_CLOCKING1_BCLK_MASK)); 914 break; 915 case WM8900_OPCLK_DIV: 916 reg = wm8900_read(codec, WM8900_REG_CLOCKING1); 917 wm8900_write(codec, WM8900_REG_CLOCKING1, 918 div | (reg & WM8900_REG_CLOCKING1_OPCLK_MASK)); 919 break; 920 case WM8900_DAC_LRCLK: 921 reg = wm8900_read(codec, WM8900_REG_AUDIO4); 922 wm8900_write(codec, WM8900_REG_AUDIO4, 923 div | (reg & WM8900_LRC_MASK)); 924 break; 925 case WM8900_ADC_LRCLK: 926 reg = wm8900_read(codec, WM8900_REG_AUDIO3); 927 wm8900_write(codec, WM8900_REG_AUDIO3, 928 div | (reg & WM8900_LRC_MASK)); 929 break; 930 case WM8900_DAC_CLKDIV: 931 reg = wm8900_read(codec, WM8900_REG_CLOCKING2); 932 wm8900_write(codec, WM8900_REG_CLOCKING2, 933 div | (reg & WM8900_REG_CLOCKING2_DAC_CLKDIV)); 934 break; 935 case WM8900_ADC_CLKDIV: 936 reg = wm8900_read(codec, WM8900_REG_CLOCKING2); 937 wm8900_write(codec, WM8900_REG_CLOCKING2, 938 div | (reg & WM8900_REG_CLOCKING2_ADC_CLKDIV)); 939 break; 940 case WM8900_LRCLK_MODE: 941 reg = wm8900_read(codec, WM8900_REG_DACCTRL); 942 wm8900_write(codec, WM8900_REG_DACCTRL, 943 div | (reg & WM8900_REG_DACCTRL_AIF_LRCLKRATE)); 944 break; 945 default: 946 return -EINVAL; 947 } 948 949 return 0; 950 } 951 952 953 static int wm8900_set_dai_fmt(struct snd_soc_dai *codec_dai, 954 unsigned int fmt) 955 { 956 struct snd_soc_codec *codec = codec_dai->codec; 957 unsigned int clocking1, aif1, aif3, aif4; 958 959 clocking1 = wm8900_read(codec, WM8900_REG_CLOCKING1); 960 aif1 = wm8900_read(codec, WM8900_REG_AUDIO1); 961 aif3 = wm8900_read(codec, WM8900_REG_AUDIO3); 962 aif4 = wm8900_read(codec, WM8900_REG_AUDIO4); 963 964 /* set master/slave audio interface */ 965 switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { 966 case SND_SOC_DAIFMT_CBS_CFS: 967 clocking1 &= ~WM8900_REG_CLOCKING1_BCLK_DIR; 968 aif3 &= ~WM8900_REG_AUDIO3_ADCLRC_DIR; 969 aif4 &= ~WM8900_REG_AUDIO4_DACLRC_DIR; 970 break; 971 case SND_SOC_DAIFMT_CBS_CFM: 972 clocking1 &= ~WM8900_REG_CLOCKING1_BCLK_DIR; 973 aif3 |= WM8900_REG_AUDIO3_ADCLRC_DIR; 974 aif4 |= WM8900_REG_AUDIO4_DACLRC_DIR; 975 break; 976 case SND_SOC_DAIFMT_CBM_CFM: 977 clocking1 |= WM8900_REG_CLOCKING1_BCLK_DIR; 978 aif3 |= WM8900_REG_AUDIO3_ADCLRC_DIR; 979 aif4 |= WM8900_REG_AUDIO4_DACLRC_DIR; 980 break; 981 case SND_SOC_DAIFMT_CBM_CFS: 982 clocking1 |= WM8900_REG_CLOCKING1_BCLK_DIR; 983 aif3 &= ~WM8900_REG_AUDIO3_ADCLRC_DIR; 984 aif4 &= ~WM8900_REG_AUDIO4_DACLRC_DIR; 985 break; 986 default: 987 return -EINVAL; 988 } 989 990 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 991 case SND_SOC_DAIFMT_DSP_A: 992 aif1 |= WM8900_REG_AUDIO1_AIF_FMT_MASK; 993 aif1 &= ~WM8900_REG_AUDIO1_LRCLK_INV; 994 break; 995 case SND_SOC_DAIFMT_DSP_B: 996 aif1 |= WM8900_REG_AUDIO1_AIF_FMT_MASK; 997 aif1 |= WM8900_REG_AUDIO1_LRCLK_INV; 998 break; 999 case SND_SOC_DAIFMT_I2S: 1000 aif1 &= ~WM8900_REG_AUDIO1_AIF_FMT_MASK; 1001 aif1 |= 0x10; 1002 break; 1003 case SND_SOC_DAIFMT_RIGHT_J: 1004 aif1 &= ~WM8900_REG_AUDIO1_AIF_FMT_MASK; 1005 break; 1006 case SND_SOC_DAIFMT_LEFT_J: 1007 aif1 &= ~WM8900_REG_AUDIO1_AIF_FMT_MASK; 1008 aif1 |= 0x8; 1009 break; 1010 default: 1011 return -EINVAL; 1012 } 1013 1014 /* Clock inversion */ 1015 switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) { 1016 case SND_SOC_DAIFMT_DSP_A: 1017 case SND_SOC_DAIFMT_DSP_B: 1018 /* frame inversion not valid for DSP modes */ 1019 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 1020 case SND_SOC_DAIFMT_NB_NF: 1021 aif1 &= ~WM8900_REG_AUDIO1_BCLK_INV; 1022 break; 1023 case SND_SOC_DAIFMT_IB_NF: 1024 aif1 |= WM8900_REG_AUDIO1_BCLK_INV; 1025 break; 1026 default: 1027 return -EINVAL; 1028 } 1029 break; 1030 case SND_SOC_DAIFMT_I2S: 1031 case SND_SOC_DAIFMT_RIGHT_J: 1032 case SND_SOC_DAIFMT_LEFT_J: 1033 switch (fmt & SND_SOC_DAIFMT_INV_MASK) { 1034 case SND_SOC_DAIFMT_NB_NF: 1035 aif1 &= ~WM8900_REG_AUDIO1_BCLK_INV; 1036 aif1 &= ~WM8900_REG_AUDIO1_LRCLK_INV; 1037 break; 1038 case SND_SOC_DAIFMT_IB_IF: 1039 aif1 |= WM8900_REG_AUDIO1_BCLK_INV; 1040 aif1 |= WM8900_REG_AUDIO1_LRCLK_INV; 1041 break; 1042 case SND_SOC_DAIFMT_IB_NF: 1043 aif1 |= WM8900_REG_AUDIO1_BCLK_INV; 1044 aif1 &= ~WM8900_REG_AUDIO1_LRCLK_INV; 1045 break; 1046 case SND_SOC_DAIFMT_NB_IF: 1047 aif1 &= ~WM8900_REG_AUDIO1_BCLK_INV; 1048 aif1 |= WM8900_REG_AUDIO1_LRCLK_INV; 1049 break; 1050 default: 1051 return -EINVAL; 1052 } 1053 break; 1054 default: 1055 return -EINVAL; 1056 } 1057 1058 wm8900_write(codec, WM8900_REG_CLOCKING1, clocking1); 1059 wm8900_write(codec, WM8900_REG_AUDIO1, aif1); 1060 wm8900_write(codec, WM8900_REG_AUDIO3, aif3); 1061 wm8900_write(codec, WM8900_REG_AUDIO4, aif4); 1062 1063 return 0; 1064 } 1065 1066 static int wm8900_digital_mute(struct snd_soc_dai *codec_dai, int mute) 1067 { 1068 struct snd_soc_codec *codec = codec_dai->codec; 1069 u16 reg; 1070 1071 reg = wm8900_read(codec, WM8900_REG_DACCTRL); 1072 1073 if (mute) 1074 reg |= WM8900_REG_DACCTRL_MUTE; 1075 else 1076 reg &= ~WM8900_REG_DACCTRL_MUTE; 1077 1078 wm8900_write(codec, WM8900_REG_DACCTRL, reg); 1079 1080 return 0; 1081 } 1082 1083 #define WM8900_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\ 1084 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 |\ 1085 SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000) 1086 1087 #define WM8900_PCM_FORMATS \ 1088 (SNDRV_PCM_FORMAT_S16_LE | SNDRV_PCM_FORMAT_S20_3LE | \ 1089 SNDRV_PCM_FORMAT_S24_LE) 1090 1091 static struct snd_soc_dai_ops wm8900_dai_ops = { 1092 .hw_params = wm8900_hw_params, 1093 .set_clkdiv = wm8900_set_dai_clkdiv, 1094 .set_pll = wm8900_set_dai_pll, 1095 .set_fmt = wm8900_set_dai_fmt, 1096 .digital_mute = wm8900_digital_mute, 1097 }; 1098 1099 struct snd_soc_dai wm8900_dai = { 1100 .name = "WM8900 HiFi", 1101 .playback = { 1102 .stream_name = "HiFi Playback", 1103 .channels_min = 1, 1104 .channels_max = 2, 1105 .rates = WM8900_RATES, 1106 .formats = WM8900_PCM_FORMATS, 1107 }, 1108 .capture = { 1109 .stream_name = "HiFi Capture", 1110 .channels_min = 1, 1111 .channels_max = 2, 1112 .rates = WM8900_RATES, 1113 .formats = WM8900_PCM_FORMATS, 1114 }, 1115 .ops = &wm8900_dai_ops, 1116 }; 1117 EXPORT_SYMBOL_GPL(wm8900_dai); 1118 1119 static int wm8900_set_bias_level(struct snd_soc_codec *codec, 1120 enum snd_soc_bias_level level) 1121 { 1122 u16 reg; 1123 1124 switch (level) { 1125 case SND_SOC_BIAS_ON: 1126 /* Enable thermal shutdown */ 1127 reg = wm8900_read(codec, WM8900_REG_GPIO); 1128 wm8900_write(codec, WM8900_REG_GPIO, 1129 reg | WM8900_REG_GPIO_TEMP_ENA); 1130 reg = wm8900_read(codec, WM8900_REG_ADDCTL); 1131 wm8900_write(codec, WM8900_REG_ADDCTL, 1132 reg | WM8900_REG_ADDCTL_TEMP_SD); 1133 break; 1134 1135 case SND_SOC_BIAS_PREPARE: 1136 break; 1137 1138 case SND_SOC_BIAS_STANDBY: 1139 /* Charge capacitors if initial power up */ 1140 if (codec->bias_level == SND_SOC_BIAS_OFF) { 1141 /* STARTUP_BIAS_ENA on */ 1142 wm8900_write(codec, WM8900_REG_POWER1, 1143 WM8900_REG_POWER1_STARTUP_BIAS_ENA); 1144 1145 /* Startup bias mode */ 1146 wm8900_write(codec, WM8900_REG_ADDCTL, 1147 WM8900_REG_ADDCTL_BIAS_SRC | 1148 WM8900_REG_ADDCTL_VMID_SOFTST); 1149 1150 /* VMID 2x50k */ 1151 wm8900_write(codec, WM8900_REG_POWER1, 1152 WM8900_REG_POWER1_STARTUP_BIAS_ENA | 0x1); 1153 1154 /* Allow capacitors to charge */ 1155 schedule_timeout_interruptible(msecs_to_jiffies(400)); 1156 1157 /* Enable bias */ 1158 wm8900_write(codec, WM8900_REG_POWER1, 1159 WM8900_REG_POWER1_STARTUP_BIAS_ENA | 1160 WM8900_REG_POWER1_BIAS_ENA | 0x1); 1161 1162 wm8900_write(codec, WM8900_REG_ADDCTL, 0); 1163 1164 wm8900_write(codec, WM8900_REG_POWER1, 1165 WM8900_REG_POWER1_BIAS_ENA | 0x1); 1166 } 1167 1168 reg = wm8900_read(codec, WM8900_REG_POWER1); 1169 wm8900_write(codec, WM8900_REG_POWER1, 1170 (reg & WM8900_REG_POWER1_FLL_ENA) | 1171 WM8900_REG_POWER1_BIAS_ENA | 0x1); 1172 wm8900_write(codec, WM8900_REG_POWER2, 1173 WM8900_REG_POWER2_SYSCLK_ENA); 1174 wm8900_write(codec, WM8900_REG_POWER3, 0); 1175 break; 1176 1177 case SND_SOC_BIAS_OFF: 1178 /* Startup bias enable */ 1179 reg = wm8900_read(codec, WM8900_REG_POWER1); 1180 wm8900_write(codec, WM8900_REG_POWER1, 1181 reg & WM8900_REG_POWER1_STARTUP_BIAS_ENA); 1182 wm8900_write(codec, WM8900_REG_ADDCTL, 1183 WM8900_REG_ADDCTL_BIAS_SRC | 1184 WM8900_REG_ADDCTL_VMID_SOFTST); 1185 1186 /* Discharge caps */ 1187 wm8900_write(codec, WM8900_REG_POWER1, 1188 WM8900_REG_POWER1_STARTUP_BIAS_ENA); 1189 schedule_timeout_interruptible(msecs_to_jiffies(500)); 1190 1191 /* Remove clamp */ 1192 wm8900_write(codec, WM8900_REG_HPCTL1, 0); 1193 1194 /* Power down */ 1195 wm8900_write(codec, WM8900_REG_ADDCTL, 0); 1196 wm8900_write(codec, WM8900_REG_POWER1, 0); 1197 wm8900_write(codec, WM8900_REG_POWER2, 0); 1198 wm8900_write(codec, WM8900_REG_POWER3, 0); 1199 1200 /* Need to let things settle before stopping the clock 1201 * to ensure that restart works, see "Stopping the 1202 * master clock" in the datasheet. */ 1203 schedule_timeout_interruptible(msecs_to_jiffies(1)); 1204 wm8900_write(codec, WM8900_REG_POWER2, 1205 WM8900_REG_POWER2_SYSCLK_ENA); 1206 break; 1207 } 1208 codec->bias_level = level; 1209 return 0; 1210 } 1211 1212 static int wm8900_suspend(struct platform_device *pdev, pm_message_t state) 1213 { 1214 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 1215 struct snd_soc_codec *codec = socdev->card->codec; 1216 struct wm8900_priv *wm8900 = codec->private_data; 1217 int fll_out = wm8900->fll_out; 1218 int fll_in = wm8900->fll_in; 1219 int ret; 1220 1221 /* Stop the FLL in an orderly fashion */ 1222 ret = wm8900_set_fll(codec, 0, 0, 0); 1223 if (ret != 0) { 1224 dev_err(&pdev->dev, "Failed to stop FLL\n"); 1225 return ret; 1226 } 1227 1228 wm8900->fll_out = fll_out; 1229 wm8900->fll_in = fll_in; 1230 1231 wm8900_set_bias_level(codec, SND_SOC_BIAS_OFF); 1232 1233 return 0; 1234 } 1235 1236 static int wm8900_resume(struct platform_device *pdev) 1237 { 1238 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 1239 struct snd_soc_codec *codec = socdev->card->codec; 1240 struct wm8900_priv *wm8900 = codec->private_data; 1241 u16 *cache; 1242 int i, ret; 1243 1244 cache = kmemdup(codec->reg_cache, sizeof(wm8900_reg_defaults), 1245 GFP_KERNEL); 1246 1247 wm8900_reset(codec); 1248 wm8900_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 1249 1250 /* Restart the FLL? */ 1251 if (wm8900->fll_out) { 1252 int fll_out = wm8900->fll_out; 1253 int fll_in = wm8900->fll_in; 1254 1255 wm8900->fll_in = 0; 1256 wm8900->fll_out = 0; 1257 1258 ret = wm8900_set_fll(codec, 0, fll_in, fll_out); 1259 if (ret != 0) { 1260 dev_err(&pdev->dev, "Failed to restart FLL\n"); 1261 return ret; 1262 } 1263 } 1264 1265 if (cache) { 1266 for (i = 0; i < WM8900_MAXREG; i++) 1267 wm8900_write(codec, i, cache[i]); 1268 kfree(cache); 1269 } else 1270 dev_err(&pdev->dev, "Unable to allocate register cache\n"); 1271 1272 return 0; 1273 } 1274 1275 static struct snd_soc_codec *wm8900_codec; 1276 1277 static __devinit int wm8900_i2c_probe(struct i2c_client *i2c, 1278 const struct i2c_device_id *id) 1279 { 1280 struct wm8900_priv *wm8900; 1281 struct snd_soc_codec *codec; 1282 unsigned int reg; 1283 int ret; 1284 1285 wm8900 = kzalloc(sizeof(struct wm8900_priv), GFP_KERNEL); 1286 if (wm8900 == NULL) 1287 return -ENOMEM; 1288 1289 codec = &wm8900->codec; 1290 codec->private_data = wm8900; 1291 codec->reg_cache = &wm8900->reg_cache[0]; 1292 codec->reg_cache_size = WM8900_MAXREG; 1293 1294 mutex_init(&codec->mutex); 1295 INIT_LIST_HEAD(&codec->dapm_widgets); 1296 INIT_LIST_HEAD(&codec->dapm_paths); 1297 1298 codec->name = "WM8900"; 1299 codec->owner = THIS_MODULE; 1300 codec->read = wm8900_read; 1301 codec->write = wm8900_write; 1302 codec->dai = &wm8900_dai; 1303 codec->num_dai = 1; 1304 codec->hw_write = (hw_write_t)i2c_master_send; 1305 codec->control_data = i2c; 1306 codec->set_bias_level = wm8900_set_bias_level; 1307 codec->dev = &i2c->dev; 1308 1309 reg = wm8900_read(codec, WM8900_REG_ID); 1310 if (reg != 0x8900) { 1311 dev_err(&i2c->dev, "Device is not a WM8900 - ID %x\n", reg); 1312 ret = -ENODEV; 1313 goto err; 1314 } 1315 1316 /* Read back from the chip */ 1317 reg = wm8900_chip_read(codec, WM8900_REG_POWER1); 1318 reg = (reg >> 12) & 0xf; 1319 dev_info(&i2c->dev, "WM8900 revision %d\n", reg); 1320 1321 wm8900_reset(codec); 1322 1323 /* Turn the chip on */ 1324 wm8900_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 1325 1326 /* Latch the volume update bits */ 1327 wm8900_write(codec, WM8900_REG_LINVOL, 1328 wm8900_read(codec, WM8900_REG_LINVOL) | 0x100); 1329 wm8900_write(codec, WM8900_REG_RINVOL, 1330 wm8900_read(codec, WM8900_REG_RINVOL) | 0x100); 1331 wm8900_write(codec, WM8900_REG_LOUT1CTL, 1332 wm8900_read(codec, WM8900_REG_LOUT1CTL) | 0x100); 1333 wm8900_write(codec, WM8900_REG_ROUT1CTL, 1334 wm8900_read(codec, WM8900_REG_ROUT1CTL) | 0x100); 1335 wm8900_write(codec, WM8900_REG_LOUT2CTL, 1336 wm8900_read(codec, WM8900_REG_LOUT2CTL) | 0x100); 1337 wm8900_write(codec, WM8900_REG_ROUT2CTL, 1338 wm8900_read(codec, WM8900_REG_ROUT2CTL) | 0x100); 1339 wm8900_write(codec, WM8900_REG_LDAC_DV, 1340 wm8900_read(codec, WM8900_REG_LDAC_DV) | 0x100); 1341 wm8900_write(codec, WM8900_REG_RDAC_DV, 1342 wm8900_read(codec, WM8900_REG_RDAC_DV) | 0x100); 1343 wm8900_write(codec, WM8900_REG_LADC_DV, 1344 wm8900_read(codec, WM8900_REG_LADC_DV) | 0x100); 1345 wm8900_write(codec, WM8900_REG_RADC_DV, 1346 wm8900_read(codec, WM8900_REG_RADC_DV) | 0x100); 1347 1348 /* Set the DAC and mixer output bias */ 1349 wm8900_write(codec, WM8900_REG_OUTBIASCTL, 0x81); 1350 1351 wm8900_dai.dev = &i2c->dev; 1352 1353 wm8900_codec = codec; 1354 1355 ret = snd_soc_register_codec(codec); 1356 if (ret != 0) { 1357 dev_err(&i2c->dev, "Failed to register codec: %d\n", ret); 1358 goto err; 1359 } 1360 1361 ret = snd_soc_register_dai(&wm8900_dai); 1362 if (ret != 0) { 1363 dev_err(&i2c->dev, "Failed to register DAI: %d\n", ret); 1364 goto err_codec; 1365 } 1366 1367 return ret; 1368 1369 err_codec: 1370 snd_soc_unregister_codec(codec); 1371 err: 1372 kfree(wm8900); 1373 wm8900_codec = NULL; 1374 return ret; 1375 } 1376 1377 static __devexit int wm8900_i2c_remove(struct i2c_client *client) 1378 { 1379 snd_soc_unregister_dai(&wm8900_dai); 1380 snd_soc_unregister_codec(wm8900_codec); 1381 1382 wm8900_set_bias_level(wm8900_codec, SND_SOC_BIAS_OFF); 1383 1384 wm8900_dai.dev = NULL; 1385 kfree(wm8900_codec->private_data); 1386 wm8900_codec = NULL; 1387 1388 return 0; 1389 } 1390 1391 static const struct i2c_device_id wm8900_i2c_id[] = { 1392 { "wm8900", 0 }, 1393 { } 1394 }; 1395 MODULE_DEVICE_TABLE(i2c, wm8900_i2c_id); 1396 1397 static struct i2c_driver wm8900_i2c_driver = { 1398 .driver = { 1399 .name = "WM8900", 1400 .owner = THIS_MODULE, 1401 }, 1402 .probe = wm8900_i2c_probe, 1403 .remove = __devexit_p(wm8900_i2c_remove), 1404 .id_table = wm8900_i2c_id, 1405 }; 1406 1407 static int wm8900_probe(struct platform_device *pdev) 1408 { 1409 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 1410 struct snd_soc_codec *codec; 1411 int ret = 0; 1412 1413 if (!wm8900_codec) { 1414 dev_err(&pdev->dev, "I2C client not yet instantiated\n"); 1415 return -ENODEV; 1416 } 1417 1418 codec = wm8900_codec; 1419 socdev->card->codec = codec; 1420 1421 /* Register pcms */ 1422 ret = snd_soc_new_pcms(socdev, SNDRV_DEFAULT_IDX1, SNDRV_DEFAULT_STR1); 1423 if (ret < 0) { 1424 dev_err(&pdev->dev, "Failed to register new PCMs\n"); 1425 goto pcm_err; 1426 } 1427 1428 snd_soc_add_controls(codec, wm8900_snd_controls, 1429 ARRAY_SIZE(wm8900_snd_controls)); 1430 wm8900_add_widgets(codec); 1431 1432 ret = snd_soc_init_card(socdev); 1433 if (ret < 0) { 1434 dev_err(&pdev->dev, "Failed to register card\n"); 1435 goto card_err; 1436 } 1437 1438 return ret; 1439 1440 card_err: 1441 snd_soc_free_pcms(socdev); 1442 snd_soc_dapm_free(socdev); 1443 pcm_err: 1444 return ret; 1445 } 1446 1447 /* power down chip */ 1448 static int wm8900_remove(struct platform_device *pdev) 1449 { 1450 struct snd_soc_device *socdev = platform_get_drvdata(pdev); 1451 1452 snd_soc_free_pcms(socdev); 1453 snd_soc_dapm_free(socdev); 1454 1455 return 0; 1456 } 1457 1458 struct snd_soc_codec_device soc_codec_dev_wm8900 = { 1459 .probe = wm8900_probe, 1460 .remove = wm8900_remove, 1461 .suspend = wm8900_suspend, 1462 .resume = wm8900_resume, 1463 }; 1464 EXPORT_SYMBOL_GPL(soc_codec_dev_wm8900); 1465 1466 static int __init wm8900_modinit(void) 1467 { 1468 return i2c_add_driver(&wm8900_i2c_driver); 1469 } 1470 module_init(wm8900_modinit); 1471 1472 static void __exit wm8900_exit(void) 1473 { 1474 i2c_del_driver(&wm8900_i2c_driver); 1475 } 1476 module_exit(wm8900_exit); 1477 1478 MODULE_DESCRIPTION("ASoC WM8900 driver"); 1479 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfonmicro.com>"); 1480 MODULE_LICENSE("GPL"); 1481