Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 //
0003 // rt711-sdw-sdca.c -- rt711 SDCA ALSA SoC audio driver
0004 //
0005 // Copyright(c) 2021 Realtek Semiconductor Corp.
0006 //
0007 //
0008 
0009 #include <linux/delay.h>
0010 #include <linux/device.h>
0011 #include <linux/mod_devicetable.h>
0012 #include <linux/soundwire/sdw_registers.h>
0013 #include <linux/module.h>
0014 #include <linux/pm_runtime.h>
0015 
0016 #include "rt711-sdca.h"
0017 #include "rt711-sdca-sdw.h"
0018 
0019 static bool rt711_sdca_readable_register(struct device *dev, unsigned int reg)
0020 {
0021     switch (reg) {
0022     case 0x201a ... 0x2027:
0023     case 0x2029 ... 0x202a:
0024     case 0x202d ... 0x2034:
0025     case 0x2200 ... 0x2204:
0026     case 0x2206 ... 0x2212:
0027     case 0x2220 ... 0x2223:
0028     case 0x2230 ... 0x2239:
0029     case 0x2f01 ... 0x2f0f:
0030     case 0x2f30 ... 0x2f36:
0031     case 0x2f50 ... 0x2f5a:
0032     case 0x2f60:
0033     case 0x3200 ... 0x3212:
0034     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_SELECTED_MODE, 0):
0035     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0):
0036     case SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_CURRENT_OWNER, 0) ...
0037         SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0):
0038     case RT711_BUF_ADDR_HID1 ... RT711_BUF_ADDR_HID2:
0039         return true;
0040     default:
0041         return false;
0042     }
0043 }
0044 
0045 static bool rt711_sdca_volatile_register(struct device *dev, unsigned int reg)
0046 {
0047     switch (reg) {
0048     case 0x201b:
0049     case 0x201c:
0050     case 0x201d:
0051     case 0x201f:
0052     case 0x2021:
0053     case 0x2023:
0054     case 0x2230:
0055     case 0x202d ... 0x202f: /* BRA */
0056     case 0x2200 ... 0x2212: /* i2c debug */
0057     case RT711_RC_CAL_STATUS:
0058     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0):
0059     case SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_CURRENT_OWNER, 0) ...
0060         SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_LENGTH, 0):
0061     case RT711_BUF_ADDR_HID1 ... RT711_BUF_ADDR_HID2:
0062         return true;
0063     default:
0064         return false;
0065     }
0066 }
0067 
0068 static bool rt711_sdca_mbq_readable_register(struct device *dev, unsigned int reg)
0069 {
0070     switch (reg) {
0071     case 0x2000000 ... 0x20000ff:
0072     case 0x5600000 ... 0x56000ff:
0073     case 0x5700000 ... 0x57000ff:
0074     case 0x5800000 ... 0x58000ff:
0075     case 0x5900000 ... 0x59000ff:
0076     case 0x5b00000 ... 0x5b000ff:
0077     case 0x5f00000 ... 0x5f000ff:
0078     case 0x6100000 ... 0x61000ff:
0079     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_L):
0080     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_R):
0081     case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_L):
0082     case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_R):
0083     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_L):
0084     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_R):
0085     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_L):
0086     case SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_R):
0087     case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_L):
0088     case SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_R):
0089         return true;
0090     default:
0091         return false;
0092     }
0093 }
0094 
0095 static bool rt711_sdca_mbq_volatile_register(struct device *dev, unsigned int reg)
0096 {
0097     switch (reg) {
0098     case 0x2000000:
0099     case 0x200001a:
0100     case 0x2000046:
0101     case 0x2000080:
0102     case 0x2000081:
0103     case 0x2000083:
0104     case 0x5800000:
0105     case 0x5800001:
0106     case 0x5f00001:
0107     case 0x6100008:
0108         return true;
0109     default:
0110         return false;
0111     }
0112 }
0113 
0114 static const struct regmap_config rt711_sdca_regmap = {
0115     .reg_bits = 32,
0116     .val_bits = 8,
0117     .readable_reg = rt711_sdca_readable_register,
0118     .volatile_reg = rt711_sdca_volatile_register,
0119     .max_register = 0x44ffffff,
0120     .reg_defaults = rt711_sdca_reg_defaults,
0121     .num_reg_defaults = ARRAY_SIZE(rt711_sdca_reg_defaults),
0122     .cache_type = REGCACHE_RBTREE,
0123     .use_single_read = true,
0124     .use_single_write = true,
0125 };
0126 
0127 static const struct regmap_config rt711_sdca_mbq_regmap = {
0128     .name = "sdw-mbq",
0129     .reg_bits = 32,
0130     .val_bits = 16,
0131     .readable_reg = rt711_sdca_mbq_readable_register,
0132     .volatile_reg = rt711_sdca_mbq_volatile_register,
0133     .max_register = 0x40800f12,
0134     .reg_defaults = rt711_sdca_mbq_defaults,
0135     .num_reg_defaults = ARRAY_SIZE(rt711_sdca_mbq_defaults),
0136     .cache_type = REGCACHE_RBTREE,
0137     .use_single_read = true,
0138     .use_single_write = true,
0139 };
0140 
0141 static int rt711_sdca_update_status(struct sdw_slave *slave,
0142                 enum sdw_slave_status status)
0143 {
0144     struct rt711_sdca_priv *rt711 = dev_get_drvdata(&slave->dev);
0145 
0146     /* Update the status */
0147     rt711->status = status;
0148 
0149     if (status == SDW_SLAVE_UNATTACHED)
0150         rt711->hw_init = false;
0151 
0152     if (status == SDW_SLAVE_ATTACHED) {
0153         if (rt711->hs_jack) {
0154             /*
0155              * Due to the SCP_SDCA_INTMASK will be cleared by any reset, and then
0156              * if the device attached again, we will need to set the setting back.
0157              * It could avoid losing the jack detection interrupt.
0158              * This also could sync with the cache value as the rt711_sdca_jack_init set.
0159              */
0160             sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK1,
0161                 SDW_SCP_SDCA_INTMASK_SDCA_0);
0162             sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK2,
0163                 SDW_SCP_SDCA_INTMASK_SDCA_8);
0164         }
0165     }
0166 
0167     /*
0168      * Perform initialization only if slave status is present and
0169      * hw_init flag is false
0170      */
0171     if (rt711->hw_init || rt711->status != SDW_SLAVE_ATTACHED)
0172         return 0;
0173 
0174     /* perform I/O transfers required for Slave initialization */
0175     return rt711_sdca_io_init(&slave->dev, slave);
0176 }
0177 
0178 static int rt711_sdca_read_prop(struct sdw_slave *slave)
0179 {
0180     struct sdw_slave_prop *prop = &slave->prop;
0181     int nval;
0182     int i, j;
0183     u32 bit;
0184     unsigned long addr;
0185     struct sdw_dpn_prop *dpn;
0186 
0187     prop->scp_int1_mask = SDW_SCP_INT1_BUS_CLASH | SDW_SCP_INT1_PARITY;
0188     prop->quirks = SDW_SLAVE_QUIRKS_INVALID_INITIAL_PARITY;
0189     prop->is_sdca = true;
0190 
0191     prop->paging_support = true;
0192 
0193     /* first we need to allocate memory for set bits in port lists */
0194     prop->source_ports = 0x14; /* BITMAP: 00010100 */
0195     prop->sink_ports = 0x8; /* BITMAP:  00001000 */
0196 
0197     nval = hweight32(prop->source_ports);
0198     prop->src_dpn_prop = devm_kcalloc(&slave->dev, nval,
0199         sizeof(*prop->src_dpn_prop), GFP_KERNEL);
0200     if (!prop->src_dpn_prop)
0201         return -ENOMEM;
0202 
0203     i = 0;
0204     dpn = prop->src_dpn_prop;
0205     addr = prop->source_ports;
0206     for_each_set_bit(bit, &addr, 32) {
0207         dpn[i].num = bit;
0208         dpn[i].type = SDW_DPN_FULL;
0209         dpn[i].simple_ch_prep_sm = true;
0210         dpn[i].ch_prep_timeout = 10;
0211         i++;
0212     }
0213 
0214     /* do this again for sink now */
0215     nval = hweight32(prop->sink_ports);
0216     prop->sink_dpn_prop = devm_kcalloc(&slave->dev, nval,
0217         sizeof(*prop->sink_dpn_prop), GFP_KERNEL);
0218     if (!prop->sink_dpn_prop)
0219         return -ENOMEM;
0220 
0221     j = 0;
0222     dpn = prop->sink_dpn_prop;
0223     addr = prop->sink_ports;
0224     for_each_set_bit(bit, &addr, 32) {
0225         dpn[j].num = bit;
0226         dpn[j].type = SDW_DPN_FULL;
0227         dpn[j].simple_ch_prep_sm = true;
0228         dpn[j].ch_prep_timeout = 10;
0229         j++;
0230     }
0231 
0232     /* set the timeout values */
0233     prop->clk_stop_timeout = 20;
0234 
0235     /* wake-up event */
0236     prop->wake_capable = 1;
0237 
0238     return 0;
0239 }
0240 
0241 static int rt711_sdca_interrupt_callback(struct sdw_slave *slave,
0242                     struct sdw_slave_intr_status *status)
0243 {
0244     struct rt711_sdca_priv *rt711 = dev_get_drvdata(&slave->dev);
0245     int ret, stat;
0246     int count = 0, retry = 3;
0247     unsigned int sdca_cascade, scp_sdca_stat1, scp_sdca_stat2 = 0;
0248 
0249     dev_dbg(&slave->dev,
0250         "%s control_port_stat=%x, sdca_cascade=%x", __func__,
0251         status->control_port, status->sdca_cascade);
0252 
0253     if (cancel_delayed_work_sync(&rt711->jack_detect_work)) {
0254         dev_warn(&slave->dev, "%s the pending delayed_work was cancelled", __func__);
0255         /* avoid the HID owner doesn't change to device */
0256         if (rt711->scp_sdca_stat2)
0257             scp_sdca_stat2 = rt711->scp_sdca_stat2;
0258     }
0259 
0260     /*
0261      * The critical section below intentionally protects a rather large piece of code.
0262      * We don't want to allow the system suspend to disable an interrupt while we are
0263      * processing it, which could be problematic given the quirky SoundWire interrupt
0264      * scheme. We do want however to prevent new workqueues from being scheduled if
0265      * the disable_irq flag was set during system suspend.
0266      */
0267     mutex_lock(&rt711->disable_irq_lock);
0268 
0269     ret = sdw_read_no_pm(rt711->slave, SDW_SCP_SDCA_INT1);
0270     if (ret < 0)
0271         goto io_error;
0272     rt711->scp_sdca_stat1 = ret;
0273     ret = sdw_read_no_pm(rt711->slave, SDW_SCP_SDCA_INT2);
0274     if (ret < 0)
0275         goto io_error;
0276     rt711->scp_sdca_stat2 = ret;
0277     if (scp_sdca_stat2)
0278         rt711->scp_sdca_stat2 |= scp_sdca_stat2;
0279 
0280     do {
0281         /* clear flag */
0282         ret = sdw_read_no_pm(rt711->slave, SDW_SCP_SDCA_INT1);
0283         if (ret < 0)
0284             goto io_error;
0285         if (ret & SDW_SCP_SDCA_INTMASK_SDCA_0) {
0286             ret = sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INT1,
0287                         SDW_SCP_SDCA_INTMASK_SDCA_0);
0288             if (ret < 0)
0289                 goto io_error;
0290         }
0291         ret = sdw_read_no_pm(rt711->slave, SDW_SCP_SDCA_INT2);
0292         if (ret < 0)
0293             goto io_error;
0294         if (ret & SDW_SCP_SDCA_INTMASK_SDCA_8) {
0295             ret = sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INT2,
0296                         SDW_SCP_SDCA_INTMASK_SDCA_8);
0297             if (ret < 0)
0298                 goto io_error;
0299         }
0300 
0301         /* check if flag clear or not */
0302         ret = sdw_read_no_pm(rt711->slave, SDW_DP0_INT);
0303         if (ret < 0)
0304             goto io_error;
0305         sdca_cascade = ret & SDW_DP0_SDCA_CASCADE;
0306 
0307         ret = sdw_read_no_pm(rt711->slave, SDW_SCP_SDCA_INT1);
0308         if (ret < 0)
0309             goto io_error;
0310         scp_sdca_stat1 = ret & SDW_SCP_SDCA_INTMASK_SDCA_0;
0311 
0312         ret = sdw_read_no_pm(rt711->slave, SDW_SCP_SDCA_INT2);
0313         if (ret < 0)
0314             goto io_error;
0315         scp_sdca_stat2 = ret & SDW_SCP_SDCA_INTMASK_SDCA_8;
0316 
0317         stat = scp_sdca_stat1 || scp_sdca_stat2 || sdca_cascade;
0318 
0319         count++;
0320     } while (stat != 0 && count < retry);
0321 
0322     if (stat)
0323         dev_warn(&slave->dev,
0324             "%s scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
0325             rt711->scp_sdca_stat1, rt711->scp_sdca_stat2);
0326 
0327     if (status->sdca_cascade && !rt711->disable_irq)
0328         mod_delayed_work(system_power_efficient_wq,
0329             &rt711->jack_detect_work, msecs_to_jiffies(30));
0330 
0331     mutex_unlock(&rt711->disable_irq_lock);
0332 
0333     return 0;
0334 
0335 io_error:
0336     mutex_unlock(&rt711->disable_irq_lock);
0337     pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
0338     return ret;
0339 }
0340 
0341 static struct sdw_slave_ops rt711_sdca_slave_ops = {
0342     .read_prop = rt711_sdca_read_prop,
0343     .interrupt_callback = rt711_sdca_interrupt_callback,
0344     .update_status = rt711_sdca_update_status,
0345 };
0346 
0347 static int rt711_sdca_sdw_probe(struct sdw_slave *slave,
0348                 const struct sdw_device_id *id)
0349 {
0350     struct regmap *regmap, *mbq_regmap;
0351 
0352     /* Regmap Initialization */
0353     mbq_regmap = devm_regmap_init_sdw_mbq(slave, &rt711_sdca_mbq_regmap);
0354     if (IS_ERR(mbq_regmap))
0355         return PTR_ERR(mbq_regmap);
0356 
0357     regmap = devm_regmap_init_sdw(slave, &rt711_sdca_regmap);
0358     if (IS_ERR(regmap))
0359         return PTR_ERR(regmap);
0360 
0361     return rt711_sdca_init(&slave->dev, regmap, mbq_regmap, slave);
0362 }
0363 
0364 static int rt711_sdca_sdw_remove(struct sdw_slave *slave)
0365 {
0366     struct rt711_sdca_priv *rt711 = dev_get_drvdata(&slave->dev);
0367 
0368     if (rt711->hw_init) {
0369         cancel_delayed_work_sync(&rt711->jack_detect_work);
0370         cancel_delayed_work_sync(&rt711->jack_btn_check_work);
0371     }
0372 
0373     if (rt711->first_hw_init)
0374         pm_runtime_disable(&slave->dev);
0375 
0376     mutex_destroy(&rt711->calibrate_mutex);
0377     mutex_destroy(&rt711->disable_irq_lock);
0378 
0379     return 0;
0380 }
0381 
0382 static const struct sdw_device_id rt711_sdca_id[] = {
0383     SDW_SLAVE_ENTRY_EXT(0x025d, 0x711, 0x3, 0x1, 0),
0384     {},
0385 };
0386 MODULE_DEVICE_TABLE(sdw, rt711_sdca_id);
0387 
0388 static int __maybe_unused rt711_sdca_dev_suspend(struct device *dev)
0389 {
0390     struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev);
0391 
0392     if (!rt711->hw_init)
0393         return 0;
0394 
0395     cancel_delayed_work_sync(&rt711->jack_detect_work);
0396     cancel_delayed_work_sync(&rt711->jack_btn_check_work);
0397 
0398     regcache_cache_only(rt711->regmap, true);
0399     regcache_cache_only(rt711->mbq_regmap, true);
0400 
0401     return 0;
0402 }
0403 
0404 static int __maybe_unused rt711_sdca_dev_system_suspend(struct device *dev)
0405 {
0406     struct rt711_sdca_priv *rt711_sdca = dev_get_drvdata(dev);
0407     struct sdw_slave *slave = dev_to_sdw_dev(dev);
0408     int ret1, ret2;
0409 
0410     if (!rt711_sdca->hw_init)
0411         return 0;
0412 
0413     /*
0414      * prevent new interrupts from being handled after the
0415      * deferred work completes and before the parent disables
0416      * interrupts on the link
0417      */
0418     mutex_lock(&rt711_sdca->disable_irq_lock);
0419     rt711_sdca->disable_irq = true;
0420     ret1 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK1,
0421                 SDW_SCP_SDCA_INTMASK_SDCA_0, 0);
0422     ret2 = sdw_update_no_pm(slave, SDW_SCP_SDCA_INTMASK2,
0423                 SDW_SCP_SDCA_INTMASK_SDCA_8, 0);
0424     mutex_unlock(&rt711_sdca->disable_irq_lock);
0425 
0426     if (ret1 < 0 || ret2 < 0) {
0427         /* log but don't prevent suspend from happening */
0428         dev_dbg(&slave->dev, "%s: could not disable SDCA interrupts\n:", __func__);
0429     }
0430 
0431     return rt711_sdca_dev_suspend(dev);
0432 }
0433 
0434 #define RT711_PROBE_TIMEOUT 5000
0435 
0436 static int __maybe_unused rt711_sdca_dev_resume(struct device *dev)
0437 {
0438     struct sdw_slave *slave = dev_to_sdw_dev(dev);
0439     struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev);
0440     unsigned long time;
0441 
0442     if (!rt711->first_hw_init)
0443         return 0;
0444 
0445     if (!slave->unattach_request)
0446         goto regmap_sync;
0447 
0448     time = wait_for_completion_timeout(&slave->initialization_complete,
0449                 msecs_to_jiffies(RT711_PROBE_TIMEOUT));
0450     if (!time) {
0451         dev_err(&slave->dev, "Initialization not complete, timed out\n");
0452         return -ETIMEDOUT;
0453     }
0454 
0455 regmap_sync:
0456     slave->unattach_request = 0;
0457     regcache_cache_only(rt711->regmap, false);
0458     regcache_sync(rt711->regmap);
0459     regcache_cache_only(rt711->mbq_regmap, false);
0460     regcache_sync(rt711->mbq_regmap);
0461     return 0;
0462 }
0463 
0464 static const struct dev_pm_ops rt711_sdca_pm = {
0465     SET_SYSTEM_SLEEP_PM_OPS(rt711_sdca_dev_system_suspend, rt711_sdca_dev_resume)
0466     SET_RUNTIME_PM_OPS(rt711_sdca_dev_suspend, rt711_sdca_dev_resume, NULL)
0467 };
0468 
0469 static struct sdw_driver rt711_sdca_sdw_driver = {
0470     .driver = {
0471         .name = "rt711-sdca",
0472         .owner = THIS_MODULE,
0473         .pm = &rt711_sdca_pm,
0474     },
0475     .probe = rt711_sdca_sdw_probe,
0476     .remove = rt711_sdca_sdw_remove,
0477     .ops = &rt711_sdca_slave_ops,
0478     .id_table = rt711_sdca_id,
0479 };
0480 module_sdw_driver(rt711_sdca_sdw_driver);
0481 
0482 MODULE_DESCRIPTION("ASoC RT711 SDCA SDW driver");
0483 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
0484 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!