Merge branch 'x86/vt-d' of git://git.kernel.org/pub/scm/linux/kernel/git/joro/iommu...
[firefly-linux-kernel-4.4.55.git] / 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                                         const struct regulator_desc *desc)
203 {
204         struct arizona_pdata *pdata = &arizona->pdata;
205         struct arizona_micsupp *micsupp = config->driver_data;
206         struct device_node *np;
207         struct regulator_init_data *init_data;
208
209         np = of_get_child_by_name(arizona->dev->of_node, "micvdd");
210
211         if (np) {
212                 config->of_node = np;
213
214                 init_data = of_get_regulator_init_data(arizona->dev, np, desc);
215
216                 if (init_data) {
217                         init_data->consumer_supplies = &micsupp->supply;
218                         init_data->num_consumer_supplies = 1;
219
220                         pdata->micvdd = init_data;
221                 }
222         }
223
224         return 0;
225 }
226
227 static int arizona_micsupp_probe(struct platform_device *pdev)
228 {
229         struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
230         const struct regulator_desc *desc;
231         struct regulator_config config = { };
232         struct arizona_micsupp *micsupp;
233         int ret;
234
235         micsupp = devm_kzalloc(&pdev->dev, sizeof(*micsupp), GFP_KERNEL);
236         if (!micsupp)
237                 return -ENOMEM;
238
239         micsupp->arizona = arizona;
240         INIT_WORK(&micsupp->check_cp_work, arizona_micsupp_check_cp);
241
242         /*
243          * Since the chip usually supplies itself we provide some
244          * default init_data for it.  This will be overridden with
245          * platform data if provided.
246          */
247         switch (arizona->type) {
248         case WM5110:
249                 desc = &arizona_micsupp_ext;
250                 micsupp->init_data = arizona_micsupp_ext_default;
251                 break;
252         default:
253                 desc = &arizona_micsupp;
254                 micsupp->init_data = arizona_micsupp_default;
255                 break;
256         }
257
258         micsupp->init_data.consumer_supplies = &micsupp->supply;
259         micsupp->supply.supply = "MICVDD";
260         micsupp->supply.dev_name = dev_name(arizona->dev);
261
262         config.dev = arizona->dev;
263         config.driver_data = micsupp;
264         config.regmap = arizona->regmap;
265
266         if (IS_ENABLED(CONFIG_OF)) {
267                 if (!dev_get_platdata(arizona->dev)) {
268                         ret = arizona_micsupp_of_get_pdata(arizona, &config,
269                                                            desc);
270                         if (ret < 0)
271                                 return ret;
272                 }
273         }
274
275         if (arizona->pdata.micvdd)
276                 config.init_data = arizona->pdata.micvdd;
277         else
278                 config.init_data = &micsupp->init_data;
279
280         /* Default to regulated mode until the API supports bypass */
281         regmap_update_bits(arizona->regmap, ARIZONA_MIC_CHARGE_PUMP_1,
282                            ARIZONA_CPMIC_BYPASS, 0);
283
284         micsupp->regulator = devm_regulator_register(&pdev->dev,
285                                                      desc,
286                                                      &config);
287         if (IS_ERR(micsupp->regulator)) {
288                 ret = PTR_ERR(micsupp->regulator);
289                 dev_err(arizona->dev, "Failed to register mic supply: %d\n",
290                         ret);
291                 return ret;
292         }
293
294         of_node_put(config.of_node);
295
296         platform_set_drvdata(pdev, micsupp);
297
298         return 0;
299 }
300
301 static struct platform_driver arizona_micsupp_driver = {
302         .probe = arizona_micsupp_probe,
303         .driver         = {
304                 .name   = "arizona-micsupp",
305                 .owner  = THIS_MODULE,
306         },
307 };
308
309 module_platform_driver(arizona_micsupp_driver);
310
311 /* Module information */
312 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
313 MODULE_DESCRIPTION("Arizona microphone supply driver");
314 MODULE_LICENSE("GPL");
315 MODULE_ALIAS("platform:arizona-micsupp");