linux/drivers/regulator/arizona-micsupp.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0+
   2//
   3// arizona-micsupp.c  --  Microphone supply for Arizona devices
   4//
   5// Copyright 2012 Wolfson Microelectronics PLC.
   6//
   7// Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
   8
   9#include <linux/module.h>
  10#include <linux/moduleparam.h>
  11#include <linux/init.h>
  12#include <linux/bitops.h>
  13#include <linux/err.h>
  14#include <linux/of.h>
  15#include <linux/platform_device.h>
  16#include <linux/regulator/driver.h>
  17#include <linux/regulator/machine.h>
  18#include <linux/regulator/of_regulator.h>
  19#include <linux/slab.h>
  20#include <linux/workqueue.h>
  21#include <sound/soc.h>
  22
  23#include <linux/mfd/arizona/core.h>
  24#include <linux/mfd/arizona/pdata.h>
  25#include <linux/mfd/arizona/registers.h>
  26
  27#include <linux/mfd/madera/core.h>
  28#include <linux/mfd/madera/pdata.h>
  29#include <linux/mfd/madera/registers.h>
  30
  31#include <linux/regulator/arizona-micsupp.h>
  32
  33struct arizona_micsupp {
  34        struct regulator_dev *regulator;
  35        struct regmap *regmap;
  36        struct snd_soc_dapm_context **dapm;
  37        unsigned int enable_reg;
  38        struct device *dev;
  39
  40        struct regulator_consumer_supply supply;
  41        struct regulator_init_data init_data;
  42
  43        struct work_struct check_cp_work;
  44};
  45
  46static void arizona_micsupp_check_cp(struct work_struct *work)
  47{
  48        struct arizona_micsupp *micsupp =
  49                container_of(work, struct arizona_micsupp, check_cp_work);
  50        struct snd_soc_dapm_context *dapm = *micsupp->dapm;
  51        struct snd_soc_component *component;
  52        unsigned int val;
  53        int ret;
  54
  55        ret = regmap_read(micsupp->regmap, micsupp->enable_reg, &val);
  56        if (ret != 0) {
  57                dev_err(micsupp->dev,
  58                        "Failed to read CP state: %d\n", ret);
  59                return;
  60        }
  61
  62        if (dapm) {
  63                component = snd_soc_dapm_to_component(dapm);
  64
  65                if ((val & (ARIZONA_CPMIC_ENA | ARIZONA_CPMIC_BYPASS)) ==
  66                    ARIZONA_CPMIC_ENA)
  67                        snd_soc_component_force_enable_pin(component,
  68                                                           "MICSUPP");
  69                else
  70                        snd_soc_component_disable_pin(component, "MICSUPP");
  71
  72                snd_soc_dapm_sync(dapm);
  73        }
  74}
  75
  76static int arizona_micsupp_enable(struct regulator_dev *rdev)
  77{
  78        struct arizona_micsupp *micsupp = rdev_get_drvdata(rdev);
  79        int ret;
  80
  81        ret = regulator_enable_regmap(rdev);
  82
  83        if (ret == 0)
  84                schedule_work(&micsupp->check_cp_work);
  85
  86        return ret;
  87}
  88
  89static int arizona_micsupp_disable(struct regulator_dev *rdev)
  90{
  91        struct arizona_micsupp *micsupp = rdev_get_drvdata(rdev);
  92        int ret;
  93
  94        ret = regulator_disable_regmap(rdev);
  95        if (ret == 0)
  96                schedule_work(&micsupp->check_cp_work);
  97
  98        return ret;
  99}
 100
 101static int arizona_micsupp_set_bypass(struct regulator_dev *rdev, bool ena)
 102{
 103        struct arizona_micsupp *micsupp = rdev_get_drvdata(rdev);
 104        int ret;
 105
 106        ret = regulator_set_bypass_regmap(rdev, ena);
 107        if (ret == 0)
 108                schedule_work(&micsupp->check_cp_work);
 109
 110        return ret;
 111}
 112
 113static const struct regulator_ops arizona_micsupp_ops = {
 114        .enable = arizona_micsupp_enable,
 115        .disable = arizona_micsupp_disable,
 116        .is_enabled = regulator_is_enabled_regmap,
 117
 118        .list_voltage = regulator_list_voltage_linear_range,
 119        .map_voltage = regulator_map_voltage_linear_range,
 120
 121        .get_voltage_sel = regulator_get_voltage_sel_regmap,
 122        .set_voltage_sel = regulator_set_voltage_sel_regmap,
 123
 124        .get_bypass = regulator_get_bypass_regmap,
 125        .set_bypass = arizona_micsupp_set_bypass,
 126};
 127
 128static const struct linear_range arizona_micsupp_ranges[] = {
 129        REGULATOR_LINEAR_RANGE(1700000, 0,    0x1e, 50000),
 130        REGULATOR_LINEAR_RANGE(3300000, 0x1f, 0x1f, 0),
 131};
 132
 133static const struct regulator_desc arizona_micsupp = {
 134        .name = "MICVDD",
 135        .supply_name = "CPVDD",
 136        .type = REGULATOR_VOLTAGE,
 137        .n_voltages = 32,
 138        .ops = &arizona_micsupp_ops,
 139
 140        .vsel_reg = ARIZONA_LDO2_CONTROL_1,
 141        .vsel_mask = ARIZONA_LDO2_VSEL_MASK,
 142        .enable_reg = ARIZONA_MIC_CHARGE_PUMP_1,
 143        .enable_mask = ARIZONA_CPMIC_ENA,
 144        .bypass_reg = ARIZONA_MIC_CHARGE_PUMP_1,
 145        .bypass_mask = ARIZONA_CPMIC_BYPASS,
 146
 147        .linear_ranges = arizona_micsupp_ranges,
 148        .n_linear_ranges = ARRAY_SIZE(arizona_micsupp_ranges),
 149
 150        .enable_time = 3000,
 151
 152        .owner = THIS_MODULE,
 153};
 154
 155static const struct linear_range arizona_micsupp_ext_ranges[] = {
 156        REGULATOR_LINEAR_RANGE(900000,  0,    0x14, 25000),
 157        REGULATOR_LINEAR_RANGE(1500000, 0x15, 0x27, 100000),
 158};
 159
 160static const struct regulator_desc arizona_micsupp_ext = {
 161        .name = "MICVDD",
 162        .supply_name = "CPVDD",
 163        .type = REGULATOR_VOLTAGE,
 164        .n_voltages = 40,
 165        .ops = &arizona_micsupp_ops,
 166
 167        .vsel_reg = ARIZONA_LDO2_CONTROL_1,
 168        .vsel_mask = ARIZONA_LDO2_VSEL_MASK,
 169        .enable_reg = ARIZONA_MIC_CHARGE_PUMP_1,
 170        .enable_mask = ARIZONA_CPMIC_ENA,
 171        .bypass_reg = ARIZONA_MIC_CHARGE_PUMP_1,
 172        .bypass_mask = ARIZONA_CPMIC_BYPASS,
 173
 174        .linear_ranges = arizona_micsupp_ext_ranges,
 175        .n_linear_ranges = ARRAY_SIZE(arizona_micsupp_ext_ranges),
 176
 177        .enable_time = 3000,
 178
 179        .owner = THIS_MODULE,
 180};
 181
 182static const struct regulator_init_data arizona_micsupp_default = {
 183        .constraints = {
 184                .valid_ops_mask = REGULATOR_CHANGE_STATUS |
 185                                REGULATOR_CHANGE_VOLTAGE |
 186                                REGULATOR_CHANGE_BYPASS,
 187                .min_uV = 1700000,
 188                .max_uV = 3300000,
 189        },
 190
 191        .num_consumer_supplies = 1,
 192};
 193
 194static const struct regulator_init_data arizona_micsupp_ext_default = {
 195        .constraints = {
 196                .valid_ops_mask = REGULATOR_CHANGE_STATUS |
 197                                REGULATOR_CHANGE_VOLTAGE |
 198                                REGULATOR_CHANGE_BYPASS,
 199                .min_uV = 900000,
 200                .max_uV = 3300000,
 201        },
 202
 203        .num_consumer_supplies = 1,
 204};
 205
 206static const struct regulator_desc madera_micsupp = {
 207        .name = "MICVDD",
 208        .supply_name = "CPVDD1",
 209        .type = REGULATOR_VOLTAGE,
 210        .n_voltages = 40,
 211        .ops = &arizona_micsupp_ops,
 212
 213        .vsel_reg = MADERA_LDO2_CONTROL_1,
 214        .vsel_mask = MADERA_LDO2_VSEL_MASK,
 215        .enable_reg = MADERA_MIC_CHARGE_PUMP_1,
 216        .enable_mask = MADERA_CPMIC_ENA,
 217        .bypass_reg = MADERA_MIC_CHARGE_PUMP_1,
 218        .bypass_mask = MADERA_CPMIC_BYPASS,
 219
 220        .linear_ranges = arizona_micsupp_ext_ranges,
 221        .n_linear_ranges = ARRAY_SIZE(arizona_micsupp_ext_ranges),
 222
 223        .enable_time = 3000,
 224
 225        .owner = THIS_MODULE,
 226};
 227
 228static int arizona_micsupp_of_get_pdata(struct arizona_micsupp_pdata *pdata,
 229                                        struct regulator_config *config,
 230                                        const struct regulator_desc *desc)
 231{
 232        struct arizona_micsupp *micsupp = config->driver_data;
 233        struct device_node *np;
 234        struct regulator_init_data *init_data;
 235
 236        np = of_get_child_by_name(config->dev->of_node, "micvdd");
 237
 238        if (np) {
 239                config->of_node = np;
 240
 241                init_data = of_get_regulator_init_data(config->dev, np, desc);
 242
 243                if (init_data) {
 244                        init_data->consumer_supplies = &micsupp->supply;
 245                        init_data->num_consumer_supplies = 1;
 246
 247                        pdata->init_data = init_data;
 248                }
 249        }
 250
 251        return 0;
 252}
 253
 254static int arizona_micsupp_common_init(struct platform_device *pdev,
 255                                       struct arizona_micsupp *micsupp,
 256                                       const struct regulator_desc *desc,
 257                                       struct arizona_micsupp_pdata *pdata)
 258{
 259        struct regulator_config config = { };
 260        int ret;
 261
 262        INIT_WORK(&micsupp->check_cp_work, arizona_micsupp_check_cp);
 263
 264        micsupp->init_data.consumer_supplies = &micsupp->supply;
 265        micsupp->supply.supply = "MICVDD";
 266        micsupp->supply.dev_name = dev_name(micsupp->dev);
 267        micsupp->enable_reg = desc->enable_reg;
 268
 269        config.dev = micsupp->dev;
 270        config.driver_data = micsupp;
 271        config.regmap = micsupp->regmap;
 272
 273        if (IS_ENABLED(CONFIG_OF)) {
 274                if (!dev_get_platdata(micsupp->dev)) {
 275                        ret = arizona_micsupp_of_get_pdata(pdata, &config,
 276                                                           desc);
 277                        if (ret < 0)
 278                                return ret;
 279                }
 280        }
 281
 282        if (pdata->init_data)
 283                config.init_data = pdata->init_data;
 284        else
 285                config.init_data = &micsupp->init_data;
 286
 287        /* Default to regulated mode */
 288        regmap_update_bits(micsupp->regmap, micsupp->enable_reg,
 289                           ARIZONA_CPMIC_BYPASS, 0);
 290
 291        micsupp->regulator = devm_regulator_register(&pdev->dev,
 292                                                     desc,
 293                                                     &config);
 294
 295        of_node_put(config.of_node);
 296
 297        if (IS_ERR(micsupp->regulator)) {
 298                ret = PTR_ERR(micsupp->regulator);
 299                dev_err(micsupp->dev, "Failed to register mic supply: %d\n",
 300                        ret);
 301                return ret;
 302        }
 303
 304        platform_set_drvdata(pdev, micsupp);
 305
 306        return 0;
 307}
 308
 309static int arizona_micsupp_probe(struct platform_device *pdev)
 310{
 311        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
 312        const struct regulator_desc *desc;
 313        struct arizona_micsupp *micsupp;
 314
 315        micsupp = devm_kzalloc(&pdev->dev, sizeof(*micsupp), GFP_KERNEL);
 316        if (!micsupp)
 317                return -ENOMEM;
 318
 319        micsupp->regmap = arizona->regmap;
 320        micsupp->dapm = &arizona->dapm;
 321        micsupp->dev = arizona->dev;
 322
 323        /*
 324         * Since the chip usually supplies itself we provide some
 325         * default init_data for it.  This will be overridden with
 326         * platform data if provided.
 327         */
 328        switch (arizona->type) {
 329        case WM5110:
 330        case WM8280:
 331                desc = &arizona_micsupp_ext;
 332                micsupp->init_data = arizona_micsupp_ext_default;
 333                break;
 334        default:
 335                desc = &arizona_micsupp;
 336                micsupp->init_data = arizona_micsupp_default;
 337                break;
 338        }
 339
 340        return arizona_micsupp_common_init(pdev, micsupp, desc,
 341                                           &arizona->pdata.micvdd);
 342}
 343
 344static int madera_micsupp_probe(struct platform_device *pdev)
 345{
 346        struct madera *madera = dev_get_drvdata(pdev->dev.parent);
 347        struct arizona_micsupp *micsupp;
 348
 349        micsupp = devm_kzalloc(&pdev->dev, sizeof(*micsupp), GFP_KERNEL);
 350        if (!micsupp)
 351                return -ENOMEM;
 352
 353        micsupp->regmap = madera->regmap;
 354        micsupp->dapm = &madera->dapm;
 355        micsupp->dev = madera->dev;
 356        micsupp->init_data = arizona_micsupp_ext_default;
 357
 358        return arizona_micsupp_common_init(pdev, micsupp, &madera_micsupp,
 359                                           &madera->pdata.micvdd);
 360}
 361
 362static struct platform_driver arizona_micsupp_driver = {
 363        .probe = arizona_micsupp_probe,
 364        .driver         = {
 365                .name   = "arizona-micsupp",
 366        },
 367};
 368
 369static struct platform_driver madera_micsupp_driver = {
 370        .probe = madera_micsupp_probe,
 371        .driver         = {
 372                .name   = "madera-micsupp",
 373        },
 374};
 375
 376static struct platform_driver * const arizona_micsupp_drivers[] = {
 377        &arizona_micsupp_driver,
 378        &madera_micsupp_driver,
 379};
 380
 381static int __init arizona_micsupp_init(void)
 382{
 383        return platform_register_drivers(arizona_micsupp_drivers,
 384                                         ARRAY_SIZE(arizona_micsupp_drivers));
 385}
 386module_init(arizona_micsupp_init);
 387
 388static void __exit arizona_micsupp_exit(void)
 389{
 390        platform_unregister_drivers(arizona_micsupp_drivers,
 391                                    ARRAY_SIZE(arizona_micsupp_drivers));
 392}
 393module_exit(arizona_micsupp_exit);
 394
 395/* Module information */
 396MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 397MODULE_DESCRIPTION("Arizona microphone supply driver");
 398MODULE_LICENSE("GPL");
 399MODULE_ALIAS("platform:arizona-micsupp");
 400MODULE_ALIAS("platform:madera-micsupp");
 401