Lines Matching refs:wcd
25 #include "wcd-clsh-v2.h"
1264 struct wcd9335_codec *wcd = dev_get_drvdata(w->dapm->dev);
1267 ucontrol->value.enumerated.item[0] = wcd->rx_port_value[port_id];
1276 struct wcd9335_codec *wcd = dev_get_drvdata(w->dapm->dev);
1281 if (wcd->rx_port_value[port_id] == ucontrol->value.enumerated.item[0])
1284 wcd->rx_port_value[port_id] = ucontrol->value.enumerated.item[0];
1287 list_del_init(&wcd->rx_chs[port_id].list);
1289 switch (wcd->rx_port_value[port_id]) {
1294 list_add_tail(&wcd->rx_chs[port_id].list,
1295 &wcd->dai[AIF1_PB].slim_ch_list);
1298 list_add_tail(&wcd->rx_chs[port_id].list,
1299 &wcd->dai[AIF2_PB].slim_ch_list);
1302 list_add_tail(&wcd->rx_chs[port_id].list,
1303 &wcd->dai[AIF3_PB].slim_ch_list);
1306 list_add_tail(&wcd->rx_chs[port_id].list,
1307 &wcd->dai[AIF4_PB].slim_ch_list);
1310 dev_err(wcd->dev, "Unknown AIF %d\n", wcd->rx_port_value[port_id]);
1314 snd_soc_dapm_mux_update_power(w->dapm, kc, wcd->rx_port_value[port_id],
1327 struct wcd9335_codec *wcd = dev_get_drvdata(dapm->dev);
1334 ucontrol->value.integer.value[0] = wcd->tx_port_value[port_id] == dai_id;
1344 struct wcd9335_codec *wcd = dev_get_drvdata(widget->dapm->dev);
1357 if (enable && wcd->tx_port_value[port_id] != dai_id) {
1358 wcd->tx_port_value[port_id] = dai_id;
1359 list_add_tail(&wcd->tx_chs[port_id].list,
1360 &wcd->dai[dai_id].slim_ch_list);
1361 } else if (!enable && wcd->tx_port_value[port_id] == dai_id) {
1362 wcd->tx_port_value[port_id] = -1;
1363 list_del_init(&wcd->tx_chs[port_id].list);
1367 dev_err(wcd->dev, "Unknown AIF %d\n", dai_id);
1617 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
1621 list_for_each_entry(ch, &wcd->dai[dai->id].slim_ch_list, list) {
1643 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
1648 list_for_each_entry(ch, &wcd->dai[dai->id].slim_ch_list, list) {
1672 dev_info(wcd->dev,
1711 static int wcd9335_slim_set_hw_params(struct wcd9335_codec *wcd,
1741 ret = regmap_write(wcd->if_regmap,
1749 ret = regmap_write(wcd->if_regmap,
1755 ret = regmap_write(wcd->if_regmap,
1762 ret = regmap_write(wcd->if_regmap,
1769 ret = regmap_write(wcd->if_regmap,
1778 dai_data->sruntime = slim_stream_allocate(wcd->slim, "WCD9335-SLIM");
1783 dev_err(wcd->dev, "Error Setting slim hw params\n");
1794 struct wcd9335_codec *wcd = snd_soc_component_get_drvdata(comp);
1800 list_for_each_entry(ch, &wcd->dai[dai->id].slim_ch_list, list) {
1803 dev_err(wcd->dev, "Invalid SLIM TX%u port DAI ID:%d\n",
1855 dev_err(wcd->dev, "RX_MIX_TX%u going to SLIM TX%u\n",
1858 dev_err(wcd->dev, "ERROR: Invalid decimator: %d\n",
1871 struct wcd9335_codec *wcd;
1874 wcd = snd_soc_component_get_drvdata(dai->component);
1880 dev_err(wcd->dev, "cannot set sample rate: %u\n",
1886 wcd->dai[dai->id].sconfig.bps = params_width(params);
1889 dev_err(wcd->dev, "%s: Invalid format 0x%x\n",
1919 dev_err(wcd->dev, "%s: Invalid TX sample rate: %d\n",
1928 dev_err(wcd->dev, "Cannot set TX Decimator rate\n");
1933 wcd->dai[dai->id].sconfig.bps = params_width(params);
1936 dev_err(wcd->dev, "%s: Invalid format 0x%x\n",
1942 dev_err(wcd->dev, "Invalid stream type %d\n",
1947 wcd->dai[dai->id].sconfig.rate = params_rate(params);
1948 wcd9335_slim_set_hw_params(wcd, &wcd->dai[dai->id], substream->stream);
1957 struct wcd9335_codec *wcd;
1960 wcd = snd_soc_component_get_drvdata(dai->component);
1962 dai_data = &wcd->dai[dai->id];
1989 struct wcd9335_codec *wcd;
1992 wcd = snd_soc_component_get_drvdata(dai->component);
1995 dev_err(wcd->dev, "Invalid tx_slot=%p, rx_slot=%p\n",
2000 wcd->num_rx_port = rx_num;
2002 wcd->rx_chs[i].ch_num = rx_slot[i];
2003 INIT_LIST_HEAD(&wcd->rx_chs[i].list);
2006 wcd->num_tx_port = tx_num;
2008 wcd->tx_chs[i].ch_num = tx_slot[i];
2009 INIT_LIST_HEAD(&wcd->tx_chs[i].list);
2020 struct wcd9335_codec *wcd;
2023 wcd = snd_soc_component_get_drvdata(dai->component);
2031 dev_err(wcd->dev, "Invalid rx_slot %p or rx_num %p\n",
2036 list_for_each_entry(ch, &wcd->dai[dai->id].slim_ch_list, list)
2045 dev_err(wcd->dev, "Invalid tx_slot %p or tx_num %p\n",
2049 list_for_each_entry(ch, &wcd->dai[dai->id].slim_ch_list, list)
2055 dev_err(wcd->dev, "Invalid DAI ID %x\n", dai->id);
2180 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
2182 ucontrol->value.integer.value[0] = wcd->comp_enabled[comp];
2190 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
2195 wcd->comp_enabled[comp] = value;
2229 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
2231 ucontrol->value.enumerated.item[0] = wcd->hph_mode;
2240 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
2246 dev_err(wcd->dev, "Invalid HPH Mode, default to ClSH HiFi\n");
2249 wcd->hph_mode = mode_val;
2498 struct wcd9335_codec *wcd = snd_soc_component_get_drvdata(component);
2503 dev_err(wcd->dev, "Invalid micbias index, micb_ind:%d\n",
2529 wcd->pullup_ref[micb_index]++;
2530 if ((wcd->pullup_ref[micb_index] == 1) &&
2531 (wcd->micb_ref[micb_index] == 0))
2536 wcd->pullup_ref[micb_index]--;
2537 if ((wcd->pullup_ref[micb_index] == 0) &&
2538 (wcd->micb_ref[micb_index] == 0))
2543 wcd->micb_ref[micb_index]++;
2544 if (wcd->micb_ref[micb_index] == 1)
2549 wcd->micb_ref[micb_index]--;
2550 if ((wcd->micb_ref[micb_index] == 0) &&
2551 (wcd->pullup_ref[micb_index] > 0))
2554 else if ((wcd->micb_ref[micb_index] == 0) &&
2555 (wcd->pullup_ref[micb_index] == 0)) {
2905 struct wcd9335_codec *wcd = snd_soc_component_get_drvdata(comp);
2930 dmic_clk_cnt = &(wcd->dmic_0_1_clk_cnt);
2935 dmic_clk_cnt = &(wcd->dmic_2_3_clk_cnt);
2940 dmic_clk_cnt = &(wcd->dmic_4_5_clk_cnt);
2953 wcd->mclk_rate,
2954 wcd->dmic_sample_rate);
2969 wcd->mclk_rate,
2970 wcd->mad_dmic_sample_rate);
2991 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
3003 regmap_read(wcd->if_regmap, reg, &val);
3005 regmap_write(wcd->if_regmap, reg,
3015 struct wcd9335_codec *wcd = snd_soc_component_get_drvdata(comp);
3016 struct wcd_slim_codec_dai_data *dai = &wcd->dai[w->shift];
3185 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3191 wcd->prim_int_users[ind]++;
3192 if (wcd->prim_int_users[ind] == 1) {
3210 wcd->prim_int_users[ind]--;
3211 if (wcd->prim_int_users[ind] == 0) {
3232 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
3241 if (!wcd->comp_enabled[comp])
3355 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
3379 wcd->hph_l_gain = hph_l_en & 0x1F;
3384 wcd->hph_r_gain = hph_r_en & 0x1F;
3530 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3531 int hph_mode = wcd->hph_mode;
3544 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl, WCD_CLSH_EVENT_PRE_DAC,
3561 if (!(wcd_clsh_ctrl_get_state(wcd->clsh_ctrl) &
3565 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl, WCD_CLSH_EVENT_POST_PA,
3579 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3583 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl, WCD_CLSH_EVENT_PRE_DAC,
3587 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl, WCD_CLSH_EVENT_POST_PA,
3599 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3603 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl, WCD_CLSH_EVENT_PRE_DAC,
3608 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl, WCD_CLSH_EVENT_POST_PA,
3616 static void wcd9335_codec_hph_post_pa_config(struct wcd9335_codec *wcd,
3638 snd_soc_component_update_bits(wcd->component,
3643 if (wcd->comp_enabled[COMPANDER_1] ||
3644 wcd->comp_enabled[COMPANDER_2]) {
3646 snd_soc_component_update_bits(wcd->component,
3650 snd_soc_component_update_bits(wcd->component,
3654 snd_soc_component_update_bits(wcd->component,
3659 snd_soc_component_update_bits(wcd->component,
3662 wcd->hph_l_gain);
3663 snd_soc_component_update_bits(wcd->component,
3666 wcd->hph_r_gain);
3670 snd_soc_component_update_bits(wcd->component,
3681 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3682 int hph_mode = wcd->hph_mode;
3699 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl,
3712 if (!(wcd_clsh_ctrl_get_state(wcd->clsh_ctrl) &
3716 wcd_clsh_ctrl_set_state(wcd->clsh_ctrl, WCD_CLSH_EVENT_POST_PA,
3730 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3731 int hph_mode = wcd->hph_mode;
3743 wcd9335_codec_hph_post_pa_config(wcd, hph_mode, event);
3760 wcd9335_codec_hph_post_pa_config(wcd, hph_mode, event);
3849 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3853 wcd->rx_bias_count++;
3854 if (wcd->rx_bias_count == 1) {
3863 wcd->rx_bias_count--;
3864 if (!wcd->rx_bias_count)
3879 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
3880 int hph_mode = wcd->hph_mode;
3891 wcd9335_codec_hph_post_pa_config(wcd, hph_mode, event);
3908 wcd9335_codec_hph_post_pa_config(wcd, hph_mode, event);
3959 struct wcd9335_codec *wcd = data;
3969 regmap_read(wcd->if_regmap, i, &val);
3976 regmap_read(wcd->if_regmap,
3986 wcd->if_regmap, reg, &int_val);
3996 dev_err_ratelimited(wcd->dev,
4001 dev_err_ratelimited(wcd->dev,
4014 wcd->if_regmap, reg, &int_val);
4017 regmap_write(wcd->if_regmap,
4022 regmap_write(wcd->if_regmap,
4039 static int wcd9335_setup_irqs(struct wcd9335_codec *wcd)
4044 irq = regmap_irq_get_virq(wcd->irq_data, wcd9335_irqs[i].irq);
4046 dev_err(wcd->dev, "Failed to get %s\n",
4051 ret = devm_request_threaded_irq(wcd->dev, irq, NULL,
4055 wcd9335_irqs[i].name, wcd);
4057 dev_err(wcd->dev, "Failed to request %s\n",
4065 regmap_write(wcd->if_regmap, WCD9335_SLIM_PGD_PORT_INT_EN0 + i,
4071 static void wcd9335_teardown_irqs(struct wcd9335_codec *wcd)
4077 regmap_write(wcd->if_regmap, WCD9335_SLIM_PGD_PORT_INT_EN0 + i,
4081 static void wcd9335_cdc_sido_ccl_enable(struct wcd9335_codec *wcd,
4084 struct snd_soc_component *comp = wcd->component;
4087 if (++wcd->sido_ccl_cnt == 1)
4091 if (wcd->sido_ccl_cnt == 0) {
4092 dev_err(wcd->dev, "sido_ccl already disabled\n");
4095 if (--wcd->sido_ccl_cnt == 0)
4101 static int wcd9335_enable_master_bias(struct wcd9335_codec *wcd)
4103 wcd->master_bias_users++;
4104 if (wcd->master_bias_users == 1) {
4105 regmap_update_bits(wcd->regmap, WCD9335_ANA_BIAS,
4108 regmap_update_bits(wcd->regmap, WCD9335_ANA_BIAS,
4116 regmap_update_bits(wcd->regmap, WCD9335_ANA_BIAS,
4119 regmap_update_bits(wcd->regmap, WCD9335_ANA_BIAS,
4127 static int wcd9335_enable_mclk(struct wcd9335_codec *wcd)
4130 if (wcd->master_bias_users <= 0)
4133 if (((wcd->clk_mclk_users == 0) && (wcd->clk_type == WCD_CLK_MCLK)) ||
4134 ((wcd->clk_mclk_users > 0) && (wcd->clk_type != WCD_CLK_MCLK))) {
4135 dev_err(wcd->dev, "Error enabling MCLK, clk_type: %d\n",
4136 wcd->clk_type);
4140 if (++wcd->clk_mclk_users == 1) {
4141 regmap_update_bits(wcd->regmap, WCD9335_ANA_CLK_TOP,
4144 regmap_update_bits(wcd->regmap, WCD9335_ANA_CLK_TOP,
4147 regmap_update_bits(wcd->regmap, WCD9335_ANA_CLK_TOP,
4150 regmap_update_bits(wcd->regmap,
4154 regmap_update_bits(wcd->regmap,
4165 wcd->clk_type = WCD_CLK_MCLK;
4170 static int wcd9335_disable_mclk(struct wcd9335_codec *wcd)
4172 if (wcd->clk_mclk_users <= 0)
4175 if (--wcd->clk_mclk_users == 0) {
4176 if (wcd->clk_rco_users > 0) {
4178 regmap_update_bits(wcd->regmap, WCD9335_ANA_CLK_TOP,
4181 wcd->clk_type = WCD_CLK_RCO;
4183 regmap_update_bits(wcd->regmap, WCD9335_ANA_CLK_TOP,
4186 wcd->clk_type = WCD_CLK_OFF;
4189 regmap_update_bits(wcd->regmap, WCD9335_ANA_CLK_TOP,
4197 static int wcd9335_disable_master_bias(struct wcd9335_codec *wcd)
4199 if (wcd->master_bias_users <= 0)
4202 wcd->master_bias_users--;
4203 if (wcd->master_bias_users == 0) {
4204 regmap_update_bits(wcd->regmap, WCD9335_ANA_BIAS,
4207 regmap_update_bits(wcd->regmap, WCD9335_ANA_BIAS,
4214 static int wcd9335_cdc_req_mclk_enable(struct wcd9335_codec *wcd,
4220 wcd9335_cdc_sido_ccl_enable(wcd, true);
4221 ret = clk_prepare_enable(wcd->mclk);
4223 dev_err(wcd->dev, "%s: ext clk enable failed\n",
4228 wcd9335_enable_master_bias(wcd);
4230 wcd9335_enable_mclk(wcd);
4234 wcd9335_disable_mclk(wcd);
4236 wcd9335_disable_master_bias(wcd);
4237 clk_disable_unprepare(wcd->mclk);
4238 wcd9335_cdc_sido_ccl_enable(wcd, false);
4244 static void wcd9335_codec_apply_sido_voltage(struct wcd9335_codec *wcd,
4247 struct snd_soc_component *comp = wcd->component;
4250 if (req_mv == wcd->sido_voltage)
4263 wcd->sido_voltage = req_mv;
4269 static int wcd9335_codec_update_sido_voltage(struct wcd9335_codec *wcd,
4275 ret = wcd9335_cdc_req_mclk_enable(wcd, true);
4277 dev_err(wcd->dev, "Ext clk enable failed\n");
4281 wcd9335_codec_apply_sido_voltage(wcd, req_mv);
4282 wcd9335_cdc_req_mclk_enable(wcd, false);
4291 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
4295 ret = wcd9335_cdc_req_mclk_enable(wcd, true);
4299 wcd9335_codec_apply_sido_voltage(wcd,
4302 wcd9335_codec_update_sido_voltage(wcd,
4303 wcd->sido_voltage);
4304 wcd9335_cdc_req_mclk_enable(wcd, false);
4782 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
4797 wcd->sido_input_src = SIDO_SOURCE_RCO_BG;
4826 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
4830 regmap_update_bits(wcd->regmap, WCD9335_CODEC_RPM_CLK_GATE,
4833 regmap_update_bits(wcd->regmap, WCD9335_CODEC_RPM_CLK_MCLK_CFG,
4848 struct wcd9335_codec *wcd = dev_get_drvdata(component->dev);
4852 snd_soc_component_init_regmap(component, wcd->regmap);
4854 wcd->clsh_ctrl = wcd_clsh_ctrl_alloc(component, WCD9335);
4855 if (IS_ERR(wcd->clsh_ctrl))
4856 return PTR_ERR(wcd->clsh_ctrl);
4859 wcd->hph_mode = CLS_H_HIFI;
4860 wcd->component = component;
4865 INIT_LIST_HEAD(&wcd->dai[i].slim_ch_list);
4867 ret = wcd9335_setup_irqs(wcd);
4874 wcd_clsh_ctrl_free(wcd->clsh_ctrl);
4880 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
4882 wcd_clsh_ctrl_free(wcd->clsh_ctrl);
4883 wcd9335_teardown_irqs(wcd);
4890 struct wcd9335_codec *wcd = dev_get_drvdata(comp->dev);
4892 wcd->mclk_rate = freq;
4894 if (wcd->mclk_rate == WCD9335_MCLK_CLK_12P288MHZ)
4899 else if (wcd->mclk_rate == WCD9335_MCLK_CLK_9P6MHZ)
4905 return clk_set_rate(wcd->mclk, freq);
4921 static int wcd9335_probe(struct wcd9335_codec *wcd)
4923 struct device *dev = wcd->dev;
4925 memcpy(wcd->rx_chs, wcd9335_rx_chs, sizeof(wcd9335_rx_chs));
4926 memcpy(wcd->tx_chs, wcd9335_tx_chs, sizeof(wcd9335_tx_chs));
4928 wcd->sido_input_src = SIDO_SOURCE_INTERNAL;
4929 wcd->sido_voltage = SIDO_VOLTAGE_NOMINAL_MV;
5032 static int wcd9335_parse_dt(struct wcd9335_codec *wcd)
5034 struct device *dev = wcd->dev;
5038 wcd->reset_gpio = of_get_named_gpio(np, "reset-gpios", 0);
5039 if (wcd->reset_gpio < 0) {
5041 return wcd->reset_gpio;
5044 wcd->mclk = devm_clk_get(dev, "mclk");
5045 if (IS_ERR(wcd->mclk)) {
5047 return PTR_ERR(wcd->mclk);
5050 wcd->native_clk = devm_clk_get(dev, "slimbus");
5051 if (IS_ERR(wcd->native_clk)) {
5053 return PTR_ERR(wcd->native_clk);
5056 wcd->supplies[0].supply = "vdd-buck";
5057 wcd->supplies[1].supply = "vdd-buck-sido";
5058 wcd->supplies[2].supply = "vdd-tx";
5059 wcd->supplies[3].supply = "vdd-rx";
5060 wcd->supplies[4].supply = "vdd-io";
5062 ret = regulator_bulk_get(dev, WCD9335_MAX_SUPPLY, wcd->supplies);
5071 static int wcd9335_power_on_reset(struct wcd9335_codec *wcd)
5073 struct device *dev = wcd->dev;
5076 ret = regulator_bulk_enable(WCD9335_MAX_SUPPLY, wcd->supplies);
5091 gpio_direction_output(wcd->reset_gpio, 0);
5093 gpio_set_value(wcd->reset_gpio, 1);
5099 static int wcd9335_bring_up(struct wcd9335_codec *wcd)
5101 struct regmap *rm = wcd->regmap;
5108 dev_err(wcd->dev, "WCD9335 CODEC version detection fail!\n");
5113 dev_info(wcd->dev, "WCD9335 CODEC version is v2.0\n");
5114 wcd->version = WCD9335_VERSION_2_0;
5124 dev_err(wcd->dev, "WCD9335 CODEC version not supported\n");
5131 static int wcd9335_irq_init(struct wcd9335_codec *wcd)
5140 wcd->intr1 = of_irq_get_byname(wcd->dev->of_node, "intr1");
5141 if (wcd->intr1 < 0)
5142 return dev_err_probe(wcd->dev, wcd->intr1,
5145 ret = devm_regmap_add_irq_chip(wcd->dev, wcd->regmap, wcd->intr1,
5147 &wcd9335_regmap_irq1_chip, &wcd->irq_data);
5149 return dev_err_probe(wcd->dev, ret, "Failed to register IRQ chip\n");
5157 struct wcd9335_codec *wcd;
5160 wcd = devm_kzalloc(dev, sizeof(*wcd), GFP_KERNEL);
5161 if (!wcd)
5164 wcd->dev = dev;
5165 ret = wcd9335_parse_dt(wcd);
5171 ret = wcd9335_power_on_reset(wcd);
5175 dev_set_drvdata(dev, wcd);
5185 struct wcd9335_codec *wcd;
5188 wcd = dev_get_drvdata(dev);
5196 wcd->slim = sdev;
5197 wcd->slim_ifc_dev = of_slim_get_device(sdev->ctrl, ifc_dev_np);
5199 if (!wcd->slim_ifc_dev) {
5204 slim_get_logical_addr(wcd->slim_ifc_dev);
5206 wcd->regmap = regmap_init_slimbus(sdev, &wcd9335_regmap_config);
5207 if (IS_ERR(wcd->regmap))
5208 return dev_err_probe(dev, PTR_ERR(wcd->regmap),
5211 wcd->if_regmap = regmap_init_slimbus(wcd->slim_ifc_dev,
5213 if (IS_ERR(wcd->if_regmap))
5214 return dev_err_probe(dev, PTR_ERR(wcd->if_regmap),
5217 ret = wcd9335_bring_up(wcd);
5223 ret = wcd9335_irq_init(wcd);
5227 wcd9335_probe(wcd);