Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit b5488b6e868454fb10d23278de5038cda98b13ab

Authored by Mark Brown
Committed by Samuel Ortiz
1 parent 26bc4e0cc5
Exists in master and in 6 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

mfd: Update wm8994 active device checks for WM1811 

This didn't go in as part of the original MFD patch for WM1811 due to
cross tree issues.

Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

Showing 1 changed file with 1 additions and 0 deletions Inline Diff

drivers/mfd/wm8994-core.c
Diff comments   View file @ b5488b6
1 /* 1 /*
2 * wm8994-core.c -- Device access for Wolfson WM8994 2 * wm8994-core.c -- Device access for Wolfson WM8994
3 * 3 *
4 * Copyright 2009 Wolfson Microelectronics PLC. 4 * Copyright 2009 Wolfson Microelectronics PLC.
5 * 5 *
6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7 * 7 *
8 * This program is free software; you can redistribute it and/or modify it 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 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 10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version. 11 * option) any later version.
12 * 12 *
13 */ 13 */
14 14
15 #include <linux/kernel.h> 15 #include <linux/kernel.h>
16 #include <linux/module.h> 16 #include <linux/module.h>
17 #include <linux/slab.h> 17 #include <linux/slab.h>
18 #include <linux/i2c.h> 18 #include <linux/i2c.h>
19 #include <linux/err.h> 19 #include <linux/err.h>
20 #include <linux/delay.h> 20 #include <linux/delay.h>
21 #include <linux/mfd/core.h> 21 #include <linux/mfd/core.h>
22 #include <linux/pm_runtime.h> 22 #include <linux/pm_runtime.h>
23 #include <linux/regmap.h> 23 #include <linux/regmap.h>
24 #include <linux/regulator/consumer.h> 24 #include <linux/regulator/consumer.h>
25 #include <linux/regulator/machine.h> 25 #include <linux/regulator/machine.h>
26 26
27 #include <linux/mfd/wm8994/core.h> 27 #include <linux/mfd/wm8994/core.h>
28 #include <linux/mfd/wm8994/pdata.h> 28 #include <linux/mfd/wm8994/pdata.h>
29 #include <linux/mfd/wm8994/registers.h> 29 #include <linux/mfd/wm8994/registers.h>
30 30
31 static int wm8994_read(struct wm8994 *wm8994, unsigned short reg, 31 static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
32 int bytes, void *dest) 32 int bytes, void *dest)
33 { 33 {
34 return regmap_raw_read(wm8994->regmap, reg, dest, bytes); 34 return regmap_raw_read(wm8994->regmap, reg, dest, bytes);
35 } 35 }
36 36
37 /** 37 /**
38 * wm8994_reg_read: Read a single WM8994 register. 38 * wm8994_reg_read: Read a single WM8994 register.
39 * 39 *
40 * @wm8994: Device to read from. 40 * @wm8994: Device to read from.
41 * @reg: Register to read. 41 * @reg: Register to read.
42 */ 42 */
43 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg) 43 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
44 { 44 {
45 unsigned int val; 45 unsigned int val;
46 int ret; 46 int ret;
47 47
48 ret = regmap_read(wm8994->regmap, reg, &val); 48 ret = regmap_read(wm8994->regmap, reg, &val);
49 49
50 if (ret < 0) 50 if (ret < 0)
51 return ret; 51 return ret;
52 else 52 else
53 return val; 53 return val;
54 } 54 }
55 EXPORT_SYMBOL_GPL(wm8994_reg_read); 55 EXPORT_SYMBOL_GPL(wm8994_reg_read);
56 56
57 /** 57 /**
58 * wm8994_bulk_read: Read multiple WM8994 registers 58 * wm8994_bulk_read: Read multiple WM8994 registers
59 * 59 *
60 * @wm8994: Device to read from 60 * @wm8994: Device to read from
61 * @reg: First register 61 * @reg: First register
62 * @count: Number of registers 62 * @count: Number of registers
63 * @buf: Buffer to fill. The data will be returned big endian. 63 * @buf: Buffer to fill. The data will be returned big endian.
64 */ 64 */
65 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg, 65 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
66 int count, u16 *buf) 66 int count, u16 *buf)
67 { 67 {
68 return regmap_bulk_read(wm8994->regmap, reg, buf, count); 68 return regmap_bulk_read(wm8994->regmap, reg, buf, count);
69 } 69 }
70 70
71 static int wm8994_write(struct wm8994 *wm8994, unsigned short reg, 71 static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
72 int bytes, const void *src) 72 int bytes, const void *src)
73 { 73 {
74 return regmap_raw_write(wm8994->regmap, reg, src, bytes); 74 return regmap_raw_write(wm8994->regmap, reg, src, bytes);
75 } 75 }
76 76
77 /** 77 /**
78 * wm8994_reg_write: Write a single WM8994 register. 78 * wm8994_reg_write: Write a single WM8994 register.
79 * 79 *
80 * @wm8994: Device to write to. 80 * @wm8994: Device to write to.
81 * @reg: Register to write to. 81 * @reg: Register to write to.
82 * @val: Value to write. 82 * @val: Value to write.
83 */ 83 */
84 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg, 84 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
85 unsigned short val) 85 unsigned short val)
86 { 86 {
87 return regmap_write(wm8994->regmap, reg, val); 87 return regmap_write(wm8994->regmap, reg, val);
88 } 88 }
89 EXPORT_SYMBOL_GPL(wm8994_reg_write); 89 EXPORT_SYMBOL_GPL(wm8994_reg_write);
90 90
91 /** 91 /**
92 * wm8994_bulk_write: Write multiple WM8994 registers 92 * wm8994_bulk_write: Write multiple WM8994 registers
93 * 93 *
94 * @wm8994: Device to write to 94 * @wm8994: Device to write to
95 * @reg: First register 95 * @reg: First register
96 * @count: Number of registers 96 * @count: Number of registers
97 * @buf: Buffer to write from. Data must be big-endian formatted. 97 * @buf: Buffer to write from. Data must be big-endian formatted.
98 */ 98 */
99 int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg, 99 int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
100 int count, const u16 *buf) 100 int count, const u16 *buf)
101 { 101 {
102 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16)); 102 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
103 } 103 }
104 EXPORT_SYMBOL_GPL(wm8994_bulk_write); 104 EXPORT_SYMBOL_GPL(wm8994_bulk_write);
105 105
106 /** 106 /**
107 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register 107 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
108 * 108 *
109 * @wm8994: Device to write to. 109 * @wm8994: Device to write to.
110 * @reg: Register to write to. 110 * @reg: Register to write to.
111 * @mask: Mask of bits to set. 111 * @mask: Mask of bits to set.
112 * @val: Value to set (unshifted) 112 * @val: Value to set (unshifted)
113 */ 113 */
114 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg, 114 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
115 unsigned short mask, unsigned short val) 115 unsigned short mask, unsigned short val)
116 { 116 {
117 return regmap_update_bits(wm8994->regmap, reg, mask, val); 117 return regmap_update_bits(wm8994->regmap, reg, mask, val);
118 } 118 }
119 EXPORT_SYMBOL_GPL(wm8994_set_bits); 119 EXPORT_SYMBOL_GPL(wm8994_set_bits);
120 120
121 static struct mfd_cell wm8994_regulator_devs[] = { 121 static struct mfd_cell wm8994_regulator_devs[] = {
122 { 122 {
123 .name = "wm8994-ldo", 123 .name = "wm8994-ldo",
124 .id = 1, 124 .id = 1,
125 .pm_runtime_no_callbacks = true, 125 .pm_runtime_no_callbacks = true,
126 }, 126 },
127 { 127 {
128 .name = "wm8994-ldo", 128 .name = "wm8994-ldo",
129 .id = 2, 129 .id = 2,
130 .pm_runtime_no_callbacks = true, 130 .pm_runtime_no_callbacks = true,
131 }, 131 },
132 }; 132 };
133 133
134 static struct resource wm8994_codec_resources[] = { 134 static struct resource wm8994_codec_resources[] = {
135 { 135 {
136 .start = WM8994_IRQ_TEMP_SHUT, 136 .start = WM8994_IRQ_TEMP_SHUT,
137 .end = WM8994_IRQ_TEMP_WARN, 137 .end = WM8994_IRQ_TEMP_WARN,
138 .flags = IORESOURCE_IRQ, 138 .flags = IORESOURCE_IRQ,
139 }, 139 },
140 }; 140 };
141 141
142 static struct resource wm8994_gpio_resources[] = { 142 static struct resource wm8994_gpio_resources[] = {
143 { 143 {
144 .start = WM8994_IRQ_GPIO(1), 144 .start = WM8994_IRQ_GPIO(1),
145 .end = WM8994_IRQ_GPIO(11), 145 .end = WM8994_IRQ_GPIO(11),
146 .flags = IORESOURCE_IRQ, 146 .flags = IORESOURCE_IRQ,
147 }, 147 },
148 }; 148 };
149 149
150 static struct mfd_cell wm8994_devs[] = { 150 static struct mfd_cell wm8994_devs[] = {
151 { 151 {
152 .name = "wm8994-codec", 152 .name = "wm8994-codec",
153 .num_resources = ARRAY_SIZE(wm8994_codec_resources), 153 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
154 .resources = wm8994_codec_resources, 154 .resources = wm8994_codec_resources,
155 }, 155 },
156 156
157 { 157 {
158 .name = "wm8994-gpio", 158 .name = "wm8994-gpio",
159 .num_resources = ARRAY_SIZE(wm8994_gpio_resources), 159 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
160 .resources = wm8994_gpio_resources, 160 .resources = wm8994_gpio_resources,
161 .pm_runtime_no_callbacks = true, 161 .pm_runtime_no_callbacks = true,
162 }, 162 },
163 }; 163 };
164 164
165 /* 165 /*
166 * Supplies for the main bulk of CODEC; the LDO supplies are ignored 166 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
167 * and should be handled via the standard regulator API supply 167 * and should be handled via the standard regulator API supply
168 * management. 168 * management.
169 */ 169 */
170 static const char *wm1811_main_supplies[] = { 170 static const char *wm1811_main_supplies[] = {
171 "DBVDD1", 171 "DBVDD1",
172 "DBVDD2", 172 "DBVDD2",
173 "DBVDD3", 173 "DBVDD3",
174 "DCVDD", 174 "DCVDD",
175 "AVDD1", 175 "AVDD1",
176 "AVDD2", 176 "AVDD2",
177 "CPVDD", 177 "CPVDD",
178 "SPKVDD1", 178 "SPKVDD1",
179 "SPKVDD2", 179 "SPKVDD2",
180 }; 180 };
181 181
182 static const char *wm8994_main_supplies[] = { 182 static const char *wm8994_main_supplies[] = {
183 "DBVDD", 183 "DBVDD",
184 "DCVDD", 184 "DCVDD",
185 "AVDD1", 185 "AVDD1",
186 "AVDD2", 186 "AVDD2",
187 "CPVDD", 187 "CPVDD",
188 "SPKVDD1", 188 "SPKVDD1",
189 "SPKVDD2", 189 "SPKVDD2",
190 }; 190 };
191 191
192 static const char *wm8958_main_supplies[] = { 192 static const char *wm8958_main_supplies[] = {
193 "DBVDD1", 193 "DBVDD1",
194 "DBVDD2", 194 "DBVDD2",
195 "DBVDD3", 195 "DBVDD3",
196 "DCVDD", 196 "DCVDD",
197 "AVDD1", 197 "AVDD1",
198 "AVDD2", 198 "AVDD2",
199 "CPVDD", 199 "CPVDD",
200 "SPKVDD1", 200 "SPKVDD1",
201 "SPKVDD2", 201 "SPKVDD2",
202 }; 202 };
203 203
204 #ifdef CONFIG_PM 204 #ifdef CONFIG_PM
205 static int wm8994_suspend(struct device *dev) 205 static int wm8994_suspend(struct device *dev)
206 { 206 {
207 struct wm8994 *wm8994 = dev_get_drvdata(dev); 207 struct wm8994 *wm8994 = dev_get_drvdata(dev);
208 int ret; 208 int ret;
209 209
210 /* Don't actually go through with the suspend if the CODEC is 210 /* Don't actually go through with the suspend if the CODEC is
211 * still active (eg, for audio passthrough from CP. */ 211 * still active (eg, for audio passthrough from CP. */
212 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1); 212 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
213 if (ret < 0) { 213 if (ret < 0) {
214 dev_err(dev, "Failed to read power status: %d\n", ret); 214 dev_err(dev, "Failed to read power status: %d\n", ret);
215 } else if (ret & WM8994_VMID_SEL_MASK) { 215 } else if (ret & WM8994_VMID_SEL_MASK) {
216 dev_dbg(dev, "CODEC still active, ignoring suspend\n"); 216 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
217 return 0; 217 return 0;
218 } 218 }
219 219
220 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4); 220 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
221 if (ret < 0) { 221 if (ret < 0) {
222 dev_err(dev, "Failed to read power status: %d\n", ret); 222 dev_err(dev, "Failed to read power status: %d\n", ret);
223 } else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA | 223 } else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA |
224 WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA | 224 WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA |
225 WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) { 225 WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) {
226 dev_dbg(dev, "CODEC still active, ignoring suspend\n"); 226 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
227 return 0; 227 return 0;
228 } 228 }
229 229
230 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5); 230 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
231 if (ret < 0) { 231 if (ret < 0) {
232 dev_err(dev, "Failed to read power status: %d\n", ret); 232 dev_err(dev, "Failed to read power status: %d\n", ret);
233 } else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA | 233 } else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA |
234 WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA | 234 WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA |
235 WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) { 235 WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) {
236 dev_dbg(dev, "CODEC still active, ignoring suspend\n"); 236 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
237 return 0; 237 return 0;
238 } 238 }
239 239
240 switch (wm8994->type) { 240 switch (wm8994->type) {
241 case WM8958: 241 case WM8958:
242 case WM1811:
242 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1); 243 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
243 if (ret < 0) { 244 if (ret < 0) {
244 dev_err(dev, "Failed to read power status: %d\n", ret); 245 dev_err(dev, "Failed to read power status: %d\n", ret);
245 } else if (ret & WM8958_MICD_ENA) { 246 } else if (ret & WM8958_MICD_ENA) {
246 dev_dbg(dev, "CODEC still active, ignoring suspend\n"); 247 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
247 return 0; 248 return 0;
248 } 249 }
249 break; 250 break;
250 default: 251 default:
251 break; 252 break;
252 } 253 }
253 254
254 /* Disable LDO pulldowns while the device is suspended if we 255 /* Disable LDO pulldowns while the device is suspended if we
255 * don't know that something will be driving them. */ 256 * don't know that something will be driving them. */
256 if (!wm8994->ldo_ena_always_driven) 257 if (!wm8994->ldo_ena_always_driven)
257 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2, 258 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
258 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD, 259 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
259 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD); 260 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
260 261
261 /* GPIO configuration state is saved here since we may be configuring 262 /* GPIO configuration state is saved here since we may be configuring
262 * the GPIO alternate functions even if we're not using the gpiolib 263 * the GPIO alternate functions even if we're not using the gpiolib
263 * driver for them. 264 * driver for them.
264 */ 265 */
265 ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2, 266 ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
266 &wm8994->gpio_regs); 267 &wm8994->gpio_regs);
267 if (ret < 0) 268 if (ret < 0)
268 dev_err(dev, "Failed to save GPIO registers: %d\n", ret); 269 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
269 270
270 /* For similar reasons we also stash the regulator states */ 271 /* For similar reasons we also stash the regulator states */
271 ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2, 272 ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
272 &wm8994->ldo_regs); 273 &wm8994->ldo_regs);
273 if (ret < 0) 274 if (ret < 0)
274 dev_err(dev, "Failed to save LDO registers: %d\n", ret); 275 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
275 276
276 /* Explicitly put the device into reset in case regulators 277 /* Explicitly put the device into reset in case regulators
277 * don't get disabled in order to ensure consistent restart. 278 * don't get disabled in order to ensure consistent restart.
278 */ 279 */
279 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994); 280 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET, 0x8994);
280 281
281 wm8994->suspended = true; 282 wm8994->suspended = true;
282 283
283 ret = regulator_bulk_disable(wm8994->num_supplies, 284 ret = regulator_bulk_disable(wm8994->num_supplies,
284 wm8994->supplies); 285 wm8994->supplies);
285 if (ret != 0) { 286 if (ret != 0) {
286 dev_err(dev, "Failed to disable supplies: %d\n", ret); 287 dev_err(dev, "Failed to disable supplies: %d\n", ret);
287 return ret; 288 return ret;
288 } 289 }
289 290
290 return 0; 291 return 0;
291 } 292 }
292 293
293 static int wm8994_resume(struct device *dev) 294 static int wm8994_resume(struct device *dev)
294 { 295 {
295 struct wm8994 *wm8994 = dev_get_drvdata(dev); 296 struct wm8994 *wm8994 = dev_get_drvdata(dev);
296 int ret, i; 297 int ret, i;
297 298
298 /* We may have lied to the PM core about suspending */ 299 /* We may have lied to the PM core about suspending */
299 if (!wm8994->suspended) 300 if (!wm8994->suspended)
300 return 0; 301 return 0;
301 302
302 ret = regulator_bulk_enable(wm8994->num_supplies, 303 ret = regulator_bulk_enable(wm8994->num_supplies,
303 wm8994->supplies); 304 wm8994->supplies);
304 if (ret != 0) { 305 if (ret != 0) {
305 dev_err(dev, "Failed to enable supplies: %d\n", ret); 306 dev_err(dev, "Failed to enable supplies: %d\n", ret);
306 return ret; 307 return ret;
307 } 308 }
308 309
309 /* Write register at a time as we use the cache on the CPU so store 310 /* Write register at a time as we use the cache on the CPU so store
310 * it in native endian. 311 * it in native endian.
311 */ 312 */
312 for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) { 313 for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
313 ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK 314 ret = wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK
314 + i, wm8994->irq_masks_cur[i]); 315 + i, wm8994->irq_masks_cur[i]);
315 if (ret < 0) 316 if (ret < 0)
316 dev_err(dev, "Failed to restore interrupt masks: %d\n", 317 dev_err(dev, "Failed to restore interrupt masks: %d\n",
317 ret); 318 ret);
318 } 319 }
319 320
320 ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2, 321 ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
321 &wm8994->ldo_regs); 322 &wm8994->ldo_regs);
322 if (ret < 0) 323 if (ret < 0)
323 dev_err(dev, "Failed to restore LDO registers: %d\n", ret); 324 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
324 325
325 ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2, 326 ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
326 &wm8994->gpio_regs); 327 &wm8994->gpio_regs);
327 if (ret < 0) 328 if (ret < 0)
328 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret); 329 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
329 330
330 /* Disable LDO pulldowns while the device is active */ 331 /* Disable LDO pulldowns while the device is active */
331 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2, 332 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
332 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD, 333 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
333 0); 334 0);
334 335
335 wm8994->suspended = false; 336 wm8994->suspended = false;
336 337
337 return 0; 338 return 0;
338 } 339 }
339 #endif 340 #endif
340 341
341 #ifdef CONFIG_REGULATOR 342 #ifdef CONFIG_REGULATOR
342 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo) 343 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
343 { 344 {
344 struct wm8994_ldo_pdata *ldo_pdata; 345 struct wm8994_ldo_pdata *ldo_pdata;
345 346
346 if (!pdata) 347 if (!pdata)
347 return 0; 348 return 0;
348 349
349 ldo_pdata = &pdata->ldo[ldo]; 350 ldo_pdata = &pdata->ldo[ldo];
350 351
351 if (!ldo_pdata->init_data) 352 if (!ldo_pdata->init_data)
352 return 0; 353 return 0;
353 354
354 return ldo_pdata->init_data->num_consumer_supplies != 0; 355 return ldo_pdata->init_data->num_consumer_supplies != 0;
355 } 356 }
356 #else 357 #else
357 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo) 358 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
358 { 359 {
359 return 0; 360 return 0;
360 } 361 }
361 #endif 362 #endif
362 363
363 static struct regmap_config wm8994_regmap_config = { 364 static struct regmap_config wm8994_regmap_config = {
364 .reg_bits = 16, 365 .reg_bits = 16,
365 .val_bits = 16, 366 .val_bits = 16,
366 }; 367 };
367 368
368 /* 369 /*
369 * Instantiate the generic non-control parts of the device. 370 * Instantiate the generic non-control parts of the device.
370 */ 371 */
371 static int wm8994_device_init(struct wm8994 *wm8994, int irq) 372 static int wm8994_device_init(struct wm8994 *wm8994, int irq)
372 { 373 {
373 struct wm8994_pdata *pdata = wm8994->dev->platform_data; 374 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
374 const char *devname; 375 const char *devname;
375 int ret, i; 376 int ret, i;
376 377
377 dev_set_drvdata(wm8994->dev, wm8994); 378 dev_set_drvdata(wm8994->dev, wm8994);
378 379
379 /* Add the on-chip regulators first for bootstrapping */ 380 /* Add the on-chip regulators first for bootstrapping */
380 ret = mfd_add_devices(wm8994->dev, -1, 381 ret = mfd_add_devices(wm8994->dev, -1,
381 wm8994_regulator_devs, 382 wm8994_regulator_devs,
382 ARRAY_SIZE(wm8994_regulator_devs), 383 ARRAY_SIZE(wm8994_regulator_devs),
383 NULL, 0); 384 NULL, 0);
384 if (ret != 0) { 385 if (ret != 0) {
385 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 386 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
386 goto err_regmap; 387 goto err_regmap;
387 } 388 }
388 389
389 switch (wm8994->type) { 390 switch (wm8994->type) {
390 case WM1811: 391 case WM1811:
391 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies); 392 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
392 break; 393 break;
393 case WM8994: 394 case WM8994:
394 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies); 395 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
395 break; 396 break;
396 case WM8958: 397 case WM8958:
397 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies); 398 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
398 break; 399 break;
399 default: 400 default:
400 BUG(); 401 BUG();
401 goto err_regmap; 402 goto err_regmap;
402 } 403 }
403 404
404 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) * 405 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
405 wm8994->num_supplies, 406 wm8994->num_supplies,
406 GFP_KERNEL); 407 GFP_KERNEL);
407 if (!wm8994->supplies) { 408 if (!wm8994->supplies) {
408 ret = -ENOMEM; 409 ret = -ENOMEM;
409 goto err_regmap; 410 goto err_regmap;
410 } 411 }
411 412
412 switch (wm8994->type) { 413 switch (wm8994->type) {
413 case WM1811: 414 case WM1811:
414 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++) 415 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
415 wm8994->supplies[i].supply = wm1811_main_supplies[i]; 416 wm8994->supplies[i].supply = wm1811_main_supplies[i];
416 break; 417 break;
417 case WM8994: 418 case WM8994:
418 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++) 419 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
419 wm8994->supplies[i].supply = wm8994_main_supplies[i]; 420 wm8994->supplies[i].supply = wm8994_main_supplies[i];
420 break; 421 break;
421 case WM8958: 422 case WM8958:
422 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++) 423 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
423 wm8994->supplies[i].supply = wm8958_main_supplies[i]; 424 wm8994->supplies[i].supply = wm8958_main_supplies[i];
424 break; 425 break;
425 default: 426 default:
426 BUG(); 427 BUG();
427 goto err_regmap; 428 goto err_regmap;
428 } 429 }
429 430
430 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies, 431 ret = regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
431 wm8994->supplies); 432 wm8994->supplies);
432 if (ret != 0) { 433 if (ret != 0) {
433 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret); 434 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
434 goto err_supplies; 435 goto err_supplies;
435 } 436 }
436 437
437 ret = regulator_bulk_enable(wm8994->num_supplies, 438 ret = regulator_bulk_enable(wm8994->num_supplies,
438 wm8994->supplies); 439 wm8994->supplies);
439 if (ret != 0) { 440 if (ret != 0) {
440 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret); 441 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
441 goto err_get; 442 goto err_get;
442 } 443 }
443 444
444 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET); 445 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
445 if (ret < 0) { 446 if (ret < 0) {
446 dev_err(wm8994->dev, "Failed to read ID register\n"); 447 dev_err(wm8994->dev, "Failed to read ID register\n");
447 goto err_enable; 448 goto err_enable;
448 } 449 }
449 switch (ret) { 450 switch (ret) {
450 case 0x1811: 451 case 0x1811:
451 devname = "WM1811"; 452 devname = "WM1811";
452 if (wm8994->type != WM1811) 453 if (wm8994->type != WM1811)
453 dev_warn(wm8994->dev, "Device registered as type %d\n", 454 dev_warn(wm8994->dev, "Device registered as type %d\n",
454 wm8994->type); 455 wm8994->type);
455 wm8994->type = WM1811; 456 wm8994->type = WM1811;
456 break; 457 break;
457 case 0x8994: 458 case 0x8994:
458 devname = "WM8994"; 459 devname = "WM8994";
459 if (wm8994->type != WM8994) 460 if (wm8994->type != WM8994)
460 dev_warn(wm8994->dev, "Device registered as type %d\n", 461 dev_warn(wm8994->dev, "Device registered as type %d\n",
461 wm8994->type); 462 wm8994->type);
462 wm8994->type = WM8994; 463 wm8994->type = WM8994;
463 break; 464 break;
464 case 0x8958: 465 case 0x8958:
465 devname = "WM8958"; 466 devname = "WM8958";
466 if (wm8994->type != WM8958) 467 if (wm8994->type != WM8958)
467 dev_warn(wm8994->dev, "Device registered as type %d\n", 468 dev_warn(wm8994->dev, "Device registered as type %d\n",
468 wm8994->type); 469 wm8994->type);
469 wm8994->type = WM8958; 470 wm8994->type = WM8958;
470 break; 471 break;
471 default: 472 default:
472 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n", 473 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
473 ret); 474 ret);
474 ret = -EINVAL; 475 ret = -EINVAL;
475 goto err_enable; 476 goto err_enable;
476 } 477 }
477 478
478 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION); 479 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
479 if (ret < 0) { 480 if (ret < 0) {
480 dev_err(wm8994->dev, "Failed to read revision register: %d\n", 481 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
481 ret); 482 ret);
482 goto err_enable; 483 goto err_enable;
483 } 484 }
484 485
485 switch (wm8994->type) { 486 switch (wm8994->type) {
486 case WM8994: 487 case WM8994:
487 switch (ret) { 488 switch (ret) {
488 case 0: 489 case 0:
489 case 1: 490 case 1:
490 dev_warn(wm8994->dev, 491 dev_warn(wm8994->dev,
491 "revision %c not fully supported\n", 492 "revision %c not fully supported\n",
492 'A' + ret); 493 'A' + ret);
493 break; 494 break;
494 default: 495 default:
495 break; 496 break;
496 } 497 }
497 break; 498 break;
498 default: 499 default:
499 break; 500 break;
500 } 501 }
501 502
502 dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret); 503 dev_info(wm8994->dev, "%s revision %c\n", devname, 'A' + ret);
503 504
504 if (pdata) { 505 if (pdata) {
505 wm8994->irq_base = pdata->irq_base; 506 wm8994->irq_base = pdata->irq_base;
506 wm8994->gpio_base = pdata->gpio_base; 507 wm8994->gpio_base = pdata->gpio_base;
507 508
508 /* GPIO configuration is only applied if it's non-zero */ 509 /* GPIO configuration is only applied if it's non-zero */
509 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { 510 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
510 if (pdata->gpio_defaults[i]) { 511 if (pdata->gpio_defaults[i]) {
511 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i, 512 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
512 0xffff, 513 0xffff,
513 pdata->gpio_defaults[i]); 514 pdata->gpio_defaults[i]);
514 } 515 }
515 } 516 }
516 517
517 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven; 518 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
518 } 519 }
519 520
520 /* Disable LDO pulldowns while the device is active */ 521 /* Disable LDO pulldowns while the device is active */
521 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2, 522 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
522 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD, 523 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
523 0); 524 0);
524 525
525 /* In some system designs where the regulators are not in use, 526 /* In some system designs where the regulators are not in use,
526 * we can achieve a small reduction in leakage currents by 527 * we can achieve a small reduction in leakage currents by
527 * floating LDO outputs. This bit makes no difference if the 528 * floating LDO outputs. This bit makes no difference if the
528 * LDOs are enabled, it only affects cases where the LDOs were 529 * LDOs are enabled, it only affects cases where the LDOs were
529 * in operation and are then disabled. 530 * in operation and are then disabled.
530 */ 531 */
531 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) { 532 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
532 if (wm8994_ldo_in_use(pdata, i)) 533 if (wm8994_ldo_in_use(pdata, i))
533 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 534 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
534 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH); 535 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
535 else 536 else
536 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 537 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
537 WM8994_LDO1_DISCH, 0); 538 WM8994_LDO1_DISCH, 0);
538 } 539 }
539 540
540 wm8994_irq_init(wm8994); 541 wm8994_irq_init(wm8994);
541 542
542 ret = mfd_add_devices(wm8994->dev, -1, 543 ret = mfd_add_devices(wm8994->dev, -1,
543 wm8994_devs, ARRAY_SIZE(wm8994_devs), 544 wm8994_devs, ARRAY_SIZE(wm8994_devs),
544 NULL, 0); 545 NULL, 0);
545 if (ret != 0) { 546 if (ret != 0) {
546 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 547 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
547 goto err_irq; 548 goto err_irq;
548 } 549 }
549 550
550 pm_runtime_enable(wm8994->dev); 551 pm_runtime_enable(wm8994->dev);
551 pm_runtime_resume(wm8994->dev); 552 pm_runtime_resume(wm8994->dev);
552 553
553 return 0; 554 return 0;
554 555
555 err_irq: 556 err_irq:
556 wm8994_irq_exit(wm8994); 557 wm8994_irq_exit(wm8994);
557 err_enable: 558 err_enable:
558 regulator_bulk_disable(wm8994->num_supplies, 559 regulator_bulk_disable(wm8994->num_supplies,
559 wm8994->supplies); 560 wm8994->supplies);
560 err_get: 561 err_get:
561 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 562 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
562 err_supplies: 563 err_supplies:
563 kfree(wm8994->supplies); 564 kfree(wm8994->supplies);
564 err_regmap: 565 err_regmap:
565 regmap_exit(wm8994->regmap); 566 regmap_exit(wm8994->regmap);
566 mfd_remove_devices(wm8994->dev); 567 mfd_remove_devices(wm8994->dev);
567 kfree(wm8994); 568 kfree(wm8994);
568 return ret; 569 return ret;
569 } 570 }
570 571
571 static void wm8994_device_exit(struct wm8994 *wm8994) 572 static void wm8994_device_exit(struct wm8994 *wm8994)
572 { 573 {
573 pm_runtime_disable(wm8994->dev); 574 pm_runtime_disable(wm8994->dev);
574 mfd_remove_devices(wm8994->dev); 575 mfd_remove_devices(wm8994->dev);
575 wm8994_irq_exit(wm8994); 576 wm8994_irq_exit(wm8994);
576 regulator_bulk_disable(wm8994->num_supplies, 577 regulator_bulk_disable(wm8994->num_supplies,
577 wm8994->supplies); 578 wm8994->supplies);
578 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies); 579 regulator_bulk_free(wm8994->num_supplies, wm8994->supplies);
579 kfree(wm8994->supplies); 580 kfree(wm8994->supplies);
580 regmap_exit(wm8994->regmap); 581 regmap_exit(wm8994->regmap);
581 kfree(wm8994); 582 kfree(wm8994);
582 } 583 }
583 584
584 static int wm8994_i2c_probe(struct i2c_client *i2c, 585 static int wm8994_i2c_probe(struct i2c_client *i2c,
585 const struct i2c_device_id *id) 586 const struct i2c_device_id *id)
586 { 587 {
587 struct wm8994 *wm8994; 588 struct wm8994 *wm8994;
588 int ret; 589 int ret;
589 590
590 wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL); 591 wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
591 if (wm8994 == NULL) 592 if (wm8994 == NULL)
592 return -ENOMEM; 593 return -ENOMEM;
593 594
594 i2c_set_clientdata(i2c, wm8994); 595 i2c_set_clientdata(i2c, wm8994);
595 wm8994->dev = &i2c->dev; 596 wm8994->dev = &i2c->dev;
596 wm8994->irq = i2c->irq; 597 wm8994->irq = i2c->irq;
597 wm8994->type = id->driver_data; 598 wm8994->type = id->driver_data;
598 599
599 wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config); 600 wm8994->regmap = regmap_init_i2c(i2c, &wm8994_regmap_config);
600 if (IS_ERR(wm8994->regmap)) { 601 if (IS_ERR(wm8994->regmap)) {
601 ret = PTR_ERR(wm8994->regmap); 602 ret = PTR_ERR(wm8994->regmap);
602 dev_err(wm8994->dev, "Failed to allocate register map: %d\n", 603 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
603 ret); 604 ret);
604 kfree(wm8994); 605 kfree(wm8994);
605 return ret; 606 return ret;
606 } 607 }
607 608
608 return wm8994_device_init(wm8994, i2c->irq); 609 return wm8994_device_init(wm8994, i2c->irq);
609 } 610 }
610 611
611 static int wm8994_i2c_remove(struct i2c_client *i2c) 612 static int wm8994_i2c_remove(struct i2c_client *i2c)
612 { 613 {
613 struct wm8994 *wm8994 = i2c_get_clientdata(i2c); 614 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
614 615
615 wm8994_device_exit(wm8994); 616 wm8994_device_exit(wm8994);
616 617
617 return 0; 618 return 0;
618 } 619 }
619 620
620 static const struct i2c_device_id wm8994_i2c_id[] = { 621 static const struct i2c_device_id wm8994_i2c_id[] = {
621 { "wm1811", WM1811 }, 622 { "wm1811", WM1811 },
622 { "wm8994", WM8994 }, 623 { "wm8994", WM8994 },
623 { "wm8958", WM8958 }, 624 { "wm8958", WM8958 },
624 { } 625 { }
625 }; 626 };
626 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id); 627 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
627 628
628 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume, 629 static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
629 NULL); 630 NULL);
630 631
631 static struct i2c_driver wm8994_i2c_driver = { 632 static struct i2c_driver wm8994_i2c_driver = {
632 .driver = { 633 .driver = {
633 .name = "wm8994", 634 .name = "wm8994",
634 .owner = THIS_MODULE, 635 .owner = THIS_MODULE,
635 .pm = &wm8994_pm_ops, 636 .pm = &wm8994_pm_ops,
636 }, 637 },
637 .probe = wm8994_i2c_probe, 638 .probe = wm8994_i2c_probe,
638 .remove = wm8994_i2c_remove, 639 .remove = wm8994_i2c_remove,
639 .id_table = wm8994_i2c_id, 640 .id_table = wm8994_i2c_id,
640 }; 641 };
641 642
642 static int __init wm8994_i2c_init(void) 643 static int __init wm8994_i2c_init(void)
643 { 644 {
644 int ret; 645 int ret;
645 646
646 ret = i2c_add_driver(&wm8994_i2c_driver); 647 ret = i2c_add_driver(&wm8994_i2c_driver);
647 if (ret != 0) 648 if (ret != 0)
648 pr_err("Failed to register wm8994 I2C driver: %d\n", ret); 649 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
649 650
650 return ret; 651 return ret;
651 } 652 }
652 module_init(wm8994_i2c_init); 653 module_init(wm8994_i2c_init);
653 654
654 static void __exit wm8994_i2c_exit(void) 655 static void __exit wm8994_i2c_exit(void)
655 { 656 {
656 i2c_del_driver(&wm8994_i2c_driver); 657 i2c_del_driver(&wm8994_i2c_driver);
657 } 658 }
658 module_exit(wm8994_i2c_exit); 659 module_exit(wm8994_i2c_exit);
659 660
660 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC"); 661 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
661 MODULE_LICENSE("GPL"); 662 MODULE_LICENSE("GPL");
662 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 663 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
663 664