Lines Matching +full:slave +full:- +full:if
1 // SPDX-License-Identifier: GPL-2.0-only
3 // rt712-sdca-sdw.c -- rt712 SDCA ALSA SoC audio driver
15 #include "rt712-sdca.h"
16 #include "rt712-sdca-sdw.h"
143 .name = "sdw-mbq",
156 static int rt712_sdca_update_status(struct sdw_slave *slave,
159 struct rt712_sdca_priv *rt712 = dev_get_drvdata(&slave->dev);
161 if (status == SDW_SLAVE_UNATTACHED)
162 rt712->hw_init = false;
164 if (status == SDW_SLAVE_ATTACHED) {
165 if (rt712->hs_jack) {
168 * if the device attached again, we will need to set the setting back.
172 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK1,
174 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK2,
180 * Perform initialization only if slave status is present and
183 if (rt712->hw_init || status != SDW_SLAVE_ATTACHED)
186 /* perform I/O transfers required for Slave initialization */
187 return rt712_sdca_io_init(&slave->dev, slave);
190 static int rt712_sdca_read_prop(struct sdw_slave *slave)
192 struct sdw_slave_prop *prop = &slave->prop;
199 sdw_slave_read_prop(slave);
201 prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY;
202 prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY;
204 prop->paging_support = true;
207 prop->source_ports = BIT(8) | BIT(4); /* BITMAP: 100010000 */
208 prop->sink_ports = BIT(3) | BIT(1); /* BITMAP: 00001010 */
210 nval = hweight32(prop->source_ports);
211 prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
212 sizeof(*prop->src_dpn_prop), GFP_KERNEL);
213 if (!prop->src_dpn_prop)
214 return -ENOMEM;
217 dpn = prop->src_dpn_prop;
218 addr = prop->source_ports;
228 nval = hweight32(prop->sink_ports);
229 prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
230 sizeof(*prop->sink_dpn_prop), GFP_KERNEL);
231 if (!prop->sink_dpn_prop)
232 return -ENOMEM;
235 dpn = prop->sink_dpn_prop;
236 addr = prop->sink_ports;
246 prop->clk_stop_timeout = 1380;
248 /* wake-up event */
249 prop->wake_capable = 1;
254 static int rt712_sdca_interrupt_callback(struct sdw_slave *slave,
257 struct rt712_sdca_priv *rt712 = dev_get_drvdata(&slave->dev);
262 dev_dbg(&slave->dev,
264 status->control_port, status->sdca_cascade);
266 if (cancel_delayed_work_sync(&rt712->jack_detect_work)) {
267 dev_warn(&slave->dev, "%s the pending delayed_work was cancelled", __func__);
269 if (rt712->scp_sdca_stat2)
270 scp_sdca_stat2 = rt712->scp_sdca_stat2;
277 * scheme. We do want however to prevent new workqueues from being scheduled if
280 mutex_lock(&rt712->disable_irq_lock);
282 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT1);
283 if (ret < 0)
285 rt712->scp_sdca_stat1 = ret;
286 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT2);
287 if (ret < 0)
289 rt712->scp_sdca_stat2 = ret;
290 if (scp_sdca_stat2)
291 rt712->scp_sdca_stat2 |= scp_sdca_stat2;
295 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT1);
296 if (ret < 0)
298 if (ret & SDW_SCP_SDCA_INTMASK_SDCA_0) {
299 ret = sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INT1,
301 if (ret < 0)
304 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT2);
305 if (ret < 0)
307 if (ret & SDW_SCP_SDCA_INTMASK_SDCA_8) {
308 ret = sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INT2,
310 if (ret < 0)
314 /* check if flag clear or not */
315 ret = sdw_read_no_pm(rt712->slave, SDW_DP0_INT);
316 if (ret < 0)
320 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT1);
321 if (ret < 0)
325 ret = sdw_read_no_pm(rt712->slave, SDW_SCP_SDCA_INT2);
326 if (ret < 0)
335 if (stat)
336 dev_warn(&slave->dev,
338 rt712->scp_sdca_stat1, rt712->scp_sdca_stat2);
340 if (status->sdca_cascade && !rt712->disable_irq)
342 &rt712->jack_detect_work, msecs_to_jiffies(30));
344 mutex_unlock(&rt712->disable_irq_lock);
349 mutex_unlock(&rt712->disable_irq_lock);
360 static int rt712_sdca_sdw_probe(struct sdw_slave *slave,
366 mbq_regmap = devm_regmap_init_sdw_mbq(slave, &rt712_sdca_mbq_regmap);
367 if (IS_ERR(mbq_regmap))
370 regmap = devm_regmap_init_sdw(slave, &rt712_sdca_regmap);
371 if (IS_ERR(regmap))
374 return rt712_sdca_init(&slave->dev, regmap, mbq_regmap, slave);
377 static int rt712_sdca_sdw_remove(struct sdw_slave *slave)
379 struct rt712_sdca_priv *rt712 = dev_get_drvdata(&slave->dev);
381 if (rt712->hw_init) {
382 cancel_delayed_work_sync(&rt712->jack_detect_work);
383 cancel_delayed_work_sync(&rt712->jack_btn_check_work);
386 pm_runtime_disable(&slave->dev);
388 mutex_destroy(&rt712->calibrate_mutex);
389 mutex_destroy(&rt712->disable_irq_lock);
407 if (!rt712->hw_init)
410 cancel_delayed_work_sync(&rt712->jack_detect_work);
411 cancel_delayed_work_sync(&rt712->jack_btn_check_work);
413 regcache_cache_only(rt712->regmap, true);
414 regcache_cache_only(rt712->mbq_regmap, true);
422 struct sdw_slave *slave = dev_to_sdw_dev(dev);
425 if (!rt712_sdca->hw_init)
433 mutex_lock(&rt712_sdca->disable_irq_lock);
434 rt712_sdca->disable_irq = true;
435 ret1 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK1,
437 ret2 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK2,
439 mutex_unlock(&rt712_sdca->disable_irq_lock);
441 if (ret1 < 0 || ret2 < 0) {
443 dev_dbg(&slave->dev, "%s: could not disable SDCA interrupts\n:", __func__);
453 struct sdw_slave *slave = dev_to_sdw_dev(dev);
457 if (!rt712->first_hw_init)
460 if (!slave->unattach_request) {
461 mutex_lock(&rt712->disable_irq_lock);
462 if (rt712->disable_irq == true) {
464 sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0);
465 sdw_write_no_pm(slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8);
466 rt712->disable_irq = false;
468 mutex_unlock(&rt712->disable_irq_lock);
472 time = wait_for_completion_timeout(&slave->initialization_complete,
474 if (!time) {
475 dev_err(&slave->dev, "%s: Initialization not complete, timed out\n", __func__);
476 sdw_show_ping_status(slave->bus, true);
478 return -ETIMEDOUT;
482 slave->unattach_request = 0;
483 regcache_cache_only(rt712->regmap, false);
484 regcache_sync(rt712->regmap);
485 regcache_cache_only(rt712->mbq_regmap, false);
486 regcache_sync(rt712->mbq_regmap);
497 .name = "rt712-sdca",