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