tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * MFD driver for TWL6040 audio device
3 *
4 * Authors: Misael Lopez Cruz <misael.lopez@ti.com>
5 * Jorge Eduardo Candelaria <jorge.candelaria@ti.com>
6 * Peter Ujfalusi <peter.ujfalusi@ti.com>
7 *
8 * Copyright: (C) 2011 Texas Instruments, Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22 * 02110-1301 USA
23 *
24 */
25
26#include <linux/module.h>
27#include <linux/types.h>
28#include <linux/slab.h>
29#include <linux/kernel.h>
30#include <linux/err.h>
31#include <linux/platform_device.h>
32#include <linux/of.h>
33#include <linux/of_irq.h>
34#include <linux/of_gpio.h>
35#include <linux/of_platform.h>
36#include <linux/gpio.h>
37#include <linux/delay.h>
38#include <linux/i2c.h>
39#include <linux/regmap.h>
40#include <linux/err.h>
41#include <linux/mfd/core.h>
42#include <linux/mfd/twl6040.h>
43#include <linux/regulator/consumer.h>
44
45#define VIBRACTRL_MEMBER(reg) ((reg == TWL6040_REG_VIBCTLL) ? 0 : 1)
46#define TWL6040_NUM_SUPPLIES (2)
47
48static bool twl6040_has_vibra(struct twl6040_platform_data *pdata,
49 struct device_node *node)
50{
51 if (pdata && pdata->vibra)
52 return true;
53
54#ifdef CONFIG_OF
55 if (of_find_node_by_name(node, "vibra"))
56 return true;
57#endif
58
59 return false;
60}
61
62int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg)
63{
64 int ret;
65 unsigned int val;
66
67 mutex_lock(&twl6040->io_mutex);
68 /* Vibra control registers from cache */
69 if (unlikely(reg == TWL6040_REG_VIBCTLL ||
70 reg == TWL6040_REG_VIBCTLR)) {
71 val = twl6040->vibra_ctrl_cache[VIBRACTRL_MEMBER(reg)];
72 } else {
73 ret = regmap_read(twl6040->regmap, reg, &val);
74 if (ret < 0) {
75 mutex_unlock(&twl6040->io_mutex);
76 return ret;
77 }
78 }
79 mutex_unlock(&twl6040->io_mutex);
80
81 return val;
82}
83EXPORT_SYMBOL(twl6040_reg_read);
84
85int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg, u8 val)
86{
87 int ret;
88
89 mutex_lock(&twl6040->io_mutex);
90 ret = regmap_write(twl6040->regmap, reg, val);
91 /* Cache the vibra control registers */
92 if (reg == TWL6040_REG_VIBCTLL || reg == TWL6040_REG_VIBCTLR)
93 twl6040->vibra_ctrl_cache[VIBRACTRL_MEMBER(reg)] = val;
94 mutex_unlock(&twl6040->io_mutex);
95
96 return ret;
97}
98EXPORT_SYMBOL(twl6040_reg_write);
99
100int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
101{
102 int ret;
103
104 mutex_lock(&twl6040->io_mutex);
105 ret = regmap_update_bits(twl6040->regmap, reg, mask, mask);
106 mutex_unlock(&twl6040->io_mutex);
107 return ret;
108}
109EXPORT_SYMBOL(twl6040_set_bits);
110
111int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
112{
113 int ret;
114
115 mutex_lock(&twl6040->io_mutex);
116 ret = regmap_update_bits(twl6040->regmap, reg, mask, 0);
117 mutex_unlock(&twl6040->io_mutex);
118 return ret;
119}
120EXPORT_SYMBOL(twl6040_clear_bits);
121
122/* twl6040 codec manual power-up sequence */
123static int twl6040_power_up(struct twl6040 *twl6040)
124{
125 u8 ldoctl, ncpctl, lppllctl;
126 int ret;
127
128 /* enable high-side LDO, reference system and internal oscillator */
129 ldoctl = TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA;
130 ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
131 if (ret)
132 return ret;
133 usleep_range(10000, 10500);
134
135 /* enable negative charge pump */
136 ncpctl = TWL6040_NCPENA;
137 ret = twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
138 if (ret)
139 goto ncp_err;
140 usleep_range(1000, 1500);
141
142 /* enable low-side LDO */
143 ldoctl |= TWL6040_LSLDOENA;
144 ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
145 if (ret)
146 goto lsldo_err;
147 usleep_range(1000, 1500);
148
149 /* enable low-power PLL */
150 lppllctl = TWL6040_LPLLENA;
151 ret = twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
152 if (ret)
153 goto lppll_err;
154 usleep_range(5000, 5500);
155
156 /* disable internal oscillator */
157 ldoctl &= ~TWL6040_OSCENA;
158 ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
159 if (ret)
160 goto osc_err;
161
162 return 0;
163
164osc_err:
165 lppllctl &= ~TWL6040_LPLLENA;
166 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
167lppll_err:
168 ldoctl &= ~TWL6040_LSLDOENA;
169 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
170lsldo_err:
171 ncpctl &= ~TWL6040_NCPENA;
172 twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
173ncp_err:
174 ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
175 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
176
177 return ret;
178}
179
180/* twl6040 manual power-down sequence */
181static void twl6040_power_down(struct twl6040 *twl6040)
182{
183 u8 ncpctl, ldoctl, lppllctl;
184
185 ncpctl = twl6040_reg_read(twl6040, TWL6040_REG_NCPCTL);
186 ldoctl = twl6040_reg_read(twl6040, TWL6040_REG_LDOCTL);
187 lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
188
189 /* enable internal oscillator */
190 ldoctl |= TWL6040_OSCENA;
191 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
192 usleep_range(1000, 1500);
193
194 /* disable low-power PLL */
195 lppllctl &= ~TWL6040_LPLLENA;
196 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
197
198 /* disable low-side LDO */
199 ldoctl &= ~TWL6040_LSLDOENA;
200 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
201
202 /* disable negative charge pump */
203 ncpctl &= ~TWL6040_NCPENA;
204 twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
205
206 /* disable high-side LDO, reference system and internal oscillator */
207 ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
208 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
209}
210
211static irqreturn_t twl6040_naudint_handler(int irq, void *data)
212{
213 struct twl6040 *twl6040 = data;
214 u8 intid, status;
215
216 intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
217
218 if (intid & TWL6040_READYINT)
219 complete(&twl6040->ready);
220
221 if (intid & TWL6040_THINT) {
222 status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS);
223 if (status & TWL6040_TSHUTDET) {
224 dev_warn(twl6040->dev,
225 "Thermal shutdown, powering-off");
226 twl6040_power(twl6040, 0);
227 } else {
228 dev_warn(twl6040->dev,
229 "Leaving thermal shutdown, powering-on");
230 twl6040_power(twl6040, 1);
231 }
232 }
233
234 return IRQ_HANDLED;
235}
236
237static int twl6040_power_up_completion(struct twl6040 *twl6040,
238 int naudint)
239{
240 int time_left;
241 u8 intid;
242
243 time_left = wait_for_completion_timeout(&twl6040->ready,
244 msecs_to_jiffies(144));
245 if (!time_left) {
246 intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
247 if (!(intid & TWL6040_READYINT)) {
248 dev_err(twl6040->dev,
249 "timeout waiting for READYINT\n");
250 return -ETIMEDOUT;
251 }
252 }
253
254 return 0;
255}
256
257int twl6040_power(struct twl6040 *twl6040, int on)
258{
259 int audpwron = twl6040->audpwron;
260 int naudint = twl6040->irq;
261 int ret = 0;
262
263 mutex_lock(&twl6040->mutex);
264
265 if (on) {
266 /* already powered-up */
267 if (twl6040->power_count++)
268 goto out;
269
270 if (gpio_is_valid(audpwron)) {
271 /* use AUDPWRON line */
272 gpio_set_value(audpwron, 1);
273 /* wait for power-up completion */
274 ret = twl6040_power_up_completion(twl6040, naudint);
275 if (ret) {
276 dev_err(twl6040->dev,
277 "automatic power-down failed\n");
278 twl6040->power_count = 0;
279 goto out;
280 }
281 } else {
282 /* use manual power-up sequence */
283 ret = twl6040_power_up(twl6040);
284 if (ret) {
285 dev_err(twl6040->dev,
286 "manual power-up failed\n");
287 twl6040->power_count = 0;
288 goto out;
289 }
290 }
291 /* Default PLL configuration after power up */
292 twl6040->pll = TWL6040_SYSCLK_SEL_LPPLL;
293 twl6040->sysclk = 19200000;
294 twl6040->mclk = 32768;
295 } else {
296 /* already powered-down */
297 if (!twl6040->power_count) {
298 dev_err(twl6040->dev,
299 "device is already powered-off\n");
300 ret = -EPERM;
301 goto out;
302 }
303
304 if (--twl6040->power_count)
305 goto out;
306
307 if (gpio_is_valid(audpwron)) {
308 /* use AUDPWRON line */
309 gpio_set_value(audpwron, 0);
310
311 /* power-down sequence latency */
312 usleep_range(500, 700);
313 } else {
314 /* use manual power-down sequence */
315 twl6040_power_down(twl6040);
316 }
317 twl6040->sysclk = 0;
318 twl6040->mclk = 0;
319 }
320
321out:
322 mutex_unlock(&twl6040->mutex);
323 return ret;
324}
325EXPORT_SYMBOL(twl6040_power);
326
327int twl6040_set_pll(struct twl6040 *twl6040, int pll_id,
328 unsigned int freq_in, unsigned int freq_out)
329{
330 u8 hppllctl, lppllctl;
331 int ret = 0;
332
333 mutex_lock(&twl6040->mutex);
334
335 hppllctl = twl6040_reg_read(twl6040, TWL6040_REG_HPPLLCTL);
336 lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
337
338 /* Force full reconfiguration when switching between PLL */
339 if (pll_id != twl6040->pll) {
340 twl6040->sysclk = 0;
341 twl6040->mclk = 0;
342 }
343
344 switch (pll_id) {
345 case TWL6040_SYSCLK_SEL_LPPLL:
346 /* low-power PLL divider */
347 /* Change the sysclk configuration only if it has been canged */
348 if (twl6040->sysclk != freq_out) {
349 switch (freq_out) {
350 case 17640000:
351 lppllctl |= TWL6040_LPLLFIN;
352 break;
353 case 19200000:
354 lppllctl &= ~TWL6040_LPLLFIN;
355 break;
356 default:
357 dev_err(twl6040->dev,
358 "freq_out %d not supported\n",
359 freq_out);
360 ret = -EINVAL;
361 goto pll_out;
362 }
363 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
364 lppllctl);
365 }
366
367 /* The PLL in use has not been change, we can exit */
368 if (twl6040->pll == pll_id)
369 break;
370
371 switch (freq_in) {
372 case 32768:
373 lppllctl |= TWL6040_LPLLENA;
374 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
375 lppllctl);
376 mdelay(5);
377 lppllctl &= ~TWL6040_HPLLSEL;
378 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
379 lppllctl);
380 hppllctl &= ~TWL6040_HPLLENA;
381 twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
382 hppllctl);
383 break;
384 default:
385 dev_err(twl6040->dev,
386 "freq_in %d not supported\n", freq_in);
387 ret = -EINVAL;
388 goto pll_out;
389 }
390 break;
391 case TWL6040_SYSCLK_SEL_HPPLL:
392 /* high-performance PLL can provide only 19.2 MHz */
393 if (freq_out != 19200000) {
394 dev_err(twl6040->dev,
395 "freq_out %d not supported\n", freq_out);
396 ret = -EINVAL;
397 goto pll_out;
398 }
399
400 if (twl6040->mclk != freq_in) {
401 hppllctl &= ~TWL6040_MCLK_MSK;
402
403 switch (freq_in) {
404 case 12000000:
405 /* PLL enabled, active mode */
406 hppllctl |= TWL6040_MCLK_12000KHZ |
407 TWL6040_HPLLENA;
408 break;
409 case 19200000:
410 /*
411 * PLL disabled
412 * (enable PLL if MCLK jitter quality
413 * doesn't meet specification)
414 */
415 hppllctl |= TWL6040_MCLK_19200KHZ;
416 break;
417 case 26000000:
418 /* PLL enabled, active mode */
419 hppllctl |= TWL6040_MCLK_26000KHZ |
420 TWL6040_HPLLENA;
421 break;
422 case 38400000:
423 /* PLL enabled, active mode */
424 hppllctl |= TWL6040_MCLK_38400KHZ |
425 TWL6040_HPLLENA;
426 break;
427 default:
428 dev_err(twl6040->dev,
429 "freq_in %d not supported\n", freq_in);
430 ret = -EINVAL;
431 goto pll_out;
432 }
433
434 /*
435 * enable clock slicer to ensure input waveform is
436 * square
437 */
438 hppllctl |= TWL6040_HPLLSQRENA;
439
440 twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
441 hppllctl);
442 usleep_range(500, 700);
443 lppllctl |= TWL6040_HPLLSEL;
444 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
445 lppllctl);
446 lppllctl &= ~TWL6040_LPLLENA;
447 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
448 lppllctl);
449 }
450 break;
451 default:
452 dev_err(twl6040->dev, "unknown pll id %d\n", pll_id);
453 ret = -EINVAL;
454 goto pll_out;
455 }
456
457 twl6040->sysclk = freq_out;
458 twl6040->mclk = freq_in;
459 twl6040->pll = pll_id;
460
461pll_out:
462 mutex_unlock(&twl6040->mutex);
463 return ret;
464}
465EXPORT_SYMBOL(twl6040_set_pll);
466
467int twl6040_get_pll(struct twl6040 *twl6040)
468{
469 if (twl6040->power_count)
470 return twl6040->pll;
471 else
472 return -ENODEV;
473}
474EXPORT_SYMBOL(twl6040_get_pll);
475
476unsigned int twl6040_get_sysclk(struct twl6040 *twl6040)
477{
478 return twl6040->sysclk;
479}
480EXPORT_SYMBOL(twl6040_get_sysclk);
481
482/* Get the combined status of the vibra control register */
483int twl6040_get_vibralr_status(struct twl6040 *twl6040)
484{
485 u8 status;
486
487 status = twl6040->vibra_ctrl_cache[0] | twl6040->vibra_ctrl_cache[1];
488 status &= (TWL6040_VIBENA | TWL6040_VIBSEL);
489
490 return status;
491}
492EXPORT_SYMBOL(twl6040_get_vibralr_status);
493
494static struct resource twl6040_vibra_rsrc[] = {
495 {
496 .flags = IORESOURCE_IRQ,
497 },
498};
499
500static struct resource twl6040_codec_rsrc[] = {
501 {
502 .flags = IORESOURCE_IRQ,
503 },
504};
505
506static bool twl6040_readable_reg(struct device *dev, unsigned int reg)
507{
508 /* Register 0 is not readable */
509 if (!reg)
510 return false;
511 return true;
512}
513
514static struct regmap_config twl6040_regmap_config = {
515 .reg_bits = 8,
516 .val_bits = 8,
517 .max_register = TWL6040_REG_STATUS, /* 0x2e */
518
519 .readable_reg = twl6040_readable_reg,
520};
521
522static int __devinit twl6040_probe(struct i2c_client *client,
523 const struct i2c_device_id *id)
524{
525 struct twl6040_platform_data *pdata = client->dev.platform_data;
526 struct device_node *node = client->dev.of_node;
527 struct twl6040 *twl6040;
528 struct mfd_cell *cell = NULL;
529 int irq, ret, children = 0;
530
531 if (!pdata && !node) {
532 dev_err(&client->dev, "Platform data is missing\n");
533 return -EINVAL;
534 }
535
536 /* In order to operate correctly we need valid interrupt config */
537 if (!client->irq) {
538 dev_err(&client->dev, "Invalid IRQ configuration\n");
539 return -EINVAL;
540 }
541
542 twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040),
543 GFP_KERNEL);
544 if (!twl6040) {
545 ret = -ENOMEM;
546 goto err;
547 }
548
549 twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config);
550 if (IS_ERR(twl6040->regmap)) {
551 ret = PTR_ERR(twl6040->regmap);
552 goto err;
553 }
554
555 i2c_set_clientdata(client, twl6040);
556
557 twl6040->supplies[0].supply = "vio";
558 twl6040->supplies[1].supply = "v2v1";
559 ret = regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES,
560 twl6040->supplies);
561 if (ret != 0) {
562 dev_err(&client->dev, "Failed to get supplies: %d\n", ret);
563 goto regulator_get_err;
564 }
565
566 ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
567 if (ret != 0) {
568 dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
569 goto power_err;
570 }
571
572 twl6040->dev = &client->dev;
573 twl6040->irq = client->irq;
574
575 mutex_init(&twl6040->mutex);
576 mutex_init(&twl6040->io_mutex);
577 init_completion(&twl6040->ready);
578
579 twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV);
580
581 /* ERRATA: Automatic power-up is not possible in ES1.0 */
582 if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0) {
583 if (pdata)
584 twl6040->audpwron = pdata->audpwron_gpio;
585 else
586 twl6040->audpwron = of_get_named_gpio(node,
587 "ti,audpwron-gpio", 0);
588 } else
589 twl6040->audpwron = -EINVAL;
590
591 if (gpio_is_valid(twl6040->audpwron)) {
592 ret = gpio_request_one(twl6040->audpwron, GPIOF_OUT_INIT_LOW,
593 "audpwron");
594 if (ret)
595 goto gpio_err;
596 }
597
598 /* codec interrupt */
599 ret = twl6040_irq_init(twl6040);
600 if (ret)
601 goto irq_init_err;
602
603 ret = request_threaded_irq(twl6040->irq_base + TWL6040_IRQ_READY,
604 NULL, twl6040_naudint_handler, 0,
605 "twl6040_irq_ready", twl6040);
606 if (ret) {
607 dev_err(twl6040->dev, "READY IRQ request failed: %d\n",
608 ret);
609 goto irq_err;
610 }
611
612 /* dual-access registers controlled by I2C only */
613 twl6040_set_bits(twl6040, TWL6040_REG_ACCCTL, TWL6040_I2CSEL);
614
615 /*
616 * The main functionality of twl6040 to provide audio on OMAP4+ systems.
617 * We can add the ASoC codec child whenever this driver has been loaded.
618 * The ASoC codec can work without pdata, pass the platform_data only if
619 * it has been provided.
620 */
621 irq = twl6040->irq_base + TWL6040_IRQ_PLUG;
622 cell = &twl6040->cells[children];
623 cell->name = "twl6040-codec";
624 twl6040_codec_rsrc[0].start = irq;
625 twl6040_codec_rsrc[0].end = irq;
626 cell->resources = twl6040_codec_rsrc;
627 cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc);
628 if (pdata && pdata->codec) {
629 cell->platform_data = pdata->codec;
630 cell->pdata_size = sizeof(*pdata->codec);
631 }
632 children++;
633
634 if (twl6040_has_vibra(pdata, node)) {
635 irq = twl6040->irq_base + TWL6040_IRQ_VIB;
636
637 cell = &twl6040->cells[children];
638 cell->name = "twl6040-vibra";
639 twl6040_vibra_rsrc[0].start = irq;
640 twl6040_vibra_rsrc[0].end = irq;
641 cell->resources = twl6040_vibra_rsrc;
642 cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc);
643
644 if (pdata && pdata->vibra) {
645 cell->platform_data = pdata->vibra;
646 cell->pdata_size = sizeof(*pdata->vibra);
647 }
648 children++;
649 }
650
651 ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children,
652 NULL, 0);
653 if (ret)
654 goto mfd_err;
655
656 return 0;
657
658mfd_err:
659 free_irq(twl6040->irq_base + TWL6040_IRQ_READY, twl6040);
660irq_err:
661 twl6040_irq_exit(twl6040);
662irq_init_err:
663 if (gpio_is_valid(twl6040->audpwron))
664 gpio_free(twl6040->audpwron);
665gpio_err:
666 regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
667power_err:
668 regulator_bulk_free(TWL6040_NUM_SUPPLIES, twl6040->supplies);
669regulator_get_err:
670 i2c_set_clientdata(client, NULL);
671err:
672 return ret;
673}
674
675static int __devexit twl6040_remove(struct i2c_client *client)
676{
677 struct twl6040 *twl6040 = i2c_get_clientdata(client);
678
679 if (twl6040->power_count)
680 twl6040_power(twl6040, 0);
681
682 if (gpio_is_valid(twl6040->audpwron))
683 gpio_free(twl6040->audpwron);
684
685 free_irq(twl6040->irq_base + TWL6040_IRQ_READY, twl6040);
686 twl6040_irq_exit(twl6040);
687
688 mfd_remove_devices(&client->dev);
689 i2c_set_clientdata(client, NULL);
690
691 regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
692 regulator_bulk_free(TWL6040_NUM_SUPPLIES, twl6040->supplies);
693
694 return 0;
695}
696
697static const struct i2c_device_id twl6040_i2c_id[] = {
698 { "twl6040", 0, },
699 { },
700};
701MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id);
702
703static struct i2c_driver twl6040_driver = {
704 .driver = {
705 .name = "twl6040",
706 .owner = THIS_MODULE,
707 },
708 .probe = twl6040_probe,
709 .remove = __devexit_p(twl6040_remove),
710 .id_table = twl6040_i2c_id,
711};
712
713module_i2c_driver(twl6040_driver);
714
715MODULE_DESCRIPTION("TWL6040 MFD");
716MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
717MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>");
718MODULE_LICENSE("GPL");
719MODULE_ALIAS("platform:twl6040");