projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
mfd: max77686: Use NULL instead of 0
[deliverable/linux.git] / drivers / mfd / wm8994-core.c
CommitLineData
9e501086
MB		 1/*
2 * wm8994-core.c -- Device access for Wolfson WM8994
3 *
4 * Copyright 2009 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
15#include <linux/kernel.h>
16#include <linux/module.h>
5a0e3ad6 17#include <linux/slab.h>
9e501086 18#include <linux/i2c.h>
d6c645fc 19#include <linux/err.h>
9e501086
MB		 20#include <linux/delay.h>
21#include <linux/mfd/core.h>
d450f19e 22#include <linux/pm_runtime.h>
d6c645fc 23#include <linux/regmap.h>
9e501086
MB		 24#include <linux/regulator/consumer.h>
25#include <linux/regulator/machine.h>
26
27#include <linux/mfd/wm8994/core.h>
28#include <linux/mfd/wm8994/pdata.h>
29#include <linux/mfd/wm8994/registers.h>
30
c3f13861 31#include "wm8994.h"
9e501086
MB		 32
33/**
34 * wm8994_reg_read: Read a single WM8994 register.
35 *
36 * @wm8994: Device to read from.
37 * @reg: Register to read.
38 */
39int wm8994_reg_read(struct wm8994 *wm8994, unsigned short reg)
40{
d6c645fc 41 unsigned int val;
9e501086
MB		 42 int ret;
43
d6c645fc 44 ret = regmap_read(wm8994->regmap, reg, &val);
9e501086
MB		 45
46 if (ret < 0)
47 return ret;
48 else
d6c645fc 49 return val;
9e501086
MB		 50}
51EXPORT_SYMBOL_GPL(wm8994_reg_read);
52
53/**
54 * wm8994_bulk_read: Read multiple WM8994 registers
55 *
56 * @wm8994: Device to read from
57 * @reg: First register
58 * @count: Number of registers
316b6cc0 59 * @buf: Buffer to fill. The data will be returned big endian.
9e501086
MB		 60 */
61int wm8994_bulk_read(struct wm8994 *wm8994, unsigned short reg,
62 int count, u16 *buf)
63{
d6c645fc 64 return regmap_bulk_read(wm8994->regmap, reg, buf, count);
9e501086 65}
9e501086 66
9e501086
MB		 67/**
68 * wm8994_reg_write: Write a single WM8994 register.
69 *
70 * @wm8994: Device to write to.
71 * @reg: Register to write to.
72 * @val: Value to write.
73 */
74int wm8994_reg_write(struct wm8994 *wm8994, unsigned short reg,
75 unsigned short val)
76{
d6c645fc 77 return regmap_write(wm8994->regmap, reg, val);
9e501086
MB		 78}
79EXPORT_SYMBOL_GPL(wm8994_reg_write);
80
e93c5387
MB		 81/**
82 * wm8994_bulk_write: Write multiple WM8994 registers
83 *
84 * @wm8994: Device to write to
85 * @reg: First register
86 * @count: Number of registers
4277163c 87 * @buf: Buffer to write from. Data must be big-endian formatted.
e93c5387
MB		 88 */
89int wm8994_bulk_write(struct wm8994 *wm8994, unsigned short reg,
07e73fbb 90 int count, const u16 *buf)
e93c5387 91{
d6c645fc 92 return regmap_raw_write(wm8994->regmap, reg, buf, count * sizeof(u16));
e93c5387
MB		 93}
94EXPORT_SYMBOL_GPL(wm8994_bulk_write);
95
9e501086
MB		 96/**
97 * wm8994_set_bits: Set the value of a bitfield in a WM8994 register
98 *
99 * @wm8994: Device to write to.
100 * @reg: Register to write to.
101 * @mask: Mask of bits to set.
102 * @val: Value to set (unshifted)
103 */
104int wm8994_set_bits(struct wm8994 *wm8994, unsigned short reg,
105 unsigned short mask, unsigned short val)
106{
d6c645fc 107 return regmap_update_bits(wm8994->regmap, reg, mask, val);
9e501086
MB		 108}
109EXPORT_SYMBOL_GPL(wm8994_set_bits);
110
111static struct mfd_cell wm8994_regulator_devs[] = {
d450f19e
MB		 112 {
113 .name = "wm8994-ldo",
114 .id = 1,
115 .pm_runtime_no_callbacks = true,
116 },
117 {
118 .name = "wm8994-ldo",
119 .id = 2,
120 .pm_runtime_no_callbacks = true,
121 },
9e501086
MB		 122};
123
c9fbf7e0
MB		 124static struct resource wm8994_codec_resources[] = {
125 {
126 .start = WM8994_IRQ_TEMP_SHUT,
127 .end = WM8994_IRQ_TEMP_WARN,
128 .flags = IORESOURCE_IRQ,
129 },
130};
131
132static struct resource wm8994_gpio_resources[] = {
133 {
134 .start = WM8994_IRQ_GPIO(1),
135 .end = WM8994_IRQ_GPIO(11),
136 .flags = IORESOURCE_IRQ,
137 },
138};
139
9e501086 140static struct mfd_cell wm8994_devs[] = {
c9fbf7e0
MB		 141 {
142 .name = "wm8994-codec",
143 .num_resources = ARRAY_SIZE(wm8994_codec_resources),
144 .resources = wm8994_codec_resources,
145 },
146
147 {
148 .name = "wm8994-gpio",
149 .num_resources = ARRAY_SIZE(wm8994_gpio_resources),
150 .resources = wm8994_gpio_resources,
d450f19e 151 .pm_runtime_no_callbacks = true,
c9fbf7e0 152 },
9e501086
MB		 153};
154
155/*
156 * Supplies for the main bulk of CODEC; the LDO supplies are ignored
157 * and should be handled via the standard regulator API supply
158 * management.
159 */
b1f43bf3
MB		 160static const char *wm1811_main_supplies[] = {
161 "DBVDD1",
162 "DBVDD2",
163 "DBVDD3",
164 "DCVDD",
165 "AVDD1",
166 "AVDD2",
167 "CPVDD",
168 "SPKVDD1",
169 "SPKVDD2",
170};
171
9e501086
MB		 172static const char *wm8994_main_supplies[] = {
173 "DBVDD",
174 "DCVDD",
175 "AVDD1",
176 "AVDD2",
177 "CPVDD",
178 "SPKVDD1",
179 "SPKVDD2",
180};
181
559e0df6
MB		 182static const char *wm8958_main_supplies[] = {
183 "DBVDD1",
184 "DBVDD2",
185 "DBVDD3",
186 "DCVDD",
187 "AVDD1",
188 "AVDD2",
189 "CPVDD",
190 "SPKVDD1",
191 "SPKVDD2",
192};
193
9e501086 194#ifdef CONFIG_PM
d450f19e 195static int wm8994_suspend(struct device *dev)
9e501086
MB		 196{
197 struct wm8994 *wm8994 = dev_get_drvdata(dev);
198 int ret;
199
77bd70e9
MB		 200 /* Don't actually go through with the suspend if the CODEC is
201 * still active (eg, for audio passthrough from CP. */
202 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_1);
203 if (ret < 0) {
204 dev_err(dev, "Failed to read power status: %d\n", ret);
205 } else if (ret & WM8994_VMID_SEL_MASK) {
206 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
207 return 0;
208 }
209
5f40c6b6
MB		 210 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_4);
211 if (ret < 0) {
212 dev_err(dev, "Failed to read power status: %d\n", ret);
213 } else if (ret & (WM8994_AIF2ADCL_ENA | WM8994_AIF2ADCR_ENA |
214 WM8994_AIF1ADC2L_ENA | WM8994_AIF1ADC2R_ENA |
215 WM8994_AIF1ADC1L_ENA | WM8994_AIF1ADC1R_ENA)) {
216 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
217 return 0;
218 }
219
220 ret = wm8994_reg_read(wm8994, WM8994_POWER_MANAGEMENT_5);
221 if (ret < 0) {
222 dev_err(dev, "Failed to read power status: %d\n", ret);
223 } else if (ret & (WM8994_AIF2DACL_ENA | WM8994_AIF2DACR_ENA |
224 WM8994_AIF1DAC2L_ENA | WM8994_AIF1DAC2R_ENA |
225 WM8994_AIF1DAC1L_ENA | WM8994_AIF1DAC1R_ENA)) {
226 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
227 return 0;
228 }
229
230 switch (wm8994->type) {
231 case WM8958:
b5488b6e 232 case WM1811:
5f40c6b6
MB		 233 ret = wm8994_reg_read(wm8994, WM8958_MIC_DETECT_1);
234 if (ret < 0) {
235 dev_err(dev, "Failed to read power status: %d\n", ret);
236 } else if (ret & WM8958_MICD_ENA) {
237 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
238 return 0;
239 }
240 break;
241 default:
242 break;
243 }
244
e7c248a0
MB		 245 switch (wm8994->type) {
246 case WM1811:
247 ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
248 if (ret < 0) {
249 dev_err(dev, "Failed to read jackdet: %d\n", ret);
250 } else if (ret & WM1811_JACKDET_MODE_MASK) {
251 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
252 return 0;
253 }
254 break;
255 default:
256 break;
257 }
258
a3462490
MB		 259 switch (wm8994->type) {
260 case WM1811:
261 ret = wm8994_reg_read(wm8994, WM8994_ANTIPOP_2);
262 if (ret < 0) {
263 dev_err(dev, "Failed to read jackdet: %d\n", ret);
264 } else if (ret & WM1811_JACKDET_MODE_MASK) {
265 dev_dbg(dev, "CODEC still active, ignoring suspend\n");
266 return 0;
267 }
268 break;
269 default:
270 break;
271 }
272
881de670
MB		 273 /* Disable LDO pulldowns while the device is suspended if we
274 * don't know that something will be driving them. */
275 if (!wm8994->ldo_ena_always_driven)
276 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
277 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
278 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD);
279
f40dff9e
MB		 280 /* Explicitly put the device into reset in case regulators
281 * don't get disabled in order to ensure consistent restart.
282 */
be79cf2f
MB		 283 wm8994_reg_write(wm8994, WM8994_SOFTWARE_RESET,
284 wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET));
f40dff9e 285
ed393dcd
MB		 286 regcache_mark_dirty(wm8994->regmap);
287
78a27cd3
CR		 288 /* Restore GPIO registers to prevent problems with mismatched
289 * pin configurations.
290 */
ed393dcd
MB		 291 ret = regcache_sync_region(wm8994->regmap, WM8994_GPIO_1,
292 WM8994_GPIO_11);
78a27cd3
CR		 293 if (ret != 0)
294 dev_err(dev, "Failed to restore GPIO registers: %d\n", ret);
295
1a2017b7
MB		 296 /* In case one of the GPIOs is used as a wake input. */
297 ret = regcache_sync_region(wm8994->regmap,
298 WM8994_INTERRUPT_STATUS_1_MASK,
299 WM8994_INTERRUPT_STATUS_1_MASK);
300 if (ret != 0)
301 dev_err(dev, "Failed to restore interrupt mask: %d\n", ret);
302
3befc925 303 regcache_cache_only(wm8994->regmap, true);
77bd70e9
MB		 304 wm8994->suspended = true;
305
559e0df6 306 ret = regulator_bulk_disable(wm8994->num_supplies,
9e501086
MB		 307 wm8994->supplies);
308 if (ret != 0) {
309 dev_err(dev, "Failed to disable supplies: %d\n", ret);
310 return ret;
311 }
312
313 return 0;
314}
315
d450f19e 316static int wm8994_resume(struct device *dev)
9e501086
MB		 317{
318 struct wm8994 *wm8994 = dev_get_drvdata(dev);
c3f13861 319 int ret;
9e501086 320
77bd70e9
MB		 321 /* We may have lied to the PM core about suspending */
322 if (!wm8994->suspended)
323 return 0;
324
559e0df6 325 ret = regulator_bulk_enable(wm8994->num_supplies,
9e501086
MB		 326 wm8994->supplies);
327 if (ret != 0) {
328 dev_err(dev, "Failed to enable supplies: %d\n", ret);
329 return ret;
330 }
331
3befc925 332 regcache_cache_only(wm8994->regmap, false);
c3f13861
MB		 333 ret = regcache_sync(wm8994->regmap);
334 if (ret != 0) {
335 dev_err(dev, "Failed to restore register map: %d\n", ret);
336 goto err_enable;
98ae1cca 337 }
c9fbf7e0 338
881de670
MB		 339 /* Disable LDO pulldowns while the device is active */
340 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
341 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD,
342 0);
343
77bd70e9
MB		 344 wm8994->suspended = false;
345
9e501086 346 return 0;
c3f13861
MB		 347
348err_enable:
349 regulator_bulk_disable(wm8994->num_supplies, wm8994->supplies);
350
351 return ret;
9e501086
MB		 352}
353#endif
354
355#ifdef CONFIG_REGULATOR
356static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
357{
358 struct wm8994_ldo_pdata *ldo_pdata;
359
360 if (!pdata)
361 return 0;
362
363 ldo_pdata = &pdata->ldo[ldo];
364
365 if (!ldo_pdata->init_data)
366 return 0;
367
368 return ldo_pdata->init_data->num_consumer_supplies != 0;
369}
370#else
371static int wm8994_ldo_in_use(struct wm8994_pdata *pdata, int ldo)
372{
373 return 0;
374}
375#endif
376
a73e5df1 377static const struct reg_default wm8994_revc_patch[] = {
462835e4
MB		 378 { 0x102, 0x3 },
379 { 0x56, 0x3 },
380 { 0x817, 0x0 },
381 { 0x102, 0x0 },
382};
383
a73e5df1 384static const struct reg_default wm8958_reva_patch[] = {
462835e4
MB		 385 { 0x102, 0x3 },
386 { 0xcb, 0x81 },
387 { 0x817, 0x0 },
388 { 0x102, 0x0 },
389};
390
a73e5df1 391static const struct reg_default wm1811_reva_patch[] = {
462835e4 392 { 0x102, 0x3 },
9282a7b9 393 { 0x56, 0xc07 },
462835e4
MB		 394 { 0x5d, 0x7e },
395 { 0x5e, 0x0 },
396 { 0x102, 0x0 },
397};
398
9e501086
MB		 399/*
400 * Instantiate the generic non-control parts of the device.
401 */
f791be49 402static int wm8994_device_init(struct wm8994 *wm8994, int irq)
9e501086 403{
a8a8fc28 404 struct wm8994_pdata *pdata;
34697898 405 struct regmap_config *regmap_config;
462835e4 406 const struct reg_default *regmap_patch = NULL;
559e0df6 407 const char *devname;
462835e4 408 int ret, i, patch_regs;
26c34c25 409 int pulls = 0;
9e501086 410
a8a8fc28
MB		 411 if (dev_get_platdata(wm8994->dev)) {
412 pdata = dev_get_platdata(wm8994->dev);
413 wm8994->pdata = *pdata;
414 }
415 pdata = &wm8994->pdata;
416
9e501086
MB		 417 dev_set_drvdata(wm8994->dev, wm8994);
418
419 /* Add the on-chip regulators first for bootstrapping */
420 ret = mfd_add_devices(wm8994->dev, -1,
421 wm8994_regulator_devs,
422 ARRAY_SIZE(wm8994_regulator_devs),
55692af5 423 NULL, 0, NULL);
9e501086
MB		 424 if (ret != 0) {
425 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
9db4249f 426 goto err;
9e501086
MB		 427 }
428
559e0df6 429 switch (wm8994->type) {
b1f43bf3
MB		 430 case WM1811:
431 wm8994->num_supplies = ARRAY_SIZE(wm1811_main_supplies);
432 break;
559e0df6
MB		 433 case WM8994:
434 wm8994->num_supplies = ARRAY_SIZE(wm8994_main_supplies);
435 break;
436 case WM8958:
437 wm8994->num_supplies = ARRAY_SIZE(wm8958_main_supplies);
438 break;
439 default:
440 BUG();
9db4249f 441 goto err;
559e0df6
MB		 442 }
443
2fa33494
MB		 444 wm8994->supplies = devm_kzalloc(wm8994->dev,
445 sizeof(struct regulator_bulk_data) *
446 wm8994->num_supplies, GFP_KERNEL);
fccbd21f
AL		 447 if (!wm8994->supplies) {
448 ret = -ENOMEM;
9db4249f 449 goto err;
fccbd21f 450 }
9e501086 451
559e0df6 452 switch (wm8994->type) {
b1f43bf3
MB		 453 case WM1811:
454 for (i = 0; i < ARRAY_SIZE(wm1811_main_supplies); i++)
455 wm8994->supplies[i].supply = wm1811_main_supplies[i];
456 break;
559e0df6
MB		 457 case WM8994:
458 for (i = 0; i < ARRAY_SIZE(wm8994_main_supplies); i++)
459 wm8994->supplies[i].supply = wm8994_main_supplies[i];
460 break;
461 case WM8958:
462 for (i = 0; i < ARRAY_SIZE(wm8958_main_supplies); i++)
463 wm8994->supplies[i].supply = wm8958_main_supplies[i];
464 break;
465 default:
466 BUG();
9db4249f 467 goto err;
559e0df6
MB		 468 }
469
f1c68e4d 470 ret = devm_regulator_bulk_get(wm8994->dev, wm8994->num_supplies,
9e501086
MB		 471 wm8994->supplies);
472 if (ret != 0) {
473 dev_err(wm8994->dev, "Failed to get supplies: %d\n", ret);
9db4249f 474 goto err;
9e501086
MB		 475 }
476
559e0df6 477 ret = regulator_bulk_enable(wm8994->num_supplies,
9e501086
MB		 478 wm8994->supplies);
479 if (ret != 0) {
480 dev_err(wm8994->dev, "Failed to enable supplies: %d\n", ret);
f1c68e4d 481 goto err;
9e501086
MB		 482 }
483
484 ret = wm8994_reg_read(wm8994, WM8994_SOFTWARE_RESET);
485 if (ret < 0) {
486 dev_err(wm8994->dev, "Failed to read ID register\n");
487 goto err_enable;
488 }
559e0df6 489 switch (ret) {
b1f43bf3
MB		 490 case 0x1811:
491 devname = "WM1811";
492 if (wm8994->type != WM1811)
493 dev_warn(wm8994->dev, "Device registered as type %d\n",
494 wm8994->type);
495 wm8994->type = WM1811;
496 break;
559e0df6
MB		 497 case 0x8994:
498 devname = "WM8994";
499 if (wm8994->type != WM8994)
500 dev_warn(wm8994->dev, "Device registered as type %d\n",
501 wm8994->type);
502 wm8994->type = WM8994;
503 break;
504 case 0x8958:
505 devname = "WM8958";
506 if (wm8994->type != WM8958)
507 dev_warn(wm8994->dev, "Device registered as type %d\n",
508 wm8994->type);
509 wm8994->type = WM8958;
510 break;
511 default:
9e501086
MB		 512 dev_err(wm8994->dev, "Device is not a WM8994, ID is %x\n",
513 ret);
514 ret = -EINVAL;
515 goto err_enable;
516 }
517
518 ret = wm8994_reg_read(wm8994, WM8994_CHIP_REVISION);
519 if (ret < 0) {
520 dev_err(wm8994->dev, "Failed to read revision register: %d\n",
521 ret);
522 goto err_enable;
523 }
cc7a7279
MB		 524 wm8994->revision = ret & WM8994_CHIP_REV_MASK;
525 wm8994->cust_id = (ret & WM8994_CUST_ID_MASK) >> WM8994_CUST_ID_SHIFT;
9e501086 526
a2495bc7
MB		 527 switch (wm8994->type) {
528 case WM8994:
7ed5849c 529 switch (wm8994->revision) {
a2495bc7
MB		 530 case 0:
531 case 1:
559e0df6
MB		 532 dev_warn(wm8994->dev,
533 "revision %c not fully supported\n",
7ed5849c 534 'A' + wm8994->revision);
a2495bc7 535 break;
462835e4
MB		 536 case 2:
537 case 3:
d54e17f9 538 default:
462835e4
MB		 539 regmap_patch = wm8994_revc_patch;
540 patch_regs = ARRAY_SIZE(wm8994_revc_patch);
541 break;
462835e4
MB		 542 }
543 break;
544
545 case WM8958:
546 switch (wm8994->revision) {
547 case 0:
548 regmap_patch = wm8958_reva_patch;
549 patch_regs = ARRAY_SIZE(wm8958_reva_patch);
550 break;
a2495bc7
MB		 551 default:
552 break;
553 }
9e501086 554 break;
462835e4 555
443e67ed
MB		 556 case WM1811:
557 /* Revision C did not change the relevant layer */
7ed5849c
MB		 558 if (wm8994->revision > 1)
559 wm8994->revision++;
d54e17f9
MB		 560
561 regmap_patch = wm1811_reva_patch;
562 patch_regs = ARRAY_SIZE(wm1811_reva_patch);
443e67ed 563 break;
462835e4 564
9e501086 565 default:
9e501086
MB		 566 break;
567 }
568
cc7a7279
MB		 569 dev_info(wm8994->dev, "%s revision %c CUST_ID %02x\n", devname,
570 'A' + wm8994->revision, wm8994->cust_id);
9e501086 571
34697898
MB		 572 switch (wm8994->type) {
573 case WM1811:
574 regmap_config = &wm1811_regmap_config;
575 break;
576 case WM8994:
577 regmap_config = &wm8994_regmap_config;
578 break;
579 case WM8958:
580 regmap_config = &wm8958_regmap_config;
581 break;
582 default:
583 dev_err(wm8994->dev, "Unknown device type %d\n", wm8994->type);
584 return -EINVAL;
585 }
586
587 ret = regmap_reinit_cache(wm8994->regmap, regmap_config);
588 if (ret != 0) {
589 dev_err(wm8994->dev, "Failed to reinit register cache: %d\n",
590 ret);
591 return ret;
592 }
9e501086 593
462835e4
MB		 594 if (regmap_patch) {
595 ret = regmap_register_patch(wm8994->regmap, regmap_patch,
596 patch_regs);
597 if (ret != 0) {
598 dev_err(wm8994->dev, "Failed to register patch: %d\n",
599 ret);
9db4249f 600 goto err;
462835e4
MB		 601 }
602 }
603
a8a8fc28
MB		 604 wm8994->irq_base = pdata->irq_base;
605 wm8994->gpio_base = pdata->gpio_base;
606
607 /* GPIO configuration is only applied if it's non-zero */
608 for (i = 0; i < ARRAY_SIZE(pdata->gpio_defaults); i++) {
609 if (pdata->gpio_defaults[i]) {
610 wm8994_set_bits(wm8994, WM8994_GPIO_1 + i,
611 0xffff, pdata->gpio_defaults[i]);
9e501086 612 }
a8a8fc28 613 }
881de670 614
a8a8fc28 615 wm8994->ldo_ena_always_driven = pdata->ldo_ena_always_driven;
26c34c25 616
a8a8fc28
MB		 617 if (pdata->spkmode_pu)
618 pulls |= WM8994_SPKMODE_PU;
9e501086 619
26c34c25 620 /* Disable unneeded pulls */
881de670 621 wm8994_set_bits(wm8994, WM8994_PULL_CONTROL_2,
26c34c25
MB		 622 WM8994_LDO1ENA_PD | WM8994_LDO2ENA_PD |
623 WM8994_SPKMODE_PU | WM8994_CSNADDR_PD,
624 pulls);
881de670 625
9e501086
MB		 626 /* In some system designs where the regulators are not in use,
627 * we can achieve a small reduction in leakage currents by
628 * floating LDO outputs. This bit makes no difference if the
629 * LDOs are enabled, it only affects cases where the LDOs were
630 * in operation and are then disabled.
631 */
632 for (i = 0; i < WM8994_NUM_LDO_REGS; i++) {
633 if (wm8994_ldo_in_use(pdata, i))
634 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
635 WM8994_LDO1_DISCH, WM8994_LDO1_DISCH);
636 else
637 wm8994_set_bits(wm8994, WM8994_LDO_1 + i,
638 WM8994_LDO1_DISCH, 0);
639 }
640
c9fbf7e0
MB		 641 wm8994_irq_init(wm8994);
642
9e501086
MB		 643 ret = mfd_add_devices(wm8994->dev, -1,
644 wm8994_devs, ARRAY_SIZE(wm8994_devs),
55692af5 645 NULL, 0, NULL);
9e501086
MB		 646 if (ret != 0) {
647 dev_err(wm8994->dev, "Failed to add children: %d\n", ret);
c9fbf7e0 648 goto err_irq;
9e501086
MB		 649 }
650
d450f19e 651 pm_runtime_enable(wm8994->dev);
ee67b0cd 652 pm_runtime_idle(wm8994->dev);
d450f19e 653
9e501086
MB		 654 return 0;
655
c9fbf7e0
MB		 656err_irq:
657 wm8994_irq_exit(wm8994);
9e501086 658err_enable:
559e0df6 659 regulator_bulk_disable(wm8994->num_supplies,
9e501086 660 wm8994->supplies);
9db4249f 661err:
9e501086 662 mfd_remove_devices(wm8994->dev);
9e501086
MB		 663 return ret;
664}
665
4740f73f 666static void wm8994_device_exit(struct wm8994 *wm8994)
9e501086 667{
d450f19e 668 pm_runtime_disable(wm8994->dev);
9e501086 669 mfd_remove_devices(wm8994->dev);
c9fbf7e0 670 wm8994_irq_exit(wm8994);
559e0df6 671 regulator_bulk_disable(wm8994->num_supplies,
9e501086 672 wm8994->supplies);
9e501086
MB		 673}
674
cf763c2e
MB		 675static const struct of_device_id wm8994_of_match[] = {
676 { .compatible = "wlf,wm1811", },
677 { .compatible = "wlf,wm8994", },
678 { .compatible = "wlf,wm8958", },
679 { }
680};
681MODULE_DEVICE_TABLE(of, wm8994_of_match);
682
f791be49 683static int wm8994_i2c_probe(struct i2c_client *i2c,
027d6766 684 const struct i2c_device_id *id)
9e501086
MB		 685{
686 struct wm8994 *wm8994;
d6c645fc 687 int ret;
9e501086 688
2fa33494 689 wm8994 = devm_kzalloc(&i2c->dev, sizeof(struct wm8994), GFP_KERNEL);
d0a11693 690 if (wm8994 == NULL)
9e501086 691 return -ENOMEM;
9e501086
MB		 692
693 i2c_set_clientdata(i2c, wm8994);
694 wm8994->dev = &i2c->dev;
c9fbf7e0 695 wm8994->irq = i2c->irq;
559e0df6 696 wm8994->type = id->driver_data;
9e501086 697
9db4249f 698 wm8994->regmap = devm_regmap_init_i2c(i2c, &wm8994_base_regmap_config);
d6c645fc
MB		 699 if (IS_ERR(wm8994->regmap)) {
700 ret = PTR_ERR(wm8994->regmap);
701 dev_err(wm8994->dev, "Failed to allocate register map: %d\n",
702 ret);
d6c645fc
MB		 703 return ret;
704 }
705
559e0df6 706 return wm8994_device_init(wm8994, i2c->irq);
9e501086
MB		 707}
708
4740f73f 709static int wm8994_i2c_remove(struct i2c_client *i2c)
9e501086
MB		 710{
711 struct wm8994 *wm8994 = i2c_get_clientdata(i2c);
712
713 wm8994_device_exit(wm8994);
714
715 return 0;
716}
717
9e501086 718static const struct i2c_device_id wm8994_i2c_id[] = {
b1f43bf3 719 { "wm1811", WM1811 },
71d17184 720 { "wm1811a", WM1811 },
559e0df6
MB		 721 { "wm8994", WM8994 },
722 { "wm8958", WM8958 },
9e501086
MB		 723 { }
724};
725MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
726
aad34310
MB		 727static UNIVERSAL_DEV_PM_OPS(wm8994_pm_ops, wm8994_suspend, wm8994_resume,
728 NULL);
d450f19e 729
9e501086
MB		 730static struct i2c_driver wm8994_i2c_driver = {
731 .driver = {
d450f19e
MB		 732 .name = "wm8994",
733 .owner = THIS_MODULE,
734 .pm = &wm8994_pm_ops,
cf763c2e 735 .of_match_table = wm8994_of_match,
9e501086
MB		 736 },
737 .probe = wm8994_i2c_probe,
84449216 738 .remove = wm8994_i2c_remove,
9e501086
MB		 739 .id_table = wm8994_i2c_id,
740};
741
ceb57d27 742module_i2c_driver(wm8994_i2c_driver);
9e501086
MB		 743
744MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
745MODULE_LICENSE("GPL");
746MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
Linux kernel - Deliverables
This page took 0.232948 seconds and 5 git commands to generate.