?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / drivers / mfd / wm8994-core.c
blobb3b2aaf89dbee70e8855c9b3124e7f04fd0aee9a
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>
17 #include <linux/slab.h>
18 #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
28 static 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 */
57 int 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 }
73 EXPORT_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 */
83 int 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 }
96 EXPORT_SYMBOL_GPL(wm8994_bulk_read);
97
98 static 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 */
124 int 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 }
137 EXPORT_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 */
147 int 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
164 out:
165 mutex_unlock(&wm8994->io_lock);
166
167 return ret;
168 }
169 EXPORT_SYMBOL_GPL(wm8994_set_bits);
170
171 static struct mfd_cell wm8994_regulator_devs[] = {
172 { .name = "wm8994-ldo", .id = 1 },
173 { .name = "wm8994-ldo", .id = 2 },
174 };
175
176 static 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
184 static 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
192 static struct mfd_cell wm8994_devs[] = {
193 {
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 },
204 };
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 */
211 static 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
222 static 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
252 static 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
264 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
269 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
284 static 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
299 static 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 */
308 static 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);
329 if (!wm8994->supplies) {
330 ret = -ENOMEM;
331 goto err;
332 }
333
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);
341 goto err_supplies;
342 }
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);
348 goto err_get;
349 }
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) {
383 wm8994->irq_base = pdata->irq_base;
384 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
411 wm8994_irq_init(wm8994);
412
413 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);
418 goto err_irq;
419 }
420
421 return 0;
422
423 err_irq:
424 wm8994_irq_exit(wm8994);
425 err_enable:
426 regulator_bulk_disable(ARRAY_SIZE(wm8994_main_supplies),
427 wm8994->supplies);
428 err_get:
429 regulator_bulk_free(ARRAY_SIZE(wm8994_main_supplies), wm8994->supplies);
430 err_supplies:
431 kfree(wm8994->supplies);
432 err:
433 mfd_remove_devices(wm8994->dev);
434 kfree(wm8994);
435 return ret;
436 }
437
438 static void wm8994_device_exit(struct wm8994 *wm8994)
439 {
440 mfd_remove_devices(wm8994->dev);
441 wm8994_irq_exit(wm8994);
442 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
449 static 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 */
474 static 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
494 static 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);
500 if (wm8994 == NULL)
501 return -ENOMEM;
502
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;
508 wm8994->irq = i2c->irq;
509
510 return wm8994_device_init(wm8994, id->driver_data, i2c->irq);
511 }
512
513 static 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
523 static int wm8994_i2c_suspend(struct i2c_client *i2c, pm_message_t state)
524 {
525 return wm8994_device_suspend(&i2c->dev);
526 }
527
528 static 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
537 static const struct i2c_device_id wm8994_i2c_id[] = {
538 { "wm8994", 0 },
539 { }
540 };
541 MODULE_DEVICE_TABLE(i2c, wm8994_i2c_id);
542
543 static 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
555 static 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 }
565 module_init(wm8994_i2c_init);
566
567 static void __exit wm8994_i2c_exit(void)
568 {
569 i2c_del_driver(&wm8994_i2c_driver);
570 }
571 module_exit(wm8994_i2c_exit);
572
573 MODULE_DESCRIPTION("Core support for the WM8994 audio CODEC");
574 MODULE_LICENSE("GPL");
575 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
Tomato firmware and modifications.