drivers/regulator/arizona-micsupp.c

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