Version:  2.0.40 2.2.26 2.4.37 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us