drivers/regulator/arizona-micsupp.c

   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
  33 struct 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
  46 static 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
  76 static 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
  89 static 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
 101 static 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
 113 static 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
 128 static const struct regulator_linear_range arizona_micsupp_ranges[] = {
 129         REGULATOR_LINEAR_RANGE(1700000, 0,    0x1e, 50000),
 130         REGULATOR_LINEAR_RANGE(3300000, 0x1f, 0x1f, 0),
 131 };
 132
 133 static 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
 155 static const struct regulator_linear_range arizona_micsupp_ext_ranges[] = {
 156         REGULATOR_LINEAR_RANGE(900000,  0,    0x14, 25000),
 157         REGULATOR_LINEAR_RANGE(1500000, 0x15, 0x27, 100000),
 158 };
 159
 160 static 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
 182 static 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
 194 static 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
 206 static 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
 228 static 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
 254 static 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
 309 static 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
 344 static 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
 362 static struct platform_driver arizona_micsupp_driver = {
 363         .probe = arizona_micsupp_probe,
 364         .driver         = {
 365                 .name   = "arizona-micsupp",
 366         },
 367 };
 368
 369 static struct platform_driver madera_micsupp_driver = {
 370         .probe = madera_micsupp_probe,
 371         .driver         = {
 372                 .name   = "madera-micsupp",
 373         },
 374 };
 375
 376 static struct platform_driver * const arizona_micsupp_drivers[] = {
 377         &arizona_micsupp_driver,
 378         &madera_micsupp_driver,
 379 };
 380
 381 static int __init arizona_micsupp_init(void)
 382 {
 383         return platform_register_drivers(arizona_micsupp_drivers,
 384                                          ARRAY_SIZE(arizona_micsupp_drivers));
 385 }
 386 module_init(arizona_micsupp_init);
 387
 388 static void __exit arizona_micsupp_exit(void)
 389 {
 390         platform_unregister_drivers(arizona_micsupp_drivers,
 391                                     ARRAY_SIZE(arizona_micsupp_drivers));
 392 }
 393 module_exit(arizona_micsupp_exit);
 394
 395 /* Module information */
 396 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
 397 MODULE_DESCRIPTION("Arizona microphone supply driver");
 398 MODULE_LICENSE("GPL");
 399 MODULE_ALIAS("platform:arizona-micsupp");
 400 MODULE_ALIAS("platform:madera-micsupp");