Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Regmap support for HD-audio verbs
0004  *
0005  * A virtual register is translated to one or more hda verbs for write,
0006  * vice versa for read.
0007  *
0008  * A few limitations:
0009  * - Provided for not all verbs but only subset standard non-volatile verbs.
0010  * - For reading, only AC_VERB_GET_* variants can be used.
0011  * - For writing, mapped to the *corresponding* AC_VERB_SET_* variants,
0012  *   so can't handle asymmetric verbs for read and write
0013  */
0014 
0015 #include <linux/slab.h>
0016 #include <linux/device.h>
0017 #include <linux/regmap.h>
0018 #include <linux/export.h>
0019 #include <linux/pm.h>
0020 #include <linux/pm_runtime.h>
0021 #include <sound/core.h>
0022 #include <sound/hdaudio.h>
0023 #include <sound/hda_regmap.h>
0024 #include "local.h"
0025 
0026 static int codec_pm_lock(struct hdac_device *codec)
0027 {
0028     return snd_hdac_keep_power_up(codec);
0029 }
0030 
0031 static void codec_pm_unlock(struct hdac_device *codec, int lock)
0032 {
0033     if (lock == 1)
0034         snd_hdac_power_down_pm(codec);
0035 }
0036 
0037 #define get_verb(reg)   (((reg) >> 8) & 0xfff)
0038 
0039 static bool hda_volatile_reg(struct device *dev, unsigned int reg)
0040 {
0041     struct hdac_device *codec = dev_to_hdac_dev(dev);
0042     unsigned int verb = get_verb(reg);
0043 
0044     switch (verb) {
0045     case AC_VERB_GET_PROC_COEF:
0046         return !codec->cache_coef;
0047     case AC_VERB_GET_COEF_INDEX:
0048     case AC_VERB_GET_PROC_STATE:
0049     case AC_VERB_GET_POWER_STATE:
0050     case AC_VERB_GET_PIN_SENSE:
0051     case AC_VERB_GET_HDMI_DIP_SIZE:
0052     case AC_VERB_GET_HDMI_ELDD:
0053     case AC_VERB_GET_HDMI_DIP_INDEX:
0054     case AC_VERB_GET_HDMI_DIP_DATA:
0055     case AC_VERB_GET_HDMI_DIP_XMIT:
0056     case AC_VERB_GET_HDMI_CP_CTRL:
0057     case AC_VERB_GET_HDMI_CHAN_SLOT:
0058     case AC_VERB_GET_DEVICE_SEL:
0059     case AC_VERB_GET_DEVICE_LIST:   /* read-only volatile */
0060         return true;
0061     }
0062 
0063     return false;
0064 }
0065 
0066 static bool hda_writeable_reg(struct device *dev, unsigned int reg)
0067 {
0068     struct hdac_device *codec = dev_to_hdac_dev(dev);
0069     unsigned int verb = get_verb(reg);
0070     const unsigned int *v;
0071     int i;
0072 
0073     snd_array_for_each(&codec->vendor_verbs, i, v) {
0074         if (verb == *v)
0075             return true;
0076     }
0077 
0078     if (codec->caps_overwriting)
0079         return true;
0080 
0081     switch (verb & 0xf00) {
0082     case AC_VERB_GET_STREAM_FORMAT:
0083     case AC_VERB_GET_AMP_GAIN_MUTE:
0084         return true;
0085     case AC_VERB_GET_PROC_COEF:
0086         return codec->cache_coef;
0087     case 0xf00:
0088         break;
0089     default:
0090         return false;
0091     }
0092 
0093     switch (verb) {
0094     case AC_VERB_GET_CONNECT_SEL:
0095     case AC_VERB_GET_SDI_SELECT:
0096     case AC_VERB_GET_PIN_WIDGET_CONTROL:
0097     case AC_VERB_GET_UNSOLICITED_RESPONSE: /* only as SET_UNSOLICITED_ENABLE */
0098     case AC_VERB_GET_BEEP_CONTROL:
0099     case AC_VERB_GET_EAPD_BTLENABLE:
0100     case AC_VERB_GET_DIGI_CONVERT_1:
0101     case AC_VERB_GET_DIGI_CONVERT_2: /* only for beep control */
0102     case AC_VERB_GET_VOLUME_KNOB_CONTROL:
0103     case AC_VERB_GET_GPIO_MASK:
0104     case AC_VERB_GET_GPIO_DIRECTION:
0105     case AC_VERB_GET_GPIO_DATA: /* not for volatile read */
0106     case AC_VERB_GET_GPIO_WAKE_MASK:
0107     case AC_VERB_GET_GPIO_UNSOLICITED_RSP_MASK:
0108     case AC_VERB_GET_GPIO_STICKY_MASK:
0109         return true;
0110     }
0111 
0112     return false;
0113 }
0114 
0115 static bool hda_readable_reg(struct device *dev, unsigned int reg)
0116 {
0117     struct hdac_device *codec = dev_to_hdac_dev(dev);
0118     unsigned int verb = get_verb(reg);
0119 
0120     if (codec->caps_overwriting)
0121         return true;
0122 
0123     switch (verb) {
0124     case AC_VERB_PARAMETERS:
0125     case AC_VERB_GET_CONNECT_LIST:
0126     case AC_VERB_GET_SUBSYSTEM_ID:
0127         return true;
0128     /* below are basically writable, but disabled for reducing unnecessary
0129      * writes at sync
0130      */
0131     case AC_VERB_GET_CONFIG_DEFAULT: /* usually just read */
0132     case AC_VERB_GET_CONV: /* managed in PCM code */
0133     case AC_VERB_GET_CVT_CHAN_COUNT: /* managed in HDMI CA code */
0134         return true;
0135     }
0136 
0137     return hda_writeable_reg(dev, reg);
0138 }
0139 
0140 /*
0141  * Stereo amp pseudo register:
0142  * for making easier to handle the stereo volume control, we provide a
0143  * fake register to deal both left and right channels by a single
0144  * (pseudo) register access.  A verb consisting of SET_AMP_GAIN with
0145  * *both* SET_LEFT and SET_RIGHT bits takes a 16bit value, the lower 8bit
0146  * for the left and the upper 8bit for the right channel.
0147  */
0148 static bool is_stereo_amp_verb(unsigned int reg)
0149 {
0150     if (((reg >> 8) & 0x700) != AC_VERB_SET_AMP_GAIN_MUTE)
0151         return false;
0152     return (reg & (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT)) ==
0153         (AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT);
0154 }
0155 
0156 /* read a pseudo stereo amp register (16bit left+right) */
0157 static int hda_reg_read_stereo_amp(struct hdac_device *codec,
0158                    unsigned int reg, unsigned int *val)
0159 {
0160     unsigned int left, right;
0161     int err;
0162 
0163     reg &= ~(AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT);
0164     err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_LEFT, 0, &left);
0165     if (err < 0)
0166         return err;
0167     err = snd_hdac_exec_verb(codec, reg | AC_AMP_GET_RIGHT, 0, &right);
0168     if (err < 0)
0169         return err;
0170     *val = left | (right << 8);
0171     return 0;
0172 }
0173 
0174 /* write a pseudo stereo amp register (16bit left+right) */
0175 static int hda_reg_write_stereo_amp(struct hdac_device *codec,
0176                     unsigned int reg, unsigned int val)
0177 {
0178     int err;
0179     unsigned int verb, left, right;
0180 
0181     verb = AC_VERB_SET_AMP_GAIN_MUTE << 8;
0182     if (reg & AC_AMP_GET_OUTPUT)
0183         verb |= AC_AMP_SET_OUTPUT;
0184     else
0185         verb |= AC_AMP_SET_INPUT | ((reg & 0xf) << 8);
0186     reg = (reg & ~0xfffff) | verb;
0187 
0188     left = val & 0xff;
0189     right = (val >> 8) & 0xff;
0190     if (left == right) {
0191         reg |= AC_AMP_SET_LEFT | AC_AMP_SET_RIGHT;
0192         return snd_hdac_exec_verb(codec, reg | left, 0, NULL);
0193     }
0194 
0195     err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_LEFT | left, 0, NULL);
0196     if (err < 0)
0197         return err;
0198     err = snd_hdac_exec_verb(codec, reg | AC_AMP_SET_RIGHT | right, 0, NULL);
0199     if (err < 0)
0200         return err;
0201     return 0;
0202 }
0203 
0204 /* read a pseudo coef register (16bit) */
0205 static int hda_reg_read_coef(struct hdac_device *codec, unsigned int reg,
0206                  unsigned int *val)
0207 {
0208     unsigned int verb;
0209     int err;
0210 
0211     if (!codec->cache_coef)
0212         return -EINVAL;
0213     /* LSB 8bit = coef index */
0214     verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8);
0215     err = snd_hdac_exec_verb(codec, verb, 0, NULL);
0216     if (err < 0)
0217         return err;
0218     verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8);
0219     return snd_hdac_exec_verb(codec, verb, 0, val);
0220 }
0221 
0222 /* write a pseudo coef register (16bit) */
0223 static int hda_reg_write_coef(struct hdac_device *codec, unsigned int reg,
0224                   unsigned int val)
0225 {
0226     unsigned int verb;
0227     int err;
0228 
0229     if (!codec->cache_coef)
0230         return -EINVAL;
0231     /* LSB 8bit = coef index */
0232     verb = (reg & ~0xfff00) | (AC_VERB_SET_COEF_INDEX << 8);
0233     err = snd_hdac_exec_verb(codec, verb, 0, NULL);
0234     if (err < 0)
0235         return err;
0236     verb = (reg & ~0xfffff) | (AC_VERB_GET_COEF_INDEX << 8) |
0237         (val & 0xffff);
0238     return snd_hdac_exec_verb(codec, verb, 0, NULL);
0239 }
0240 
0241 static int hda_reg_read(void *context, unsigned int reg, unsigned int *val)
0242 {
0243     struct hdac_device *codec = context;
0244     int verb = get_verb(reg);
0245     int err;
0246     int pm_lock = 0;
0247 
0248     if (verb != AC_VERB_GET_POWER_STATE) {
0249         pm_lock = codec_pm_lock(codec);
0250         if (pm_lock < 0)
0251             return -EAGAIN;
0252     }
0253     reg |= (codec->addr << 28);
0254     if (is_stereo_amp_verb(reg)) {
0255         err = hda_reg_read_stereo_amp(codec, reg, val);
0256         goto out;
0257     }
0258     if (verb == AC_VERB_GET_PROC_COEF) {
0259         err = hda_reg_read_coef(codec, reg, val);
0260         goto out;
0261     }
0262     if ((verb & 0x700) == AC_VERB_SET_AMP_GAIN_MUTE)
0263         reg &= ~AC_AMP_FAKE_MUTE;
0264 
0265     err = snd_hdac_exec_verb(codec, reg, 0, val);
0266     if (err < 0)
0267         goto out;
0268     /* special handling for asymmetric reads */
0269     if (verb == AC_VERB_GET_POWER_STATE) {
0270         if (*val & AC_PWRST_ERROR)
0271             *val = -1;
0272         else /* take only the actual state */
0273             *val = (*val >> 4) & 0x0f;
0274     }
0275  out:
0276     codec_pm_unlock(codec, pm_lock);
0277     return err;
0278 }
0279 
0280 static int hda_reg_write(void *context, unsigned int reg, unsigned int val)
0281 {
0282     struct hdac_device *codec = context;
0283     unsigned int verb;
0284     int i, bytes, err;
0285     int pm_lock = 0;
0286 
0287     if (codec->caps_overwriting)
0288         return 0;
0289 
0290     reg &= ~0x00080000U; /* drop GET bit */
0291     reg |= (codec->addr << 28);
0292     verb = get_verb(reg);
0293 
0294     if (verb != AC_VERB_SET_POWER_STATE) {
0295         pm_lock = codec_pm_lock(codec);
0296         if (pm_lock < 0)
0297             return codec->lazy_cache ? 0 : -EAGAIN;
0298     }
0299 
0300     if (is_stereo_amp_verb(reg)) {
0301         err = hda_reg_write_stereo_amp(codec, reg, val);
0302         goto out;
0303     }
0304 
0305     if (verb == AC_VERB_SET_PROC_COEF) {
0306         err = hda_reg_write_coef(codec, reg, val);
0307         goto out;
0308     }
0309 
0310     switch (verb & 0xf00) {
0311     case AC_VERB_SET_AMP_GAIN_MUTE:
0312         if ((reg & AC_AMP_FAKE_MUTE) && (val & AC_AMP_MUTE))
0313             val = 0;
0314         verb = AC_VERB_SET_AMP_GAIN_MUTE;
0315         if (reg & AC_AMP_GET_LEFT)
0316             verb |= AC_AMP_SET_LEFT >> 8;
0317         else
0318             verb |= AC_AMP_SET_RIGHT >> 8;
0319         if (reg & AC_AMP_GET_OUTPUT) {
0320             verb |= AC_AMP_SET_OUTPUT >> 8;
0321         } else {
0322             verb |= AC_AMP_SET_INPUT >> 8;
0323             verb |= reg & 0xf;
0324         }
0325         break;
0326     }
0327 
0328     switch (verb) {
0329     case AC_VERB_SET_DIGI_CONVERT_1:
0330         bytes = 2;
0331         break;
0332     case AC_VERB_SET_CONFIG_DEFAULT_BYTES_0:
0333         bytes = 4;
0334         break;
0335     default:
0336         bytes = 1;
0337         break;
0338     }
0339 
0340     for (i = 0; i < bytes; i++) {
0341         reg &= ~0xfffff;
0342         reg |= (verb + i) << 8 | ((val >> (8 * i)) & 0xff);
0343         err = snd_hdac_exec_verb(codec, reg, 0, NULL);
0344         if (err < 0)
0345             goto out;
0346     }
0347 
0348  out:
0349     codec_pm_unlock(codec, pm_lock);
0350     return err;
0351 }
0352 
0353 static const struct regmap_config hda_regmap_cfg = {
0354     .name = "hdaudio",
0355     .reg_bits = 32,
0356     .val_bits = 32,
0357     .max_register = 0xfffffff,
0358     .writeable_reg = hda_writeable_reg,
0359     .readable_reg = hda_readable_reg,
0360     .volatile_reg = hda_volatile_reg,
0361     .cache_type = REGCACHE_RBTREE,
0362     .reg_read = hda_reg_read,
0363     .reg_write = hda_reg_write,
0364     .use_single_read = true,
0365     .use_single_write = true,
0366     .disable_locking = true,
0367 };
0368 
0369 /**
0370  * snd_hdac_regmap_init - Initialize regmap for HDA register accesses
0371  * @codec: the codec object
0372  *
0373  * Returns zero for success or a negative error code.
0374  */
0375 int snd_hdac_regmap_init(struct hdac_device *codec)
0376 {
0377     struct regmap *regmap;
0378 
0379     regmap = regmap_init(&codec->dev, NULL, codec, &hda_regmap_cfg);
0380     if (IS_ERR(regmap))
0381         return PTR_ERR(regmap);
0382     codec->regmap = regmap;
0383     snd_array_init(&codec->vendor_verbs, sizeof(unsigned int), 8);
0384     return 0;
0385 }
0386 EXPORT_SYMBOL_GPL(snd_hdac_regmap_init);
0387 
0388 /**
0389  * snd_hdac_regmap_exit - Release the regmap from HDA codec
0390  * @codec: the codec object
0391  */
0392 void snd_hdac_regmap_exit(struct hdac_device *codec)
0393 {
0394     if (codec->regmap) {
0395         regmap_exit(codec->regmap);
0396         codec->regmap = NULL;
0397         snd_array_free(&codec->vendor_verbs);
0398     }
0399 }
0400 EXPORT_SYMBOL_GPL(snd_hdac_regmap_exit);
0401 
0402 /**
0403  * snd_hdac_regmap_add_vendor_verb - add a vendor-specific verb to regmap
0404  * @codec: the codec object
0405  * @verb: verb to allow accessing via regmap
0406  *
0407  * Returns zero for success or a negative error code.
0408  */
0409 int snd_hdac_regmap_add_vendor_verb(struct hdac_device *codec,
0410                     unsigned int verb)
0411 {
0412     unsigned int *p = snd_array_new(&codec->vendor_verbs);
0413 
0414     if (!p)
0415         return -ENOMEM;
0416     *p = verb | 0x800; /* set GET bit */
0417     return 0;
0418 }
0419 EXPORT_SYMBOL_GPL(snd_hdac_regmap_add_vendor_verb);
0420 
0421 /*
0422  * helper functions
0423  */
0424 
0425 /* write a pseudo-register value (w/o power sequence) */
0426 static int reg_raw_write(struct hdac_device *codec, unsigned int reg,
0427              unsigned int val)
0428 {
0429     int err;
0430 
0431     mutex_lock(&codec->regmap_lock);
0432     if (!codec->regmap)
0433         err = hda_reg_write(codec, reg, val);
0434     else
0435         err = regmap_write(codec->regmap, reg, val);
0436     mutex_unlock(&codec->regmap_lock);
0437     return err;
0438 }
0439 
0440 /* a helper macro to call @func_call; retry with power-up if failed */
0441 #define CALL_RAW_FUNC(codec, func_call)             \
0442     ({                          \
0443         int _err = func_call;               \
0444         if (_err == -EAGAIN) {              \
0445             _err = snd_hdac_power_up_pm(codec); \
0446             if (_err >= 0)              \
0447                 _err = func_call;       \
0448             snd_hdac_power_down_pm(codec);      \
0449         }                       \
0450         _err;})
0451 
0452 /**
0453  * snd_hdac_regmap_write_raw - write a pseudo register with power mgmt
0454  * @codec: the codec object
0455  * @reg: pseudo register
0456  * @val: value to write
0457  *
0458  * Returns zero if successful or a negative error code.
0459  */
0460 int snd_hdac_regmap_write_raw(struct hdac_device *codec, unsigned int reg,
0461                   unsigned int val)
0462 {
0463     return CALL_RAW_FUNC(codec, reg_raw_write(codec, reg, val));
0464 }
0465 EXPORT_SYMBOL_GPL(snd_hdac_regmap_write_raw);
0466 
0467 static int reg_raw_read(struct hdac_device *codec, unsigned int reg,
0468             unsigned int *val, bool uncached)
0469 {
0470     int err;
0471 
0472     mutex_lock(&codec->regmap_lock);
0473     if (uncached || !codec->regmap)
0474         err = hda_reg_read(codec, reg, val);
0475     else
0476         err = regmap_read(codec->regmap, reg, val);
0477     mutex_unlock(&codec->regmap_lock);
0478     return err;
0479 }
0480 
0481 static int __snd_hdac_regmap_read_raw(struct hdac_device *codec,
0482                       unsigned int reg, unsigned int *val,
0483                       bool uncached)
0484 {
0485     return CALL_RAW_FUNC(codec, reg_raw_read(codec, reg, val, uncached));
0486 }
0487 
0488 /**
0489  * snd_hdac_regmap_read_raw - read a pseudo register with power mgmt
0490  * @codec: the codec object
0491  * @reg: pseudo register
0492  * @val: pointer to store the read value
0493  *
0494  * Returns zero if successful or a negative error code.
0495  */
0496 int snd_hdac_regmap_read_raw(struct hdac_device *codec, unsigned int reg,
0497                  unsigned int *val)
0498 {
0499     return __snd_hdac_regmap_read_raw(codec, reg, val, false);
0500 }
0501 EXPORT_SYMBOL_GPL(snd_hdac_regmap_read_raw);
0502 
0503 /* Works like snd_hdac_regmap_read_raw(), but this doesn't read from the
0504  * cache but always via hda verbs.
0505  */
0506 int snd_hdac_regmap_read_raw_uncached(struct hdac_device *codec,
0507                       unsigned int reg, unsigned int *val)
0508 {
0509     return __snd_hdac_regmap_read_raw(codec, reg, val, true);
0510 }
0511 
0512 static int reg_raw_update(struct hdac_device *codec, unsigned int reg,
0513               unsigned int mask, unsigned int val)
0514 {
0515     unsigned int orig;
0516     bool change;
0517     int err;
0518 
0519     mutex_lock(&codec->regmap_lock);
0520     if (codec->regmap) {
0521         err = regmap_update_bits_check(codec->regmap, reg, mask, val,
0522                            &change);
0523         if (!err)
0524             err = change ? 1 : 0;
0525     } else {
0526         err = hda_reg_read(codec, reg, &orig);
0527         if (!err) {
0528             val &= mask;
0529             val |= orig & ~mask;
0530             if (val != orig) {
0531                 err = hda_reg_write(codec, reg, val);
0532                 if (!err)
0533                     err = 1;
0534             }
0535         }
0536     }
0537     mutex_unlock(&codec->regmap_lock);
0538     return err;
0539 }
0540 
0541 /**
0542  * snd_hdac_regmap_update_raw - update a pseudo register with power mgmt
0543  * @codec: the codec object
0544  * @reg: pseudo register
0545  * @mask: bit mask to update
0546  * @val: value to update
0547  *
0548  * Returns zero if successful or a negative error code.
0549  */
0550 int snd_hdac_regmap_update_raw(struct hdac_device *codec, unsigned int reg,
0551                    unsigned int mask, unsigned int val)
0552 {
0553     return CALL_RAW_FUNC(codec, reg_raw_update(codec, reg, mask, val));
0554 }
0555 EXPORT_SYMBOL_GPL(snd_hdac_regmap_update_raw);
0556 
0557 static int reg_raw_update_once(struct hdac_device *codec, unsigned int reg,
0558                    unsigned int mask, unsigned int val)
0559 {
0560     unsigned int orig;
0561     int err;
0562 
0563     if (!codec->regmap)
0564         return reg_raw_update(codec, reg, mask, val);
0565 
0566     mutex_lock(&codec->regmap_lock);
0567     regcache_cache_only(codec->regmap, true);
0568     err = regmap_read(codec->regmap, reg, &orig);
0569     regcache_cache_only(codec->regmap, false);
0570     if (err < 0)
0571         err = regmap_update_bits(codec->regmap, reg, mask, val);
0572     mutex_unlock(&codec->regmap_lock);
0573     return err;
0574 }
0575 
0576 /**
0577  * snd_hdac_regmap_update_raw_once - initialize the register value only once
0578  * @codec: the codec object
0579  * @reg: pseudo register
0580  * @mask: bit mask to update
0581  * @val: value to update
0582  *
0583  * Performs the update of the register bits only once when the register
0584  * hasn't been initialized yet.  Used in HD-audio legacy driver.
0585  * Returns zero if successful or a negative error code
0586  */
0587 int snd_hdac_regmap_update_raw_once(struct hdac_device *codec, unsigned int reg,
0588                     unsigned int mask, unsigned int val)
0589 {
0590     return CALL_RAW_FUNC(codec, reg_raw_update_once(codec, reg, mask, val));
0591 }
0592 EXPORT_SYMBOL_GPL(snd_hdac_regmap_update_raw_once);
0593 
0594 /**
0595  * snd_hdac_regmap_sync - sync out the cached values for PM resume
0596  * @codec: the codec object
0597  */
0598 void snd_hdac_regmap_sync(struct hdac_device *codec)
0599 {
0600     if (codec->regmap) {
0601         mutex_lock(&codec->regmap_lock);
0602         regcache_sync(codec->regmap);
0603         mutex_unlock(&codec->regmap_lock);
0604     }
0605 }
0606 EXPORT_SYMBOL_GPL(snd_hdac_regmap_sync);
[ 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!