Gedichte Musik Bilder Quellcodebibliothek Diashow Normaldarstellung
Quellcodebibliothek Statistik Leitseite products/sources/formale Sprachen/C/Linux/sound/soc/codecs/   (Open Source Betriebssystem Version 6.17.9©)  Datei vom 24.10.2025 mit Größe 114 kB image not shown  

Quelle  wcd938x.c   Sprache: C

 
// SPDX-License-Identifier: GPL-2.0-only
// Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/platform_device.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/gpio/consumer.h>
#include <linux/kernel.h>
#include <linux/pm_runtime.h>
#include <linux/component.h>
#include <sound/tlv.h>
#include <linux/of.h>
#include <sound/jack.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <linux/regmap.h>
#include <sound/soc.h>
#include <sound/soc-dapm.h>
#include <linux/mux/consumer.h>
#include <linux/regulator/consumer.h>

#include "wcd-clsh-v2.h"
#include "wcd-mbhc-v2.h"
#include "wcd938x.h"

#define CHIPID_WCD9380   0x0
#define CHIPID_WCD9385   0x5

#define WCD938X_MAX_MICBIAS  (4)
#define WCD938X_MBHC_MAX_BUTTONS (8)
#define TX_ADC_MAX   (4)

#define WCD938X_RATES_MASK (SNDRV_PCM_RATE_8000 | SNDRV_PCM_RATE_16000 |\
       SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_48000 |\
       SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000)
/* Fractional Rates */
#define WCD938X_FRAC_RATES_MASK (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_88200 |\
     SNDRV_PCM_RATE_176400)
#define WCD938X_FORMATS_S16_S24_LE (SNDRV_PCM_FMTBIT_S16_LE | \
        SNDRV_PCM_FMTBIT_S24_LE)
#define SWR_CLK_RATE_0P6MHZ  (600000)
#define SWR_CLK_RATE_1P2MHZ  (1200000)
#define SWR_CLK_RATE_2P4MHZ  (2400000)
#define SWR_CLK_RATE_4P8MHZ  (4800000)
#define SWR_CLK_RATE_9P6MHZ  (9600000)
#define SWR_CLK_RATE_11P2896MHZ  (1128960)

#define EAR_RX_PATH_AUX   (1)

#define ADC_MODE_VAL_HIFI  0x01
#define ADC_MODE_VAL_LO_HIF  0x02
#define ADC_MODE_VAL_NORMAL  0x03
#define ADC_MODE_VAL_LP   0x05
#define ADC_MODE_VAL_ULP1  0x09
#define ADC_MODE_VAL_ULP2  0x0B

/* Z value defined in milliohm */
#define WCD938X_ZDET_VAL_32             (32000)
#define WCD938X_ZDET_VAL_400            (400000)
#define WCD938X_ZDET_VAL_1200           (1200000)
#define WCD938X_ZDET_VAL_100K           (100000000)
/* Z floating defined in ohms */
#define WCD938X_ZDET_FLOATING_IMPEDANCE (0x0FFFFFFE)
#define WCD938X_ZDET_NUM_MEASUREMENTS   (900)
#define WCD938X_MBHC_GET_C1(c)          ((c & 0xC000) >> 14)
#define WCD938X_MBHC_GET_X1(x)          (x & 0x3FFF)
/* Z value compared in milliOhm */
#define WCD938X_MBHC_IS_SECOND_RAMP_REQUIRED(z) ((z > 400000) || (z < 32000))
#define WCD938X_MBHC_ZDET_CONST         (86 * 16384)
#define WCD_MBHC_HS_V_MAX           1600

#define WCD938X_EAR_PA_GAIN_TLV(xname, reg, shift, max, invert, tlv_array) \
 SOC_SINGLE_EXT_TLV(xname, reg, shift, max, invert, snd_soc_get_volsw, \
      wcd938x_ear_pa_put_gain, tlv_array)

enum {
 /* INTR_CTRL_INT_MASK_0 */
 WCD938X_IRQ_MBHC_BUTTON_PRESS_DET = 0,
 WCD938X_IRQ_MBHC_BUTTON_RELEASE_DET,
 WCD938X_IRQ_MBHC_ELECT_INS_REM_DET,
 WCD938X_IRQ_MBHC_ELECT_INS_REM_LEG_DET,
 WCD938X_IRQ_MBHC_SW_DET,
 WCD938X_IRQ_HPHR_OCP_INT,
 WCD938X_IRQ_HPHR_CNP_INT,
 WCD938X_IRQ_HPHL_OCP_INT,

 /* INTR_CTRL_INT_MASK_1 */
 WCD938X_IRQ_HPHL_CNP_INT,
 WCD938X_IRQ_EAR_CNP_INT,
 WCD938X_IRQ_EAR_SCD_INT,
 WCD938X_IRQ_AUX_CNP_INT,
 WCD938X_IRQ_AUX_SCD_INT,
 WCD938X_IRQ_HPHL_PDM_WD_INT,
 WCD938X_IRQ_HPHR_PDM_WD_INT,
 WCD938X_IRQ_AUX_PDM_WD_INT,

 /* INTR_CTRL_INT_MASK_2 */
 WCD938X_IRQ_LDORT_SCD_INT,
 WCD938X_IRQ_MBHC_MOISTURE_INT,
 WCD938X_IRQ_HPHL_SURGE_DET_INT,
 WCD938X_IRQ_HPHR_SURGE_DET_INT,
 WCD938X_NUM_IRQS,
};

enum {
 WCD_ADC1 = 0,
 WCD_ADC2,
 WCD_ADC3,
 WCD_ADC4,
 ALLOW_BUCK_DISABLE,
 HPH_COMP_DELAY,
 HPH_PA_DELAY,
 AMIC2_BCS_ENABLE,
 WCD_SUPPLIES_LPM_MODE,
};

enum {
 ADC_MODE_INVALID = 0,
 ADC_MODE_HIFI,
 ADC_MODE_LO_HIF,
 ADC_MODE_NORMAL,
 ADC_MODE_LP,
 ADC_MODE_ULP1,
 ADC_MODE_ULP2,
};

enum {
 AIF1_PB = 0,
 AIF1_CAP,
 NUM_CODEC_DAIS,
};

static u8 tx_mode_bit[] = {
 [ADC_MODE_INVALID] = 0x00,
 [ADC_MODE_HIFI] = 0x01,
 [ADC_MODE_LO_HIF] = 0x02,
 [ADC_MODE_NORMAL] = 0x04,
 [ADC_MODE_LP] = 0x08,
 [ADC_MODE_ULP1] = 0x10,
 [ADC_MODE_ULP2] = 0x20,
};

struct wcd938x_priv {
 struct sdw_slave *tx_sdw_dev;
 struct wcd938x_sdw_priv *sdw_priv[NUM_CODEC_DAIS];
 struct device *txdev;
 struct device *rxdev;
 struct device_node *rxnode, *txnode;
 struct regmap *regmap;
 struct mutex micb_lock;
 /* mbhc module */
 struct wcd_mbhc *wcd_mbhc;
 struct wcd_mbhc_config mbhc_cfg;
 struct wcd_mbhc_intr intr_ids;
 struct wcd_clsh_ctrl *clsh_info;
 struct irq_domain *virq;
 struct regmap_irq_chip_data *irq_chip;
 struct snd_soc_jack *jack;
 unsigned long status_mask;
 s32 micb_ref[WCD938X_MAX_MICBIAS];
 s32 pullup_ref[WCD938X_MAX_MICBIAS];
 u32 hph_mode;
 u32 tx_mode[TX_ADC_MAX];
 int flyback_cur_det_disable;
 int ear_rx_path;
 struct gpio_desc *reset_gpio;
 struct gpio_desc *us_euro_gpio;
 struct mux_control *us_euro_mux;
 unsigned int mux_state;
 u32 micb1_mv;
 u32 micb2_mv;
 u32 micb3_mv;
 u32 micb4_mv;
 int hphr_pdm_wd_int;
 int hphl_pdm_wd_int;
 int aux_pdm_wd_int;
 bool comp1_enable;
 bool comp2_enable;
 bool ldoh;
 bool mux_setup_done;
};

static const char * const wcd938x_supplies[] = {
 "vdd-rxtx", "vdd-io", "vdd-buck", "vdd-mic-bias",
};

static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(ear_pa_gain, 600, -1800);
static const DECLARE_TLV_DB_SCALE(line_gain, -3000, 150, 0);
static const SNDRV_CTL_TLVD_DECLARE_DB_MINMAX(analog_gain, 0, 3000);

struct wcd938x_mbhc_zdet_param {
 u16 ldo_ctl;
 u16 noff;
 u16 nshift;
 u16 btn5;
 u16 btn6;
 u16 btn7;
};

static const struct wcd_mbhc_field wcd_mbhc_fields[WCD_MBHC_REG_FUNC_MAX] = {
 WCD_MBHC_FIELD(WCD_MBHC_L_DET_EN, WCD938X_ANA_MBHC_MECH, 0x80),
 WCD_MBHC_FIELD(WCD_MBHC_GND_DET_EN, WCD938X_ANA_MBHC_MECH, 0x40),
 WCD_MBHC_FIELD(WCD_MBHC_MECH_DETECTION_TYPE, WCD938X_ANA_MBHC_MECH, 0x20),
 WCD_MBHC_FIELD(WCD_MBHC_MIC_CLAMP_CTL, WCD938X_MBHC_NEW_PLUG_DETECT_CTL, 0x30),
 WCD_MBHC_FIELD(WCD_MBHC_ELECT_DETECTION_TYPE, WCD938X_ANA_MBHC_ELECT, 0x08),
 WCD_MBHC_FIELD(WCD_MBHC_HS_L_DET_PULL_UP_CTRL, WCD938X_MBHC_NEW_INT_MECH_DET_CURRENT, 0x1F),
 WCD_MBHC_FIELD(WCD_MBHC_HS_L_DET_PULL_UP_COMP_CTRL, WCD938X_ANA_MBHC_MECH, 0x04),
 WCD_MBHC_FIELD(WCD_MBHC_HPHL_PLUG_TYPE, WCD938X_ANA_MBHC_MECH, 0x10),
 WCD_MBHC_FIELD(WCD_MBHC_GND_PLUG_TYPE, WCD938X_ANA_MBHC_MECH, 0x08),
 WCD_MBHC_FIELD(WCD_MBHC_SW_HPH_LP_100K_TO_GND, WCD938X_ANA_MBHC_MECH, 0x01),
 WCD_MBHC_FIELD(WCD_MBHC_ELECT_SCHMT_ISRC, WCD938X_ANA_MBHC_ELECT, 0x06),
 WCD_MBHC_FIELD(WCD_MBHC_FSM_EN, WCD938X_ANA_MBHC_ELECT, 0x80),
 WCD_MBHC_FIELD(WCD_MBHC_INSREM_DBNC, WCD938X_MBHC_NEW_PLUG_DETECT_CTL, 0x0F),
 WCD_MBHC_FIELD(WCD_MBHC_BTN_DBNC, WCD938X_MBHC_NEW_CTL_1, 0x03),
 WCD_MBHC_FIELD(WCD_MBHC_HS_VREF, WCD938X_MBHC_NEW_CTL_2, 0x03),
 WCD_MBHC_FIELD(WCD_MBHC_HS_COMP_RESULT, WCD938X_ANA_MBHC_RESULT_3, 0x08),
 WCD_MBHC_FIELD(WCD_MBHC_IN2P_CLAMP_STATE, WCD938X_ANA_MBHC_RESULT_3, 0x10),
 WCD_MBHC_FIELD(WCD_MBHC_MIC_SCHMT_RESULT, WCD938X_ANA_MBHC_RESULT_3, 0x20),
 WCD_MBHC_FIELD(WCD_MBHC_HPHL_SCHMT_RESULT, WCD938X_ANA_MBHC_RESULT_3, 0x80),
 WCD_MBHC_FIELD(WCD_MBHC_HPHR_SCHMT_RESULT, WCD938X_ANA_MBHC_RESULT_3, 0x40),
 WCD_MBHC_FIELD(WCD_MBHC_OCP_FSM_EN, WCD938X_HPH_OCP_CTL, 0x10),
 WCD_MBHC_FIELD(WCD_MBHC_BTN_RESULT, WCD938X_ANA_MBHC_RESULT_3, 0x07),
 WCD_MBHC_FIELD(WCD_MBHC_BTN_ISRC_CTL, WCD938X_ANA_MBHC_ELECT, 0x70),
 WCD_MBHC_FIELD(WCD_MBHC_ELECT_RESULT, WCD938X_ANA_MBHC_RESULT_3, 0xFF),
 WCD_MBHC_FIELD(WCD_MBHC_MICB_CTRL, WCD938X_ANA_MICB2, 0xC0),
 WCD_MBHC_FIELD(WCD_MBHC_HPH_CNP_WG_TIME, WCD938X_HPH_CNP_WG_TIME, 0xFF),
 WCD_MBHC_FIELD(WCD_MBHC_HPHR_PA_EN, WCD938X_ANA_HPH, 0x40),
 WCD_MBHC_FIELD(WCD_MBHC_HPHL_PA_EN, WCD938X_ANA_HPH, 0x80),
 WCD_MBHC_FIELD(WCD_MBHC_HPH_PA_EN, WCD938X_ANA_HPH, 0xC0),
 WCD_MBHC_FIELD(WCD_MBHC_SWCH_LEVEL_REMOVE, WCD938X_ANA_MBHC_RESULT_3, 0x10),
 WCD_MBHC_FIELD(WCD_MBHC_ANC_DET_EN, WCD938X_MBHC_CTL_BCS, 0x02),
 WCD_MBHC_FIELD(WCD_MBHC_FSM_STATUS, WCD938X_MBHC_NEW_FSM_STATUS, 0x01),
 WCD_MBHC_FIELD(WCD_MBHC_MUX_CTL, WCD938X_MBHC_NEW_CTL_2, 0x70),
 WCD_MBHC_FIELD(WCD_MBHC_MOISTURE_STATUS, WCD938X_MBHC_NEW_FSM_STATUS, 0x20),
 WCD_MBHC_FIELD(WCD_MBHC_HPHR_GND, WCD938X_HPH_PA_CTL2, 0x40),
 WCD_MBHC_FIELD(WCD_MBHC_HPHL_GND, WCD938X_HPH_PA_CTL2, 0x10),
 WCD_MBHC_FIELD(WCD_MBHC_HPHL_OCP_DET_EN, WCD938X_HPH_L_TEST, 0x01),
 WCD_MBHC_FIELD(WCD_MBHC_HPHR_OCP_DET_EN, WCD938X_HPH_R_TEST, 0x01),
 WCD_MBHC_FIELD(WCD_MBHC_HPHL_OCP_STATUS, WCD938X_DIGITAL_INTR_STATUS_0, 0x80),
 WCD_MBHC_FIELD(WCD_MBHC_HPHR_OCP_STATUS, WCD938X_DIGITAL_INTR_STATUS_0, 0x20),
 WCD_MBHC_FIELD(WCD_MBHC_ADC_EN, WCD938X_MBHC_NEW_CTL_1, 0x08),
 WCD_MBHC_FIELD(WCD_MBHC_ADC_COMPLETE, WCD938X_MBHC_NEW_FSM_STATUS, 0x40),
 WCD_MBHC_FIELD(WCD_MBHC_ADC_TIMEOUT, WCD938X_MBHC_NEW_FSM_STATUS, 0x80),
 WCD_MBHC_FIELD(WCD_MBHC_ADC_RESULT, WCD938X_MBHC_NEW_ADC_RESULT, 0xFF),
 WCD_MBHC_FIELD(WCD_MBHC_MICB2_VOUT, WCD938X_ANA_MICB2, 0x3F),
 WCD_MBHC_FIELD(WCD_MBHC_ADC_MODE, WCD938X_MBHC_NEW_CTL_1, 0x10),
 WCD_MBHC_FIELD(WCD_MBHC_DETECTION_DONE, WCD938X_MBHC_NEW_CTL_1, 0x04),
 WCD_MBHC_FIELD(WCD_MBHC_ELECT_ISRC_EN, WCD938X_ANA_MBHC_ZDET, 0x02),
};

static const struct regmap_irq wcd938x_irqs[WCD938X_NUM_IRQS] = {
 REGMAP_IRQ_REG(WCD938X_IRQ_MBHC_BUTTON_PRESS_DET, 0, 0x01),
 REGMAP_IRQ_REG(WCD938X_IRQ_MBHC_BUTTON_RELEASE_DET, 0, 0x02),
 REGMAP_IRQ_REG(WCD938X_IRQ_MBHC_ELECT_INS_REM_DET, 0, 0x04),
 REGMAP_IRQ_REG(WCD938X_IRQ_MBHC_ELECT_INS_REM_LEG_DET, 0, 0x08),
 REGMAP_IRQ_REG(WCD938X_IRQ_MBHC_SW_DET, 0, 0x10),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHR_OCP_INT, 0, 0x20),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHR_CNP_INT, 0, 0x40),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHL_OCP_INT, 0, 0x80),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHL_CNP_INT, 1, 0x01),
 REGMAP_IRQ_REG(WCD938X_IRQ_EAR_CNP_INT, 1, 0x02),
 REGMAP_IRQ_REG(WCD938X_IRQ_EAR_SCD_INT, 1, 0x04),
 REGMAP_IRQ_REG(WCD938X_IRQ_AUX_CNP_INT, 1, 0x08),
 REGMAP_IRQ_REG(WCD938X_IRQ_AUX_SCD_INT, 1, 0x10),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHL_PDM_WD_INT, 1, 0x20),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHR_PDM_WD_INT, 1, 0x40),
 REGMAP_IRQ_REG(WCD938X_IRQ_AUX_PDM_WD_INT, 1, 0x80),
 REGMAP_IRQ_REG(WCD938X_IRQ_LDORT_SCD_INT, 2, 0x01),
 REGMAP_IRQ_REG(WCD938X_IRQ_MBHC_MOISTURE_INT, 2, 0x02),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHL_SURGE_DET_INT, 2, 0x04),
 REGMAP_IRQ_REG(WCD938X_IRQ_HPHR_SURGE_DET_INT, 2, 0x08),
};

static const struct regmap_irq_chip wcd938x_regmap_irq_chip = {
 .name = "wcd938x",
 .irqs = wcd938x_irqs,
 .num_irqs = ARRAY_SIZE(wcd938x_irqs),
 .num_regs = 3,
 .status_base = WCD938X_DIGITAL_INTR_STATUS_0,
 .mask_base = WCD938X_DIGITAL_INTR_MASK_0,
 .ack_base = WCD938X_DIGITAL_INTR_CLEAR_0,
 .use_ack = 1,
 .runtime_pm = true,
 .irq_drv_data = NULL,
};

static int wcd938x_get_clk_rate(int mode)
{
 int rate;

 switch (mode) {
 case ADC_MODE_ULP2:
  rate = SWR_CLK_RATE_0P6MHZ;
  break;
 case ADC_MODE_ULP1:
  rate = SWR_CLK_RATE_1P2MHZ;
  break;
 case ADC_MODE_LP:
  rate = SWR_CLK_RATE_4P8MHZ;
  break;
 case ADC_MODE_NORMAL:
 case ADC_MODE_LO_HIF:
 case ADC_MODE_HIFI:
 case ADC_MODE_INVALID:
 default:
  rate = SWR_CLK_RATE_9P6MHZ;
  break;
 }

 return rate;
}

static int wcd938x_set_swr_clk_rate(struct snd_soc_component *component, int rate, int bank)
{
 u8 mask = (bank ? 0xF0 : 0x0F);
 u8 val = 0;

 switch (rate) {
 case SWR_CLK_RATE_0P6MHZ:
  val = (bank ? 0x60 : 0x06);
  break;
 case SWR_CLK_RATE_1P2MHZ:
  val = (bank ? 0x50 : 0x05);
  break;
 case SWR_CLK_RATE_2P4MHZ:
  val = (bank ? 0x30 : 0x03);
  break;
 case SWR_CLK_RATE_4P8MHZ:
  val = (bank ? 0x10 : 0x01);
  break;
 case SWR_CLK_RATE_9P6MHZ:
 default:
  val = 0x00;
  break;
 }
 snd_soc_component_update_bits(component, WCD938X_DIGITAL_SWR_TX_CLK_RATE,
          mask, val);

 return 0;
}

static int wcd938x_io_init(struct wcd938x_priv *wcd938x)
{
 struct regmap *rm = wcd938x->regmap;

 regmap_update_bits(rm, WCD938X_SLEEP_CTL, 0x0E, 0x0E);
 regmap_update_bits(rm, WCD938X_SLEEP_CTL, 0x80, 0x80);
 /* 1 msec delay as per HW requirement */
 usleep_range(1000, 1010);
 regmap_update_bits(rm, WCD938X_SLEEP_CTL, 0x40, 0x40);
 /* 1 msec delay as per HW requirement */
 usleep_range(1000, 1010);
 regmap_update_bits(rm, WCD938X_LDORXTX_CONFIG, 0x10, 0x00);
 regmap_update_bits(rm, WCD938X_BIAS_VBG_FINE_ADJ,
        0xF0, 0x80);
 regmap_update_bits(rm, WCD938X_ANA_BIAS, 0x80, 0x80);
 regmap_update_bits(rm, WCD938X_ANA_BIAS, 0x40, 0x40);
 /* 10 msec delay as per HW requirement */
 usleep_range(10000, 10010);

 regmap_update_bits(rm, WCD938X_ANA_BIAS, 0x40, 0x00);
 regmap_update_bits(rm, WCD938X_HPH_NEW_INT_RDAC_GAIN_CTL,
          0xF0, 0x00);
 regmap_update_bits(rm, WCD938X_HPH_NEW_INT_RDAC_HD2_CTL_L_NEW,
          0x1F, 0x15);
 regmap_update_bits(rm, WCD938X_HPH_NEW_INT_RDAC_HD2_CTL_R_NEW,
          0x1F, 0x15);
 regmap_update_bits(rm, WCD938X_HPH_REFBUFF_UHQA_CTL,
          0xC0, 0x80);
 regmap_update_bits(rm, WCD938X_DIGITAL_CDC_DMIC_CTL,
          0x02, 0x02);

 regmap_update_bits(rm, WCD938X_TX_COM_NEW_INT_TXFE_ICTRL_STG2CASC_ULP,
      0xFF, 0x14);
 regmap_update_bits(rm, WCD938X_TX_COM_NEW_INT_TXFE_ICTRL_STG2MAIN_ULP,
      0x1F, 0x08);

 regmap_update_bits(rm, WCD938X_DIGITAL_TX_REQ_FB_CTL_0, 0xFF, 0x55);
 regmap_update_bits(rm, WCD938X_DIGITAL_TX_REQ_FB_CTL_1, 0xFF, 0x44);
 regmap_update_bits(rm, WCD938X_DIGITAL_TX_REQ_FB_CTL_2, 0xFF, 0x11);
 regmap_update_bits(rm, WCD938X_DIGITAL_TX_REQ_FB_CTL_3, 0xFF, 0x00);
 regmap_update_bits(rm, WCD938X_DIGITAL_TX_REQ_FB_CTL_4, 0xFF, 0x00);

 /* Set Noise Filter Resistor value */
 regmap_update_bits(rm, WCD938X_MICB1_TEST_CTL_1, 0xE0, 0xE0);
 regmap_update_bits(rm, WCD938X_MICB2_TEST_CTL_1, 0xE0, 0xE0);
 regmap_update_bits(rm, WCD938X_MICB3_TEST_CTL_1, 0xE0, 0xE0);
 regmap_update_bits(rm, WCD938X_MICB4_TEST_CTL_1, 0xE0, 0xE0);

 regmap_update_bits(rm, WCD938X_TX_3_4_TEST_BLK_EN2, 0x01, 0x00);
 regmap_update_bits(rm, WCD938X_HPH_SURGE_HPHLR_SURGE_EN, 0xC0, 0xC0);

 return 0;

}

static int wcd938x_sdw_connect_port(const struct wcd938x_sdw_ch_info *ch_info,
        struct sdw_port_config *port_config,
        u8 enable)
{
 u8 ch_mask, port_num;

 port_num = ch_info->port_num;
 ch_mask = ch_info->ch_mask;

 port_config->num = port_num;

 if (enable)
  port_config->ch_mask |= ch_mask;
 else
  port_config->ch_mask &= ~ch_mask;

 return 0;
}

static int wcd938x_connect_port(struct wcd938x_sdw_priv *wcd, u8 port_num, u8 ch_id, u8 enable)
{
 return wcd938x_sdw_connect_port(&wcd->ch_info[ch_id],
     &wcd->port_config[port_num - 1],
     enable);
}

static int wcd938x_codec_enable_rxclk(struct snd_soc_dapm_widget *w,
          struct snd_kcontrol *kcontrol,
          int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_RX_CLK_EN_MASK, 1);
  snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
    WCD938X_RX_BIAS_EN_MASK, 1);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_RX0_CTL,
    WCD938X_DEM_DITHER_ENABLE_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_RX1_CTL,
    WCD938X_DEM_DITHER_ENABLE_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_RX2_CTL,
    WCD938X_DEM_DITHER_ENABLE_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_RX_DIV2_CLK_EN_MASK, 1);
  snd_soc_component_write_field(component, WCD938X_AUX_AUXPA,
           WCD938X_AUXPA_CLK_EN_MASK, 1);
  break;
 case SND_SOC_DAPM_POST_PMD:
  snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
    WCD938X_VNEG_EN_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
    WCD938X_VPOS_EN_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
    WCD938X_RX_BIAS_EN_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_RX_DIV2_CLK_EN_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_RX_CLK_EN_MASK, 0);
  break;
 }
 return 0;
}

static int wcd938x_codec_hphl_dac_event(struct snd_soc_dapm_widget *w,
     struct snd_kcontrol *kcontrol,
     int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_RXD0_CLK_EN_MASK, 0x01);
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_HPH_GAIN_CTL,
    WCD938X_HPHL_RX_EN_MASK, 1);
  snd_soc_component_write_field(component,
    WCD938X_HPH_RDAC_CLK_CTL1,
    WCD938X_CHOP_CLK_EN_MASK, 0);
  break;
 case SND_SOC_DAPM_POST_PMU:
  snd_soc_component_write_field(component,
    WCD938X_HPH_NEW_INT_RDAC_HD2_CTL_L,
    WCD938X_HPH_RES_DIV_MASK, 0x02);
  if (wcd938x->comp1_enable) {
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_COMP_CTL_0,
    WCD938X_HPHL_COMP_EN_MASK, 1);
   /* 5msec compander delay as per HW requirement */
   if (!wcd938x->comp2_enable || (snd_soc_component_read(component,
        WCD938X_DIGITAL_CDC_COMP_CTL_0) & 0x01))
    usleep_range(5000, 5010);
   snd_soc_component_write_field(component, WCD938X_HPH_NEW_INT_HPH_TIMER1,
           WCD938X_AUTOCHOP_TIMER_EN, 0);
  } else {
   snd_soc_component_write_field(component,
     WCD938X_DIGITAL_CDC_COMP_CTL_0,
     WCD938X_HPHL_COMP_EN_MASK, 0);
   snd_soc_component_write_field(component,
     WCD938X_HPH_L_EN,
     WCD938X_GAIN_SRC_SEL_MASK,
     WCD938X_GAIN_SRC_SEL_REGISTER);

  }
  break;
 case SND_SOC_DAPM_POST_PMD:
  snd_soc_component_write_field(component,
   WCD938X_HPH_NEW_INT_RDAC_HD2_CTL_R,
   WCD938X_HPH_RES_DIV_MASK, 0x1);
  break;
 }

 return 0;
}

static int wcd938x_codec_hphr_dac_event(struct snd_soc_dapm_widget *w,
     struct snd_kcontrol *kcontrol,
     int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_RXD1_CLK_EN_MASK, 1);
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_HPH_GAIN_CTL,
    WCD938X_HPHR_RX_EN_MASK, 1);
  snd_soc_component_write_field(component,
    WCD938X_HPH_RDAC_CLK_CTL1,
    WCD938X_CHOP_CLK_EN_MASK, 0);
  break;
 case SND_SOC_DAPM_POST_PMU:
  snd_soc_component_write_field(component,
    WCD938X_HPH_NEW_INT_RDAC_HD2_CTL_R,
    WCD938X_HPH_RES_DIV_MASK, 0x02);
  if (wcd938x->comp2_enable) {
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_COMP_CTL_0,
    WCD938X_HPHR_COMP_EN_MASK, 1);
   /* 5msec compander delay as per HW requirement */
   if (!wcd938x->comp1_enable ||
    (snd_soc_component_read(component,
     WCD938X_DIGITAL_CDC_COMP_CTL_0) & 0x02))
    usleep_range(5000, 5010);
   snd_soc_component_write_field(component, WCD938X_HPH_NEW_INT_HPH_TIMER1,
           WCD938X_AUTOCHOP_TIMER_EN, 0);
  } else {
   snd_soc_component_write_field(component,
     WCD938X_DIGITAL_CDC_COMP_CTL_0,
     WCD938X_HPHR_COMP_EN_MASK, 0);
   snd_soc_component_write_field(component,
     WCD938X_HPH_R_EN,
     WCD938X_GAIN_SRC_SEL_MASK,
     WCD938X_GAIN_SRC_SEL_REGISTER);
  }
  break;
 case SND_SOC_DAPM_POST_PMD:
  snd_soc_component_write_field(component,
   WCD938X_HPH_NEW_INT_RDAC_HD2_CTL_R,
   WCD938X_HPH_RES_DIV_MASK, 0x01);
  break;
 }

 return 0;
}

static int wcd938x_codec_ear_dac_event(struct snd_soc_dapm_widget *w,
           struct snd_kcontrol *kcontrol,
           int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  wcd938x->ear_rx_path =
   snd_soc_component_read(
    component, WCD938X_DIGITAL_CDC_EAR_PATH_CTL);
  if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX) {
   snd_soc_component_write_field(component,
    WCD938X_EAR_EAR_DAC_CON,
    WCD938X_DAC_SAMPLE_EDGE_SEL_MASK, 0);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_AUX_GAIN_CTL,
    WCD938X_AUX_EN_MASK, 1);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_RXD2_CLK_EN_MASK, 1);
   snd_soc_component_write_field(component,
    WCD938X_ANA_EAR_COMPANDER_CTL,
    WCD938X_GAIN_OVRD_REG_MASK, 1);
  } else {
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_HPH_GAIN_CTL,
    WCD938X_HPHL_RX_EN_MASK, 1);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_RXD0_CLK_EN_MASK, 1);
   if (wcd938x->comp1_enable)
    snd_soc_component_write_field(component,
     WCD938X_DIGITAL_CDC_COMP_CTL_0,
     WCD938X_HPHL_COMP_EN_MASK, 1);
  }
  /* 5 msec delay as per HW requirement */
  usleep_range(5000, 5010);
  if (wcd938x->flyback_cur_det_disable == 0)
   snd_soc_component_write_field(component, WCD938X_FLYBACK_EN,
            WCD938X_EN_CUR_DET_MASK, 0);
  wcd938x->flyback_cur_det_disable++;
  wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
        WCD_CLSH_EVENT_PRE_DAC,
        WCD_CLSH_STATE_EAR,
        wcd938x->hph_mode);
  break;
 case SND_SOC_DAPM_POST_PMD:
  if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX) {
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_AUX_GAIN_CTL,
    WCD938X_AUX_EN_MASK, 0);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_RXD2_CLK_EN_MASK, 0);
  } else {
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_HPH_GAIN_CTL,
    WCD938X_HPHL_RX_EN_MASK, 0);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_RXD0_CLK_EN_MASK, 0);
   if (wcd938x->comp1_enable)
    snd_soc_component_write_field(component,
     WCD938X_DIGITAL_CDC_COMP_CTL_0,
     WCD938X_HPHL_COMP_EN_MASK, 0);
  }
  snd_soc_component_write_field(component, WCD938X_ANA_EAR_COMPANDER_CTL,
           WCD938X_GAIN_OVRD_REG_MASK, 0);
  snd_soc_component_write_field(component,
    WCD938X_EAR_EAR_DAC_CON,
    WCD938X_DAC_SAMPLE_EDGE_SEL_MASK, 1);
  break;
 }
 return 0;

}

static int wcd938x_codec_aux_dac_event(struct snd_soc_dapm_widget *w,
           struct snd_kcontrol *kcontrol,
           int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_RX_DIV4_CLK_EN_MASK, 1);
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_RXD2_CLK_EN_MASK, 1);
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_AUX_GAIN_CTL,
    WCD938X_AUX_EN_MASK, 1);
  if (wcd938x->flyback_cur_det_disable == 0)
   snd_soc_component_write_field(component, WCD938X_FLYBACK_EN,
            WCD938X_EN_CUR_DET_MASK, 0);
  wcd938x->flyback_cur_det_disable++;
  wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
        WCD_CLSH_EVENT_PRE_DAC,
        WCD_CLSH_STATE_AUX,
        wcd938x->hph_mode);
  break;
 case SND_SOC_DAPM_POST_PMD:
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_RX_DIV4_CLK_EN_MASK, 0);
  break;
 }
 return 0;

}

static int wcd938x_codec_enable_hphr_pa(struct snd_soc_dapm_widget *w,
     struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int hph_mode = wcd938x->hph_mode;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  if (wcd938x->ldoh)
   snd_soc_component_write_field(component, WCD938X_LDOH_MODE,
            WCD938X_LDOH_EN_MASK, 1);
  wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
     WCD_CLSH_STATE_HPHR, hph_mode);
  wcd_clsh_set_hph_mode(wcd938x->clsh_info, CLS_H_HIFI);

  if (hph_mode == CLS_H_LP || hph_mode == CLS_H_LOHIFI ||
      hph_mode == CLS_H_ULP) {
   snd_soc_component_write_field(component,
    WCD938X_HPH_REFBUFF_LP_CTL,
    WCD938X_PREREF_FLIT_BYPASS_MASK, 1);
  }
  snd_soc_component_write_field(component, WCD938X_ANA_HPH,
           WCD938X_HPHR_REF_EN_MASK, 1);
  wcd_clsh_set_hph_mode(wcd938x->clsh_info, hph_mode);
  /* 100 usec delay as per HW requirement */
  usleep_range(100, 110);
  set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  snd_soc_component_write_field(component,
           WCD938X_DIGITAL_PDM_WD_CTL1,
           WCD938X_PDM_WD_EN_MASK, 0x3);
  break;
 case SND_SOC_DAPM_POST_PMU:
  /*
 * 7ms sleep is required if compander is enabled as per
 * HW requirement. If compander is disabled, then
 * 20ms delay is required.
 */
  if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
   if (!wcd938x->comp2_enable)
    usleep_range(20000, 20100);
   else
    usleep_range(7000, 7100);

   if (hph_mode == CLS_H_LP || hph_mode == CLS_H_LOHIFI ||
       hph_mode == CLS_H_ULP)
    snd_soc_component_write_field(component,
      WCD938X_HPH_REFBUFF_LP_CTL,
      WCD938X_PREREF_FLIT_BYPASS_MASK, 0);
   clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  }
  snd_soc_component_write_field(component, WCD938X_HPH_NEW_INT_HPH_TIMER1,
           WCD938X_AUTOCHOP_TIMER_EN, 1);
  if (hph_mode == CLS_AB || hph_mode == CLS_AB_HIFI ||
   hph_mode == CLS_AB_LP || hph_mode == CLS_AB_LOHIFI)
   snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
     WCD938X_REGULATOR_MODE_MASK,
     WCD938X_REGULATOR_MODE_CLASS_AB);
  enable_irq(wcd938x->hphr_pdm_wd_int);
  break;
 case SND_SOC_DAPM_PRE_PMD:
  disable_irq_nosync(wcd938x->hphr_pdm_wd_int);
  /*
 * 7ms sleep is required if compander is enabled as per
 * HW requirement. If compander is disabled, then
 * 20ms delay is required.
 */
  if (!wcd938x->comp2_enable)
   usleep_range(20000, 20100);
  else
   usleep_range(7000, 7100);
  snd_soc_component_write_field(component, WCD938X_ANA_HPH,
           WCD938X_HPHR_EN_MASK, 0);
  wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
          WCD_EVENT_PRE_HPHR_PA_OFF);
  set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  break;
 case SND_SOC_DAPM_POST_PMD:
  /*
 * 7ms sleep is required if compander is enabled as per
 * HW requirement. If compander is disabled, then
 * 20ms delay is required.
 */
  if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
   if (!wcd938x->comp2_enable)
    usleep_range(20000, 20100);
   else
    usleep_range(7000, 7100);
   clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  }
  wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
          WCD_EVENT_POST_HPHR_PA_OFF);
  snd_soc_component_write_field(component, WCD938X_ANA_HPH,
           WCD938X_HPHR_REF_EN_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_PDM_WD_CTL1,
           WCD938X_PDM_WD_EN_MASK, 0);
  wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
     WCD_CLSH_STATE_HPHR, hph_mode);
  if (wcd938x->ldoh)
   snd_soc_component_write_field(component, WCD938X_LDOH_MODE,
            WCD938X_LDOH_EN_MASK, 0);
  break;
 }

 return 0;
}

static int wcd938x_codec_enable_hphl_pa(struct snd_soc_dapm_widget *w,
     struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int hph_mode = wcd938x->hph_mode;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  if (wcd938x->ldoh)
   snd_soc_component_write_field(component, WCD938X_LDOH_MODE,
            WCD938X_LDOH_EN_MASK, 1);
  wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_PRE_DAC,
     WCD_CLSH_STATE_HPHL, hph_mode);
  wcd_clsh_set_hph_mode(wcd938x->clsh_info, CLS_H_HIFI);
  if (hph_mode == CLS_H_LP || hph_mode == CLS_H_LOHIFI ||
      hph_mode == CLS_H_ULP) {
   snd_soc_component_write_field(component,
     WCD938X_HPH_REFBUFF_LP_CTL,
     WCD938X_PREREF_FLIT_BYPASS_MASK, 1);
  }
  snd_soc_component_write_field(component, WCD938X_ANA_HPH,
           WCD938X_HPHL_REF_EN_MASK, 1);
  wcd_clsh_set_hph_mode(wcd938x->clsh_info, hph_mode);
  /* 100 usec delay as per HW requirement */
  usleep_range(100, 110);
  set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  snd_soc_component_write_field(component,
     WCD938X_DIGITAL_PDM_WD_CTL0,
     WCD938X_PDM_WD_EN_MASK, 0x3);
  break;
 case SND_SOC_DAPM_POST_PMU:
  /*
 * 7ms sleep is required if compander is enabled as per
 * HW requirement. If compander is disabled, then
 * 20ms delay is required.
 */
  if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
   if (!wcd938x->comp1_enable)
    usleep_range(20000, 20100);
   else
    usleep_range(7000, 7100);
   if (hph_mode == CLS_H_LP || hph_mode == CLS_H_LOHIFI ||
       hph_mode == CLS_H_ULP)
    snd_soc_component_write_field(component,
     WCD938X_HPH_REFBUFF_LP_CTL,
     WCD938X_PREREF_FLIT_BYPASS_MASK, 0);
   clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  }

  snd_soc_component_write_field(component, WCD938X_HPH_NEW_INT_HPH_TIMER1,
           WCD938X_AUTOCHOP_TIMER_EN, 1);
  if (hph_mode == CLS_AB || hph_mode == CLS_AB_HIFI ||
   hph_mode == CLS_AB_LP || hph_mode == CLS_AB_LOHIFI)
   snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
     WCD938X_REGULATOR_MODE_MASK,
     WCD938X_REGULATOR_MODE_CLASS_AB);
  enable_irq(wcd938x->hphl_pdm_wd_int);
  break;
 case SND_SOC_DAPM_PRE_PMD:
  disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
  /*
 * 7ms sleep is required if compander is enabled as per
 * HW requirement. If compander is disabled, then
 * 20ms delay is required.
 */
  if (!wcd938x->comp1_enable)
   usleep_range(20000, 20100);
  else
   usleep_range(7000, 7100);
  snd_soc_component_write_field(component, WCD938X_ANA_HPH,
           WCD938X_HPHL_EN_MASK, 0);
  wcd_mbhc_event_notify(wcd938x->wcd_mbhc, WCD_EVENT_PRE_HPHL_PA_OFF);
  set_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  break;
 case SND_SOC_DAPM_POST_PMD:
  /*
 * 7ms sleep is required if compander is enabled as per
 * HW requirement. If compander is disabled, then
 * 20ms delay is required.
 */
  if (test_bit(HPH_PA_DELAY, &wcd938x->status_mask)) {
   if (!wcd938x->comp1_enable)
    usleep_range(21000, 21100);
   else
    usleep_range(7000, 7100);
   clear_bit(HPH_PA_DELAY, &wcd938x->status_mask);
  }
  wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
          WCD_EVENT_POST_HPHL_PA_OFF);
  snd_soc_component_write_field(component, WCD938X_ANA_HPH,
           WCD938X_HPHL_REF_EN_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_PDM_WD_CTL0,
           WCD938X_PDM_WD_EN_MASK, 0);
  wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
     WCD_CLSH_STATE_HPHL, hph_mode);
  if (wcd938x->ldoh)
   snd_soc_component_write_field(component, WCD938X_LDOH_MODE,
            WCD938X_LDOH_EN_MASK, 0);
  break;
 }

 return 0;
}

static int wcd938x_codec_enable_aux_pa(struct snd_soc_dapm_widget *w,
           struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int hph_mode = wcd938x->hph_mode;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component, WCD938X_DIGITAL_PDM_WD_CTL2,
           WCD938X_AUX_PDM_WD_EN_MASK, 1);
  break;
 case SND_SOC_DAPM_POST_PMU:
  /* 1 msec delay as per HW requirement */
  usleep_range(1000, 1010);
  if (hph_mode == CLS_AB || hph_mode == CLS_AB_HIFI ||
   hph_mode == CLS_AB_LP || hph_mode == CLS_AB_LOHIFI)
   snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
     WCD938X_REGULATOR_MODE_MASK,
     WCD938X_REGULATOR_MODE_CLASS_AB);
  enable_irq(wcd938x->aux_pdm_wd_int);
  break;
 case SND_SOC_DAPM_PRE_PMD:
  disable_irq_nosync(wcd938x->aux_pdm_wd_int);
  break;
 case SND_SOC_DAPM_POST_PMD:
  /* 1 msec delay as per HW requirement */
  usleep_range(1000, 1010);
  snd_soc_component_write_field(component, WCD938X_DIGITAL_PDM_WD_CTL2,
           WCD938X_AUX_PDM_WD_EN_MASK, 0);
  wcd_clsh_ctrl_set_state(wcd938x->clsh_info,
        WCD_CLSH_EVENT_POST_PA,
        WCD_CLSH_STATE_AUX,
        hph_mode);

  wcd938x->flyback_cur_det_disable--;
  if (wcd938x->flyback_cur_det_disable == 0)
   snd_soc_component_write_field(component, WCD938X_FLYBACK_EN,
            WCD938X_EN_CUR_DET_MASK, 1);
  break;
 }
 return 0;
}

static int wcd938x_codec_enable_ear_pa(struct snd_soc_dapm_widget *w,
           struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int hph_mode = wcd938x->hph_mode;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  /*
 * Enable watchdog interrupt for HPHL or AUX
 * depending on mux value
 */
  wcd938x->ear_rx_path = snd_soc_component_read(component,
             WCD938X_DIGITAL_CDC_EAR_PATH_CTL);
  if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
   snd_soc_component_write_field(component, WCD938X_DIGITAL_PDM_WD_CTL2,
           WCD938X_AUX_PDM_WD_EN_MASK, 1);
  else
   snd_soc_component_write_field(component,
            WCD938X_DIGITAL_PDM_WD_CTL0,
            WCD938X_PDM_WD_EN_MASK, 0x3);
  if (!wcd938x->comp1_enable)
   snd_soc_component_write_field(component,
            WCD938X_ANA_EAR_COMPANDER_CTL,
            WCD938X_GAIN_OVRD_REG_MASK, 1);

  break;
 case SND_SOC_DAPM_POST_PMU:
  /* 6 msec delay as per HW requirement */
  usleep_range(6000, 6010);
  if (hph_mode == CLS_AB || hph_mode == CLS_AB_HIFI ||
   hph_mode == CLS_AB_LP || hph_mode == CLS_AB_LOHIFI)
   snd_soc_component_write_field(component, WCD938X_ANA_RX_SUPPLIES,
     WCD938X_REGULATOR_MODE_MASK,
     WCD938X_REGULATOR_MODE_CLASS_AB);
  if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
   enable_irq(wcd938x->aux_pdm_wd_int);
  else
   enable_irq(wcd938x->hphl_pdm_wd_int);
  break;
 case SND_SOC_DAPM_PRE_PMD:
  if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
   disable_irq_nosync(wcd938x->aux_pdm_wd_int);
  else
   disable_irq_nosync(wcd938x->hphl_pdm_wd_int);
  break;
 case SND_SOC_DAPM_POST_PMD:
  if (!wcd938x->comp1_enable)
   snd_soc_component_write_field(component, WCD938X_ANA_EAR_COMPANDER_CTL,
            WCD938X_GAIN_OVRD_REG_MASK, 0);
  /* 7 msec delay as per HW requirement */
  usleep_range(7000, 7010);
  if (wcd938x->ear_rx_path & EAR_RX_PATH_AUX)
   snd_soc_component_write_field(component, WCD938X_DIGITAL_PDM_WD_CTL2,
           WCD938X_AUX_PDM_WD_EN_MASK, 0);
  else
   snd_soc_component_write_field(component, WCD938X_DIGITAL_PDM_WD_CTL0,
     WCD938X_PDM_WD_EN_MASK, 0);

  wcd_clsh_ctrl_set_state(wcd938x->clsh_info, WCD_CLSH_EVENT_POST_PA,
     WCD_CLSH_STATE_EAR, hph_mode);

  wcd938x->flyback_cur_det_disable--;
  if (wcd938x->flyback_cur_det_disable == 0)
   snd_soc_component_write_field(component, WCD938X_FLYBACK_EN,
            WCD938X_EN_CUR_DET_MASK, 1);
  break;
 }

 return 0;
}

static int wcd938x_codec_enable_dmic(struct snd_soc_dapm_widget *w,
         struct snd_kcontrol *kcontrol,
         int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 u16 dmic_clk_reg, dmic_clk_en_reg;
 u8 dmic_sel_mask, dmic_clk_mask;

 switch (w->shift) {
 case 0:
 case 1:
  dmic_clk_reg = WCD938X_DIGITAL_CDC_DMIC_RATE_1_2;
  dmic_clk_en_reg = WCD938X_DIGITAL_CDC_DMIC1_CTL;
  dmic_clk_mask = WCD938X_DMIC1_RATE_MASK;
  dmic_sel_mask = WCD938X_AMIC1_IN_SEL_MASK;
  break;
 case 2:
 case 3:
  dmic_clk_reg = WCD938X_DIGITAL_CDC_DMIC_RATE_1_2;
  dmic_clk_en_reg = WCD938X_DIGITAL_CDC_DMIC2_CTL;
  dmic_clk_mask = WCD938X_DMIC2_RATE_MASK;
  dmic_sel_mask = WCD938X_AMIC3_IN_SEL_MASK;
  break;
 case 4:
 case 5:
  dmic_clk_reg = WCD938X_DIGITAL_CDC_DMIC_RATE_3_4;
  dmic_clk_en_reg = WCD938X_DIGITAL_CDC_DMIC3_CTL;
  dmic_clk_mask = WCD938X_DMIC3_RATE_MASK;
  dmic_sel_mask = WCD938X_AMIC4_IN_SEL_MASK;
  break;
 case 6:
 case 7:
  dmic_clk_reg = WCD938X_DIGITAL_CDC_DMIC_RATE_3_4;
  dmic_clk_en_reg = WCD938X_DIGITAL_CDC_DMIC4_CTL;
  dmic_clk_mask = WCD938X_DMIC4_RATE_MASK;
  dmic_sel_mask = WCD938X_AMIC5_IN_SEL_MASK;
  break;
 default:
  dev_err(component->dev, "%s: Invalid DMIC Selection\n",
   __func__);
  return -EINVAL;
 }

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_AMIC_CTL,
    dmic_sel_mask,
    WCD938X_AMIC1_IN_SEL_DMIC);
  /* 250us sleep as per HW requirement */
  usleep_range(250, 260);
  /* Setting DMIC clock rate to 2.4MHz */
  snd_soc_component_write_field(component, dmic_clk_reg,
           dmic_clk_mask,
           WCD938X_DMIC4_RATE_2P4MHZ);
  snd_soc_component_write_field(component, dmic_clk_en_reg,
           WCD938X_DMIC_CLK_EN_MASK, 1);
  /* enable clock scaling */
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_DMIC_CTL,
           WCD938X_DMIC_CLK_SCALING_EN_MASK, 0x3);
  break;
 case SND_SOC_DAPM_POST_PMD:
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_AMIC_CTL,
    dmic_sel_mask, WCD938X_AMIC1_IN_SEL_AMIC);
  snd_soc_component_write_field(component, dmic_clk_en_reg,
           WCD938X_DMIC_CLK_EN_MASK, 0);
  break;
 }
 return 0;
}

static int wcd938x_tx_swr_ctrl(struct snd_soc_dapm_widget *w,
          struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int bank;
 int rate;

 bank = (wcd938x_swr_get_current_bank(wcd938x->sdw_priv[AIF1_CAP]->sdev)) ? 0 : 1;
 bank = bank ? 0 : 1;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  if (strnstr(w->name, "ADC", sizeof("ADC"))) {
   int i = 0, mode = 0;

   if (test_bit(WCD_ADC1, &wcd938x->status_mask))
    mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC1]];
   if (test_bit(WCD_ADC2, &wcd938x->status_mask))
    mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC2]];
   if (test_bit(WCD_ADC3, &wcd938x->status_mask))
    mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC3]];
   if (test_bit(WCD_ADC4, &wcd938x->status_mask))
    mode |= tx_mode_bit[wcd938x->tx_mode[WCD_ADC4]];

   if (mode != 0) {
    for (i = 0; i < ADC_MODE_ULP2; i++) {
     if (mode & (1 << i)) {
      i++;
      break;
     }
    }
   }
   rate = wcd938x_get_clk_rate(i);
   wcd938x_set_swr_clk_rate(component, rate, bank);
   /* Copy clk settings to active bank */
   wcd938x_set_swr_clk_rate(component, rate, !bank);
  }
  break;
 case SND_SOC_DAPM_POST_PMD:
  if (strnstr(w->name, "ADC", sizeof("ADC"))) {
   rate = wcd938x_get_clk_rate(ADC_MODE_INVALID);
   wcd938x_set_swr_clk_rate(component, rate, !bank);
   wcd938x_set_swr_clk_rate(component, rate, bank);
  }
  break;
 }

 return 0;
}

static int wcd938x_get_adc_mode(int val)
{
 int ret = 0;

 switch (val) {
 case ADC_MODE_INVALID:
  ret = ADC_MODE_VAL_NORMAL;
  break;
 case ADC_MODE_HIFI:
  ret = ADC_MODE_VAL_HIFI;
  break;
 case ADC_MODE_LO_HIF:
  ret = ADC_MODE_VAL_LO_HIF;
  break;
 case ADC_MODE_NORMAL:
  ret = ADC_MODE_VAL_NORMAL;
  break;
 case ADC_MODE_LP:
  ret = ADC_MODE_VAL_LP;
  break;
 case ADC_MODE_ULP1:
  ret = ADC_MODE_VAL_ULP1;
  break;
 case ADC_MODE_ULP2:
  ret = ADC_MODE_VAL_ULP2;
  break;
 default:
  ret = -EINVAL;
  break;
 }
 return ret;
}

static int wcd938x_codec_enable_adc(struct snd_soc_dapm_widget *w,
        struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component,
           WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
           WCD938X_ANA_TX_CLK_EN_MASK, 1);
  snd_soc_component_write_field(component,
           WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
           WCD938X_ANA_TX_DIV2_CLK_EN_MASK, 1);
  set_bit(w->shift, &wcd938x->status_mask);
  break;
 case SND_SOC_DAPM_POST_PMD:
  snd_soc_component_write_field(component, WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
           WCD938X_ANA_TX_CLK_EN_MASK, 0);
  clear_bit(w->shift, &wcd938x->status_mask);
  break;
 }

 return 0;
}

static void wcd938x_tx_channel_config(struct snd_soc_component *component,
         int channel, int mode)
{
 int reg, mask;

 switch (channel) {
 case 0:
  reg = WCD938X_ANA_TX_CH2;
  mask = WCD938X_HPF1_INIT_MASK;
  break;
 case 1:
  reg = WCD938X_ANA_TX_CH2;
  mask = WCD938X_HPF2_INIT_MASK;
  break;
 case 2:
  reg = WCD938X_ANA_TX_CH4;
  mask = WCD938X_HPF3_INIT_MASK;
  break;
 case 3:
  reg = WCD938X_ANA_TX_CH4;
  mask = WCD938X_HPF4_INIT_MASK;
  break;
 default:
  return;
 }

 snd_soc_component_write_field(component, reg, mask, mode);
}

static int wcd938x_adc_enable_req(struct snd_soc_dapm_widget *w,
      struct snd_kcontrol *kcontrol, int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int mode;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_REQ_CTL,
    WCD938X_FS_RATE_4P8_MASK, 1);
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_REQ_CTL,
    WCD938X_NO_NOTCH_MASK, 0);
  wcd938x_tx_channel_config(component, w->shift, 1);
  mode = wcd938x_get_adc_mode(wcd938x->tx_mode[w->shift]);
  if (mode < 0) {
   dev_info(component->dev, "Invalid ADC mode\n");
   return -EINVAL;
  }
  switch (w->shift) {
  case 0:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_0_1,
    WCD938X_TXD0_MODE_MASK, mode);
   snd_soc_component_write_field(component,
      WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
      WCD938X_TXD0_CLK_EN_MASK, 1);
   break;
  case 1:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_0_1,
    WCD938X_TXD1_MODE_MASK, mode);
   snd_soc_component_write_field(component,
           WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
           WCD938X_TXD1_CLK_EN_MASK, 1);
   break;
  case 2:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_2_3,
    WCD938X_TXD2_MODE_MASK, mode);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_TXD2_CLK_EN_MASK, 1);
   break;
  case 3:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_2_3,
    WCD938X_TXD3_MODE_MASK, mode);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_TXD3_CLK_EN_MASK, 1);
   break;
  default:
   break;
  }

  wcd938x_tx_channel_config(component, w->shift, 0);
  break;
 case SND_SOC_DAPM_POST_PMD:
  switch (w->shift) {
  case 0:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_0_1,
    WCD938X_TXD0_MODE_MASK, 0);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_TXD0_CLK_EN_MASK, 0);
   break;
  case 1:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_0_1,
    WCD938X_TXD1_MODE_MASK, 0);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_TXD1_CLK_EN_MASK, 0);
   break;
  case 2:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_2_3,
    WCD938X_TXD2_MODE_MASK, 0);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_TXD2_CLK_EN_MASK, 0);
   break;
  case 3:
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_TX_ANA_MODE_2_3,
    WCD938X_TXD3_MODE_MASK, 0);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_TXD3_CLK_EN_MASK, 0);
   break;
  default:
   break;
  }
  snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_TX_DIV2_CLK_EN_MASK, 0);
  break;
 }

 return 0;
}

static int wcd938x_micbias_control(struct snd_soc_component *component,
       int micb_num, int req, bool is_dapm)
{
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int micb_index = micb_num - 1;
 u16 micb_reg;

 switch (micb_num) {
 case MIC_BIAS_1:
  micb_reg = WCD938X_ANA_MICB1;
  break;
 case MIC_BIAS_2:
  micb_reg = WCD938X_ANA_MICB2;
  break;
 case MIC_BIAS_3:
  micb_reg = WCD938X_ANA_MICB3;
  break;
 case MIC_BIAS_4:
  micb_reg = WCD938X_ANA_MICB4;
  break;
 default:
  dev_err(component->dev, "%s: Invalid micbias number: %d\n",
   __func__, micb_num);
  return -EINVAL;
 }

 switch (req) {
 case MICB_PULLUP_ENABLE:
  wcd938x->pullup_ref[micb_index]++;
  if ((wcd938x->pullup_ref[micb_index] == 1) &&
      (wcd938x->micb_ref[micb_index] == 0))
   snd_soc_component_write_field(component, micb_reg,
            WCD938X_MICB_EN_MASK,
            WCD938X_MICB_PULL_UP);
  break;
 case MICB_PULLUP_DISABLE:
  if (wcd938x->pullup_ref[micb_index] > 0)
   wcd938x->pullup_ref[micb_index]--;

  if ((wcd938x->pullup_ref[micb_index] == 0) &&
      (wcd938x->micb_ref[micb_index] == 0))
   snd_soc_component_write_field(component, micb_reg,
            WCD938X_MICB_EN_MASK, 0);
  break;
 case MICB_ENABLE:
  wcd938x->micb_ref[micb_index]++;
  if (wcd938x->micb_ref[micb_index] == 1) {
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_DIG_CLK_CTL,
    WCD938X_TX_CLK_EN_MASK, 0xF);
   snd_soc_component_write_field(component,
    WCD938X_DIGITAL_CDC_ANA_CLK_CTL,
    WCD938X_ANA_TX_DIV2_CLK_EN_MASK, 1);
   snd_soc_component_write_field(component,
          WCD938X_DIGITAL_CDC_ANA_TX_CLK_CTL,
          WCD938X_TX_SC_CLK_EN_MASK, 1);

   snd_soc_component_write_field(component, micb_reg,
            WCD938X_MICB_EN_MASK,
            WCD938X_MICB_ENABLE);
   if (micb_num  == MIC_BIAS_2)
    wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
            WCD_EVENT_POST_MICBIAS_2_ON);
  }
  if (micb_num  == MIC_BIAS_2 && is_dapm)
   wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
           WCD_EVENT_POST_DAPM_MICBIAS_2_ON);


  break;
 case MICB_DISABLE:
  if (wcd938x->micb_ref[micb_index] > 0)
   wcd938x->micb_ref[micb_index]--;

  if ((wcd938x->micb_ref[micb_index] == 0) &&
      (wcd938x->pullup_ref[micb_index] > 0))
   snd_soc_component_write_field(component, micb_reg,
            WCD938X_MICB_EN_MASK,
            WCD938X_MICB_PULL_UP);
  else if ((wcd938x->micb_ref[micb_index] == 0) &&
    (wcd938x->pullup_ref[micb_index] == 0)) {
   if (micb_num  == MIC_BIAS_2)
    wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
            WCD_EVENT_PRE_MICBIAS_2_OFF);

   snd_soc_component_write_field(component, micb_reg,
            WCD938X_MICB_EN_MASK, 0);
   if (micb_num  == MIC_BIAS_2)
    wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
            WCD_EVENT_POST_MICBIAS_2_OFF);
  }
  if (is_dapm && micb_num  == MIC_BIAS_2)
   wcd_mbhc_event_notify(wcd938x->wcd_mbhc,
           WCD_EVENT_POST_DAPM_MICBIAS_2_OFF);
  break;
 }

 return 0;
}

static int wcd938x_codec_enable_micbias(struct snd_soc_dapm_widget *w,
     struct snd_kcontrol *kcontrol,
     int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 int micb_num = w->shift;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  wcd938x_micbias_control(component, micb_num, MICB_ENABLE, true);
  break;
 case SND_SOC_DAPM_POST_PMU:
  /* 1 msec delay as per HW requirement */
  usleep_range(1000, 1100);
  break;
 case SND_SOC_DAPM_POST_PMD:
  wcd938x_micbias_control(component, micb_num, MICB_DISABLE, true);
  break;
 }

 return 0;
}

static int wcd938x_codec_enable_micbias_pullup(struct snd_soc_dapm_widget *w,
            struct snd_kcontrol *kcontrol,
            int event)
{
 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
 int micb_num = w->shift;

 switch (event) {
 case SND_SOC_DAPM_PRE_PMU:
  wcd938x_micbias_control(component, micb_num,
     MICB_PULLUP_ENABLE, true);
  break;
 case SND_SOC_DAPM_POST_PMU:
  /* 1 msec delay as per HW requirement */
  usleep_range(1000, 1100);
  break;
 case SND_SOC_DAPM_POST_PMD:
  wcd938x_micbias_control(component, micb_num,
     MICB_PULLUP_DISABLE, true);
  break;
 }

 return 0;
}

static int wcd938x_tx_mode_get(struct snd_kcontrol *kcontrol,
          struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 int path = e->shift_l;

 ucontrol->value.enumerated.item[0] = wcd938x->tx_mode[path];

 return 0;
}

static int wcd938x_tx_mode_put(struct snd_kcontrol *kcontrol,
          struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
 int path = e->shift_l;

 if (wcd938x->tx_mode[path] == ucontrol->value.enumerated.item[0])
  return 0;

 wcd938x->tx_mode[path] = ucontrol->value.enumerated.item[0];

 return 1;
}

static int wcd938x_rx_hph_mode_get(struct snd_kcontrol *kcontrol,
     struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 ucontrol->value.enumerated.item[0] = wcd938x->hph_mode;

 return 0;
}

static int wcd938x_rx_hph_mode_put(struct snd_kcontrol *kcontrol,
       struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 if (wcd938x->hph_mode == ucontrol->value.enumerated.item[0])
  return 0;

 wcd938x->hph_mode = ucontrol->value.enumerated.item[0];

 return 1;
}

static int wcd938x_ear_pa_put_gain(struct snd_kcontrol *kcontrol,
       struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 if (wcd938x->comp1_enable) {
  dev_err(component->dev, "Can not set EAR PA Gain, compander1 is enabled\n");
  return -EINVAL;
 }

 snd_soc_component_write_field(component, WCD938X_ANA_EAR_COMPANDER_CTL,
          WCD938X_EAR_GAIN_MASK,
          ucontrol->value.integer.value[0]);

 return 1;
}

static int wcd938x_get_compander(struct snd_kcontrol *kcontrol,
     struct snd_ctl_elem_value *ucontrol)
{

 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 struct soc_mixer_control *mc;
 bool hphr;

 mc = (struct soc_mixer_control *)(kcontrol->private_value);
 hphr = mc->shift;

 if (hphr)
  ucontrol->value.integer.value[0] = wcd938x->comp2_enable;
 else
  ucontrol->value.integer.value[0] = wcd938x->comp1_enable;

 return 0;
}

static int wcd938x_set_compander(struct snd_kcontrol *kcontrol,
     struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 struct wcd938x_sdw_priv *wcd;
 int value = ucontrol->value.integer.value[0];
 int portidx;
 struct soc_mixer_control *mc;
 bool hphr;

 mc = (struct soc_mixer_control *)(kcontrol->private_value);
 hphr = mc->shift;

 wcd = wcd938x->sdw_priv[AIF1_PB];

 if (hphr)
  wcd938x->comp2_enable = value;
 else
  wcd938x->comp1_enable = value;

 portidx = wcd->ch_info[mc->reg].port_num;

 if (value)
  wcd938x_connect_port(wcd, portidx, mc->reg, true);
 else
  wcd938x_connect_port(wcd, portidx, mc->reg, false);

 return 1;
}

static int wcd938x_ldoh_get(struct snd_kcontrol *kcontrol,
       struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 ucontrol->value.integer.value[0] = wcd938x->ldoh;

 return 0;
}

static int wcd938x_ldoh_put(struct snd_kcontrol *kcontrol,
       struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);

 if (wcd938x->ldoh == ucontrol->value.integer.value[0])
  return 0;

 wcd938x->ldoh = ucontrol->value.integer.value[0];

 return 1;
}

static const char * const tx_mode_mux_text_wcd9380[] = {
 "ADC_INVALID", "ADC_HIFI", "ADC_LO_HIF", "ADC_NORMAL", "ADC_LP",
};

static const char * const tx_mode_mux_text[] = {
 "ADC_INVALID", "ADC_HIFI", "ADC_LO_HIF", "ADC_NORMAL", "ADC_LP",
 "ADC_ULP1", "ADC_ULP2",
};

static const char * const rx_hph_mode_mux_text_wcd9380[] = {
 "CLS_H_INVALID", "CLS_H_INVALID_1", "CLS_H_LP", "CLS_AB",
 "CLS_H_LOHIFI", "CLS_H_ULP", "CLS_H_INVALID_2", "CLS_AB_LP",
 "CLS_AB_LOHIFI",
};

static const char * const rx_hph_mode_mux_text[] = {
 "CLS_H_INVALID", "CLS_H_HIFI", "CLS_H_LP", "CLS_AB", "CLS_H_LOHIFI",
 "CLS_H_ULP", "CLS_AB_HIFI", "CLS_AB_LP", "CLS_AB_LOHIFI",
};

static const char * const adc2_mux_text[] = {
 "INP2", "INP3"
};

static const char * const adc3_mux_text[] = {
 "INP4", "INP6"
};

static const char * const adc4_mux_text[] = {
 "INP5", "INP7"
};

static const char * const rdac3_mux_text[] = {
 "RX1", "RX3"
};

static const char * const hdr12_mux_text[] = {
 "NO_HDR12", "HDR12"
};

static const char * const hdr34_mux_text[] = {
 "NO_HDR34", "HDR34"
};

static const struct soc_enum tx0_mode_enum_wcd9380 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(tx_mode_mux_text_wcd9380),
   tx_mode_mux_text_wcd9380);

static const struct soc_enum tx1_mode_enum_wcd9380 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 1, ARRAY_SIZE(tx_mode_mux_text_wcd9380),
   tx_mode_mux_text_wcd9380);

static const struct soc_enum tx2_mode_enum_wcd9380 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 2, ARRAY_SIZE(tx_mode_mux_text_wcd9380),
   tx_mode_mux_text_wcd9380);

static const struct soc_enum tx3_mode_enum_wcd9380 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 3, ARRAY_SIZE(tx_mode_mux_text_wcd9380),
   tx_mode_mux_text_wcd9380);

static const struct soc_enum tx0_mode_enum_wcd9385 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 0, ARRAY_SIZE(tx_mode_mux_text),
   tx_mode_mux_text);

static const struct soc_enum tx1_mode_enum_wcd9385 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 1, ARRAY_SIZE(tx_mode_mux_text),
   tx_mode_mux_text);

static const struct soc_enum tx2_mode_enum_wcd9385 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 2, ARRAY_SIZE(tx_mode_mux_text),
   tx_mode_mux_text);

static const struct soc_enum tx3_mode_enum_wcd9385 =
 SOC_ENUM_SINGLE(SND_SOC_NOPM, 3, ARRAY_SIZE(tx_mode_mux_text),
   tx_mode_mux_text);

static const struct soc_enum rx_hph_mode_mux_enum_wcd9380 =
  SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(rx_hph_mode_mux_text_wcd9380),
        rx_hph_mode_mux_text_wcd9380);

static const struct soc_enum rx_hph_mode_mux_enum =
  SOC_ENUM_SINGLE_EXT(ARRAY_SIZE(rx_hph_mode_mux_text),
        rx_hph_mode_mux_text);

static const struct soc_enum adc2_enum =
  SOC_ENUM_SINGLE(WCD938X_TX_NEW_AMIC_MUX_CFG, 7,
    ARRAY_SIZE(adc2_mux_text), adc2_mux_text);

static const struct soc_enum adc3_enum =
  SOC_ENUM_SINGLE(WCD938X_TX_NEW_AMIC_MUX_CFG, 6,
    ARRAY_SIZE(adc3_mux_text), adc3_mux_text);

static const struct soc_enum adc4_enum =
  SOC_ENUM_SINGLE(WCD938X_TX_NEW_AMIC_MUX_CFG, 5,
    ARRAY_SIZE(adc4_mux_text), adc4_mux_text);

static const struct soc_enum hdr12_enum =
  SOC_ENUM_SINGLE(WCD938X_TX_NEW_AMIC_MUX_CFG, 4,
    ARRAY_SIZE(hdr12_mux_text), hdr12_mux_text);

static const struct soc_enum hdr34_enum =
  SOC_ENUM_SINGLE(WCD938X_TX_NEW_AMIC_MUX_CFG, 3,
    ARRAY_SIZE(hdr34_mux_text), hdr34_mux_text);

static const struct soc_enum rdac3_enum =
  SOC_ENUM_SINGLE(WCD938X_DIGITAL_CDC_EAR_PATH_CTL, 0,
    ARRAY_SIZE(rdac3_mux_text), rdac3_mux_text);

static const struct snd_kcontrol_new adc1_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new adc2_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new adc3_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new adc4_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic1_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic2_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic3_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic4_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic5_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic6_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic7_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new dmic8_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new ear_rdac_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new aux_rdac_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new hphl_rdac_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new hphr_rdac_switch[] = {
 SOC_DAPM_SINGLE("Switch", SND_SOC_NOPM, 0, 1, 0)
};

static const struct snd_kcontrol_new tx_adc2_mux =
 SOC_DAPM_ENUM("ADC2 MUX Mux", adc2_enum);

static const struct snd_kcontrol_new tx_adc3_mux =
 SOC_DAPM_ENUM("ADC3 MUX Mux", adc3_enum);

static const struct snd_kcontrol_new tx_adc4_mux =
 SOC_DAPM_ENUM("ADC4 MUX Mux", adc4_enum);

static const struct snd_kcontrol_new tx_hdr12_mux =
 SOC_DAPM_ENUM("HDR12 MUX Mux", hdr12_enum);

static const struct snd_kcontrol_new tx_hdr34_mux =
 SOC_DAPM_ENUM("HDR34 MUX Mux", hdr34_enum);

static const struct snd_kcontrol_new rx_rdac3_mux =
 SOC_DAPM_ENUM("RDAC3_MUX Mux", rdac3_enum);

static const struct snd_kcontrol_new wcd9380_snd_controls[] = {
 SOC_ENUM_EXT("RX HPH Mode", rx_hph_mode_mux_enum_wcd9380,
       wcd938x_rx_hph_mode_get, wcd938x_rx_hph_mode_put),
 SOC_ENUM_EXT("TX0 MODE", tx0_mode_enum_wcd9380,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
 SOC_ENUM_EXT("TX1 MODE", tx1_mode_enum_wcd9380,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
 SOC_ENUM_EXT("TX2 MODE", tx2_mode_enum_wcd9380,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
 SOC_ENUM_EXT("TX3 MODE", tx3_mode_enum_wcd9380,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
};

static const struct snd_kcontrol_new wcd9385_snd_controls[] = {
 SOC_ENUM_EXT("RX HPH Mode", rx_hph_mode_mux_enum,
       wcd938x_rx_hph_mode_get, wcd938x_rx_hph_mode_put),
 SOC_ENUM_EXT("TX0 MODE", tx0_mode_enum_wcd9385,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
 SOC_ENUM_EXT("TX1 MODE", tx1_mode_enum_wcd9385,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
 SOC_ENUM_EXT("TX2 MODE", tx2_mode_enum_wcd9385,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
 SOC_ENUM_EXT("TX3 MODE", tx3_mode_enum_wcd9385,
       wcd938x_tx_mode_get, wcd938x_tx_mode_put),
};

static int wcd938x_get_swr_port(struct snd_kcontrol *kcontrol,
       struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(comp);
 struct wcd938x_sdw_priv *wcd;
 struct soc_mixer_control *mixer = (struct soc_mixer_control *)kcontrol->private_value;
 int dai_id = mixer->shift;
 int portidx, ch_idx = mixer->reg;


 wcd = wcd938x->sdw_priv[dai_id];
 portidx = wcd->ch_info[ch_idx].port_num;

 ucontrol->value.integer.value[0] = wcd->port_enable[portidx];

 return 0;
}

static int wcd938x_set_swr_port(struct snd_kcontrol *kcontrol,
       struct snd_ctl_elem_value *ucontrol)
{
 struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(comp);
 struct wcd938x_sdw_priv *wcd;
 struct soc_mixer_control *mixer =
  (struct soc_mixer_control *)kcontrol->private_value;
 int ch_idx = mixer->reg;
 int portidx;
 int dai_id = mixer->shift;
 bool enable;

 wcd = wcd938x->sdw_priv[dai_id];

 portidx = wcd->ch_info[ch_idx].port_num;
 if (ucontrol->value.integer.value[0])
  enable = true;
 else
  enable = false;

 wcd->port_enable[portidx] = enable;

 wcd938x_connect_port(wcd, portidx, ch_idx, enable);

 return 1;

}

/* MBHC related */
static void wcd938x_mbhc_clk_setup(struct snd_soc_component *component,
       bool enable)
{
 snd_soc_component_write_field(component, WCD938X_MBHC_NEW_CTL_1,
          WCD938X_MBHC_CTL_RCO_EN_MASK, enable);
}

static void wcd938x_mbhc_mbhc_bias_control(struct snd_soc_component *component,
        bool enable)
{
 snd_soc_component_write_field(component, WCD938X_ANA_MBHC_ELECT,
          WCD938X_ANA_MBHC_BIAS_EN, enable);
}

static void wcd938x_mbhc_program_btn_thr(struct snd_soc_component *component,
      int *btn_low, int *btn_high,
      int num_btn, bool is_micbias)
{
 int i, vth;

 if (num_btn > WCD_MBHC_DEF_BUTTONS) {
  dev_err(component->dev, "%s: invalid number of buttons: %d\n",
   __func__, num_btn);
  return;
 }

 for (i = 0; i < num_btn; i++) {
  vth = ((btn_high[i] * 2) / 25) & 0x3F;
  snd_soc_component_write_field(component, WCD938X_ANA_MBHC_BTN0 + i,
        WCD938X_MBHC_BTN_VTH_MASK, vth);
  dev_dbg(component->dev, "%s: btn_high[%d]: %d, vth: %d\n",
   __func__, i, btn_high[i], vth);
 }
}

static bool wcd938x_mbhc_micb_en_status(struct snd_soc_component *component, int micb_num)
{
 u8 val;

 if (micb_num == MIC_BIAS_2) {
  val = snd_soc_component_read_field(component,
         WCD938X_ANA_MICB2,
         WCD938X_MICB_EN_MASK);
  if (val == WCD938X_MICB_ENABLE)
   return true;
 }
 return false;
}

static void wcd938x_mbhc_hph_l_pull_up_control(struct snd_soc_component *component,
       int pull_up_cur)
{
 /* Default pull up current to 2uA */
 if (pull_up_cur > HS_PULLUP_I_OFF || pull_up_cur < HS_PULLUP_I_3P0_UA)
  pull_up_cur = HS_PULLUP_I_2P0_UA;

 snd_soc_component_write_field(component,
          WCD938X_MBHC_NEW_INT_MECH_DET_CURRENT,
          WCD938X_HSDET_PULLUP_C_MASK, pull_up_cur);
}

static int wcd938x_mbhc_request_micbias(struct snd_soc_component *component,
     int micb_num, int req)
{
 return wcd938x_micbias_control(component, micb_num, req, false);
}

static void wcd938x_mbhc_micb_ramp_control(struct snd_soc_component *component,
        bool enable)
{
 if (enable) {
  snd_soc_component_write_field(component, WCD938X_ANA_MICB2_RAMP,
        WCD938X_RAMP_SHIFT_CTRL_MASK, 0x0C);
  snd_soc_component_write_field(component, WCD938X_ANA_MICB2_RAMP,
        WCD938X_RAMP_EN_MASK, 1);
 } else {
  snd_soc_component_write_field(component, WCD938X_ANA_MICB2_RAMP,
        WCD938X_RAMP_EN_MASK, 0);
  snd_soc_component_write_field(component, WCD938X_ANA_MICB2_RAMP,
        WCD938X_RAMP_SHIFT_CTRL_MASK, 0);
 }
}

static int wcd938x_get_micb_vout_ctl_val(u32 micb_mv)
{
 /* min micbias voltage is 1V and maximum is 2.85V */
 if (micb_mv < 1000 || micb_mv > 2850)
  return -EINVAL;

 return (micb_mv - 1000) / 50;
}

static int wcd938x_mbhc_micb_adjust_voltage(struct snd_soc_component *component,
         int req_volt, int micb_num)
{
 struct wcd938x_priv *wcd938x =  snd_soc_component_get_drvdata(component);
 int cur_vout_ctl, req_vout_ctl, micb_reg, micb_en, ret = 0;

 switch (micb_num) {
 case MIC_BIAS_1:
  micb_reg = WCD938X_ANA_MICB1;
  break;
 case MIC_BIAS_2:
  micb_reg = WCD938X_ANA_MICB2;
  break;
 case MIC_BIAS_3:
  micb_reg = WCD938X_ANA_MICB3;
  break;
 case MIC_BIAS_4:
  micb_reg = WCD938X_ANA_MICB4;
  break;
 default:
  return -EINVAL;
 }
 mutex_lock(&wcd938x->micb_lock);
 /*
 * If requested micbias voltage is same as current micbias
 * voltage, then just return. Otherwise, adjust voltage as
 * per requested value. If micbias is already enabled, then
 * to avoid slow micbias ramp-up or down enable pull-up
 * momentarily, change the micbias value and then re-enable
 * micbias.
 */
 micb_en = snd_soc_component_read_field(component, micb_reg,
      WCD938X_MICB_EN_MASK);
 cur_vout_ctl = snd_soc_component_read_field(component, micb_reg,
          WCD938X_MICB_VOUT_MASK);

 req_vout_ctl = wcd938x_get_micb_vout_ctl_val(req_volt);
 if (req_vout_ctl < 0) {
  ret = -EINVAL;
  goto exit;
 }

 if (cur_vout_ctl == req_vout_ctl) {
  ret = 0;
  goto exit;
 }

 if (micb_en == WCD938X_MICB_ENABLE)
  snd_soc_component_write_field(component, micb_reg,
           WCD938X_MICB_EN_MASK,
           WCD938X_MICB_PULL_UP);

 snd_soc_component_write_field(component, micb_reg,
          WCD938X_MICB_VOUT_MASK,
          req_vout_ctl);

 if (micb_en == WCD938X_MICB_ENABLE) {
  snd_soc_component_write_field(component, micb_reg,
           WCD938X_MICB_EN_MASK,
           WCD938X_MICB_ENABLE);
  /*
 * Add 2ms delay as per HW requirement after enabling
 * micbias
 */
  usleep_range(2000, 2100);
 }
exit:
 mutex_unlock(&wcd938x->micb_lock);
 return ret;
}

static int wcd938x_mbhc_micb_ctrl_threshold_mic(struct snd_soc_component *component,
      int micb_num, bool req_en)
{
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
 int micb_mv;

 if (micb_num != MIC_BIAS_2)
  return -EINVAL;
 /*
 * If device tree micbias level is already above the minimum
 * voltage needed to detect threshold microphone, then do
 * not change the micbias, just return.
 */
 if (wcd938x->micb2_mv >= WCD_MBHC_THR_HS_MICB_MV)
  return 0;

 micb_mv = req_en ? WCD_MBHC_THR_HS_MICB_MV : wcd938x->micb2_mv;

 return wcd938x_mbhc_micb_adjust_voltage(component, micb_mv, MIC_BIAS_2);
}

static void wcd938x_mbhc_get_result_params(struct snd_soc_component *component,
      s16 *d1_a, u16 noff,
      int32_t *zdet)
{
 struct wcd938x_priv *wcd938x = snd_soc_component_get_drvdata(component);
--> --------------------

--> maximum size reached

--> --------------------

Messung V0.5
C=96 H=96 G=95

¤ Dauer der Verarbeitung: 0.11 Sekunden  (vorverarbeitet)  ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.