Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit d0a11693967295772d2a7c22b6b37eb20684e709

Authored by Axel Lin
Committed by Samuel Ortiz
1 parent a2cddb6e41
Exists in master and in 7 other branches imx_3.0.35_4.1.0, 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: Fix incorrect kfree(i2c) in wm8994-core i2c_driver probe 

The i2c_client received in probe() should not be kfree()'d.

Signed-off-by: Axel Lin <axel.lin@gmail.com>
Acked-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>

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

drivers/mfd/wm8994-core.c
Diff comments   View file @ d0a1169
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/delay.h> 19 #include <linux/delay.h>
20 #include <linux/mfd/core.h> 20 #include <linux/mfd/core.h>
21 #include <linux/regulator/consumer.h> 21 #include <linux/regulator/consumer.h>
22 #include <linux/regulator/machine.h> 22 #include <linux/regulator/machine.h>
23 23
24 #include <linux/mfd/wm8994/core.h> 24 #include <linux/mfd/wm8994/core.h>
25 #include <linux/mfd/wm8994/pdata.h> 25 #include <linux/mfd/wm8994/pdata.h>
26 #include <linux/mfd/wm8994/registers.h> 26 #include <linux/mfd/wm8994/registers.h>
27 27
28 static int wm8994_read(struct wm8994 *wm8994, unsigned short reg, 28 static int wm8994_read(struct wm8994 *wm8994, unsigned short reg,
29 int bytes, void *dest) 29 int bytes, void *dest)
30 { 30 {
31 int ret, i; 31 int ret, i;
32 u16 *buf = dest; 32 u16 *buf = dest;
33 33
34 BUG_ON(bytes % 2); 34 BUG_ON(bytes % 2);
35 BUG_ON(bytes <= 0); 35 BUG_ON(bytes <= 0);
36 36
37 ret = wm8994->read_dev(wm8994, reg, bytes, dest); 37 ret = wm8994->read_dev(wm8994, reg, bytes, dest);
38 if (ret < 0) 38 if (ret < 0)
39 return ret; 39 return ret;
40 40
41 for (i = 0; i < bytes / 2; i++) { 41 for (i = 0; i < bytes / 2; i++) {
42 buf[i] = be16_to_cpu(buf[i]); 42 buf[i] = be16_to_cpu(buf[i]);
43 43
44 dev_vdbg(wm8994->dev, "Read %04x from R%d(0x%x)\n", 44 dev_vdbg(wm8994->dev, "Read %04x from R%d(0x%x)\n",
45 buf[i], reg + i, reg + i); 45 buf[i], reg + i, reg + i);
46 } 46 }
47 47
48 return 0; 48 return 0;
49 } 49 }
50 50
51 /** 51 /**
52 * wm8994_reg_read: Read a single WM8994 register. 52 * wm8994_reg_read: Read a single WM8994 register.
53 * 53 *
54 * @wm8994: Device to read from. 54 * @wm8994: Device to read from.
55 * @reg: Register to read. 55 * @reg: Register to read.
56 */ 56 */
57 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg) 57 int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
58 { 58 {
59 unsigned short val; 59 unsigned short val;
60 int ret; 60 int ret;
61 61
62 mutex_lock(&wm8994->io_lock); 62 mutex_lock(&wm8994->io_lock);
63 63
64 ret = wm8994_read(wm8994, reg, 2, &val); 64 ret = wm8994_read(wm8994, reg, 2, &val);
65 65
66 mutex_unlock(&wm8994->io_lock); 66 mutex_unlock(&wm8994->io_lock);
67 67
68 if (ret < 0) 68 if (ret < 0)
69 return ret; 69 return ret;
70 else 70 else
71 return val; 71 return val;
72 } 72 }
73 EXPORT_SYMBOL_GPL(wm8994_reg_read); 73 EXPORT_SYMBOL_GPL(wm8994_reg_read);
74 74
75 /** 75 /**
76 * wm8994_bulk_read: Read multiple WM8994 registers 76 * wm8994_bulk_read: Read multiple WM8994 registers
77 * 77 *
78 * @wm8994: Device to read from 78 * @wm8994: Device to read from
79 * @reg: First register 79 * @reg: First register
80 * @count: Number of registers 80 * @count: Number of registers
81 * @buf: Buffer to fill. 81 * @buf: Buffer to fill.
82 */ 82 */
83 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg, 83 int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
84 int count, u16 *buf) 84 int count, u16 *buf)
85 { 85 {
86 int ret; 86 int ret;
87 87
88 mutex_lock(&wm8994->io_lock); 88 mutex_lock(&wm8994->io_lock);
89 89
90 ret = wm8994_read(wm8994, reg, count * 2, buf); 90 ret = wm8994_read(wm8994, reg, count * 2, buf);
91 91
92 mutex_unlock(&wm8994->io_lock); 92 mutex_unlock(&wm8994->io_lock);
93 93
94 return ret; 94 return ret;
95 } 95 }
96 EXPORT_SYMBOL_GPL(wm8994_bulk_read); 96 EXPORT_SYMBOL_GPL(wm8994_bulk_read);
97 97
98 static int wm8994_write(struct wm8994 *wm8994, unsigned short reg, 98 static int wm8994_write(struct wm8994 *wm8994, unsigned short reg,
99 int bytes, void *src) 99 int bytes, void *src)
100 { 100 {
101 u16 *buf = src; 101 u16 *buf = src;
102 int i; 102 int i;
103 103
104 BUG_ON(bytes % 2); 104 BUG_ON(bytes % 2);
105 BUG_ON(bytes <= 0); 105 BUG_ON(bytes <= 0);
106 106
107 for (i = 0; i < bytes / 2; i++) { 107 for (i = 0; i < bytes / 2; i++) {
108 dev_vdbg(wm8994->dev, "Write %04x to R%d(0x%x)\n", 108 dev_vdbg(wm8994->dev, "Write %04x to R%d(0x%x)\n",
109 buf[i], reg + i, reg + i); 109 buf[i], reg + i, reg + i);
110 110
111 buf[i] = cpu_to_be16(buf[i]); 111 buf[i] = cpu_to_be16(buf[i]);
112 } 112 }
113 113
114 return wm8994->write_dev(wm8994, reg, bytes, src); 114 return wm8994->write_dev(wm8994, reg, bytes, src);
115 } 115 }
116 116
117 /** 117 /**
118 * wm8994_reg_write: Write a single WM8994 register. 118 * wm8994_reg_write: Write a single WM8994 register.
119 * 119 *
120 * @wm8994: Device to write to. 120 * @wm8994: Device to write to.
121 * @reg: Register to write to. 121 * @reg: Register to write to.
122 * @val: Value to write. 122 * @val: Value to write.
123 */ 123 */
124 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg, 124 int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
125 unsigned short val) 125 unsigned short val)
126 { 126 {
127 int ret; 127 int ret;
128 128
129 mutex_lock(&wm8994->io_lock); 129 mutex_lock(&wm8994->io_lock);
130 130
131 ret = wm8994_write(wm8994, reg, 2, &val); 131 ret = wm8994_write(wm8994, reg, 2, &val);
132 132
133 mutex_unlock(&wm8994->io_lock); 133 mutex_unlock(&wm8994->io_lock);
134 134
135 return ret; 135 return ret;
136 } 136 }
137 EXPORT_SYMBOL_GPL(wm8994_reg_write); 137 EXPORT_SYMBOL_GPL(wm8994_reg_write);
138 138
139 /** 139 /**
140 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register 140 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
141 * 141 *
142 * @wm8994: Device to write to. 142 * @wm8994: Device to write to.
143 * @reg: Register to write to. 143 * @reg: Register to write to.
144 * @mask: Mask of bits to set. 144 * @mask: Mask of bits to set.
145 * @val: Value to set (unshifted) 145 * @val: Value to set (unshifted)
146 */ 146 */
147 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg, 147 int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
148 unsigned short mask, unsigned short val) 148 unsigned short mask, unsigned short val)
149 { 149 {
150 int ret; 150 int ret;
151 u16 r; 151 u16 r;
152 152
153 mutex_lock(&wm8994->io_lock); 153 mutex_lock(&wm8994->io_lock);
154 154
155 ret = wm8994_read(wm8994, reg, 2, &r); 155 ret = wm8994_read(wm8994, reg, 2, &r);
156 if (ret < 0) 156 if (ret < 0)
157 goto out; 157 goto out;
158 158
159 r &= ~mask; 159 r &= ~mask;
160 r |= val; 160 r |= val;
161 161
162 ret = wm8994_write(wm8994, reg, 2, &r); 162 ret = wm8994_write(wm8994, reg, 2, &r);
163 163
164 out: 164 out:
165 mutex_unlock(&wm8994->io_lock); 165 mutex_unlock(&wm8994->io_lock);
166 166
167 return ret; 167 return ret;
168 } 168 }
169 EXPORT_SYMBOL_GPL(wm8994_set_bits); 169 EXPORT_SYMBOL_GPL(wm8994_set_bits);
170 170
171 static struct mfd_cell wm8994_regulator_devs[] = { 171 static struct mfd_cell wm8994_regulator_devs[] = {
172 { .name = "wm8994-ldo", .id = 1 }, 172 { .name = "wm8994-ldo", .id = 1 },
173 { .name = "wm8994-ldo", .id = 2 }, 173 { .name = "wm8994-ldo", .id = 2 },
174 }; 174 };
175 175
176 static struct resource wm8994_codec_resources[] = { 176 static struct resource wm8994_codec_resources[] = {
177 { 177 {
178 .start = WM8994_IRQ_TEMP_SHUT, 178 .start = WM8994_IRQ_TEMP_SHUT,
179 .end = WM8994_IRQ_TEMP_WARN, 179 .end = WM8994_IRQ_TEMP_WARN,
180 .flags = IORESOURCE_IRQ, 180 .flags = IORESOURCE_IRQ,
181 }, 181 },
182 }; 182 };
183 183
184 static struct resource wm8994_gpio_resources[] = { 184 static struct resource wm8994_gpio_resources[] = {
185 { 185 {
186 .start = WM8994_IRQ_GPIO(1), 186 .start = WM8994_IRQ_GPIO(1),
187 .end = WM8994_IRQ_GPIO(11), 187 .end = WM8994_IRQ_GPIO(11),
188 .flags = IORESOURCE_IRQ, 188 .flags = IORESOURCE_IRQ,
189 }, 189 },
190 }; 190 };
191 191
192 static struct mfd_cell wm8994_devs[] = { 192 static struct mfd_cell wm8994_devs[] = {
193 { 193 {
194 .name = "wm8994-codec", 194 .name = "wm8994-codec",
195 .num_resources = ARRAY_SIZE(wm8994_codec_resources), 195 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
196 .resources = wm8994_codec_resources, 196 .resources = wm8994_codec_resources,
197 }, 197 },
198 198
199 { 199 {
200 .name = "wm8994-gpio", 200 .name = "wm8994-gpio",
201 .num_resources = ARRAY_SIZE(wm8994_gpio_resources), 201 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
202 .resources = wm8994_gpio_resources, 202 .resources = wm8994_gpio_resources,
203 }, 203 },
204 }; 204 };
205 205
206 /* 206 /*
207 * Supplies for the main bulk of CODEC; the LDO supplies are ignored 207 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
208 * and should be handled via the standard regulator API supply 208 * and should be handled via the standard regulator API supply
209 * management. 209 * management.
210 */ 210 */
211 static const char *wm8994_main_supplies[] = { 211 static const char *wm8994_main_supplies[] = {
212 "DBVDD", 212 "DBVDD",
213 "DCVDD", 213 "DCVDD",
214 "AVDD1", 214 "AVDD1",
215 "AVDD2", 215 "AVDD2",
216 "CPVDD", 216 "CPVDD",
217 "SPKVDD1", 217 "SPKVDD1",
218 "SPKVDD2", 218 "SPKVDD2",
219 }; 219 };
220 220
221 #ifdef CONFIG_PM 221 #ifdef CONFIG_PM
222 static int wm8994_device_suspend(struct device *dev) 222 static int wm8994_device_suspend(struct device *dev)
223 { 223 {
224 struct wm8994 *wm8994 = dev_get_drvdata(dev); 224 struct wm8994 *wm8994 = dev_get_drvdata(dev);
225 int ret; 225 int ret;
226 226
227 /* GPIO configuration state is saved here since we may be configuring 227 /* GPIO configuration state is saved here since we may be configuring
228 * the GPIO alternate functions even if we're not using the gpiolib 228 * the GPIO alternate functions even if we're not using the gpiolib
229 * driver for them. 229 * driver for them.
230 */ 230 */
231 ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2, 231 ret = wm8994_read(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
232 &wm8994->gpio_regs); 232 &wm8994->gpio_regs);
233 if (ret < 0) 233 if (ret < 0)
234 dev_err(dev, "Failed to save GPIO registers: %d\n", ret); 234 dev_err(dev, "Failed to save GPIO registers: %d\n", ret);
235 235
236 /* For similar reasons we also stash the regulator states */ 236 /* For similar reasons we also stash the regulator states */
237 ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2, 237 ret = wm8994_read(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
238 &wm8994->ldo_regs); 238 &wm8994->ldo_regs);
239 if (ret < 0) 239 if (ret < 0)
240 dev_err(dev, "Failed to save LDO registers: %d\n", ret); 240 dev_err(dev, "Failed to save LDO registers: %d\n", ret);
241 241
242 ret = regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies), 242 ret = regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
243 wm8994->supplies); 243 wm8994->supplies);
244 if (ret != 0) { 244 if (ret != 0) {
245 dev_err(dev, "Failed to disable supplies: %d\n", ret); 245 dev_err(dev, "Failed to disable supplies: %d\n", ret);
246 return ret; 246 return ret;
247 } 247 }
248 248
249 return 0; 249 return 0;
250 } 250 }
251 251
252 static int wm8994_device_resume(struct device *dev) 252 static int wm8994_device_resume(struct device *dev)
253 { 253 {
254 struct wm8994 *wm8994 = dev_get_drvdata(dev); 254 struct wm8994 *wm8994 = dev_get_drvdata(dev);
255 int ret; 255 int ret;
256 256
257 ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies), 257 ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies),
258 wm8994->supplies); 258 wm8994->supplies);
259 if (ret != 0) { 259 if (ret != 0) {
260 dev_err(dev, "Failed to enable supplies: %d\n", ret); 260 dev_err(dev, "Failed to enable supplies: %d\n", ret);
261 return ret; 261 return ret;
262 } 262 }
263 263
264 ret = wm8994_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK, 264 ret = wm8994_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK,
265 WM8994_NUM_IRQ_REGS * 2, &wm8994->irq_masks_cur); 265 WM8994_NUM_IRQ_REGS * 2, &wm8994->irq_masks_cur);
266 if (ret < 0) 266 if (ret < 0)
267 dev_err(dev, "Failed to restore interrupt masks: %d\n", ret); 267 dev_err(dev, "Failed to restore interrupt masks: %d\n", ret);
268 268
269 ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2, 269 ret = wm8994_write(wm8994, WM8994_LDO_1, WM8994_NUM_LDO_REGS * 2,
270 &wm8994->ldo_regs); 270 &wm8994->ldo_regs);
271 if (ret < 0) 271 if (ret < 0)
272 dev_err(dev, "Failed to restore LDO registers: %d\n", ret); 272 dev_err(dev, "Failed to restore LDO registers: %d\n", ret);
273 273
274 ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2, 274 ret = wm8994_write(wm8994, WM8994_GPIO_1, WM8994_NUM_GPIO_REGS * 2,
275 &wm8994->gpio_regs); 275 &wm8994->gpio_regs);
276 if (ret < 0) 276 if (ret < 0)
277 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret); 277 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
278 278
279 return 0; 279 return 0;
280 } 280 }
281 #endif 281 #endif
282 282
283 #ifdef CONFIG_REGULATOR 283 #ifdef CONFIG_REGULATOR
284 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo) 284 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
285 { 285 {
286 struct wm8994_ldo_pdata *ldo_pdata; 286 struct wm8994_ldo_pdata *ldo_pdata;
287 287
288 if (!pdata) 288 if (!pdata)
289 return 0; 289 return 0;
290 290
291 ldo_pdata = &pdata->ldo[ldo]; 291 ldo_pdata = &pdata->ldo[ldo];
292 292
293 if (!ldo_pdata->init_data) 293 if (!ldo_pdata->init_data)
294 return 0; 294 return 0;
295 295
296 return ldo_pdata->init_data->num_consumer_supplies != 0; 296 return ldo_pdata->init_data->num_consumer_supplies != 0;
297 } 297 }
298 #else 298 #else
299 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo) 299 static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
300 { 300 {
301 return 0; 301 return 0;
302 } 302 }
303 #endif 303 #endif
304 304
305 /* 305 /*
306 * Instantiate the generic non-control parts of the device. 306 * Instantiate the generic non-control parts of the device.
307 */ 307 */
308 static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq) 308 static int wm8994_device_init(struct wm8994 *wm8994, unsigned long id, int irq)
309 { 309 {
310 struct wm8994_pdata *pdata = wm8994->dev->platform_data; 310 struct wm8994_pdata *pdata = wm8994->dev->platform_data;
311 int ret, i; 311 int ret, i;
312 312
313 mutex_init(&wm8994->io_lock); 313 mutex_init(&wm8994->io_lock);
314 dev_set_drvdata(wm8994->dev, wm8994); 314 dev_set_drvdata(wm8994->dev, wm8994);
315 315
316 /* Add the on-chip regulators first for bootstrapping */ 316 /* Add the on-chip regulators first for bootstrapping */
317 ret = mfd_add_devices(wm8994->dev, -1, 317 ret = mfd_add_devices(wm8994->dev, -1,
318 wm8994_regulator_devs, 318 wm8994_regulator_devs,
319 ARRAY_SIZE(wm8994_regulator_devs), 319 ARRAY_SIZE(wm8994_regulator_devs),
320 NULL, 0); 320 NULL, 0);
321 if (ret != 0) { 321 if (ret != 0) {
322 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 322 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
323 goto err; 323 goto err;
324 } 324 }
325 325
326 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) * 326 wm8994->supplies = kzalloc(sizeof(struct regulator_bulk_data) *
327 ARRAY_SIZE(wm8994_main_supplies), 327 ARRAY_SIZE(wm8994_main_supplies),
328 GFP_KERNEL); 328 GFP_KERNEL);
329 if (!wm8994->supplies) { 329 if (!wm8994->supplies) {
330 ret = -ENOMEM; 330 ret = -ENOMEM;
331 goto err; 331 goto err;
332 } 332 }
333 333
334 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++) 334 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
335 wm8994->supplies[i].supply = wm8994_main_supplies[i]; 335 wm8994->supplies[i].supply = wm8994_main_supplies[i];
336 336
337 ret = regulator_bulk_get(wm8994->dev, ARRAY_SIZE(wm8994_main_supplies), 337 ret = regulator_bulk_get(wm8994->dev, ARRAY_SIZE(wm8994_main_supplies),
338 wm8994->supplies); 338 wm8994->supplies);
339 if (ret != 0) { 339 if (ret != 0) {
340 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret); 340 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
341 goto err_supplies; 341 goto err_supplies;
342 } 342 }
343 343
344 ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies), 344 ret = regulator_bulk_enable(ARRAY_SIZE(wm8994_main_supplies),
345 wm8994->supplies); 345 wm8994->supplies);
346 if (ret != 0) { 346 if (ret != 0) {
347 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret); 347 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
348 goto err_get; 348 goto err_get;
349 } 349 }
350 350
351 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET); 351 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
352 if (ret < 0) { 352 if (ret < 0) {
353 dev_err(wm8994->dev, "Failed to read ID register\n"); 353 dev_err(wm8994->dev, "Failed to read ID register\n");
354 goto err_enable; 354 goto err_enable;
355 } 355 }
356 if (ret != 0x8994) { 356 if (ret != 0x8994) {
357 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n", 357 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
358 ret); 358 ret);
359 ret = -EINVAL; 359 ret = -EINVAL;
360 goto err_enable; 360 goto err_enable;
361 } 361 }
362 362
363 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION); 363 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
364 if (ret < 0) { 364 if (ret < 0) {
365 dev_err(wm8994->dev, "Failed to read revision register: %d\n", 365 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
366 ret); 366 ret);
367 goto err_enable; 367 goto err_enable;
368 } 368 }
369 369
370 switch (ret) { 370 switch (ret) {
371 case 0: 371 case 0:
372 case 1: 372 case 1:
373 dev_warn(wm8994->dev, "revision %c not fully supported\n", 373 dev_warn(wm8994->dev, "revision %c not fully supported\n",
374 'A' + ret); 374 'A' + ret);
375 break; 375 break;
376 default: 376 default:
377 dev_info(wm8994->dev, "revision %c\n", 'A' + ret); 377 dev_info(wm8994->dev, "revision %c\n", 'A' + ret);
378 break; 378 break;
379 } 379 }
380 380
381 381
382 if (pdata) { 382 if (pdata) {
383 wm8994->irq_base = pdata->irq_base; 383 wm8994->irq_base = pdata->irq_base;
384 wm8994->gpio_base = pdata->gpio_base; 384 wm8994->gpio_base = pdata->gpio_base;
385 385
386 /* GPIO configuration is only applied if it's non-zero */ 386 /* GPIO configuration is only applied if it's non-zero */
387 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) { 387 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
388 if (pdata->gpio_defaults[i]) { 388 if (pdata->gpio_defaults[i]) {
389 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i, 389 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
390 0xffff, 390 0xffff,
391 pdata->gpio_defaults[i]); 391 pdata->gpio_defaults[i]);
392 } 392 }
393 } 393 }
394 } 394 }
395 395
396 /* In some system designs where the regulators are not in use, 396 /* In some system designs where the regulators are not in use,
397 * we can achieve a small reduction in leakage currents by 397 * we can achieve a small reduction in leakage currents by
398 * floating LDO outputs. This bit makes no difference if the 398 * floating LDO outputs. This bit makes no difference if the
399 * LDOs are enabled, it only affects cases where the LDOs were 399 * LDOs are enabled, it only affects cases where the LDOs were
400 * in operation and are then disabled. 400 * in operation and are then disabled.
401 */ 401 */
402 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) { 402 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
403 if (wm8994_ldo_in_use(pdata, i)) 403 if (wm8994_ldo_in_use(pdata, i))
404 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 404 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
405 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH); 405 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
406 else 406 else
407 wm8994_set_bits(wm8994, WM8994_LDO_1 + i, 407 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
408 WM8994_LDO1_DISCH, 0); 408 WM8994_LDO1_DISCH, 0);
409 } 409 }
410 410
411 wm8994_irq_init(wm8994); 411 wm8994_irq_init(wm8994);
412 412
413 ret = mfd_add_devices(wm8994->dev, -1, 413 ret = mfd_add_devices(wm8994->dev, -1,
414 wm8994_devs, ARRAY_SIZE(wm8994_devs), 414 wm8994_devs, ARRAY_SIZE(wm8994_devs),
415 NULL, 0); 415 NULL, 0);
416 if (ret != 0) { 416 if (ret != 0) {
417 dev_err(wm8994->dev, "Failed to add children: %d\n", ret); 417 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
418 goto err_irq; 418 goto err_irq;
419 } 419 }
420 420
421 return 0; 421 return 0;
422 422
423 err_irq: 423 err_irq:
424 wm8994_irq_exit(wm8994); 424 wm8994_irq_exit(wm8994);
425 err_enable: 425 err_enable:
426 regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies), 426 regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
427 wm8994->supplies); 427 wm8994->supplies);
428 err_get: 428 err_get:
429 regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); 429 regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies);
430 err_supplies: 430 err_supplies:
431 kfree(wm8994->supplies); 431 kfree(wm8994->supplies);
432 err: 432 err:
433 mfd_remove_devices(wm8994->dev); 433 mfd_remove_devices(wm8994->dev);
434 kfree(wm8994); 434 kfree(wm8994);
435 return ret; 435 return ret;
436 } 436 }
437 437
438 static void wm8994_device_exit(struct wm8994 *wm8994) 438 static void wm8994_device_exit(struct wm8994 *wm8994)
439 { 439 {
440 mfd_remove_devices(wm8994->dev); 440 mfd_remove_devices(wm8994->dev);
441 wm8994_irq_exit(wm8994); 441 wm8994_irq_exit(wm8994);
442 regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies), 442 regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
443 wm8994->supplies); 443 wm8994->supplies);
444 regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies); 444 regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies);
445 kfree(wm8994->supplies); 445 kfree(wm8994->supplies);
446 kfree(wm8994); 446 kfree(wm8994);
447 } 447 }
448 448
449 static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg, 449 static int wm8994_i2c_read_device(struct wm8994 *wm8994, unsigned short reg,
450 int bytes, void *dest) 450 int bytes, void *dest)
451 { 451 {
452 struct i2c_client *i2c = wm8994->control_data; 452 struct i2c_client *i2c = wm8994->control_data;
453 int ret; 453 int ret;
454 u16 r = cpu_to_be16(reg); 454 u16 r = cpu_to_be16(reg);
455 455
456 ret = i2c_master_send(i2c, (unsigned char *)&r, 2); 456 ret = i2c_master_send(i2c, (unsigned char *)&r, 2);
457 if (ret < 0) 457 if (ret < 0)
458 return ret; 458 return ret;
459 if (ret != 2) 459 if (ret != 2)
460 return -EIO; 460 return -EIO;
461 461
462 ret = i2c_master_recv(i2c, dest, bytes); 462 ret = i2c_master_recv(i2c, dest, bytes);
463 if (ret < 0) 463 if (ret < 0)
464 return ret; 464 return ret;
465 if (ret != bytes) 465 if (ret != bytes)
466 return -EIO; 466 return -EIO;
467 return 0; 467 return 0;
468 } 468 }
469 469
470 /* Currently we allocate the write buffer on the stack; this is OK for 470 /* Currently we allocate the write buffer on the stack; this is OK for
471 * small writes - if we need to do large writes this will need to be 471 * small writes - if we need to do large writes this will need to be
472 * revised. 472 * revised.
473 */ 473 */
474 static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg, 474 static int wm8994_i2c_write_device(struct wm8994 *wm8994, unsigned short reg,
475 int bytes, void *src) 475 int bytes, void *src)
476 { 476 {
477 struct i2c_client *i2c = wm8994->control_data; 477 struct i2c_client *i2c = wm8994->control_data;
478 unsigned char msg[bytes + 2]; 478 unsigned char msg[bytes + 2];
479 int ret; 479 int ret;
480 480
481 reg = cpu_to_be16(reg); 481 reg = cpu_to_be16(reg);
482 memcpy(&msg[0], &reg, 2); 482 memcpy(&msg[0], &reg, 2);
483 memcpy(&msg[2], src, bytes); 483 memcpy(&msg[2], src, bytes);
484 484
485 ret = i2c_master_send(i2c, msg, bytes + 2); 485 ret = i2c_master_send(i2c, msg, bytes + 2);
486 if (ret < 0) 486 if (ret < 0)
487 return ret; 487 return ret;
488 if (ret < bytes + 2) 488 if (ret < bytes + 2)
489 return -EIO; 489 return -EIO;
490 490
491 return 0; 491 return 0;
492 } 492 }
493 493
494 static int wm8994_i2c_probe(struct i2c_client *i2c, 494 static int wm8994_i2c_probe(struct i2c_client *i2c,
495 const struct i2c_device_id *id) 495 const struct i2c_device_id *id)
496 { 496 {
497 struct wm8994 *wm8994; 497 struct wm8994 *wm8994;
498 498
499 wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL); 499 wm8994 = kzalloc(sizeof(struct wm8994), GFP_KERNEL);
500 if (wm8994 == NULL) { 500 if (wm8994 == NULL)
501 kfree(i2c);
502 return -ENOMEM; 501 return -ENOMEM;
503 }
504 502
505 i2c_set_clientdata(i2c, wm8994); 503 i2c_set_clientdata(i2c, wm8994);
506 wm8994->dev = &i2c->dev; 504 wm8994->dev = &i2c->dev;
507 wm8994->control_data = i2c; 505 wm8994->control_data = i2c;
508 wm8994->read_dev = wm8994_i2c_read_device; 506 wm8994->read_dev = wm8994_i2c_read_device;
509 wm8994->write_dev = wm8994_i2c_write_device; 507 wm8994->write_dev = wm8994_i2c_write_device;
510 wm8994->irq = i2c->irq; 508 wm8994->irq = i2c->irq;
511 509
512 return wm8994_device_init(wm8994, id->driver_data, i2c->irq); 510 return wm8994_device_init(wm8994, id->driver_data, i2c->irq);
513 } 511 }
514 512
515 static int wm8994_i2c_remove(struct i2c_client *i2c) 513 static int wm8994_i2c_remove(struct i2c_client *i2c)
516 { 514 {
517 struct wm8994 *wm8994 = i2c_get_clientdata(i2c); 515 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
518 516
519 wm8994_device_exit(wm8994); 517 wm8994_device_exit(wm8994);
520 518
521 return 0; 519 return 0;
522 } 520 }
523 521
524 #ifdef CONFIG_PM 522 #ifdef CONFIG_PM
525 static int wm8994_i2c_suspend(struct i2c_client *i2c, pm_message_t state) 523 static int wm8994_i2c_suspend(struct i2c_client *i2c, pm_message_t state)
526 { 524 {
527 return wm8994_device_suspend(&i2c->dev); 525 return wm8994_device_suspend(&i2c->dev);
528 } 526 }
529 527
530 static int wm8994_i2c_resume(struct i2c_client *i2c) 528 static int wm8994_i2c_resume(struct i2c_client *i2c)
531 { 529 {
532 return wm8994_device_resume(&i2c->dev); 530 return wm8994_device_resume(&i2c->dev);
533 } 531 }
534 #else 532 #else
535 #define wm8994_i2c_suspend NULL 533 #define wm8994_i2c_suspend NULL
536 #define wm8994_i2c_resume NULL 534 #define wm8994_i2c_resume NULL
537 #endif 535 #endif
538 536
539 static const struct i2c_device_id wm8994_i2c_id[] = { 537 static const struct i2c_device_id wm8994_i2c_id[] = {
540 { "wm8994", 0 }, 538 { "wm8994", 0 },
541 { } 539 { }
542 }; 540 };
543 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id); 541 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
544 542
545 static struct i2c_driver wm8994_i2c_driver = { 543 static struct i2c_driver wm8994_i2c_driver = {
546 .driver = { 544 .driver = {
547 .name = "wm8994", 545 .name = "wm8994",
548 .owner = THIS_MODULE, 546 .owner = THIS_MODULE,
549 }, 547 },
550 .probe = wm8994_i2c_probe, 548 .probe = wm8994_i2c_probe,
551 .remove = wm8994_i2c_remove, 549 .remove = wm8994_i2c_remove,
552 .suspend = wm8994_i2c_suspend, 550 .suspend = wm8994_i2c_suspend,
553 .resume = wm8994_i2c_resume, 551 .resume = wm8994_i2c_resume,
554 .id_table = wm8994_i2c_id, 552 .id_table = wm8994_i2c_id,
555 }; 553 };
556 554
557 static int __init wm8994_i2c_init(void) 555 static int __init wm8994_i2c_init(void)
558 { 556 {
559 int ret; 557 int ret;
560 558
561 ret = i2c_add_driver(&wm8994_i2c_driver); 559 ret = i2c_add_driver(&wm8994_i2c_driver);
562 if (ret != 0) 560 if (ret != 0)
563 pr_err("Failed to register wm8994 I2C driver: %d\n", ret); 561 pr_err("Failed to register wm8994 I2C driver: %d\n", ret);
564 562
565 return ret; 563 return ret;
566 } 564 }
567 module_init(wm8994_i2c_init); 565 module_init(wm8994_i2c_init);
568 566
569 static void __exit wm8994_i2c_exit(void) 567 static void __exit wm8994_i2c_exit(void)
570 { 568 {
571 i2c_del_driver(&wm8994_i2c_driver); 569 i2c_del_driver(&wm8994_i2c_driver);
572 } 570 }
573 module_exit(wm8994_i2c_exit); 571 module_exit(wm8994_i2c_exit);
574 572
575 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC"); 573 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
576 MODULE_LICENSE("GPL"); 574 MODULE_LICENSE("GPL");
577 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 575 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
578 576