sound/soc/codecs/wm8971.c

   1 /*
   2  * wm8971.c  --  WM8971 ALSA SoC Audio driver
   3  *
   4  * Copyright 2005 Lab126, Inc.
   5  *
   6  * Author: Kenneth Kiraly <kiraly@lab126.com>
   7  *
   8  * Based on wm8753.c by Liam Girdwood
   9  *
  10  *  This program is free software; you can redistribute  it and/or modify it
  11  *  under  the terms of  the GNU General  Public License as published by the
  12  *  Free Software Foundation;  either version 2 of the  License, or (at your
  13  *  option) any later version.
  14  */
  15
  16 #include <linux/module.h>
  17 #include <linux/moduleparam.h>
  18 #include <linux/init.h>
  19 #include <linux/delay.h>
  20 #include <linux/pm.h>
  21 #include <linux/i2c.h>
  22 #include <linux/regmap.h>
  23 #include <linux/slab.h>
  24 #include <sound/core.h>
  25 #include <sound/pcm.h>
  26 #include <sound/pcm_params.h>
  27 #include <sound/soc.h>
  28 #include <sound/initval.h>
  29
  30 #include "wm8971.h"
  31
  32 #define WM8971_REG_COUNT                43
  33
  34 /* codec private data */
  35 struct wm8971_priv {
  36         unsigned int sysclk;
  37         struct delayed_work charge_work;
  38         struct regmap *regmap;
  39 };
  40
  41 /*
  42  * wm8971 register cache
  43  * We can't read the WM8971 register space when we
  44  * are using 2 wire for device control, so we cache them instead.
  45  */
  46 static const struct reg_default wm8971_reg_defaults[] = {
  47         {  0, 0x0097 },
  48         {  1, 0x0097 },
  49         {  2, 0x0079 },
  50         {  3, 0x0079 },
  51         {  4, 0x0000 },
  52         {  5, 0x0008 },
  53         {  6, 0x0000 },
  54         {  7, 0x000a },
  55         {  8, 0x0000 },
  56         {  9, 0x0000 },
  57         { 10, 0x00ff },
  58         { 11, 0x00ff },
  59         { 12, 0x000f },
  60         { 13, 0x000f },
  61         { 14, 0x0000 },
  62         { 15, 0x0000 },
  63         { 16, 0x0000 },
  64         { 17, 0x007b },
  65         { 18, 0x0000 },
  66         { 19, 0x0032 },
  67         { 20, 0x0000 },
  68         { 21, 0x00c3 },
  69         { 22, 0x00c3 },
  70         { 23, 0x00c0 },
  71         { 24, 0x0000 },
  72         { 25, 0x0000 },
  73         { 26, 0x0000 },
  74         { 27, 0x0000 },
  75         { 28, 0x0000 },
  76         { 29, 0x0000 },
  77         { 30, 0x0000 },
  78         { 31, 0x0000 },
  79         { 32, 0x0000 },
  80         { 33, 0x0000 },
  81         { 34, 0x0050 },
  82         { 35, 0x0050 },
  83         { 36, 0x0050 },
  84         { 37, 0x0050 },
  85         { 38, 0x0050 },
  86         { 39, 0x0050 },
  87         { 40, 0x0079 },
  88         { 41, 0x0079 },
  89         { 42, 0x0079 },
  90 };
  91
  92 #define wm8971_reset(c) snd_soc_write(c, WM8971_RESET, 0)
  93
  94 /* WM8971 Controls */
  95 static const char *wm8971_bass[] = { "Linear Control", "Adaptive Boost" };
  96 static const char *wm8971_bass_filter[] = { "130Hz @ 48kHz",
  97         "200Hz @ 48kHz" };
  98 static const char *wm8971_treble[] = { "8kHz", "4kHz" };
  99 static const char *wm8971_alc_func[] = { "Off", "Right", "Left", "Stereo" };
 100 static const char *wm8971_ng_type[] = { "Constant PGA Gain",
 101         "Mute ADC Output" };
 102 static const char *wm8971_deemp[] = { "None", "32kHz", "44.1kHz", "48kHz" };
 103 static const char *wm8971_mono_mux[] = {"Stereo", "Mono (Left)",
 104         "Mono (Right)", "Digital Mono"};
 105 static const char *wm8971_dac_phase[] = { "Non Inverted", "Inverted" };
 106 static const char *wm8971_lline_mux[] = {"Line", "NC", "NC", "PGA",
 107         "Differential"};
 108 static const char *wm8971_rline_mux[] = {"Line", "Mic", "NC", "PGA",
 109         "Differential"};
 110 static const char *wm8971_lpga_sel[] = {"Line", "NC", "NC", "Differential"};
 111 static const char *wm8971_rpga_sel[] = {"Line", "Mic", "NC", "Differential"};
 112 static const char *wm8971_adcpol[] = {"Normal", "L Invert", "R Invert",
 113         "L + R Invert"};
 114
 115 static const struct soc_enum wm8971_enum[] = {
 116         SOC_ENUM_SINGLE(WM8971_BASS, 7, 2, wm8971_bass),        /* 0 */
 117         SOC_ENUM_SINGLE(WM8971_BASS, 6, 2, wm8971_bass_filter),
 118         SOC_ENUM_SINGLE(WM8971_TREBLE, 6, 2, wm8971_treble),
 119         SOC_ENUM_SINGLE(WM8971_ALC1, 7, 4, wm8971_alc_func),
 120         SOC_ENUM_SINGLE(WM8971_NGATE, 1, 2, wm8971_ng_type),    /* 4 */
 121         SOC_ENUM_SINGLE(WM8971_ADCDAC, 1, 4, wm8971_deemp),
 122         SOC_ENUM_SINGLE(WM8971_ADCTL1, 4, 4, wm8971_mono_mux),
 123         SOC_ENUM_SINGLE(WM8971_ADCTL1, 1, 2, wm8971_dac_phase),
 124         SOC_ENUM_SINGLE(WM8971_LOUTM1, 0, 5, wm8971_lline_mux), /* 8 */
 125         SOC_ENUM_SINGLE(WM8971_ROUTM1, 0, 5, wm8971_rline_mux),
 126         SOC_ENUM_SINGLE(WM8971_LADCIN, 6, 4, wm8971_lpga_sel),
 127         SOC_ENUM_SINGLE(WM8971_RADCIN, 6, 4, wm8971_rpga_sel),
 128         SOC_ENUM_SINGLE(WM8971_ADCDAC, 5, 4, wm8971_adcpol),    /* 12 */
 129         SOC_ENUM_SINGLE(WM8971_ADCIN, 6, 4, wm8971_mono_mux),
 130 };
 131
 132 static const struct snd_kcontrol_new wm8971_snd_controls[] = {
 133         SOC_DOUBLE_R("Capture Volume", WM8971_LINVOL, WM8971_RINVOL, 0, 63, 0),
 134         SOC_DOUBLE_R("Capture ZC Switch", WM8971_LINVOL, WM8971_RINVOL,
 135                      6, 1, 0),
 136         SOC_DOUBLE_R("Capture Switch", WM8971_LINVOL, WM8971_RINVOL, 7, 1, 1),
 137
 138         SOC_DOUBLE_R("Headphone Playback ZC Switch", WM8971_LOUT1V,
 139                 WM8971_ROUT1V, 7, 1, 0),
 140         SOC_DOUBLE_R("Speaker Playback ZC Switch", WM8971_LOUT2V,
 141                 WM8971_ROUT2V, 7, 1, 0),
 142         SOC_SINGLE("Mono Playback ZC Switch", WM8971_MOUTV, 7, 1, 0),
 143
 144         SOC_DOUBLE_R("PCM Volume", WM8971_LDAC, WM8971_RDAC, 0, 255, 0),
 145
 146         SOC_DOUBLE_R("Bypass Left Playback Volume", WM8971_LOUTM1,
 147                 WM8971_LOUTM2, 4, 7, 1),
 148         SOC_DOUBLE_R("Bypass Right Playback Volume", WM8971_ROUTM1,
 149                 WM8971_ROUTM2, 4, 7, 1),
 150         SOC_DOUBLE_R("Bypass Mono Playback Volume", WM8971_MOUTM1,
 151                 WM8971_MOUTM2, 4, 7, 1),
 152
 153         SOC_DOUBLE_R("Headphone Playback Volume", WM8971_LOUT1V,
 154                 WM8971_ROUT1V, 0, 127, 0),
 155         SOC_DOUBLE_R("Speaker Playback Volume", WM8971_LOUT2V,
 156                 WM8971_ROUT2V, 0, 127, 0),
 157
 158         SOC_ENUM("Bass Boost", wm8971_enum[0]),
 159         SOC_ENUM("Bass Filter", wm8971_enum[1]),
 160         SOC_SINGLE("Bass Volume", WM8971_BASS, 0, 7, 1),
 161
 162         SOC_SINGLE("Treble Volume", WM8971_TREBLE, 0, 7, 0),
 163         SOC_ENUM("Treble Cut-off", wm8971_enum[2]),
 164
 165         SOC_SINGLE("Capture Filter Switch", WM8971_ADCDAC, 0, 1, 1),
 166
 167         SOC_SINGLE("ALC Target Volume", WM8971_ALC1, 0, 7, 0),
 168         SOC_SINGLE("ALC Max Volume", WM8971_ALC1, 4, 7, 0),
 169
 170         SOC_SINGLE("ALC Capture Target Volume", WM8971_ALC1, 0, 7, 0),
 171         SOC_SINGLE("ALC Capture Max Volume", WM8971_ALC1, 4, 7, 0),
 172         SOC_ENUM("ALC Capture Function", wm8971_enum[3]),
 173         SOC_SINGLE("ALC Capture ZC Switch", WM8971_ALC2, 7, 1, 0),
 174         SOC_SINGLE("ALC Capture Hold Time", WM8971_ALC2, 0, 15, 0),
 175         SOC_SINGLE("ALC Capture Decay Time", WM8971_ALC3, 4, 15, 0),
 176         SOC_SINGLE("ALC Capture Attack Time", WM8971_ALC3, 0, 15, 0),
 177         SOC_SINGLE("ALC Capture NG Threshold", WM8971_NGATE, 3, 31, 0),
 178         SOC_ENUM("ALC Capture NG Type", wm8971_enum[4]),
 179         SOC_SINGLE("ALC Capture NG Switch", WM8971_NGATE, 0, 1, 0),
 180
 181         SOC_SINGLE("Capture 6dB Attenuate", WM8971_ADCDAC, 8, 1, 0),
 182         SOC_SINGLE("Playback 6dB Attenuate", WM8971_ADCDAC, 7, 1, 0),
 183
 184         SOC_ENUM("Playback De-emphasis", wm8971_enum[5]),
 185         SOC_ENUM("Playback Function", wm8971_enum[6]),
 186         SOC_ENUM("Playback Phase", wm8971_enum[7]),
 187
 188         SOC_DOUBLE_R("Mic Boost", WM8971_LADCIN, WM8971_RADCIN, 4, 3, 0),
 189 };
 190
 191 /*
 192  * DAPM Controls
 193  */
 194
 195 /* Left Mixer */
 196 static const struct snd_kcontrol_new wm8971_left_mixer_controls[] = {
 197 SOC_DAPM_SINGLE("Playback Switch", WM8971_LOUTM1, 8, 1, 0),
 198 SOC_DAPM_SINGLE("Left Bypass Switch", WM8971_LOUTM1, 7, 1, 0),
 199 SOC_DAPM_SINGLE("Right Playback Switch", WM8971_LOUTM2, 8, 1, 0),
 200 SOC_DAPM_SINGLE("Right Bypass Switch", WM8971_LOUTM2, 7, 1, 0),
 201 };
 202
 203 /* Right Mixer */
 204 static const struct snd_kcontrol_new wm8971_right_mixer_controls[] = {
 205 SOC_DAPM_SINGLE("Left Playback Switch", WM8971_ROUTM1, 8, 1, 0),
 206 SOC_DAPM_SINGLE("Left Bypass Switch", WM8971_ROUTM1, 7, 1, 0),
 207 SOC_DAPM_SINGLE("Playback Switch", WM8971_ROUTM2, 8, 1, 0),
 208 SOC_DAPM_SINGLE("Right Bypass Switch", WM8971_ROUTM2, 7, 1, 0),
 209 };
 210
 211 /* Mono Mixer */
 212 static const struct snd_kcontrol_new wm8971_mono_mixer_controls[] = {
 213 SOC_DAPM_SINGLE("Left Playback Switch", WM8971_MOUTM1, 8, 1, 0),
 214 SOC_DAPM_SINGLE("Left Bypass Switch", WM8971_MOUTM1, 7, 1, 0),
 215 SOC_DAPM_SINGLE("Right Playback Switch", WM8971_MOUTM2, 8, 1, 0),
 216 SOC_DAPM_SINGLE("Right Bypass Switch", WM8971_MOUTM2, 7, 1, 0),
 217 };
 218
 219 /* Left Line Mux */
 220 static const struct snd_kcontrol_new wm8971_left_line_controls =
 221 SOC_DAPM_ENUM("Route", wm8971_enum[8]);
 222
 223 /* Right Line Mux */
 224 static const struct snd_kcontrol_new wm8971_right_line_controls =
 225 SOC_DAPM_ENUM("Route", wm8971_enum[9]);
 226
 227 /* Left PGA Mux */
 228 static const struct snd_kcontrol_new wm8971_left_pga_controls =
 229 SOC_DAPM_ENUM("Route", wm8971_enum[10]);
 230
 231 /* Right PGA Mux */
 232 static const struct snd_kcontrol_new wm8971_right_pga_controls =
 233 SOC_DAPM_ENUM("Route", wm8971_enum[11]);
 234
 235 /* Mono ADC Mux */
 236 static const struct snd_kcontrol_new wm8971_monomux_controls =
 237 SOC_DAPM_ENUM("Route", wm8971_enum[13]);
 238
 239 static const struct snd_soc_dapm_widget wm8971_dapm_widgets[] = {
 240         SND_SOC_DAPM_MIXER("Left Mixer", SND_SOC_NOPM, 0, 0,
 241                 &wm8971_left_mixer_controls[0],
 242                 ARRAY_SIZE(wm8971_left_mixer_controls)),
 243         SND_SOC_DAPM_MIXER("Right Mixer", SND_SOC_NOPM, 0, 0,
 244                 &wm8971_right_mixer_controls[0],
 245                 ARRAY_SIZE(wm8971_right_mixer_controls)),
 246         SND_SOC_DAPM_MIXER("Mono Mixer", WM8971_PWR2, 2, 0,
 247                 &wm8971_mono_mixer_controls[0],
 248                 ARRAY_SIZE(wm8971_mono_mixer_controls)),
 249
 250         SND_SOC_DAPM_PGA("Right Out 2", WM8971_PWR2, 3, 0, NULL, 0),
 251         SND_SOC_DAPM_PGA("Left Out 2", WM8971_PWR2, 4, 0, NULL, 0),
 252         SND_SOC_DAPM_PGA("Right Out 1", WM8971_PWR2, 5, 0, NULL, 0),
 253         SND_SOC_DAPM_PGA("Left Out 1", WM8971_PWR2, 6, 0, NULL, 0),
 254         SND_SOC_DAPM_DAC("Right DAC", "Right Playback", WM8971_PWR2, 7, 0),
 255         SND_SOC_DAPM_DAC("Left DAC", "Left Playback", WM8971_PWR2, 8, 0),
 256         SND_SOC_DAPM_PGA("Mono Out 1", WM8971_PWR2, 2, 0, NULL, 0),
 257
 258         SND_SOC_DAPM_SUPPLY("Mic Bias", WM8971_PWR1, 1, 0, NULL, 0),
 259         SND_SOC_DAPM_ADC("Right ADC", "Right Capture", WM8971_PWR1, 2, 0),
 260         SND_SOC_DAPM_ADC("Left ADC", "Left Capture", WM8971_PWR1, 3, 0),
 261
 262         SND_SOC_DAPM_MUX("Left PGA Mux", WM8971_PWR1, 5, 0,
 263                 &wm8971_left_pga_controls),
 264         SND_SOC_DAPM_MUX("Right PGA Mux", WM8971_PWR1, 4, 0,
 265                 &wm8971_right_pga_controls),
 266         SND_SOC_DAPM_MUX("Left Line Mux", SND_SOC_NOPM, 0, 0,
 267                 &wm8971_left_line_controls),
 268         SND_SOC_DAPM_MUX("Right Line Mux", SND_SOC_NOPM, 0, 0,
 269                 &wm8971_right_line_controls),
 270
 271         SND_SOC_DAPM_MUX("Left ADC Mux", SND_SOC_NOPM, 0, 0,
 272                 &wm8971_monomux_controls),
 273         SND_SOC_DAPM_MUX("Right ADC Mux", SND_SOC_NOPM, 0, 0,
 274                 &wm8971_monomux_controls),
 275
 276         SND_SOC_DAPM_OUTPUT("LOUT1"),
 277         SND_SOC_DAPM_OUTPUT("ROUT1"),
 278         SND_SOC_DAPM_OUTPUT("LOUT2"),
 279         SND_SOC_DAPM_OUTPUT("ROUT2"),
 280         SND_SOC_DAPM_OUTPUT("MONO"),
 281
 282         SND_SOC_DAPM_INPUT("LINPUT1"),
 283         SND_SOC_DAPM_INPUT("RINPUT1"),
 284         SND_SOC_DAPM_INPUT("MIC"),
 285 };
 286
 287 static const struct snd_soc_dapm_route wm8971_dapm_routes[] = {
 288         /* left mixer */
 289         {"Left Mixer", "Playback Switch", "Left DAC"},
 290         {"Left Mixer", "Left Bypass Switch", "Left Line Mux"},
 291         {"Left Mixer", "Right Playback Switch", "Right DAC"},
 292         {"Left Mixer", "Right Bypass Switch", "Right Line Mux"},
 293
 294         /* right mixer */
 295         {"Right Mixer", "Left Playback Switch", "Left DAC"},
 296         {"Right Mixer", "Left Bypass Switch", "Left Line Mux"},
 297         {"Right Mixer", "Playback Switch", "Right DAC"},
 298         {"Right Mixer", "Right Bypass Switch", "Right Line Mux"},
 299
 300         /* left out 1 */
 301         {"Left Out 1", NULL, "Left Mixer"},
 302         {"LOUT1", NULL, "Left Out 1"},
 303
 304         /* left out 2 */
 305         {"Left Out 2", NULL, "Left Mixer"},
 306         {"LOUT2", NULL, "Left Out 2"},
 307
 308         /* right out 1 */
 309         {"Right Out 1", NULL, "Right Mixer"},
 310         {"ROUT1", NULL, "Right Out 1"},
 311
 312         /* right out 2 */
 313         {"Right Out 2", NULL, "Right Mixer"},
 314         {"ROUT2", NULL, "Right Out 2"},
 315
 316         /* mono mixer */
 317         {"Mono Mixer", "Left Playback Switch", "Left DAC"},
 318         {"Mono Mixer", "Left Bypass Switch", "Left Line Mux"},
 319         {"Mono Mixer", "Right Playback Switch", "Right DAC"},
 320         {"Mono Mixer", "Right Bypass Switch", "Right Line Mux"},
 321
 322         /* mono out */
 323         {"Mono Out", NULL, "Mono Mixer"},
 324         {"MONO1", NULL, "Mono Out"},
 325
 326         /* Left Line Mux */
 327         {"Left Line Mux", "Line", "LINPUT1"},
 328         {"Left Line Mux", "PGA", "Left PGA Mux"},
 329         {"Left Line Mux", "Differential", "Differential Mux"},
 330
 331         /* Right Line Mux */
 332         {"Right Line Mux", "Line", "RINPUT1"},
 333         {"Right Line Mux", "Mic", "MIC"},
 334         {"Right Line Mux", "PGA", "Right PGA Mux"},
 335         {"Right Line Mux", "Differential", "Differential Mux"},
 336
 337         /* Left PGA Mux */
 338         {"Left PGA Mux", "Line", "LINPUT1"},
 339         {"Left PGA Mux", "Differential", "Differential Mux"},
 340
 341         /* Right PGA Mux */
 342         {"Right PGA Mux", "Line", "RINPUT1"},
 343         {"Right PGA Mux", "Differential", "Differential Mux"},
 344
 345         /* Differential Mux */
 346         {"Differential Mux", "Line", "LINPUT1"},
 347         {"Differential Mux", "Line", "RINPUT1"},
 348
 349         /* Left ADC Mux */
 350         {"Left ADC Mux", "Stereo", "Left PGA Mux"},
 351         {"Left ADC Mux", "Mono (Left)", "Left PGA Mux"},
 352         {"Left ADC Mux", "Digital Mono", "Left PGA Mux"},
 353
 354         /* Right ADC Mux */
 355         {"Right ADC Mux", "Stereo", "Right PGA Mux"},
 356         {"Right ADC Mux", "Mono (Right)", "Right PGA Mux"},
 357         {"Right ADC Mux", "Digital Mono", "Right PGA Mux"},
 358
 359         /* ADC */
 360         {"Left ADC", NULL, "Left ADC Mux"},
 361         {"Right ADC", NULL, "Right ADC Mux"},
 362 };
 363
 364 struct _coeff_div {
 365         u32 mclk;
 366         u32 rate;
 367         u16 fs;
 368         u8 sr:5;
 369         u8 usb:1;
 370 };
 371
 372 /* codec hifi mclk clock divider coefficients */
 373 static const struct _coeff_div coeff_div[] = {
 374         /* 8k */
 375         {12288000, 8000, 1536, 0x6, 0x0},
 376         {11289600, 8000, 1408, 0x16, 0x0},
 377         {18432000, 8000, 2304, 0x7, 0x0},
 378         {16934400, 8000, 2112, 0x17, 0x0},
 379         {12000000, 8000, 1500, 0x6, 0x1},
 380
 381         /* 11.025k */
 382         {11289600, 11025, 1024, 0x18, 0x0},
 383         {16934400, 11025, 1536, 0x19, 0x0},
 384         {12000000, 11025, 1088, 0x19, 0x1},
 385
 386         /* 16k */
 387         {12288000, 16000, 768, 0xa, 0x0},
 388         {18432000, 16000, 1152, 0xb, 0x0},
 389         {12000000, 16000, 750, 0xa, 0x1},
 390
 391         /* 22.05k */
 392         {11289600, 22050, 512, 0x1a, 0x0},
 393         {16934400, 22050, 768, 0x1b, 0x0},
 394         {12000000, 22050, 544, 0x1b, 0x1},
 395
 396         /* 32k */
 397         {12288000, 32000, 384, 0xc, 0x0},
 398         {18432000, 32000, 576, 0xd, 0x0},
 399         {12000000, 32000, 375, 0xa, 0x1},
 400
 401         /* 44.1k */
 402         {11289600, 44100, 256, 0x10, 0x0},
 403         {16934400, 44100, 384, 0x11, 0x0},
 404         {12000000, 44100, 272, 0x11, 0x1},
 405
 406         /* 48k */
 407         {12288000, 48000, 256, 0x0, 0x0},
 408         {18432000, 48000, 384, 0x1, 0x0},
 409         {12000000, 48000, 250, 0x0, 0x1},
 410
 411         /* 88.2k */
 412         {11289600, 88200, 128, 0x1e, 0x0},
 413         {16934400, 88200, 192, 0x1f, 0x0},
 414         {12000000, 88200, 136, 0x1f, 0x1},
 415
 416         /* 96k */
 417         {12288000, 96000, 128, 0xe, 0x0},
 418         {18432000, 96000, 192, 0xf, 0x0},
 419         {12000000, 96000, 125, 0xe, 0x1},
 420 };
 421
 422 static int get_coeff(int mclk, int rate)
 423 {
 424         int i;
 425
 426         for (i = 0; i < ARRAY_SIZE(coeff_div); i++) {
 427                 if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk)
 428                         return i;
 429         }
 430         return -EINVAL;
 431 }
 432
 433 static int wm8971_set_dai_sysclk(struct snd_soc_dai *codec_dai,
 434                 int clk_id, unsigned int freq, int dir)
 435 {
 436         struct snd_soc_codec *codec = codec_dai->codec;
 437         struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
 438
 439         switch (freq) {
 440         case 11289600:
 441         case 12000000:
 442         case 12288000:
 443         case 16934400:
 444         case 18432000:
 445                 wm8971->sysclk = freq;
 446                 return 0;
 447         }
 448         return -EINVAL;
 449 }
 450
 451 static int wm8971_set_dai_fmt(struct snd_soc_dai *codec_dai,
 452                 unsigned int fmt)
 453 {
 454         struct snd_soc_codec *codec = codec_dai->codec;
 455         u16 iface = 0;
 456
 457         /* set master/slave audio interface */
 458         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 459         case SND_SOC_DAIFMT_CBM_CFM:
 460                 iface = 0x0040;
 461                 break;
 462         case SND_SOC_DAIFMT_CBS_CFS:
 463                 break;
 464         default:
 465                 return -EINVAL;
 466         }
 467
 468         /* interface format */
 469         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 470         case SND_SOC_DAIFMT_I2S:
 471                 iface |= 0x0002;
 472                 break;
 473         case SND_SOC_DAIFMT_RIGHT_J:
 474                 break;
 475         case SND_SOC_DAIFMT_LEFT_J:
 476                 iface |= 0x0001;
 477                 break;
 478         case SND_SOC_DAIFMT_DSP_A:
 479                 iface |= 0x0003;
 480                 break;
 481         case SND_SOC_DAIFMT_DSP_B:
 482                 iface |= 0x0013;
 483                 break;
 484         default:
 485                 return -EINVAL;
 486         }
 487
 488         /* clock inversion */
 489         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 490         case SND_SOC_DAIFMT_NB_NF:
 491                 break;
 492         case SND_SOC_DAIFMT_IB_IF:
 493                 iface |= 0x0090;
 494                 break;
 495         case SND_SOC_DAIFMT_IB_NF:
 496                 iface |= 0x0080;
 497                 break;
 498         case SND_SOC_DAIFMT_NB_IF:
 499                 iface |= 0x0010;
 500                 break;
 501         default:
 502                 return -EINVAL;
 503         }
 504
 505         snd_soc_write(codec, WM8971_IFACE, iface);
 506         return 0;
 507 }
 508
 509 static int wm8971_pcm_hw_params(struct snd_pcm_substream *substream,
 510         struct snd_pcm_hw_params *params,
 511         struct snd_soc_dai *dai)
 512 {
 513         struct snd_soc_codec *codec = dai->codec;
 514         struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
 515         u16 iface = snd_soc_read(codec, WM8971_IFACE) & 0x1f3;
 516         u16 srate = snd_soc_read(codec, WM8971_SRATE) & 0x1c0;
 517         int coeff = get_coeff(wm8971->sysclk, params_rate(params));
 518
 519         /* bit size */
 520         switch (params_width(params)) {
 521         case 16:
 522                 break;
 523         case 20:
 524                 iface |= 0x0004;
 525                 break;
 526         case 24:
 527                 iface |= 0x0008;
 528                 break;
 529         case 32:
 530                 iface |= 0x000c;
 531                 break;
 532         }
 533
 534         /* set iface & srate */
 535         snd_soc_write(codec, WM8971_IFACE, iface);
 536         if (coeff >= 0)
 537                 snd_soc_write(codec, WM8971_SRATE, srate |
 538                         (coeff_div[coeff].sr << 1) | coeff_div[coeff].usb);
 539
 540         return 0;
 541 }
 542
 543 static int wm8971_mute(struct snd_soc_dai *dai, int mute)
 544 {
 545         struct snd_soc_codec *codec = dai->codec;
 546         u16 mute_reg = snd_soc_read(codec, WM8971_ADCDAC) & 0xfff7;
 547
 548         if (mute)
 549                 snd_soc_write(codec, WM8971_ADCDAC, mute_reg | 0x8);
 550         else
 551                 snd_soc_write(codec, WM8971_ADCDAC, mute_reg);
 552         return 0;
 553 }
 554
 555 static void wm8971_charge_work(struct work_struct *work)
 556 {
 557         struct wm8971_priv *wm8971 =
 558                 container_of(work, struct wm8971_priv, charge_work.work);
 559
 560         /* Set to 500k */
 561         regmap_update_bits(wm8971->regmap, WM8971_PWR1, 0x0180, 0x0100);
 562 }
 563
 564 static int wm8971_set_bias_level(struct snd_soc_codec *codec,
 565         enum snd_soc_bias_level level)
 566 {
 567         struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
 568         u16 pwr_reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
 569
 570         switch (level) {
 571         case SND_SOC_BIAS_ON:
 572                 /* set vmid to 50k and unmute dac */
 573                 snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x00c1);
 574                 break;
 575         case SND_SOC_BIAS_PREPARE:
 576                 /* Wait until fully charged */
 577                 flush_delayed_work(&wm8971->charge_work);
 578                 break;
 579         case SND_SOC_BIAS_STANDBY:
 580                 if (snd_soc_codec_get_bias_level(codec) == SND_SOC_BIAS_OFF) {
 581                         snd_soc_cache_sync(codec);
 582                         /* charge output caps - set vmid to 5k for quick power up */
 583                         snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x01c0);
 584                         queue_delayed_work(system_power_efficient_wq,
 585                                 &wm8971->charge_work, msecs_to_jiffies(1000));
 586                 } else {
 587                         /* mute dac and set vmid to 500k, enable VREF */
 588                         snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x0140);
 589                 }
 590
 591                 break;
 592         case SND_SOC_BIAS_OFF:
 593                 cancel_delayed_work_sync(&wm8971->charge_work);
 594                 snd_soc_write(codec, WM8971_PWR1, 0x0001);
 595                 break;
 596         }
 597         return 0;
 598 }
 599
 600 #define WM8971_RATES (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_11025 |\
 601                 SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_44100 | \
 602                 SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000)
 603
 604 #define WM8971_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE |\
 605         SNDRV_PCM_FMTBIT_S24_LE)
 606
 607 static const struct snd_soc_dai_ops wm8971_dai_ops = {
 608         .hw_params      = wm8971_pcm_hw_params,
 609         .digital_mute   = wm8971_mute,
 610         .set_fmt        = wm8971_set_dai_fmt,
 611         .set_sysclk     = wm8971_set_dai_sysclk,
 612 };
 613
 614 static struct snd_soc_dai_driver wm8971_dai = {
 615         .name = "wm8971-hifi",
 616         .playback = {
 617                 .stream_name = "Playback",
 618                 .channels_min = 1,
 619                 .channels_max = 2,
 620                 .rates = WM8971_RATES,
 621                 .formats = WM8971_FORMATS,},
 622         .capture = {
 623                 .stream_name = "Capture",
 624                 .channels_min = 1,
 625                 .channels_max = 2,
 626                 .rates = WM8971_RATES,
 627                 .formats = WM8971_FORMATS,},
 628         .ops = &wm8971_dai_ops,
 629 };
 630
 631 static int wm8971_probe(struct snd_soc_codec *codec)
 632 {
 633         struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
 634
 635         INIT_DELAYED_WORK(&wm8971->charge_work, wm8971_charge_work);
 636
 637         wm8971_reset(codec);
 638
 639         /* set the update bits */
 640         snd_soc_update_bits(codec, WM8971_LDAC, 0x0100, 0x0100);
 641         snd_soc_update_bits(codec, WM8971_RDAC, 0x0100, 0x0100);
 642         snd_soc_update_bits(codec, WM8971_LOUT1V, 0x0100, 0x0100);
 643         snd_soc_update_bits(codec, WM8971_ROUT1V, 0x0100, 0x0100);
 644         snd_soc_update_bits(codec, WM8971_LOUT2V, 0x0100, 0x0100);
 645         snd_soc_update_bits(codec, WM8971_ROUT2V, 0x0100, 0x0100);
 646         snd_soc_update_bits(codec, WM8971_LINVOL, 0x0100, 0x0100);
 647         snd_soc_update_bits(codec, WM8971_RINVOL, 0x0100, 0x0100);
 648
 649         return 0;
 650 }
 651
 652 static const struct snd_soc_codec_driver soc_codec_dev_wm8971 = {
 653         .probe =        wm8971_probe,
 654         .set_bias_level = wm8971_set_bias_level,
 655         .suspend_bias_off = true,
 656
 657         .component_driver = {
 658                 .controls               = wm8971_snd_controls,
 659                 .num_controls           = ARRAY_SIZE(wm8971_snd_controls),
 660                 .dapm_widgets           = wm8971_dapm_widgets,
 661                 .num_dapm_widgets       = ARRAY_SIZE(wm8971_dapm_widgets),
 662                 .dapm_routes            = wm8971_dapm_routes,
 663                 .num_dapm_routes        = ARRAY_SIZE(wm8971_dapm_routes),
 664         },
 665 };
 666
 667 static const struct regmap_config wm8971_regmap = {
 668         .reg_bits = 7,
 669         .val_bits = 9,
 670         .max_register = WM8971_MOUTV,
 671
 672         .reg_defaults = wm8971_reg_defaults,
 673         .num_reg_defaults = ARRAY_SIZE(wm8971_reg_defaults),
 674         .cache_type = REGCACHE_RBTREE,
 675 };
 676
 677 static int wm8971_i2c_probe(struct i2c_client *i2c,
 678                             const struct i2c_device_id *id)
 679 {
 680         struct wm8971_priv *wm8971;
 681         int ret;
 682
 683         wm8971 = devm_kzalloc(&i2c->dev, sizeof(struct wm8971_priv),
 684                               GFP_KERNEL);
 685         if (wm8971 == NULL)
 686                 return -ENOMEM;
 687
 688         wm8971->regmap = devm_regmap_init_i2c(i2c, &wm8971_regmap);
 689         if (IS_ERR(wm8971->regmap))
 690                 return PTR_ERR(wm8971->regmap);
 691
 692         i2c_set_clientdata(i2c, wm8971);
 693
 694         ret = snd_soc_register_codec(&i2c->dev,
 695                         &soc_codec_dev_wm8971, &wm8971_dai, 1);
 696
 697         return ret;
 698 }
 699
 700 static int wm8971_i2c_remove(struct i2c_client *client)
 701 {
 702         snd_soc_unregister_codec(&client->dev);
 703         return 0;
 704 }
 705
 706 static const struct i2c_device_id wm8971_i2c_id[] = {
 707         { "wm8971", 0 },
 708         { }
 709 };
 710 MODULE_DEVICE_TABLE(i2c, wm8971_i2c_id);
 711
 712 static struct i2c_driver wm8971_i2c_driver = {
 713         .driver = {
 714                 .name = "wm8971",
 715         },
 716         .probe =    wm8971_i2c_probe,
 717         .remove =   wm8971_i2c_remove,
 718         .id_table = wm8971_i2c_id,
 719 };
 720
 721 module_i2c_driver(wm8971_i2c_driver);
 722
 723 MODULE_DESCRIPTION("ASoC WM8971 driver");
 724 MODULE_AUTHOR("Lab126");
 725 MODULE_LICENSE("GPL");