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