sound/soc/codecs/cs42l56.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * cs42l56.c -- CS42L56 ALSA SoC audio driver
   4  *
   5  * Copyright 2014 CirrusLogic, Inc.
   6  *
   7  * Author: Brian Austin <brian.austin@cirrus.com>
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/moduleparam.h>
  12 #include <linux/kernel.h>
  13 #include <linux/init.h>
  14 #include <linux/delay.h>
  15 #include <linux/pm.h>
  16 #include <linux/i2c.h>
  17 #include <linux/input.h>
  18 #include <linux/regmap.h>
  19 #include <linux/slab.h>
  20 #include <linux/workqueue.h>
  21 #include <linux/platform_device.h>
  22 #include <linux/regulator/consumer.h>
  23 #include <linux/of_device.h>
  24 #include <linux/of_gpio.h>
  25 #include <sound/core.h>
  26 #include <sound/pcm.h>
  27 #include <sound/pcm_params.h>
  28 #include <sound/soc.h>
  29 #include <sound/soc-dapm.h>
  30 #include <sound/initval.h>
  31 #include <sound/tlv.h>
  32 #include <sound/cs42l56.h>
  33 #include "cs42l56.h"
  34
  35 #define CS42L56_NUM_SUPPLIES 3
  36 static const char *const cs42l56_supply_names[CS42L56_NUM_SUPPLIES] = {
  37         "VA",
  38         "VCP",
  39         "VLDO",
  40 };
  41
  42 struct  cs42l56_private {
  43         struct regmap *regmap;
  44         struct snd_soc_component *component;
  45         struct device *dev;
  46         struct cs42l56_platform_data pdata;
  47         struct regulator_bulk_data supplies[CS42L56_NUM_SUPPLIES];
  48         u32 mclk;
  49         u8 mclk_prediv;
  50         u8 mclk_div2;
  51         u8 mclk_ratio;
  52         u8 iface;
  53         u8 iface_fmt;
  54         u8 iface_inv;
  55 #if IS_ENABLED(CONFIG_INPUT)
  56         struct input_dev *beep;
  57         struct work_struct beep_work;
  58         int beep_rate;
  59 #endif
  60 };
  61
  62 static const struct reg_default cs42l56_reg_defaults[] = {
  63         { 3, 0x7f },    /* r03  - Power Ctl 1 */
  64         { 4, 0xff },    /* r04  - Power Ctl 2 */
  65         { 5, 0x00 },    /* ro5  - Clocking Ctl 1 */
  66         { 6, 0x0b },    /* r06  - Clocking Ctl 2 */
  67         { 7, 0x00 },    /* r07  - Serial Format */
  68         { 8, 0x05 },    /* r08  - Class H Ctl */
  69         { 9, 0x0c },    /* r09  - Misc Ctl */
  70         { 10, 0x80 },   /* r0a  - INT Status */
  71         { 11, 0x00 },   /* r0b  - Playback Ctl */
  72         { 12, 0x0c },   /* r0c  - DSP Mute Ctl */
  73         { 13, 0x00 },   /* r0d  - ADCA Mixer Volume */
  74         { 14, 0x00 },   /* r0e  - ADCB Mixer Volume */
  75         { 15, 0x00 },   /* r0f  - PCMA Mixer Volume */
  76         { 16, 0x00 },   /* r10  - PCMB Mixer Volume */
  77         { 17, 0x00 },   /* r11  - Analog Input Advisory Volume */
  78         { 18, 0x00 },   /* r12  - Digital Input Advisory Volume */
  79         { 19, 0x00 },   /* r13  - Master A Volume */
  80         { 20, 0x00 },   /* r14  - Master B Volume */
  81         { 21, 0x00 },   /* r15  - Beep Freq / On Time */
  82         { 22, 0x00 },   /* r16  - Beep Volume / Off Time */
  83         { 23, 0x00 },   /* r17  - Beep Tone Ctl */
  84         { 24, 0x88 },   /* r18  - Tone Ctl */
  85         { 25, 0x00 },   /* r19  - Channel Mixer & Swap */
  86         { 26, 0x00 },   /* r1a  - AIN Ref Config / ADC Mux */
  87         { 27, 0xa0 },   /* r1b  - High-Pass Filter Ctl */
  88         { 28, 0x00 },   /* r1c  - Misc ADC Ctl */
  89         { 29, 0x00 },   /* r1d  - Gain & Bias Ctl */
  90         { 30, 0x00 },   /* r1e  - PGAA Mux & Volume */
  91         { 31, 0x00 },   /* r1f  - PGAB Mux & Volume */
  92         { 32, 0x00 },   /* r20  - ADCA Attenuator */
  93         { 33, 0x00 },   /* r21  - ADCB Attenuator */
  94         { 34, 0x00 },   /* r22  - ALC Enable & Attack Rate */
  95         { 35, 0xbf },   /* r23  - ALC Release Rate */
  96         { 36, 0x00 },   /* r24  - ALC Threshold */
  97         { 37, 0x00 },   /* r25  - Noise Gate Ctl */
  98         { 38, 0x00 },   /* r26  - ALC, Limiter, SFT, ZeroCross */
  99         { 39, 0x00 },   /* r27  - Analog Mute, LO & HP Mux */
 100         { 40, 0x00 },   /* r28  - HP A Volume */
 101         { 41, 0x00 },   /* r29  - HP B Volume */
 102         { 42, 0x00 },   /* r2a  - LINEOUT A Volume */
 103         { 43, 0x00 },   /* r2b  - LINEOUT B Volume */
 104         { 44, 0x00 },   /* r2c  - Limit Threshold Ctl */
 105         { 45, 0x7f },   /* r2d  - Limiter Ctl & Release Rate */
 106         { 46, 0x00 },   /* r2e  - Limiter Attack Rate */
 107 };
 108
 109 static bool cs42l56_readable_register(struct device *dev, unsigned int reg)
 110 {
 111         switch (reg) {
 112         case CS42L56_CHIP_ID_1 ... CS42L56_LIM_ATTACK_RATE:
 113                 return true;
 114         default:
 115                 return false;
 116         }
 117 }
 118
 119 static bool cs42l56_volatile_register(struct device *dev, unsigned int reg)
 120 {
 121         switch (reg) {
 122         case CS42L56_INT_STATUS:
 123                 return true;
 124         default:
 125                 return false;
 126         }
 127 }
 128
 129 static DECLARE_TLV_DB_SCALE(beep_tlv, -5000, 200, 0);
 130 static DECLARE_TLV_DB_SCALE(hl_tlv, -6000, 50, 0);
 131 static DECLARE_TLV_DB_SCALE(adv_tlv, -10200, 50, 0);
 132 static DECLARE_TLV_DB_SCALE(adc_tlv, -9600, 100, 0);
 133 static DECLARE_TLV_DB_SCALE(tone_tlv, -1050, 150, 0);
 134 static DECLARE_TLV_DB_SCALE(preamp_tlv, 0, 1000, 0);
 135 static DECLARE_TLV_DB_SCALE(pga_tlv, -600, 50, 0);
 136
 137 static const DECLARE_TLV_DB_RANGE(ngnb_tlv,
 138         0, 1, TLV_DB_SCALE_ITEM(-8200, 600, 0),
 139         2, 5, TLV_DB_SCALE_ITEM(-7600, 300, 0)
 140 );
 141 static const DECLARE_TLV_DB_RANGE(ngb_tlv,
 142         0, 2, TLV_DB_SCALE_ITEM(-6400, 600, 0),
 143         3, 7, TLV_DB_SCALE_ITEM(-4600, 300, 0)
 144 );
 145 static const DECLARE_TLV_DB_RANGE(alc_tlv,
 146         0, 2, TLV_DB_SCALE_ITEM(-3000, 600, 0),
 147         3, 7, TLV_DB_SCALE_ITEM(-1200, 300, 0)
 148 );
 149
 150 static const char * const beep_config_text[] = {
 151         "Off", "Single", "Multiple", "Continuous"
 152 };
 153
 154 static const struct soc_enum beep_config_enum =
 155         SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 6,
 156                         ARRAY_SIZE(beep_config_text), beep_config_text);
 157
 158 static const char * const beep_pitch_text[] = {
 159         "C4", "C5", "D5", "E5", "F5", "G5", "A5", "B5",
 160         "C6", "D6", "E6", "F6", "G6", "A6", "B6", "C7"
 161 };
 162
 163 static const struct soc_enum beep_pitch_enum =
 164         SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_ONTIME, 4,
 165                         ARRAY_SIZE(beep_pitch_text), beep_pitch_text);
 166
 167 static const char * const beep_ontime_text[] = {
 168         "86 ms", "430 ms", "780 ms", "1.20 s", "1.50 s",
 169         "1.80 s", "2.20 s", "2.50 s", "2.80 s", "3.20 s",
 170         "3.50 s", "3.80 s", "4.20 s", "4.50 s", "4.80 s", "5.20 s"
 171 };
 172
 173 static const struct soc_enum beep_ontime_enum =
 174         SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_ONTIME, 0,
 175                         ARRAY_SIZE(beep_ontime_text), beep_ontime_text);
 176
 177 static const char * const beep_offtime_text[] = {
 178         "1.23 s", "2.58 s", "3.90 s", "5.20 s",
 179         "6.60 s", "8.05 s", "9.35 s", "10.80 s"
 180 };
 181
 182 static const struct soc_enum beep_offtime_enum =
 183         SOC_ENUM_SINGLE(CS42L56_BEEP_FREQ_OFFTIME, 5,
 184                         ARRAY_SIZE(beep_offtime_text), beep_offtime_text);
 185
 186 static const char * const beep_treble_text[] = {
 187         "5kHz", "7kHz", "10kHz", "15kHz"
 188 };
 189
 190 static const struct soc_enum beep_treble_enum =
 191         SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 3,
 192                         ARRAY_SIZE(beep_treble_text), beep_treble_text);
 193
 194 static const char * const beep_bass_text[] = {
 195         "50Hz", "100Hz", "200Hz", "250Hz"
 196 };
 197
 198 static const struct soc_enum beep_bass_enum =
 199         SOC_ENUM_SINGLE(CS42L56_BEEP_TONE_CFG, 1,
 200                         ARRAY_SIZE(beep_bass_text), beep_bass_text);
 201
 202 static const char * const adc_swap_text[] = {
 203         "None", "A+B/2", "A-B/2", "Swap"
 204 };
 205
 206 static const struct soc_enum adc_swap_enum =
 207         SOC_ENUM_SINGLE(CS42L56_MISC_ADC_CTL, 3,
 208                         ARRAY_SIZE(adc_swap_text), adc_swap_text);
 209
 210 static const char * const pgaa_mux_text[] = {
 211         "AIN1A", "AIN2A", "AIN3A"};
 212
 213 static const struct soc_enum pgaa_mux_enum =
 214         SOC_ENUM_SINGLE(CS42L56_PGAA_MUX_VOLUME, 0,
 215                               ARRAY_SIZE(pgaa_mux_text),
 216                               pgaa_mux_text);
 217
 218 static const struct snd_kcontrol_new pgaa_mux =
 219         SOC_DAPM_ENUM("Route", pgaa_mux_enum);
 220
 221 static const char * const pgab_mux_text[] = {
 222         "AIN1B", "AIN2B", "AIN3B"};
 223
 224 static const struct soc_enum pgab_mux_enum =
 225         SOC_ENUM_SINGLE(CS42L56_PGAB_MUX_VOLUME, 0,
 226                               ARRAY_SIZE(pgab_mux_text),
 227                               pgab_mux_text);
 228
 229 static const struct snd_kcontrol_new pgab_mux =
 230         SOC_DAPM_ENUM("Route", pgab_mux_enum);
 231
 232 static const char * const adca_mux_text[] = {
 233         "PGAA", "AIN1A", "AIN2A", "AIN3A"};
 234
 235 static const struct soc_enum adca_mux_enum =
 236         SOC_ENUM_SINGLE(CS42L56_AIN_REFCFG_ADC_MUX, 0,
 237                               ARRAY_SIZE(adca_mux_text),
 238                               adca_mux_text);
 239
 240 static const struct snd_kcontrol_new adca_mux =
 241         SOC_DAPM_ENUM("Route", adca_mux_enum);
 242
 243 static const char * const adcb_mux_text[] = {
 244         "PGAB", "AIN1B", "AIN2B", "AIN3B"};
 245
 246 static const struct soc_enum adcb_mux_enum =
 247         SOC_ENUM_SINGLE(CS42L56_AIN_REFCFG_ADC_MUX, 2,
 248                               ARRAY_SIZE(adcb_mux_text),
 249                               adcb_mux_text);
 250
 251 static const struct snd_kcontrol_new adcb_mux =
 252         SOC_DAPM_ENUM("Route", adcb_mux_enum);
 253
 254 static const char * const left_swap_text[] = {
 255         "Left", "LR 2", "Right"};
 256
 257 static const char * const right_swap_text[] = {
 258         "Right", "LR 2", "Left"};
 259
 260 static const unsigned int swap_values[] = { 0, 1, 3 };
 261
 262 static const struct soc_enum adca_swap_enum =
 263         SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 0, 3,
 264                               ARRAY_SIZE(left_swap_text),
 265                               left_swap_text,
 266                               swap_values);
 267 static const struct snd_kcontrol_new adca_swap_mux =
 268         SOC_DAPM_ENUM("Route", adca_swap_enum);
 269
 270 static const struct soc_enum pcma_swap_enum =
 271         SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 4, 3,
 272                               ARRAY_SIZE(left_swap_text),
 273                               left_swap_text,
 274                               swap_values);
 275 static const struct snd_kcontrol_new pcma_swap_mux =
 276         SOC_DAPM_ENUM("Route", pcma_swap_enum);
 277
 278 static const struct soc_enum adcb_swap_enum =
 279         SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 2, 3,
 280                               ARRAY_SIZE(right_swap_text),
 281                               right_swap_text,
 282                               swap_values);
 283 static const struct snd_kcontrol_new adcb_swap_mux =
 284         SOC_DAPM_ENUM("Route", adcb_swap_enum);
 285
 286 static const struct soc_enum pcmb_swap_enum =
 287         SOC_VALUE_ENUM_SINGLE(CS42L56_CHAN_MIX_SWAP, 6, 3,
 288                               ARRAY_SIZE(right_swap_text),
 289                               right_swap_text,
 290                               swap_values);
 291 static const struct snd_kcontrol_new pcmb_swap_mux =
 292         SOC_DAPM_ENUM("Route", pcmb_swap_enum);
 293
 294 static const struct snd_kcontrol_new hpa_switch =
 295         SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 6, 1, 1);
 296
 297 static const struct snd_kcontrol_new hpb_switch =
 298         SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 4, 1, 1);
 299
 300 static const struct snd_kcontrol_new loa_switch =
 301         SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 2, 1, 1);
 302
 303 static const struct snd_kcontrol_new lob_switch =
 304         SOC_DAPM_SINGLE("Switch", CS42L56_PWRCTL_2, 0, 1, 1);
 305
 306 static const char * const hploa_input_text[] = {
 307         "DACA", "PGAA"};
 308
 309 static const struct soc_enum lineouta_input_enum =
 310         SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 2,
 311                               ARRAY_SIZE(hploa_input_text),
 312                               hploa_input_text);
 313
 314 static const struct snd_kcontrol_new lineouta_input =
 315         SOC_DAPM_ENUM("Route", lineouta_input_enum);
 316
 317 static const struct soc_enum hpa_input_enum =
 318         SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 0,
 319                               ARRAY_SIZE(hploa_input_text),
 320                               hploa_input_text);
 321
 322 static const struct snd_kcontrol_new hpa_input =
 323         SOC_DAPM_ENUM("Route", hpa_input_enum);
 324
 325 static const char * const hplob_input_text[] = {
 326         "DACB", "PGAB"};
 327
 328 static const struct soc_enum lineoutb_input_enum =
 329         SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 3,
 330                               ARRAY_SIZE(hplob_input_text),
 331                               hplob_input_text);
 332
 333 static const struct snd_kcontrol_new lineoutb_input =
 334         SOC_DAPM_ENUM("Route", lineoutb_input_enum);
 335
 336 static const struct soc_enum hpb_input_enum =
 337         SOC_ENUM_SINGLE(CS42L56_AMUTE_HPLO_MUX, 1,
 338                               ARRAY_SIZE(hplob_input_text),
 339                               hplob_input_text);
 340
 341 static const struct snd_kcontrol_new hpb_input =
 342         SOC_DAPM_ENUM("Route", hpb_input_enum);
 343
 344 static const char * const dig_mux_text[] = {
 345         "ADC", "DSP"};
 346
 347 static const struct soc_enum dig_mux_enum =
 348         SOC_ENUM_SINGLE(CS42L56_MISC_CTL, 7,
 349                               ARRAY_SIZE(dig_mux_text),
 350                               dig_mux_text);
 351
 352 static const struct snd_kcontrol_new dig_mux =
 353         SOC_DAPM_ENUM("Route", dig_mux_enum);
 354
 355 static const char * const hpf_freq_text[] = {
 356         "1.8Hz", "119Hz", "236Hz", "464Hz"
 357 };
 358
 359 static const struct soc_enum hpfa_freq_enum =
 360         SOC_ENUM_SINGLE(CS42L56_HPF_CTL, 0,
 361                         ARRAY_SIZE(hpf_freq_text), hpf_freq_text);
 362
 363 static const struct soc_enum hpfb_freq_enum =
 364         SOC_ENUM_SINGLE(CS42L56_HPF_CTL, 2,
 365                         ARRAY_SIZE(hpf_freq_text), hpf_freq_text);
 366
 367 static const char * const ng_delay_text[] = {
 368         "50ms", "100ms", "150ms", "200ms"
 369 };
 370
 371 static const struct soc_enum ng_delay_enum =
 372         SOC_ENUM_SINGLE(CS42L56_NOISE_GATE_CTL, 0,
 373                         ARRAY_SIZE(ng_delay_text), ng_delay_text);
 374
 375 static const struct snd_kcontrol_new cs42l56_snd_controls[] = {
 376
 377         SOC_DOUBLE_R_SX_TLV("Master Volume", CS42L56_MASTER_A_VOLUME,
 378                               CS42L56_MASTER_B_VOLUME, 0, 0x34, 0xE4, adv_tlv),
 379         SOC_DOUBLE("Master Mute Switch", CS42L56_DSP_MUTE_CTL, 0, 1, 1, 1),
 380
 381         SOC_DOUBLE_R_SX_TLV("ADC Mixer Volume", CS42L56_ADCA_MIX_VOLUME,
 382                               CS42L56_ADCB_MIX_VOLUME, 0, 0x88, 0x90, hl_tlv),
 383         SOC_DOUBLE("ADC Mixer Mute Switch", CS42L56_DSP_MUTE_CTL, 6, 7, 1, 1),
 384
 385         SOC_DOUBLE_R_SX_TLV("PCM Mixer Volume", CS42L56_PCMA_MIX_VOLUME,
 386                               CS42L56_PCMB_MIX_VOLUME, 0, 0x88, 0x90, hl_tlv),
 387         SOC_DOUBLE("PCM Mixer Mute Switch", CS42L56_DSP_MUTE_CTL, 4, 5, 1, 1),
 388
 389         SOC_SINGLE_TLV("Analog Advisory Volume",
 390                           CS42L56_ANAINPUT_ADV_VOLUME, 0, 0x00, 1, adv_tlv),
 391         SOC_SINGLE_TLV("Digital Advisory Volume",
 392                           CS42L56_DIGINPUT_ADV_VOLUME, 0, 0x00, 1, adv_tlv),
 393
 394         SOC_DOUBLE_R_SX_TLV("PGA Volume", CS42L56_PGAA_MUX_VOLUME,
 395                               CS42L56_PGAB_MUX_VOLUME, 0, 0x34, 0x24, pga_tlv),
 396         SOC_DOUBLE_R_TLV("ADC Volume", CS42L56_ADCA_ATTENUATOR,
 397                               CS42L56_ADCB_ATTENUATOR, 0, 0x00, 1, adc_tlv),
 398         SOC_DOUBLE("ADC Mute Switch", CS42L56_MISC_ADC_CTL, 2, 3, 1, 1),
 399         SOC_DOUBLE("ADC Boost Switch", CS42L56_GAIN_BIAS_CTL, 3, 2, 1, 1),
 400
 401         SOC_DOUBLE_R_SX_TLV("Headphone Volume", CS42L56_HPA_VOLUME,
 402                               CS42L56_HPB_VOLUME, 0, 0x84, 0x48, hl_tlv),
 403         SOC_DOUBLE_R_SX_TLV("LineOut Volume", CS42L56_LOA_VOLUME,
 404                               CS42L56_LOB_VOLUME, 0, 0x84, 0x48, hl_tlv),
 405
 406         SOC_SINGLE_TLV("Bass Shelving Volume", CS42L56_TONE_CTL,
 407                         0, 0x00, 1, tone_tlv),
 408         SOC_SINGLE_TLV("Treble Shelving Volume", CS42L56_TONE_CTL,
 409                         4, 0x00, 1, tone_tlv),
 410
 411         SOC_DOUBLE_TLV("PGA Preamp Volume", CS42L56_GAIN_BIAS_CTL,
 412                         4, 6, 0x02, 1, preamp_tlv),
 413
 414         SOC_SINGLE("DSP Switch", CS42L56_PLAYBACK_CTL, 7, 1, 1),
 415         SOC_SINGLE("Gang Playback Switch", CS42L56_PLAYBACK_CTL, 4, 1, 1),
 416         SOC_SINGLE("Gang ADC Switch", CS42L56_MISC_ADC_CTL, 7, 1, 1),
 417         SOC_SINGLE("Gang PGA Switch", CS42L56_MISC_ADC_CTL, 6, 1, 1),
 418
 419         SOC_SINGLE("PCMA Invert", CS42L56_PLAYBACK_CTL, 2, 1, 1),
 420         SOC_SINGLE("PCMB Invert", CS42L56_PLAYBACK_CTL, 3, 1, 1),
 421         SOC_SINGLE("ADCA Invert", CS42L56_MISC_ADC_CTL, 2, 1, 1),
 422         SOC_SINGLE("ADCB Invert", CS42L56_MISC_ADC_CTL, 3, 1, 1),
 423
 424         SOC_DOUBLE("HPF Switch", CS42L56_HPF_CTL, 5, 7, 1, 1),
 425         SOC_DOUBLE("HPF Freeze Switch", CS42L56_HPF_CTL, 4, 6, 1, 1),
 426         SOC_ENUM("HPFA Corner Freq", hpfa_freq_enum),
 427         SOC_ENUM("HPFB Corner Freq", hpfb_freq_enum),
 428
 429         SOC_SINGLE("Analog Soft Ramp", CS42L56_MISC_CTL, 4, 1, 1),
 430         SOC_DOUBLE("Analog Soft Ramp Disable", CS42L56_ALC_LIM_SFT_ZC,
 431                 7, 5, 1, 1),
 432         SOC_SINGLE("Analog Zero Cross", CS42L56_MISC_CTL, 3, 1, 1),
 433         SOC_DOUBLE("Analog Zero Cross Disable", CS42L56_ALC_LIM_SFT_ZC,
 434                 6, 4, 1, 1),
 435         SOC_SINGLE("Digital Soft Ramp", CS42L56_MISC_CTL, 2, 1, 1),
 436         SOC_SINGLE("Digital Soft Ramp Disable", CS42L56_ALC_LIM_SFT_ZC,
 437                 3, 1, 1),
 438
 439         SOC_SINGLE("HL Deemphasis", CS42L56_PLAYBACK_CTL, 6, 1, 1),
 440
 441         SOC_SINGLE("ALC Switch", CS42L56_ALC_EN_ATTACK_RATE, 6, 1, 1),
 442         SOC_SINGLE("ALC Limit All Switch", CS42L56_ALC_RELEASE_RATE, 7, 1, 1),
 443         SOC_SINGLE_RANGE("ALC Attack", CS42L56_ALC_EN_ATTACK_RATE,
 444                         0, 0, 0x3f, 0),
 445         SOC_SINGLE_RANGE("ALC Release", CS42L56_ALC_RELEASE_RATE,
 446                         0, 0x3f, 0, 0),
 447         SOC_SINGLE_TLV("ALC MAX", CS42L56_ALC_THRESHOLD,
 448                         5, 0x07, 1, alc_tlv),
 449         SOC_SINGLE_TLV("ALC MIN", CS42L56_ALC_THRESHOLD,
 450                         2, 0x07, 1, alc_tlv),
 451
 452         SOC_SINGLE("Limiter Switch", CS42L56_LIM_CTL_RELEASE_RATE, 7, 1, 1),
 453         SOC_SINGLE("Limit All Switch", CS42L56_LIM_CTL_RELEASE_RATE, 6, 1, 1),
 454         SOC_SINGLE_RANGE("Limiter Attack", CS42L56_LIM_ATTACK_RATE,
 455                         0, 0, 0x3f, 0),
 456         SOC_SINGLE_RANGE("Limiter Release", CS42L56_LIM_CTL_RELEASE_RATE,
 457                         0, 0x3f, 0, 0),
 458         SOC_SINGLE_TLV("Limiter MAX", CS42L56_LIM_THRESHOLD_CTL,
 459                         5, 0x07, 1, alc_tlv),
 460         SOC_SINGLE_TLV("Limiter Cushion", CS42L56_ALC_THRESHOLD,
 461                         2, 0x07, 1, alc_tlv),
 462
 463         SOC_SINGLE("NG Switch", CS42L56_NOISE_GATE_CTL, 6, 1, 1),
 464         SOC_SINGLE("NG All Switch", CS42L56_NOISE_GATE_CTL, 7, 1, 1),
 465         SOC_SINGLE("NG Boost Switch", CS42L56_NOISE_GATE_CTL, 5, 1, 1),
 466         SOC_SINGLE_TLV("NG Unboost Threshold", CS42L56_NOISE_GATE_CTL,
 467                         2, 0x07, 1, ngnb_tlv),
 468         SOC_SINGLE_TLV("NG Boost Threshold", CS42L56_NOISE_GATE_CTL,
 469                         2, 0x07, 1, ngb_tlv),
 470         SOC_ENUM("NG Delay", ng_delay_enum),
 471
 472         SOC_ENUM("Beep Config", beep_config_enum),
 473         SOC_ENUM("Beep Pitch", beep_pitch_enum),
 474         SOC_ENUM("Beep on Time", beep_ontime_enum),
 475         SOC_ENUM("Beep off Time", beep_offtime_enum),
 476         SOC_SINGLE_SX_TLV("Beep Volume", CS42L56_BEEP_FREQ_OFFTIME,
 477                         0, 0x07, 0x23, beep_tlv),
 478         SOC_SINGLE("Beep Tone Ctl Switch", CS42L56_BEEP_TONE_CFG, 0, 1, 1),
 479         SOC_ENUM("Beep Treble Corner Freq", beep_treble_enum),
 480         SOC_ENUM("Beep Bass Corner Freq", beep_bass_enum),
 481
 482 };
 483
 484 static const struct snd_soc_dapm_widget cs42l56_dapm_widgets[] = {
 485
 486         SND_SOC_DAPM_SIGGEN("Beep"),
 487         SND_SOC_DAPM_SUPPLY("VBUF", CS42L56_PWRCTL_1, 5, 1, NULL, 0),
 488         SND_SOC_DAPM_MICBIAS("MIC1 Bias", CS42L56_PWRCTL_1, 4, 1),
 489         SND_SOC_DAPM_SUPPLY("Charge Pump", CS42L56_PWRCTL_1, 3, 1, NULL, 0),
 490
 491         SND_SOC_DAPM_INPUT("AIN1A"),
 492         SND_SOC_DAPM_INPUT("AIN2A"),
 493         SND_SOC_DAPM_INPUT("AIN1B"),
 494         SND_SOC_DAPM_INPUT("AIN2B"),
 495         SND_SOC_DAPM_INPUT("AIN3A"),
 496         SND_SOC_DAPM_INPUT("AIN3B"),
 497
 498         SND_SOC_DAPM_AIF_OUT("SDOUT", NULL,  0,
 499                         SND_SOC_NOPM, 0, 0),
 500
 501         SND_SOC_DAPM_AIF_IN("SDIN", NULL,  0,
 502                         SND_SOC_NOPM, 0, 0),
 503
 504         SND_SOC_DAPM_MUX("Digital Output Mux", SND_SOC_NOPM,
 505                          0, 0, &dig_mux),
 506
 507         SND_SOC_DAPM_PGA("PGAA", SND_SOC_NOPM, 0, 0, NULL, 0),
 508         SND_SOC_DAPM_PGA("PGAB", SND_SOC_NOPM, 0, 0, NULL, 0),
 509         SND_SOC_DAPM_MUX("PGAA Input Mux",
 510                         SND_SOC_NOPM, 0, 0, &pgaa_mux),
 511         SND_SOC_DAPM_MUX("PGAB Input Mux",
 512                         SND_SOC_NOPM, 0, 0, &pgab_mux),
 513
 514         SND_SOC_DAPM_MUX("ADCA Mux", SND_SOC_NOPM,
 515                          0, 0, &adca_mux),
 516         SND_SOC_DAPM_MUX("ADCB Mux", SND_SOC_NOPM,
 517                          0, 0, &adcb_mux),
 518
 519         SND_SOC_DAPM_ADC("ADCA", NULL, CS42L56_PWRCTL_1, 1, 1),
 520         SND_SOC_DAPM_ADC("ADCB", NULL, CS42L56_PWRCTL_1, 2, 1),
 521
 522         SND_SOC_DAPM_MUX("ADCA Swap Mux", SND_SOC_NOPM, 0, 0,
 523                 &adca_swap_mux),
 524         SND_SOC_DAPM_MUX("ADCB Swap Mux", SND_SOC_NOPM, 0, 0,
 525                 &adcb_swap_mux),
 526
 527         SND_SOC_DAPM_MUX("PCMA Swap Mux", SND_SOC_NOPM, 0, 0,
 528                 &pcma_swap_mux),
 529         SND_SOC_DAPM_MUX("PCMB Swap Mux", SND_SOC_NOPM, 0, 0,
 530                 &pcmb_swap_mux),
 531
 532         SND_SOC_DAPM_DAC("DACA", NULL, SND_SOC_NOPM, 0, 0),
 533         SND_SOC_DAPM_DAC("DACB", NULL, SND_SOC_NOPM, 0, 0),
 534
 535         SND_SOC_DAPM_OUTPUT("HPA"),
 536         SND_SOC_DAPM_OUTPUT("LOA"),
 537         SND_SOC_DAPM_OUTPUT("HPB"),
 538         SND_SOC_DAPM_OUTPUT("LOB"),
 539
 540         SND_SOC_DAPM_SWITCH("Headphone Right",
 541                             CS42L56_PWRCTL_2, 4, 1, &hpb_switch),
 542         SND_SOC_DAPM_SWITCH("Headphone Left",
 543                             CS42L56_PWRCTL_2, 6, 1, &hpa_switch),
 544
 545         SND_SOC_DAPM_SWITCH("Lineout Right",
 546                             CS42L56_PWRCTL_2, 0, 1, &lob_switch),
 547         SND_SOC_DAPM_SWITCH("Lineout Left",
 548                             CS42L56_PWRCTL_2, 2, 1, &loa_switch),
 549
 550         SND_SOC_DAPM_MUX("LINEOUTA Input Mux", SND_SOC_NOPM,
 551                          0, 0, &lineouta_input),
 552         SND_SOC_DAPM_MUX("LINEOUTB Input Mux", SND_SOC_NOPM,
 553                          0, 0, &lineoutb_input),
 554         SND_SOC_DAPM_MUX("HPA Input Mux", SND_SOC_NOPM,
 555                          0, 0, &hpa_input),
 556         SND_SOC_DAPM_MUX("HPB Input Mux", SND_SOC_NOPM,
 557                          0, 0, &hpb_input),
 558
 559 };
 560
 561 static const struct snd_soc_dapm_route cs42l56_audio_map[] = {
 562
 563         {"HiFi Capture", "DSP", "Digital Output Mux"},
 564         {"HiFi Capture", "ADC", "Digital Output Mux"},
 565
 566         {"Digital Output Mux", NULL, "ADCA"},
 567         {"Digital Output Mux", NULL, "ADCB"},
 568
 569         {"ADCB", NULL, "ADCB Swap Mux"},
 570         {"ADCA", NULL, "ADCA Swap Mux"},
 571
 572         {"ADCA Swap Mux", NULL, "ADCA"},
 573         {"ADCB Swap Mux", NULL, "ADCB"},
 574
 575         {"DACA", "Left", "ADCA Swap Mux"},
 576         {"DACA", "LR 2", "ADCA Swap Mux"},
 577         {"DACA", "Right", "ADCA Swap Mux"},
 578
 579         {"DACB", "Left", "ADCB Swap Mux"},
 580         {"DACB", "LR 2", "ADCB Swap Mux"},
 581         {"DACB", "Right", "ADCB Swap Mux"},
 582
 583         {"ADCA Mux", NULL, "AIN3A"},
 584         {"ADCA Mux", NULL, "AIN2A"},
 585         {"ADCA Mux", NULL, "AIN1A"},
 586         {"ADCA Mux", NULL, "PGAA"},
 587         {"ADCB Mux", NULL, "AIN3B"},
 588         {"ADCB Mux", NULL, "AIN2B"},
 589         {"ADCB Mux", NULL, "AIN1B"},
 590         {"ADCB Mux", NULL, "PGAB"},
 591
 592         {"PGAA", "AIN1A", "PGAA Input Mux"},
 593         {"PGAA", "AIN2A", "PGAA Input Mux"},
 594         {"PGAA", "AIN3A", "PGAA Input Mux"},
 595         {"PGAB", "AIN1B", "PGAB Input Mux"},
 596         {"PGAB", "AIN2B", "PGAB Input Mux"},
 597         {"PGAB", "AIN3B", "PGAB Input Mux"},
 598
 599         {"PGAA Input Mux", NULL, "AIN1A"},
 600         {"PGAA Input Mux", NULL, "AIN2A"},
 601         {"PGAA Input Mux", NULL, "AIN3A"},
 602         {"PGAB Input Mux", NULL, "AIN1B"},
 603         {"PGAB Input Mux", NULL, "AIN2B"},
 604         {"PGAB Input Mux", NULL, "AIN3B"},
 605
 606         {"LOB", "Switch", "LINEOUTB Input Mux"},
 607         {"LOA", "Switch", "LINEOUTA Input Mux"},
 608
 609         {"LINEOUTA Input Mux", "PGAA", "PGAA"},
 610         {"LINEOUTB Input Mux", "PGAB", "PGAB"},
 611         {"LINEOUTA Input Mux", "DACA", "DACA"},
 612         {"LINEOUTB Input Mux", "DACB", "DACB"},
 613
 614         {"HPA", "Switch", "HPB Input Mux"},
 615         {"HPB", "Switch", "HPA Input Mux"},
 616
 617         {"HPA Input Mux", "PGAA", "PGAA"},
 618         {"HPB Input Mux", "PGAB", "PGAB"},
 619         {"HPA Input Mux", "DACA", "DACA"},
 620         {"HPB Input Mux", "DACB", "DACB"},
 621
 622         {"DACA", NULL, "PCMA Swap Mux"},
 623         {"DACB", NULL, "PCMB Swap Mux"},
 624
 625         {"PCMB Swap Mux", "Left", "HiFi Playback"},
 626         {"PCMB Swap Mux", "LR 2", "HiFi Playback"},
 627         {"PCMB Swap Mux", "Right", "HiFi Playback"},
 628
 629         {"PCMA Swap Mux", "Left", "HiFi Playback"},
 630         {"PCMA Swap Mux", "LR 2", "HiFi Playback"},
 631         {"PCMA Swap Mux", "Right", "HiFi Playback"},
 632
 633 };
 634
 635 struct cs42l56_clk_para {
 636         u32 mclk;
 637         u32 srate;
 638         u8 ratio;
 639 };
 640
 641 static const struct cs42l56_clk_para clk_ratio_table[] = {
 642         /* 8k */
 643         { 6000000, 8000, CS42L56_MCLK_LRCLK_768 },
 644         { 6144000, 8000, CS42L56_MCLK_LRCLK_750 },
 645         { 12000000, 8000, CS42L56_MCLK_LRCLK_768 },
 646         { 12288000, 8000, CS42L56_MCLK_LRCLK_750 },
 647         { 24000000, 8000, CS42L56_MCLK_LRCLK_768 },
 648         { 24576000, 8000, CS42L56_MCLK_LRCLK_750 },
 649         /* 11.025k */
 650         { 5644800, 11025, CS42L56_MCLK_LRCLK_512},
 651         { 11289600, 11025, CS42L56_MCLK_LRCLK_512},
 652         { 22579200, 11025, CS42L56_MCLK_LRCLK_512 },
 653         /* 11.0294k */
 654         { 6000000, 110294, CS42L56_MCLK_LRCLK_544 },
 655         { 12000000, 110294, CS42L56_MCLK_LRCLK_544 },
 656         { 24000000, 110294, CS42L56_MCLK_LRCLK_544 },
 657         /* 12k */
 658         { 6000000, 12000, CS42L56_MCLK_LRCLK_500 },
 659         { 6144000, 12000, CS42L56_MCLK_LRCLK_512 },
 660         { 12000000, 12000, CS42L56_MCLK_LRCLK_500 },
 661         { 12288000, 12000, CS42L56_MCLK_LRCLK_512 },
 662         { 24000000, 12000, CS42L56_MCLK_LRCLK_500 },
 663         { 24576000, 12000, CS42L56_MCLK_LRCLK_512 },
 664         /* 16k */
 665         { 6000000, 16000, CS42L56_MCLK_LRCLK_375 },
 666         { 6144000, 16000, CS42L56_MCLK_LRCLK_384 },
 667         { 12000000, 16000, CS42L56_MCLK_LRCLK_375 },
 668         { 12288000, 16000, CS42L56_MCLK_LRCLK_384 },
 669         { 24000000, 16000, CS42L56_MCLK_LRCLK_375 },
 670         { 24576000, 16000, CS42L56_MCLK_LRCLK_384 },
 671         /* 22.050k */
 672         { 5644800, 22050, CS42L56_MCLK_LRCLK_256 },
 673         { 11289600, 22050, CS42L56_MCLK_LRCLK_256 },
 674         { 22579200, 22050, CS42L56_MCLK_LRCLK_256 },
 675         /* 22.0588k */
 676         { 6000000, 220588, CS42L56_MCLK_LRCLK_272 },
 677         { 12000000, 220588, CS42L56_MCLK_LRCLK_272 },
 678         { 24000000, 220588, CS42L56_MCLK_LRCLK_272 },
 679         /* 24k */
 680         { 6000000, 24000, CS42L56_MCLK_LRCLK_250 },
 681         { 6144000, 24000, CS42L56_MCLK_LRCLK_256 },
 682         { 12000000, 24000, CS42L56_MCLK_LRCLK_250 },
 683         { 12288000, 24000, CS42L56_MCLK_LRCLK_256 },
 684         { 24000000, 24000, CS42L56_MCLK_LRCLK_250 },
 685         { 24576000, 24000, CS42L56_MCLK_LRCLK_256 },
 686         /* 32k */
 687         { 6000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
 688         { 6144000, 32000, CS42L56_MCLK_LRCLK_192 },
 689         { 12000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
 690         { 12288000, 32000, CS42L56_MCLK_LRCLK_192 },
 691         { 24000000, 32000, CS42L56_MCLK_LRCLK_187P5 },
 692         { 24576000, 32000, CS42L56_MCLK_LRCLK_192 },
 693         /* 44.118k */
 694         { 6000000, 44118, CS42L56_MCLK_LRCLK_136 },
 695         { 12000000, 44118, CS42L56_MCLK_LRCLK_136 },
 696         { 24000000, 44118, CS42L56_MCLK_LRCLK_136 },
 697         /* 44.1k */
 698         { 5644800, 44100, CS42L56_MCLK_LRCLK_128 },
 699         { 11289600, 44100, CS42L56_MCLK_LRCLK_128 },
 700         { 22579200, 44100, CS42L56_MCLK_LRCLK_128 },
 701         /* 48k */
 702         { 6000000, 48000, CS42L56_MCLK_LRCLK_125 },
 703         { 6144000, 48000, CS42L56_MCLK_LRCLK_128 },
 704         { 12000000, 48000, CS42L56_MCLK_LRCLK_125 },
 705         { 12288000, 48000, CS42L56_MCLK_LRCLK_128 },
 706         { 24000000, 48000, CS42L56_MCLK_LRCLK_125 },
 707         { 24576000, 48000, CS42L56_MCLK_LRCLK_128 },
 708 };
 709
 710 static int cs42l56_get_mclk_ratio(int mclk, int rate)
 711 {
 712         int i;
 713
 714         for (i = 0; i < ARRAY_SIZE(clk_ratio_table); i++) {
 715                 if (clk_ratio_table[i].mclk == mclk &&
 716                     clk_ratio_table[i].srate == rate)
 717                         return clk_ratio_table[i].ratio;
 718         }
 719         return -EINVAL;
 720 }
 721
 722 static int cs42l56_set_sysclk(struct snd_soc_dai *codec_dai,
 723                         int clk_id, unsigned int freq, int dir)
 724 {
 725         struct snd_soc_component *component = codec_dai->component;
 726         struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
 727
 728         switch (freq) {
 729         case CS42L56_MCLK_5P6448MHZ:
 730         case CS42L56_MCLK_6MHZ:
 731         case CS42L56_MCLK_6P144MHZ:
 732                 cs42l56->mclk_div2 = 0;
 733                 cs42l56->mclk_prediv = 0;
 734                 break;
 735         case CS42L56_MCLK_11P2896MHZ:
 736         case CS42L56_MCLK_12MHZ:
 737         case CS42L56_MCLK_12P288MHZ:
 738                 cs42l56->mclk_div2 = CS42L56_MCLK_DIV2;
 739                 cs42l56->mclk_prediv = 0;
 740                 break;
 741         case CS42L56_MCLK_22P5792MHZ:
 742         case CS42L56_MCLK_24MHZ:
 743         case CS42L56_MCLK_24P576MHZ:
 744                 cs42l56->mclk_div2 = CS42L56_MCLK_DIV2;
 745                 cs42l56->mclk_prediv = CS42L56_MCLK_PREDIV;
 746                 break;
 747         default:
 748                 return -EINVAL;
 749         }
 750         cs42l56->mclk = freq;
 751
 752         snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
 753                             CS42L56_MCLK_PREDIV_MASK,
 754                                 cs42l56->mclk_prediv);
 755         snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
 756                             CS42L56_MCLK_DIV2_MASK,
 757                                 cs42l56->mclk_div2);
 758
 759         return 0;
 760 }
 761
 762 static int cs42l56_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
 763 {
 764         struct snd_soc_component *component = codec_dai->component;
 765         struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
 766
 767         switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
 768         case SND_SOC_DAIFMT_CBM_CFM:
 769                 cs42l56->iface = CS42L56_MASTER_MODE;
 770                 break;
 771         case SND_SOC_DAIFMT_CBS_CFS:
 772                 cs42l56->iface = CS42L56_SLAVE_MODE;
 773                 break;
 774         default:
 775                 return -EINVAL;
 776         }
 777
 778          /* interface format */
 779         switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
 780         case SND_SOC_DAIFMT_I2S:
 781                 cs42l56->iface_fmt = CS42L56_DIG_FMT_I2S;
 782                 break;
 783         case SND_SOC_DAIFMT_LEFT_J:
 784                 cs42l56->iface_fmt = CS42L56_DIG_FMT_LEFT_J;
 785                 break;
 786         default:
 787                 return -EINVAL;
 788         }
 789
 790         /* sclk inversion */
 791         switch (fmt & SND_SOC_DAIFMT_INV_MASK) {
 792         case SND_SOC_DAIFMT_NB_NF:
 793                 cs42l56->iface_inv = 0;
 794                 break;
 795         case SND_SOC_DAIFMT_IB_NF:
 796                 cs42l56->iface_inv = CS42L56_SCLK_INV;
 797                 break;
 798         default:
 799                 return -EINVAL;
 800         }
 801
 802         snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
 803                             CS42L56_MS_MODE_MASK, cs42l56->iface);
 804         snd_soc_component_update_bits(component, CS42L56_SERIAL_FMT,
 805                             CS42L56_DIG_FMT_MASK, cs42l56->iface_fmt);
 806         snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
 807                             CS42L56_SCLK_INV_MASK, cs42l56->iface_inv);
 808         return 0;
 809 }
 810
 811 static int cs42l56_digital_mute(struct snd_soc_dai *dai, int mute)
 812 {
 813         struct snd_soc_component *component = dai->component;
 814
 815         if (mute) {
 816                 /* Hit the DSP Mixer first */
 817                 snd_soc_component_update_bits(component, CS42L56_DSP_MUTE_CTL,
 818                                     CS42L56_ADCAMIX_MUTE_MASK |
 819                                     CS42L56_ADCBMIX_MUTE_MASK |
 820                                     CS42L56_PCMAMIX_MUTE_MASK |
 821                                     CS42L56_PCMBMIX_MUTE_MASK |
 822                                     CS42L56_MSTB_MUTE_MASK |
 823                                     CS42L56_MSTA_MUTE_MASK,
 824                                     CS42L56_MUTE_ALL);
 825                 /* Mute ADC's */
 826                 snd_soc_component_update_bits(component, CS42L56_MISC_ADC_CTL,
 827                                     CS42L56_ADCA_MUTE_MASK |
 828                                     CS42L56_ADCB_MUTE_MASK,
 829                                     CS42L56_MUTE_ALL);
 830                 /* HP And LO */
 831                 snd_soc_component_update_bits(component, CS42L56_HPA_VOLUME,
 832                                     CS42L56_HP_MUTE_MASK, CS42L56_MUTE_ALL);
 833                 snd_soc_component_update_bits(component, CS42L56_HPB_VOLUME,
 834                                     CS42L56_HP_MUTE_MASK, CS42L56_MUTE_ALL);
 835                 snd_soc_component_update_bits(component, CS42L56_LOA_VOLUME,
 836                                     CS42L56_LO_MUTE_MASK, CS42L56_MUTE_ALL);
 837                 snd_soc_component_update_bits(component, CS42L56_LOB_VOLUME,
 838                                     CS42L56_LO_MUTE_MASK, CS42L56_MUTE_ALL);
 839         } else {
 840                 snd_soc_component_update_bits(component, CS42L56_DSP_MUTE_CTL,
 841                                     CS42L56_ADCAMIX_MUTE_MASK |
 842                                     CS42L56_ADCBMIX_MUTE_MASK |
 843                                     CS42L56_PCMAMIX_MUTE_MASK |
 844                                     CS42L56_PCMBMIX_MUTE_MASK |
 845                                     CS42L56_MSTB_MUTE_MASK |
 846                                     CS42L56_MSTA_MUTE_MASK,
 847                                     CS42L56_UNMUTE);
 848
 849                 snd_soc_component_update_bits(component, CS42L56_MISC_ADC_CTL,
 850                                     CS42L56_ADCA_MUTE_MASK |
 851                                     CS42L56_ADCB_MUTE_MASK,
 852                                     CS42L56_UNMUTE);
 853
 854                 snd_soc_component_update_bits(component, CS42L56_HPA_VOLUME,
 855                                     CS42L56_HP_MUTE_MASK, CS42L56_UNMUTE);
 856                 snd_soc_component_update_bits(component, CS42L56_HPB_VOLUME,
 857                                     CS42L56_HP_MUTE_MASK, CS42L56_UNMUTE);
 858                 snd_soc_component_update_bits(component, CS42L56_LOA_VOLUME,
 859                                     CS42L56_LO_MUTE_MASK, CS42L56_UNMUTE);
 860                 snd_soc_component_update_bits(component, CS42L56_LOB_VOLUME,
 861                                     CS42L56_LO_MUTE_MASK, CS42L56_UNMUTE);
 862         }
 863         return 0;
 864 }
 865
 866 static int cs42l56_pcm_hw_params(struct snd_pcm_substream *substream,
 867                                      struct snd_pcm_hw_params *params,
 868                                      struct snd_soc_dai *dai)
 869 {
 870         struct snd_soc_component *component = dai->component;
 871         struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
 872         int ratio;
 873
 874         ratio = cs42l56_get_mclk_ratio(cs42l56->mclk, params_rate(params));
 875         if (ratio >= 0) {
 876                 snd_soc_component_update_bits(component, CS42L56_CLKCTL_2,
 877                                     CS42L56_CLK_RATIO_MASK, ratio);
 878         } else {
 879                 dev_err(component->dev, "unsupported mclk/sclk/lrclk ratio\n");
 880                 return -EINVAL;
 881         }
 882
 883         return 0;
 884 }
 885
 886 static int cs42l56_set_bias_level(struct snd_soc_component *component,
 887                                         enum snd_soc_bias_level level)
 888 {
 889         struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
 890         int ret;
 891
 892         switch (level) {
 893         case SND_SOC_BIAS_ON:
 894                 break;
 895         case SND_SOC_BIAS_PREPARE:
 896                 snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
 897                                     CS42L56_MCLK_DIS_MASK, 0);
 898                 snd_soc_component_update_bits(component, CS42L56_PWRCTL_1,
 899                                     CS42L56_PDN_ALL_MASK, 0);
 900                 break;
 901         case SND_SOC_BIAS_STANDBY:
 902                 if (snd_soc_component_get_bias_level(component) == SND_SOC_BIAS_OFF) {
 903                         regcache_cache_only(cs42l56->regmap, false);
 904                         regcache_sync(cs42l56->regmap);
 905                         ret = regulator_bulk_enable(ARRAY_SIZE(cs42l56->supplies),
 906                                                     cs42l56->supplies);
 907                         if (ret != 0) {
 908                                 dev_err(cs42l56->dev,
 909                                         "Failed to enable regulators: %d\n",
 910                                         ret);
 911                                 return ret;
 912                         }
 913                 }
 914                 snd_soc_component_update_bits(component, CS42L56_PWRCTL_1,
 915                                     CS42L56_PDN_ALL_MASK, 1);
 916                 break;
 917         case SND_SOC_BIAS_OFF:
 918                 snd_soc_component_update_bits(component, CS42L56_PWRCTL_1,
 919                                     CS42L56_PDN_ALL_MASK, 1);
 920                 snd_soc_component_update_bits(component, CS42L56_CLKCTL_1,
 921                                     CS42L56_MCLK_DIS_MASK, 1);
 922                 regcache_cache_only(cs42l56->regmap, true);
 923                 regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
 924                                                     cs42l56->supplies);
 925                 break;
 926         }
 927
 928         return 0;
 929 }
 930
 931 #define CS42L56_RATES (SNDRV_PCM_RATE_8000_48000)
 932
 933 #define CS42L56_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S18_3LE | \
 934                         SNDRV_PCM_FMTBIT_S20_3LE | SNDRV_PCM_FMTBIT_S24_LE | \
 935                         SNDRV_PCM_FMTBIT_S32_LE)
 936
 937
 938 static const struct snd_soc_dai_ops cs42l56_ops = {
 939         .hw_params      = cs42l56_pcm_hw_params,
 940         .digital_mute   = cs42l56_digital_mute,
 941         .set_fmt        = cs42l56_set_dai_fmt,
 942         .set_sysclk     = cs42l56_set_sysclk,
 943 };
 944
 945 static struct snd_soc_dai_driver cs42l56_dai = {
 946                 .name = "cs42l56",
 947                 .playback = {
 948                         .stream_name = "HiFi Playback",
 949                         .channels_min = 1,
 950                         .channels_max = 2,
 951                         .rates = CS42L56_RATES,
 952                         .formats = CS42L56_FORMATS,
 953                 },
 954                 .capture = {
 955                         .stream_name = "HiFi Capture",
 956                         .channels_min = 1,
 957                         .channels_max = 2,
 958                         .rates = CS42L56_RATES,
 959                         .formats = CS42L56_FORMATS,
 960                 },
 961                 .ops = &cs42l56_ops,
 962 };
 963
 964 static int beep_freq[] = {
 965         261, 522, 585, 667, 706, 774, 889, 1000,
 966         1043, 1200, 1333, 1412, 1600, 1714, 2000, 2182
 967 };
 968
 969 static void cs42l56_beep_work(struct work_struct *work)
 970 {
 971         struct cs42l56_private *cs42l56 =
 972                 container_of(work, struct cs42l56_private, beep_work);
 973         struct snd_soc_component *component = cs42l56->component;
 974         struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 975         int i;
 976         int val = 0;
 977         int best = 0;
 978
 979         if (cs42l56->beep_rate) {
 980                 for (i = 0; i < ARRAY_SIZE(beep_freq); i++) {
 981                         if (abs(cs42l56->beep_rate - beep_freq[i]) <
 982                             abs(cs42l56->beep_rate - beep_freq[best]))
 983                                 best = i;
 984                 }
 985
 986                 dev_dbg(component->dev, "Set beep rate %dHz for requested %dHz\n",
 987                         beep_freq[best], cs42l56->beep_rate);
 988
 989                 val = (best << CS42L56_BEEP_RATE_SHIFT);
 990
 991                 snd_soc_dapm_enable_pin(dapm, "Beep");
 992         } else {
 993                 dev_dbg(component->dev, "Disabling beep\n");
 994                 snd_soc_dapm_disable_pin(dapm, "Beep");
 995         }
 996
 997         snd_soc_component_update_bits(component, CS42L56_BEEP_FREQ_ONTIME,
 998                             CS42L56_BEEP_FREQ_MASK, val);
 999
1000         snd_soc_dapm_sync(dapm);
1001 }
1002
1003 /* For usability define a way of injecting beep events for the device -
1004  * many systems will not have a keyboard.
1005  */
1006 static int cs42l56_beep_event(struct input_dev *dev, unsigned int type,
1007                              unsigned int code, int hz)
1008 {
1009         struct snd_soc_component *component = input_get_drvdata(dev);
1010         struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
1011
1012         dev_dbg(component->dev, "Beep event %x %x\n", code, hz);
1013
1014         switch (code) {
1015         case SND_BELL:
1016                 if (hz)
1017                         hz = 261;
1018         case SND_TONE:
1019                 break;
1020         default:
1021                 return -1;
1022         }
1023
1024         /* Kick the beep from a workqueue */
1025         cs42l56->beep_rate = hz;
1026         schedule_work(&cs42l56->beep_work);
1027         return 0;
1028 }
1029
1030 static ssize_t cs42l56_beep_set(struct device *dev,
1031                                struct device_attribute *attr,
1032                                const char *buf, size_t count)
1033 {
1034         struct cs42l56_private *cs42l56 = dev_get_drvdata(dev);
1035         long int time;
1036         int ret;
1037
1038         ret = kstrtol(buf, 10, &time);
1039         if (ret != 0)
1040                 return ret;
1041
1042         input_event(cs42l56->beep, EV_SND, SND_TONE, time);
1043
1044         return count;
1045 }
1046
1047 static DEVICE_ATTR(beep, 0200, NULL, cs42l56_beep_set);
1048
1049 static void cs42l56_init_beep(struct snd_soc_component *component)
1050 {
1051         struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
1052         int ret;
1053
1054         cs42l56->beep = devm_input_allocate_device(component->dev);
1055         if (!cs42l56->beep) {
1056                 dev_err(component->dev, "Failed to allocate beep device\n");
1057                 return;
1058         }
1059
1060         INIT_WORK(&cs42l56->beep_work, cs42l56_beep_work);
1061         cs42l56->beep_rate = 0;
1062
1063         cs42l56->beep->name = "CS42L56 Beep Generator";
1064         cs42l56->beep->phys = dev_name(component->dev);
1065         cs42l56->beep->id.bustype = BUS_I2C;
1066
1067         cs42l56->beep->evbit[0] = BIT_MASK(EV_SND);
1068         cs42l56->beep->sndbit[0] = BIT_MASK(SND_BELL) | BIT_MASK(SND_TONE);
1069         cs42l56->beep->event = cs42l56_beep_event;
1070         cs42l56->beep->dev.parent = component->dev;
1071         input_set_drvdata(cs42l56->beep, component);
1072
1073         ret = input_register_device(cs42l56->beep);
1074         if (ret != 0) {
1075                 cs42l56->beep = NULL;
1076                 dev_err(component->dev, "Failed to register beep device\n");
1077         }
1078
1079         ret = device_create_file(component->dev, &dev_attr_beep);
1080         if (ret != 0) {
1081                 dev_err(component->dev, "Failed to create keyclick file: %d\n",
1082                         ret);
1083         }
1084 }
1085
1086 static void cs42l56_free_beep(struct snd_soc_component *component)
1087 {
1088         struct cs42l56_private *cs42l56 = snd_soc_component_get_drvdata(component);
1089
1090         device_remove_file(component->dev, &dev_attr_beep);
1091         cancel_work_sync(&cs42l56->beep_work);
1092         cs42l56->beep = NULL;
1093
1094         snd_soc_component_update_bits(component, CS42L56_BEEP_TONE_CFG,
1095                             CS42L56_BEEP_EN_MASK, 0);
1096 }
1097
1098 static int cs42l56_probe(struct snd_soc_component *component)
1099 {
1100         cs42l56_init_beep(component);
1101
1102         return 0;
1103 }
1104
1105 static void cs42l56_remove(struct snd_soc_component *component)
1106 {
1107         cs42l56_free_beep(component);
1108 }
1109
1110 static const struct snd_soc_component_driver soc_component_dev_cs42l56 = {
1111         .probe                  = cs42l56_probe,
1112         .remove                 = cs42l56_remove,
1113         .set_bias_level         = cs42l56_set_bias_level,
1114         .controls               = cs42l56_snd_controls,
1115         .num_controls           = ARRAY_SIZE(cs42l56_snd_controls),
1116         .dapm_widgets           = cs42l56_dapm_widgets,
1117         .num_dapm_widgets       = ARRAY_SIZE(cs42l56_dapm_widgets),
1118         .dapm_routes            = cs42l56_audio_map,
1119         .num_dapm_routes        = ARRAY_SIZE(cs42l56_audio_map),
1120         .suspend_bias_off       = 1,
1121         .idle_bias_on           = 1,
1122         .use_pmdown_time        = 1,
1123         .endianness             = 1,
1124         .non_legacy_dai_naming  = 1,
1125 };
1126
1127 static const struct regmap_config cs42l56_regmap = {
1128         .reg_bits = 8,
1129         .val_bits = 8,
1130
1131         .max_register = CS42L56_MAX_REGISTER,
1132         .reg_defaults = cs42l56_reg_defaults,
1133         .num_reg_defaults = ARRAY_SIZE(cs42l56_reg_defaults),
1134         .readable_reg = cs42l56_readable_register,
1135         .volatile_reg = cs42l56_volatile_register,
1136         .cache_type = REGCACHE_RBTREE,
1137 };
1138
1139 static int cs42l56_handle_of_data(struct i2c_client *i2c_client,
1140                                     struct cs42l56_platform_data *pdata)
1141 {
1142         struct device_node *np = i2c_client->dev.of_node;
1143         u32 val32;
1144
1145         if (of_property_read_bool(np, "cirrus,ain1a-reference-cfg"))
1146                 pdata->ain1a_ref_cfg = true;
1147
1148         if (of_property_read_bool(np, "cirrus,ain2a-reference-cfg"))
1149                 pdata->ain2a_ref_cfg = true;
1150
1151         if (of_property_read_bool(np, "cirrus,ain1b-reference-cfg"))
1152                 pdata->ain1b_ref_cfg = true;
1153
1154         if (of_property_read_bool(np, "cirrus,ain2b-reference-cfg"))
1155                 pdata->ain2b_ref_cfg = true;
1156
1157         if (of_property_read_u32(np, "cirrus,micbias-lvl", &val32) >= 0)
1158                 pdata->micbias_lvl = val32;
1159
1160         if (of_property_read_u32(np, "cirrus,chgfreq-divisor", &val32) >= 0)
1161                 pdata->chgfreq = val32;
1162
1163         if (of_property_read_u32(np, "cirrus,adaptive-pwr-cfg", &val32) >= 0)
1164                 pdata->adaptive_pwr = val32;
1165
1166         if (of_property_read_u32(np, "cirrus,hpf-left-freq", &val32) >= 0)
1167                 pdata->hpfa_freq = val32;
1168
1169         if (of_property_read_u32(np, "cirrus,hpf-left-freq", &val32) >= 0)
1170                 pdata->hpfb_freq = val32;
1171
1172         pdata->gpio_nreset = of_get_named_gpio(np, "cirrus,gpio-nreset", 0);
1173
1174         return 0;
1175 }
1176
1177 static int cs42l56_i2c_probe(struct i2c_client *i2c_client,
1178                              const struct i2c_device_id *id)
1179 {
1180         struct cs42l56_private *cs42l56;
1181         struct cs42l56_platform_data *pdata =
1182                 dev_get_platdata(&i2c_client->dev);
1183         int ret, i;
1184         unsigned int devid = 0;
1185         unsigned int alpha_rev, metal_rev;
1186         unsigned int reg;
1187
1188         cs42l56 = devm_kzalloc(&i2c_client->dev, sizeof(*cs42l56), GFP_KERNEL);
1189         if (cs42l56 == NULL)
1190                 return -ENOMEM;
1191         cs42l56->dev = &i2c_client->dev;
1192
1193         cs42l56->regmap = devm_regmap_init_i2c(i2c_client, &cs42l56_regmap);
1194         if (IS_ERR(cs42l56->regmap)) {
1195                 ret = PTR_ERR(cs42l56->regmap);
1196                 dev_err(&i2c_client->dev, "regmap_init() failed: %d\n", ret);
1197                 return ret;
1198         }
1199
1200         if (pdata) {
1201                 cs42l56->pdata = *pdata;
1202         } else {
1203                 pdata = devm_kzalloc(&i2c_client->dev, sizeof(*pdata),
1204                                      GFP_KERNEL);
1205                 if (!pdata)
1206                         return -ENOMEM;
1207
1208                 if (i2c_client->dev.of_node) {
1209                         ret = cs42l56_handle_of_data(i2c_client,
1210                                                      &cs42l56->pdata);
1211                         if (ret != 0)
1212                                 return ret;
1213                 }
1214                 cs42l56->pdata = *pdata;
1215         }
1216
1217         if (cs42l56->pdata.gpio_nreset) {
1218                 ret = gpio_request_one(cs42l56->pdata.gpio_nreset,
1219                                        GPIOF_OUT_INIT_HIGH, "CS42L56 /RST");
1220                 if (ret < 0) {
1221                         dev_err(&i2c_client->dev,
1222                                 "Failed to request /RST %d: %d\n",
1223                                 cs42l56->pdata.gpio_nreset, ret);
1224                         return ret;
1225                 }
1226                 gpio_set_value_cansleep(cs42l56->pdata.gpio_nreset, 0);
1227                 gpio_set_value_cansleep(cs42l56->pdata.gpio_nreset, 1);
1228         }
1229
1230
1231         i2c_set_clientdata(i2c_client, cs42l56);
1232
1233         for (i = 0; i < ARRAY_SIZE(cs42l56->supplies); i++)
1234                 cs42l56->supplies[i].supply = cs42l56_supply_names[i];
1235
1236         ret = devm_regulator_bulk_get(&i2c_client->dev,
1237                                       ARRAY_SIZE(cs42l56->supplies),
1238                                       cs42l56->supplies);
1239         if (ret != 0) {
1240                 dev_err(&i2c_client->dev,
1241                         "Failed to request supplies: %d\n", ret);
1242                 return ret;
1243         }
1244
1245         ret = regulator_bulk_enable(ARRAY_SIZE(cs42l56->supplies),
1246                                     cs42l56->supplies);
1247         if (ret != 0) {
1248                 dev_err(&i2c_client->dev,
1249                         "Failed to enable supplies: %d\n", ret);
1250                 return ret;
1251         }
1252
1253         ret = regmap_read(cs42l56->regmap, CS42L56_CHIP_ID_1, &reg);
1254         devid = reg & CS42L56_CHIP_ID_MASK;
1255         if (devid != CS42L56_DEVID) {
1256                 dev_err(&i2c_client->dev,
1257                         "CS42L56 Device ID (%X). Expected %X\n",
1258                         devid, CS42L56_DEVID);
1259                 goto err_enable;
1260         }
1261         alpha_rev = reg & CS42L56_AREV_MASK;
1262         metal_rev = reg & CS42L56_MTLREV_MASK;
1263
1264         dev_info(&i2c_client->dev, "Cirrus Logic CS42L56 ");
1265         dev_info(&i2c_client->dev, "Alpha Rev %X Metal Rev %X\n",
1266                  alpha_rev, metal_rev);
1267
1268         if (cs42l56->pdata.ain1a_ref_cfg)
1269                 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1270                                    CS42L56_AIN1A_REF_MASK,
1271                                    CS42L56_AIN1A_REF_MASK);
1272
1273         if (cs42l56->pdata.ain1b_ref_cfg)
1274                 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1275                                    CS42L56_AIN1B_REF_MASK,
1276                                    CS42L56_AIN1B_REF_MASK);
1277
1278         if (cs42l56->pdata.ain2a_ref_cfg)
1279                 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1280                                    CS42L56_AIN2A_REF_MASK,
1281                                    CS42L56_AIN2A_REF_MASK);
1282
1283         if (cs42l56->pdata.ain2b_ref_cfg)
1284                 regmap_update_bits(cs42l56->regmap, CS42L56_AIN_REFCFG_ADC_MUX,
1285                                    CS42L56_AIN2B_REF_MASK,
1286                                    CS42L56_AIN2B_REF_MASK);
1287
1288         if (cs42l56->pdata.micbias_lvl)
1289                 regmap_update_bits(cs42l56->regmap, CS42L56_GAIN_BIAS_CTL,
1290                                    CS42L56_MIC_BIAS_MASK,
1291                                 cs42l56->pdata.micbias_lvl);
1292
1293         if (cs42l56->pdata.chgfreq)
1294                 regmap_update_bits(cs42l56->regmap, CS42L56_CLASSH_CTL,
1295                                    CS42L56_CHRG_FREQ_MASK,
1296                                 cs42l56->pdata.chgfreq);
1297
1298         if (cs42l56->pdata.hpfb_freq)
1299                 regmap_update_bits(cs42l56->regmap, CS42L56_HPF_CTL,
1300                                    CS42L56_HPFB_FREQ_MASK,
1301                                 cs42l56->pdata.hpfb_freq);
1302
1303         if (cs42l56->pdata.hpfa_freq)
1304                 regmap_update_bits(cs42l56->regmap, CS42L56_HPF_CTL,
1305                                    CS42L56_HPFA_FREQ_MASK,
1306                                 cs42l56->pdata.hpfa_freq);
1307
1308         if (cs42l56->pdata.adaptive_pwr)
1309                 regmap_update_bits(cs42l56->regmap, CS42L56_CLASSH_CTL,
1310                                    CS42L56_ADAPT_PWR_MASK,
1311                                 cs42l56->pdata.adaptive_pwr);
1312
1313         ret =  devm_snd_soc_register_component(&i2c_client->dev,
1314                         &soc_component_dev_cs42l56, &cs42l56_dai, 1);
1315         if (ret < 0)
1316                 return ret;
1317
1318         return 0;
1319
1320 err_enable:
1321         regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
1322                                cs42l56->supplies);
1323         return ret;
1324 }
1325
1326 static int cs42l56_i2c_remove(struct i2c_client *client)
1327 {
1328         struct cs42l56_private *cs42l56 = i2c_get_clientdata(client);
1329
1330         regulator_bulk_disable(ARRAY_SIZE(cs42l56->supplies),
1331                                cs42l56->supplies);
1332         return 0;
1333 }
1334
1335 static const struct of_device_id cs42l56_of_match[] = {
1336         { .compatible = "cirrus,cs42l56", },
1337         { }
1338 };
1339 MODULE_DEVICE_TABLE(of, cs42l56_of_match);
1340
1341
1342 static const struct i2c_device_id cs42l56_id[] = {
1343         { "cs42l56", 0 },
1344         { }
1345 };
1346 MODULE_DEVICE_TABLE(i2c, cs42l56_id);
1347
1348 static struct i2c_driver cs42l56_i2c_driver = {
1349         .driver = {
1350                 .name = "cs42l56",
1351                 .of_match_table = cs42l56_of_match,
1352         },
1353         .id_table = cs42l56_id,
1354         .probe =    cs42l56_i2c_probe,
1355         .remove =   cs42l56_i2c_remove,
1356 };
1357
1358 module_i2c_driver(cs42l56_i2c_driver);
1359
1360 MODULE_DESCRIPTION("ASoC CS42L56 driver");
1361 MODULE_AUTHOR("Brian Austin, Cirrus Logic Inc, <brian.austin@cirrus.com>");
1362 MODULE_LICENSE("GPL");