Merge ath-current from ath.git
[firefly-linux-kernel-4.4.55.git] / drivers / mfd / twl6040.c
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/mfd/core.h>
41 #include <linux/mfd/twl6040.h>
42 #include <linux/regulator/consumer.h>
43
44 #define VIBRACTRL_MEMBER(reg) ((reg == TWL6040_REG_VIBCTLL) ? 0 : 1)
45 #define TWL6040_NUM_SUPPLIES    (2)
46
47 static const struct reg_default twl6040_defaults[] = {
48         { 0x01, 0x4B }, /* REG_ASICID   (ro) */
49         { 0x02, 0x00 }, /* REG_ASICREV  (ro) */
50         { 0x03, 0x00 }, /* REG_INTID    */
51         { 0x04, 0x00 }, /* REG_INTMR    */
52         { 0x05, 0x00 }, /* REG_NCPCTRL  */
53         { 0x06, 0x00 }, /* REG_LDOCTL   */
54         { 0x07, 0x60 }, /* REG_HPPLLCTL */
55         { 0x08, 0x00 }, /* REG_LPPLLCTL */
56         { 0x09, 0x4A }, /* REG_LPPLLDIV */
57         { 0x0A, 0x00 }, /* REG_AMICBCTL */
58         { 0x0B, 0x00 }, /* REG_DMICBCTL */
59         { 0x0C, 0x00 }, /* REG_MICLCTL  */
60         { 0x0D, 0x00 }, /* REG_MICRCTL  */
61         { 0x0E, 0x00 }, /* REG_MICGAIN  */
62         { 0x0F, 0x1B }, /* REG_LINEGAIN */
63         { 0x10, 0x00 }, /* REG_HSLCTL   */
64         { 0x11, 0x00 }, /* REG_HSRCTL   */
65         { 0x12, 0x00 }, /* REG_HSGAIN   */
66         { 0x13, 0x00 }, /* REG_EARCTL   */
67         { 0x14, 0x00 }, /* REG_HFLCTL   */
68         { 0x15, 0x00 }, /* REG_HFLGAIN  */
69         { 0x16, 0x00 }, /* REG_HFRCTL   */
70         { 0x17, 0x00 }, /* REG_HFRGAIN  */
71         { 0x18, 0x00 }, /* REG_VIBCTLL  */
72         { 0x19, 0x00 }, /* REG_VIBDATL  */
73         { 0x1A, 0x00 }, /* REG_VIBCTLR  */
74         { 0x1B, 0x00 }, /* REG_VIBDATR  */
75         { 0x1C, 0x00 }, /* REG_HKCTL1   */
76         { 0x1D, 0x00 }, /* REG_HKCTL2   */
77         { 0x1E, 0x00 }, /* REG_GPOCTL   */
78         { 0x1F, 0x00 }, /* REG_ALB      */
79         { 0x20, 0x00 }, /* REG_DLB      */
80         /* 0x28, REG_TRIM1 */
81         /* 0x29, REG_TRIM2 */
82         /* 0x2A, REG_TRIM3 */
83         /* 0x2B, REG_HSOTRIM */
84         /* 0x2C, REG_HFOTRIM */
85         { 0x2D, 0x08 }, /* REG_ACCCTL   */
86         { 0x2E, 0x00 }, /* REG_STATUS   (ro) */
87 };
88
89 static struct reg_sequence twl6040_patch[] = {
90         /*
91          * Select I2C bus access to dual access registers
92          * Interrupt register is cleared on read
93          * Select fast mode for i2c (400KHz)
94          */
95         { TWL6040_REG_ACCCTL,
96                 TWL6040_I2CSEL | TWL6040_INTCLRMODE | TWL6040_I2CMODE(1) },
97 };
98
99
100 static bool twl6040_has_vibra(struct device_node *node)
101 {
102 #ifdef CONFIG_OF
103         if (of_find_node_by_name(node, "vibra"))
104                 return true;
105 #endif
106         return false;
107 }
108
109 int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg)
110 {
111         int ret;
112         unsigned int val;
113
114         ret = regmap_read(twl6040->regmap, reg, &val);
115         if (ret < 0)
116                 return ret;
117
118         return val;
119 }
120 EXPORT_SYMBOL(twl6040_reg_read);
121
122 int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg, u8 val)
123 {
124         int ret;
125
126         ret = regmap_write(twl6040->regmap, reg, val);
127
128         return ret;
129 }
130 EXPORT_SYMBOL(twl6040_reg_write);
131
132 int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
133 {
134         return regmap_update_bits(twl6040->regmap, reg, mask, mask);
135 }
136 EXPORT_SYMBOL(twl6040_set_bits);
137
138 int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
139 {
140         return regmap_update_bits(twl6040->regmap, reg, mask, 0);
141 }
142 EXPORT_SYMBOL(twl6040_clear_bits);
143
144 /* twl6040 codec manual power-up sequence */
145 static int twl6040_power_up_manual(struct twl6040 *twl6040)
146 {
147         u8 ldoctl, ncpctl, lppllctl;
148         int ret;
149
150         /* enable high-side LDO, reference system and internal oscillator */
151         ldoctl = TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA;
152         ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
153         if (ret)
154                 return ret;
155         usleep_range(10000, 10500);
156
157         /* enable negative charge pump */
158         ncpctl = TWL6040_NCPENA;
159         ret = twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
160         if (ret)
161                 goto ncp_err;
162         usleep_range(1000, 1500);
163
164         /* enable low-side LDO */
165         ldoctl |= TWL6040_LSLDOENA;
166         ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
167         if (ret)
168                 goto lsldo_err;
169         usleep_range(1000, 1500);
170
171         /* enable low-power PLL */
172         lppllctl = TWL6040_LPLLENA;
173         ret = twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
174         if (ret)
175                 goto lppll_err;
176         usleep_range(5000, 5500);
177
178         /* disable internal oscillator */
179         ldoctl &= ~TWL6040_OSCENA;
180         ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
181         if (ret)
182                 goto osc_err;
183
184         return 0;
185
186 osc_err:
187         lppllctl &= ~TWL6040_LPLLENA;
188         twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
189 lppll_err:
190         ldoctl &= ~TWL6040_LSLDOENA;
191         twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
192 lsldo_err:
193         ncpctl &= ~TWL6040_NCPENA;
194         twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
195 ncp_err:
196         ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
197         twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
198
199         dev_err(twl6040->dev, "manual power-up failed\n");
200         return ret;
201 }
202
203 /* twl6040 manual power-down sequence */
204 static void twl6040_power_down_manual(struct twl6040 *twl6040)
205 {
206         u8 ncpctl, ldoctl, lppllctl;
207
208         ncpctl = twl6040_reg_read(twl6040, TWL6040_REG_NCPCTL);
209         ldoctl = twl6040_reg_read(twl6040, TWL6040_REG_LDOCTL);
210         lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
211
212         /* enable internal oscillator */
213         ldoctl |= TWL6040_OSCENA;
214         twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
215         usleep_range(1000, 1500);
216
217         /* disable low-power PLL */
218         lppllctl &= ~TWL6040_LPLLENA;
219         twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
220
221         /* disable low-side LDO */
222         ldoctl &= ~TWL6040_LSLDOENA;
223         twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
224
225         /* disable negative charge pump */
226         ncpctl &= ~TWL6040_NCPENA;
227         twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
228
229         /* disable high-side LDO, reference system and internal oscillator */
230         ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
231         twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
232 }
233
234 static irqreturn_t twl6040_readyint_handler(int irq, void *data)
235 {
236         struct twl6040 *twl6040 = data;
237
238         complete(&twl6040->ready);
239
240         return IRQ_HANDLED;
241 }
242
243 static irqreturn_t twl6040_thint_handler(int irq, void *data)
244 {
245         struct twl6040 *twl6040 = data;
246         u8 status;
247
248         status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS);
249         if (status & TWL6040_TSHUTDET) {
250                 dev_warn(twl6040->dev, "Thermal shutdown, powering-off");
251                 twl6040_power(twl6040, 0);
252         } else {
253                 dev_warn(twl6040->dev, "Leaving thermal shutdown, powering-on");
254                 twl6040_power(twl6040, 1);
255         }
256
257         return IRQ_HANDLED;
258 }
259
260 static int twl6040_power_up_automatic(struct twl6040 *twl6040)
261 {
262         int time_left;
263
264         gpio_set_value(twl6040->audpwron, 1);
265
266         time_left = wait_for_completion_timeout(&twl6040->ready,
267                                                 msecs_to_jiffies(144));
268         if (!time_left) {
269                 u8 intid;
270
271                 dev_warn(twl6040->dev, "timeout waiting for READYINT\n");
272                 intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
273                 if (!(intid & TWL6040_READYINT)) {
274                         dev_err(twl6040->dev, "automatic power-up failed\n");
275                         gpio_set_value(twl6040->audpwron, 0);
276                         return -ETIMEDOUT;
277                 }
278         }
279
280         return 0;
281 }
282
283 int twl6040_power(struct twl6040 *twl6040, int on)
284 {
285         int ret = 0;
286
287         mutex_lock(&twl6040->mutex);
288
289         if (on) {
290                 /* already powered-up */
291                 if (twl6040->power_count++)
292                         goto out;
293
294                 clk_prepare_enable(twl6040->clk32k);
295
296                 /* Allow writes to the chip */
297                 regcache_cache_only(twl6040->regmap, false);
298
299                 if (gpio_is_valid(twl6040->audpwron)) {
300                         /* use automatic power-up sequence */
301                         ret = twl6040_power_up_automatic(twl6040);
302                         if (ret) {
303                                 twl6040->power_count = 0;
304                                 goto out;
305                         }
306                 } else {
307                         /* use manual power-up sequence */
308                         ret = twl6040_power_up_manual(twl6040);
309                         if (ret) {
310                                 twl6040->power_count = 0;
311                                 goto out;
312                         }
313                 }
314
315                 /* Sync with the HW */
316                 regcache_sync(twl6040->regmap);
317
318                 /* Default PLL configuration after power up */
319                 twl6040->pll = TWL6040_SYSCLK_SEL_LPPLL;
320                 twl6040->sysclk = 19200000;
321                 twl6040->mclk = 32768;
322         } else {
323                 /* already powered-down */
324                 if (!twl6040->power_count) {
325                         dev_err(twl6040->dev,
326                                 "device is already powered-off\n");
327                         ret = -EPERM;
328                         goto out;
329                 }
330
331                 if (--twl6040->power_count)
332                         goto out;
333
334                 if (gpio_is_valid(twl6040->audpwron)) {
335                         /* use AUDPWRON line */
336                         gpio_set_value(twl6040->audpwron, 0);
337
338                         /* power-down sequence latency */
339                         usleep_range(500, 700);
340                 } else {
341                         /* use manual power-down sequence */
342                         twl6040_power_down_manual(twl6040);
343                 }
344
345                 /* Set regmap to cache only and mark it as dirty */
346                 regcache_cache_only(twl6040->regmap, true);
347                 regcache_mark_dirty(twl6040->regmap);
348
349                 twl6040->sysclk = 0;
350                 twl6040->mclk = 0;
351
352                 clk_disable_unprepare(twl6040->clk32k);
353         }
354
355 out:
356         mutex_unlock(&twl6040->mutex);
357         return ret;
358 }
359 EXPORT_SYMBOL(twl6040_power);
360
361 int twl6040_set_pll(struct twl6040 *twl6040, int pll_id,
362                     unsigned int freq_in, unsigned int freq_out)
363 {
364         u8 hppllctl, lppllctl;
365         int ret = 0;
366
367         mutex_lock(&twl6040->mutex);
368
369         hppllctl = twl6040_reg_read(twl6040, TWL6040_REG_HPPLLCTL);
370         lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
371
372         /* Force full reconfiguration when switching between PLL */
373         if (pll_id != twl6040->pll) {
374                 twl6040->sysclk = 0;
375                 twl6040->mclk = 0;
376         }
377
378         switch (pll_id) {
379         case TWL6040_SYSCLK_SEL_LPPLL:
380                 /* low-power PLL divider */
381                 /* Change the sysclk configuration only if it has been canged */
382                 if (twl6040->sysclk != freq_out) {
383                         switch (freq_out) {
384                         case 17640000:
385                                 lppllctl |= TWL6040_LPLLFIN;
386                                 break;
387                         case 19200000:
388                                 lppllctl &= ~TWL6040_LPLLFIN;
389                                 break;
390                         default:
391                                 dev_err(twl6040->dev,
392                                         "freq_out %d not supported\n",
393                                         freq_out);
394                                 ret = -EINVAL;
395                                 goto pll_out;
396                         }
397                         twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
398                                           lppllctl);
399                 }
400
401                 /* The PLL in use has not been change, we can exit */
402                 if (twl6040->pll == pll_id)
403                         break;
404
405                 switch (freq_in) {
406                 case 32768:
407                         lppllctl |= TWL6040_LPLLENA;
408                         twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
409                                           lppllctl);
410                         mdelay(5);
411                         lppllctl &= ~TWL6040_HPLLSEL;
412                         twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
413                                           lppllctl);
414                         hppllctl &= ~TWL6040_HPLLENA;
415                         twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
416                                           hppllctl);
417                         break;
418                 default:
419                         dev_err(twl6040->dev,
420                                 "freq_in %d not supported\n", freq_in);
421                         ret = -EINVAL;
422                         goto pll_out;
423                 }
424                 break;
425         case TWL6040_SYSCLK_SEL_HPPLL:
426                 /* high-performance PLL can provide only 19.2 MHz */
427                 if (freq_out != 19200000) {
428                         dev_err(twl6040->dev,
429                                 "freq_out %d not supported\n", freq_out);
430                         ret = -EINVAL;
431                         goto pll_out;
432                 }
433
434                 if (twl6040->mclk != freq_in) {
435                         hppllctl &= ~TWL6040_MCLK_MSK;
436
437                         switch (freq_in) {
438                         case 12000000:
439                                 /* PLL enabled, active mode */
440                                 hppllctl |= TWL6040_MCLK_12000KHZ |
441                                             TWL6040_HPLLENA;
442                                 break;
443                         case 19200000:
444                                 /* PLL enabled, bypass mode */
445                                 hppllctl |= TWL6040_MCLK_19200KHZ |
446                                             TWL6040_HPLLBP | TWL6040_HPLLENA;
447                                 break;
448                         case 26000000:
449                                 /* PLL enabled, active mode */
450                                 hppllctl |= TWL6040_MCLK_26000KHZ |
451                                             TWL6040_HPLLENA;
452                                 break;
453                         case 38400000:
454                                 /* PLL enabled, bypass mode */
455                                 hppllctl |= TWL6040_MCLK_38400KHZ |
456                                             TWL6040_HPLLBP | TWL6040_HPLLENA;
457                                 break;
458                         default:
459                                 dev_err(twl6040->dev,
460                                         "freq_in %d not supported\n", freq_in);
461                                 ret = -EINVAL;
462                                 goto pll_out;
463                         }
464
465                         /*
466                          * enable clock slicer to ensure input waveform is
467                          * square
468                          */
469                         hppllctl |= TWL6040_HPLLSQRENA;
470
471                         twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
472                                           hppllctl);
473                         usleep_range(500, 700);
474                         lppllctl |= TWL6040_HPLLSEL;
475                         twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
476                                           lppllctl);
477                         lppllctl &= ~TWL6040_LPLLENA;
478                         twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
479                                           lppllctl);
480                 }
481                 break;
482         default:
483                 dev_err(twl6040->dev, "unknown pll id %d\n", pll_id);
484                 ret = -EINVAL;
485                 goto pll_out;
486         }
487
488         twl6040->sysclk = freq_out;
489         twl6040->mclk = freq_in;
490         twl6040->pll = pll_id;
491
492 pll_out:
493         mutex_unlock(&twl6040->mutex);
494         return ret;
495 }
496 EXPORT_SYMBOL(twl6040_set_pll);
497
498 int twl6040_get_pll(struct twl6040 *twl6040)
499 {
500         if (twl6040->power_count)
501                 return twl6040->pll;
502         else
503                 return -ENODEV;
504 }
505 EXPORT_SYMBOL(twl6040_get_pll);
506
507 unsigned int twl6040_get_sysclk(struct twl6040 *twl6040)
508 {
509         return twl6040->sysclk;
510 }
511 EXPORT_SYMBOL(twl6040_get_sysclk);
512
513 /* Get the combined status of the vibra control register */
514 int twl6040_get_vibralr_status(struct twl6040 *twl6040)
515 {
516         unsigned int reg;
517         int ret;
518         u8 status;
519
520         ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLL, &reg);
521         if (ret != 0)
522                 return ret;
523         status = reg;
524
525         ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLR, &reg);
526         if (ret != 0)
527                 return ret;
528         status |= reg;
529
530         status &= (TWL6040_VIBENA | TWL6040_VIBSEL);
531
532         return status;
533 }
534 EXPORT_SYMBOL(twl6040_get_vibralr_status);
535
536 static struct resource twl6040_vibra_rsrc[] = {
537         {
538                 .flags = IORESOURCE_IRQ,
539         },
540 };
541
542 static struct resource twl6040_codec_rsrc[] = {
543         {
544                 .flags = IORESOURCE_IRQ,
545         },
546 };
547
548 static bool twl6040_readable_reg(struct device *dev, unsigned int reg)
549 {
550         /* Register 0 is not readable */
551         if (!reg)
552                 return false;
553         return true;
554 }
555
556 static bool twl6040_volatile_reg(struct device *dev, unsigned int reg)
557 {
558         switch (reg) {
559         case TWL6040_REG_ASICID:
560         case TWL6040_REG_ASICREV:
561         case TWL6040_REG_INTID:
562         case TWL6040_REG_LPPLLCTL:
563         case TWL6040_REG_HPPLLCTL:
564         case TWL6040_REG_STATUS:
565                 return true;
566         default:
567                 return false;
568         }
569 }
570
571 static bool twl6040_writeable_reg(struct device *dev, unsigned int reg)
572 {
573         switch (reg) {
574         case TWL6040_REG_ASICID:
575         case TWL6040_REG_ASICREV:
576         case TWL6040_REG_STATUS:
577                 return false;
578         default:
579                 return true;
580         }
581 }
582
583 static const struct regmap_config twl6040_regmap_config = {
584         .reg_bits = 8,
585         .val_bits = 8,
586
587         .reg_defaults = twl6040_defaults,
588         .num_reg_defaults = ARRAY_SIZE(twl6040_defaults),
589
590         .max_register = TWL6040_REG_STATUS, /* 0x2e */
591
592         .readable_reg = twl6040_readable_reg,
593         .volatile_reg = twl6040_volatile_reg,
594         .writeable_reg = twl6040_writeable_reg,
595
596         .cache_type = REGCACHE_RBTREE,
597 };
598
599 static const struct regmap_irq twl6040_irqs[] = {
600         { .reg_offset = 0, .mask = TWL6040_THINT, },
601         { .reg_offset = 0, .mask = TWL6040_PLUGINT | TWL6040_UNPLUGINT, },
602         { .reg_offset = 0, .mask = TWL6040_HOOKINT, },
603         { .reg_offset = 0, .mask = TWL6040_HFINT, },
604         { .reg_offset = 0, .mask = TWL6040_VIBINT, },
605         { .reg_offset = 0, .mask = TWL6040_READYINT, },
606 };
607
608 static struct regmap_irq_chip twl6040_irq_chip = {
609         .name = "twl6040",
610         .irqs = twl6040_irqs,
611         .num_irqs = ARRAY_SIZE(twl6040_irqs),
612
613         .num_regs = 1,
614         .status_base = TWL6040_REG_INTID,
615         .mask_base = TWL6040_REG_INTMR,
616 };
617
618 static int twl6040_probe(struct i2c_client *client,
619                          const struct i2c_device_id *id)
620 {
621         struct device_node *node = client->dev.of_node;
622         struct twl6040 *twl6040;
623         struct mfd_cell *cell = NULL;
624         int irq, ret, children = 0;
625
626         if (!node) {
627                 dev_err(&client->dev, "of node is missing\n");
628                 return -EINVAL;
629         }
630
631         /* In order to operate correctly we need valid interrupt config */
632         if (!client->irq) {
633                 dev_err(&client->dev, "Invalid IRQ configuration\n");
634                 return -EINVAL;
635         }
636
637         twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040),
638                                GFP_KERNEL);
639         if (!twl6040)
640                 return -ENOMEM;
641
642         twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config);
643         if (IS_ERR(twl6040->regmap))
644                 return PTR_ERR(twl6040->regmap);
645
646         i2c_set_clientdata(client, twl6040);
647
648         twl6040->clk32k = devm_clk_get(&client->dev, "clk32k");
649         if (IS_ERR(twl6040->clk32k)) {
650                 if (PTR_ERR(twl6040->clk32k) == -EPROBE_DEFER)
651                         return -EPROBE_DEFER;
652                 dev_info(&client->dev, "clk32k is not handled\n");
653                 twl6040->clk32k = NULL;
654         }
655
656         twl6040->supplies[0].supply = "vio";
657         twl6040->supplies[1].supply = "v2v1";
658         ret = devm_regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES,
659                                       twl6040->supplies);
660         if (ret != 0) {
661                 dev_err(&client->dev, "Failed to get supplies: %d\n", ret);
662                 return ret;
663         }
664
665         ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
666         if (ret != 0) {
667                 dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
668                 return ret;
669         }
670
671         twl6040->dev = &client->dev;
672         twl6040->irq = client->irq;
673
674         mutex_init(&twl6040->mutex);
675         init_completion(&twl6040->ready);
676
677         regmap_register_patch(twl6040->regmap, twl6040_patch,
678                               ARRAY_SIZE(twl6040_patch));
679
680         twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV);
681         if (twl6040->rev < 0) {
682                 dev_err(&client->dev, "Failed to read revision register: %d\n",
683                         twl6040->rev);
684                 ret = twl6040->rev;
685                 goto gpio_err;
686         }
687
688         /* ERRATA: Automatic power-up is not possible in ES1.0 */
689         if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0)
690                 twl6040->audpwron = of_get_named_gpio(node,
691                                                       "ti,audpwron-gpio", 0);
692         else
693                 twl6040->audpwron = -EINVAL;
694
695         if (gpio_is_valid(twl6040->audpwron)) {
696                 ret = devm_gpio_request_one(&client->dev, twl6040->audpwron,
697                                             GPIOF_OUT_INIT_LOW, "audpwron");
698                 if (ret)
699                         goto gpio_err;
700
701                 /* Clear any pending interrupt */
702                 twl6040_reg_read(twl6040, TWL6040_REG_INTID);
703         }
704
705         ret = regmap_add_irq_chip(twl6040->regmap, twl6040->irq, IRQF_ONESHOT,
706                                   0, &twl6040_irq_chip, &twl6040->irq_data);
707         if (ret < 0)
708                 goto gpio_err;
709
710         twl6040->irq_ready = regmap_irq_get_virq(twl6040->irq_data,
711                                                  TWL6040_IRQ_READY);
712         twl6040->irq_th = regmap_irq_get_virq(twl6040->irq_data,
713                                               TWL6040_IRQ_TH);
714
715         ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_ready, NULL,
716                                         twl6040_readyint_handler, IRQF_ONESHOT,
717                                         "twl6040_irq_ready", twl6040);
718         if (ret) {
719                 dev_err(twl6040->dev, "READY IRQ request failed: %d\n", ret);
720                 goto readyirq_err;
721         }
722
723         ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_th, NULL,
724                                         twl6040_thint_handler, IRQF_ONESHOT,
725                                         "twl6040_irq_th", twl6040);
726         if (ret) {
727                 dev_err(twl6040->dev, "Thermal IRQ request failed: %d\n", ret);
728                 goto readyirq_err;
729         }
730
731         /*
732          * The main functionality of twl6040 to provide audio on OMAP4+ systems.
733          * We can add the ASoC codec child whenever this driver has been loaded.
734          */
735         irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_PLUG);
736         cell = &twl6040->cells[children];
737         cell->name = "twl6040-codec";
738         twl6040_codec_rsrc[0].start = irq;
739         twl6040_codec_rsrc[0].end = irq;
740         cell->resources = twl6040_codec_rsrc;
741         cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc);
742         children++;
743
744         /* Vibra input driver support */
745         if (twl6040_has_vibra(node)) {
746                 irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_VIB);
747
748                 cell = &twl6040->cells[children];
749                 cell->name = "twl6040-vibra";
750                 twl6040_vibra_rsrc[0].start = irq;
751                 twl6040_vibra_rsrc[0].end = irq;
752                 cell->resources = twl6040_vibra_rsrc;
753                 cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc);
754                 children++;
755         }
756
757         /* GPO support */
758         cell = &twl6040->cells[children];
759         cell->name = "twl6040-gpo";
760         children++;
761
762         /* The chip is powered down so mark regmap to cache only and dirty */
763         regcache_cache_only(twl6040->regmap, true);
764         regcache_mark_dirty(twl6040->regmap);
765
766         ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children,
767                               NULL, 0, NULL);
768         if (ret)
769                 goto readyirq_err;
770
771         return 0;
772
773 readyirq_err:
774         regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
775 gpio_err:
776         regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
777         return ret;
778 }
779
780 static int twl6040_remove(struct i2c_client *client)
781 {
782         struct twl6040 *twl6040 = i2c_get_clientdata(client);
783
784         if (twl6040->power_count)
785                 twl6040_power(twl6040, 0);
786
787         regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
788
789         mfd_remove_devices(&client->dev);
790
791         regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
792
793         return 0;
794 }
795
796 static const struct i2c_device_id twl6040_i2c_id[] = {
797         { "twl6040", 0, },
798         { "twl6041", 0, },
799         { },
800 };
801 MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id);
802
803 static struct i2c_driver twl6040_driver = {
804         .driver = {
805                 .name = "twl6040",
806         },
807         .probe          = twl6040_probe,
808         .remove         = twl6040_remove,
809         .id_table       = twl6040_i2c_id,
810 };
811
812 module_i2c_driver(twl6040_driver);
813
814 MODULE_DESCRIPTION("TWL6040 MFD");
815 MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
816 MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>");
817 MODULE_LICENSE("GPL");