]> Pileus Git - ~andy/linux/blob - drivers/mfd/twl-core.c
Merge tag 'writeback-proportions' of git://git.kernel.org/pub/scm/linux/kernel/git...
[~andy/linux] / drivers / mfd / twl-core.c
1 /*
2  * twl_core.c - driver for TWL4030/TWL5030/TWL60X0/TPS659x0 PM
3  * and audio CODEC devices
4  *
5  * Copyright (C) 2005-2006 Texas Instruments, Inc.
6  *
7  * Modifications to defer interrupt handling to a kernel thread:
8  * Copyright (C) 2006 MontaVista Software, Inc.
9  *
10  * Based on tlv320aic23.c:
11  * Copyright (c) by Kai Svahn <kai.svahn@nokia.com>
12  *
13  * Code cleanup and modifications to IRQ handler.
14  * by syed khasim <x0khasim@ti.com>
15  *
16  * This program is free software; you can redistribute it and/or modify
17  * it under the terms of the GNU General Public License as published by
18  * the Free Software Foundation; either version 2 of the License, or
19  * (at your option) any later version.
20  *
21  * This program is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24  * GNU General Public License for more details.
25  *
26  * You should have received a copy of the GNU General Public License
27  * along with this program; if not, write to the Free Software
28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
29  */
30
31 #include <linux/init.h>
32 #include <linux/mutex.h>
33 #include <linux/module.h>
34 #include <linux/platform_device.h>
35 #include <linux/clk.h>
36 #include <linux/err.h>
37 #include <linux/device.h>
38 #include <linux/of.h>
39 #include <linux/of_irq.h>
40 #include <linux/of_platform.h>
41 #include <linux/irq.h>
42 #include <linux/irqdomain.h>
43
44 #include <linux/regulator/machine.h>
45
46 #include <linux/i2c.h>
47 #include <linux/i2c/twl.h>
48
49 #include "twl-core.h"
50
51 /*
52  * The TWL4030 "Triton 2" is one of a family of a multi-function "Power
53  * Management and System Companion Device" chips originally designed for
54  * use in OMAP2 and OMAP 3 based systems.  Its control interfaces use I2C,
55  * often at around 3 Mbit/sec, including for interrupt handling.
56  *
57  * This driver core provides genirq support for the interrupts emitted,
58  * by the various modules, and exports register access primitives.
59  *
60  * FIXME this driver currently requires use of the first interrupt line
61  * (and associated registers).
62  */
63
64 #define DRIVER_NAME                     "twl"
65
66 #if defined(CONFIG_KEYBOARD_TWL4030) || defined(CONFIG_KEYBOARD_TWL4030_MODULE)
67 #define twl_has_keypad()        true
68 #else
69 #define twl_has_keypad()        false
70 #endif
71
72 #if defined(CONFIG_GPIO_TWL4030) || defined(CONFIG_GPIO_TWL4030_MODULE)
73 #define twl_has_gpio()  true
74 #else
75 #define twl_has_gpio()  false
76 #endif
77
78 #if defined(CONFIG_REGULATOR_TWL4030) \
79         || defined(CONFIG_REGULATOR_TWL4030_MODULE)
80 #define twl_has_regulator()     true
81 #else
82 #define twl_has_regulator()     false
83 #endif
84
85 #if defined(CONFIG_TWL4030_MADC) || defined(CONFIG_TWL4030_MADC_MODULE)
86 #define twl_has_madc()  true
87 #else
88 #define twl_has_madc()  false
89 #endif
90
91 #ifdef CONFIG_TWL4030_POWER
92 #define twl_has_power()        true
93 #else
94 #define twl_has_power()        false
95 #endif
96
97 #if defined(CONFIG_RTC_DRV_TWL4030) || defined(CONFIG_RTC_DRV_TWL4030_MODULE)
98 #define twl_has_rtc()   true
99 #else
100 #define twl_has_rtc()   false
101 #endif
102
103 #if defined(CONFIG_TWL4030_USB) || defined(CONFIG_TWL4030_USB_MODULE) ||\
104         defined(CONFIG_TWL6030_USB) || defined(CONFIG_TWL6030_USB_MODULE)
105 #define twl_has_usb()   true
106 #else
107 #define twl_has_usb()   false
108 #endif
109
110 #if defined(CONFIG_TWL4030_WATCHDOG) || \
111         defined(CONFIG_TWL4030_WATCHDOG_MODULE)
112 #define twl_has_watchdog()        true
113 #else
114 #define twl_has_watchdog()        false
115 #endif
116
117 #if defined(CONFIG_MFD_TWL4030_AUDIO) || \
118         defined(CONFIG_MFD_TWL4030_AUDIO_MODULE)
119 #define twl_has_codec() true
120 #else
121 #define twl_has_codec() false
122 #endif
123
124 #if defined(CONFIG_CHARGER_TWL4030) || defined(CONFIG_CHARGER_TWL4030_MODULE)
125 #define twl_has_bci()   true
126 #else
127 #define twl_has_bci()   false
128 #endif
129
130 /* Triton Core internal information (BEGIN) */
131
132 /* Last - for index max*/
133 #define TWL4030_MODULE_LAST             TWL4030_MODULE_SECURED_REG
134
135 #define TWL_NUM_SLAVES          4
136
137 #if defined(CONFIG_INPUT_TWL4030_PWRBUTTON) \
138         || defined(CONFIG_INPUT_TWL4030_PWRBUTTON_MODULE)
139 #define twl_has_pwrbutton()     true
140 #else
141 #define twl_has_pwrbutton()     false
142 #endif
143
144 #define SUB_CHIP_ID0 0
145 #define SUB_CHIP_ID1 1
146 #define SUB_CHIP_ID2 2
147 #define SUB_CHIP_ID3 3
148 #define SUB_CHIP_ID_INVAL 0xff
149
150 #define TWL_MODULE_LAST TWL4030_MODULE_LAST
151
152 /* Base Address defns for twl4030_map[] */
153
154 /* subchip/slave 0 - USB ID */
155 #define TWL4030_BASEADD_USB             0x0000
156
157 /* subchip/slave 1 - AUD ID */
158 #define TWL4030_BASEADD_AUDIO_VOICE     0x0000
159 #define TWL4030_BASEADD_GPIO            0x0098
160 #define TWL4030_BASEADD_INTBR           0x0085
161 #define TWL4030_BASEADD_PIH             0x0080
162 #define TWL4030_BASEADD_TEST            0x004C
163
164 /* subchip/slave 2 - AUX ID */
165 #define TWL4030_BASEADD_INTERRUPTS      0x00B9
166 #define TWL4030_BASEADD_LED             0x00EE
167 #define TWL4030_BASEADD_MADC            0x0000
168 #define TWL4030_BASEADD_MAIN_CHARGE     0x0074
169 #define TWL4030_BASEADD_PRECHARGE       0x00AA
170 #define TWL4030_BASEADD_PWM0            0x00F8
171 #define TWL4030_BASEADD_PWM1            0x00FB
172 #define TWL4030_BASEADD_PWMA            0x00EF
173 #define TWL4030_BASEADD_PWMB            0x00F1
174 #define TWL4030_BASEADD_KEYPAD          0x00D2
175
176 #define TWL5031_BASEADD_ACCESSORY       0x0074 /* Replaces Main Charge */
177 #define TWL5031_BASEADD_INTERRUPTS      0x00B9 /* Different than TWL4030's
178                                                   one */
179
180 /* subchip/slave 3 - POWER ID */
181 #define TWL4030_BASEADD_BACKUP          0x0014
182 #define TWL4030_BASEADD_INT             0x002E
183 #define TWL4030_BASEADD_PM_MASTER       0x0036
184 #define TWL4030_BASEADD_PM_RECEIVER     0x005B
185 #define TWL4030_BASEADD_RTC             0x001C
186 #define TWL4030_BASEADD_SECURED_REG     0x0000
187
188 /* Triton Core internal information (END) */
189
190
191 /* subchip/slave 0 0x48 - POWER */
192 #define TWL6030_BASEADD_RTC             0x0000
193 #define TWL6030_BASEADD_MEM             0x0017
194 #define TWL6030_BASEADD_PM_MASTER       0x001F
195 #define TWL6030_BASEADD_PM_SLAVE_MISC   0x0030 /* PM_RECEIVER */
196 #define TWL6030_BASEADD_PM_MISC         0x00E2
197 #define TWL6030_BASEADD_PM_PUPD         0x00F0
198
199 /* subchip/slave 1 0x49 - FEATURE */
200 #define TWL6030_BASEADD_USB             0x0000
201 #define TWL6030_BASEADD_GPADC_CTRL      0x002E
202 #define TWL6030_BASEADD_AUX             0x0090
203 #define TWL6030_BASEADD_PWM             0x00BA
204 #define TWL6030_BASEADD_GASGAUGE        0x00C0
205 #define TWL6030_BASEADD_PIH             0x00D0
206 #define TWL6030_BASEADD_CHARGER         0x00E0
207 #define TWL6025_BASEADD_CHARGER         0x00DA
208
209 /* subchip/slave 2 0x4A - DFT */
210 #define TWL6030_BASEADD_DIEID           0x00C0
211
212 /* subchip/slave 3 0x4B - AUDIO */
213 #define TWL6030_BASEADD_AUDIO           0x0000
214 #define TWL6030_BASEADD_RSV             0x0000
215 #define TWL6030_BASEADD_ZERO            0x0000
216
217 /* Few power values */
218 #define R_CFG_BOOT                      0x05
219
220 /* some fields in R_CFG_BOOT */
221 #define HFCLK_FREQ_19p2_MHZ             (1 << 0)
222 #define HFCLK_FREQ_26_MHZ               (2 << 0)
223 #define HFCLK_FREQ_38p4_MHZ             (3 << 0)
224 #define HIGH_PERF_SQ                    (1 << 3)
225 #define CK32K_LOWPWR_EN                 (1 << 7)
226
227 /*----------------------------------------------------------------------*/
228
229 /* is driver active, bound to a chip? */
230 static bool inuse;
231
232 /* TWL IDCODE Register value */
233 static u32 twl_idcode;
234
235 static unsigned int twl_id;
236 unsigned int twl_rev(void)
237 {
238         return twl_id;
239 }
240 EXPORT_SYMBOL(twl_rev);
241
242 /* Structure for each TWL4030/TWL6030 Slave */
243 struct twl_client {
244         struct i2c_client *client;
245         u8 address;
246
247         /* max numb of i2c_msg required is for read =2 */
248         struct i2c_msg xfer_msg[2];
249
250         /* To lock access to xfer_msg */
251         struct mutex xfer_lock;
252 };
253
254 static struct twl_client twl_modules[TWL_NUM_SLAVES];
255
256 /* mapping the module id to slave id and base address */
257 struct twl_mapping {
258         unsigned char sid;      /* Slave ID */
259         unsigned char base;     /* base address */
260 };
261 static struct twl_mapping *twl_map;
262
263 static struct twl_mapping twl4030_map[TWL4030_MODULE_LAST + 1] = {
264         /*
265          * NOTE:  don't change this table without updating the
266          * <linux/i2c/twl.h> defines for TWL4030_MODULE_*
267          * so they continue to match the order in this table.
268          */
269
270         { 0, TWL4030_BASEADD_USB },
271
272         { 1, TWL4030_BASEADD_AUDIO_VOICE },
273         { 1, TWL4030_BASEADD_GPIO },
274         { 1, TWL4030_BASEADD_INTBR },
275         { 1, TWL4030_BASEADD_PIH },
276         { 1, TWL4030_BASEADD_TEST },
277
278         { 2, TWL4030_BASEADD_KEYPAD },
279         { 2, TWL4030_BASEADD_MADC },
280         { 2, TWL4030_BASEADD_INTERRUPTS },
281         { 2, TWL4030_BASEADD_LED },
282         { 2, TWL4030_BASEADD_MAIN_CHARGE },
283         { 2, TWL4030_BASEADD_PRECHARGE },
284         { 2, TWL4030_BASEADD_PWM0 },
285         { 2, TWL4030_BASEADD_PWM1 },
286         { 2, TWL4030_BASEADD_PWMA },
287         { 2, TWL4030_BASEADD_PWMB },
288         { 2, TWL5031_BASEADD_ACCESSORY },
289         { 2, TWL5031_BASEADD_INTERRUPTS },
290
291         { 3, TWL4030_BASEADD_BACKUP },
292         { 3, TWL4030_BASEADD_INT },
293         { 3, TWL4030_BASEADD_PM_MASTER },
294         { 3, TWL4030_BASEADD_PM_RECEIVER },
295         { 3, TWL4030_BASEADD_RTC },
296         { 3, TWL4030_BASEADD_SECURED_REG },
297 };
298
299 static struct twl_mapping twl6030_map[] = {
300         /*
301          * NOTE:  don't change this table without updating the
302          * <linux/i2c/twl.h> defines for TWL4030_MODULE_*
303          * so they continue to match the order in this table.
304          */
305         { SUB_CHIP_ID1, TWL6030_BASEADD_USB },
306         { SUB_CHIP_ID_INVAL, TWL6030_BASEADD_AUDIO },
307         { SUB_CHIP_ID2, TWL6030_BASEADD_DIEID },
308         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
309         { SUB_CHIP_ID1, TWL6030_BASEADD_PIH },
310
311         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
312         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
313         { SUB_CHIP_ID1, TWL6030_BASEADD_GPADC_CTRL },
314         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
315         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
316
317         { SUB_CHIP_ID1, TWL6030_BASEADD_CHARGER },
318         { SUB_CHIP_ID1, TWL6030_BASEADD_GASGAUGE },
319         { SUB_CHIP_ID1, TWL6030_BASEADD_PWM },
320         { SUB_CHIP_ID0, TWL6030_BASEADD_ZERO },
321         { SUB_CHIP_ID1, TWL6030_BASEADD_ZERO },
322
323         { SUB_CHIP_ID2, TWL6030_BASEADD_ZERO },
324         { SUB_CHIP_ID2, TWL6030_BASEADD_ZERO },
325         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
326         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
327         { SUB_CHIP_ID2, TWL6030_BASEADD_RSV },
328         { SUB_CHIP_ID0, TWL6030_BASEADD_PM_MASTER },
329         { SUB_CHIP_ID0, TWL6030_BASEADD_PM_SLAVE_MISC },
330
331         { SUB_CHIP_ID0, TWL6030_BASEADD_RTC },
332         { SUB_CHIP_ID0, TWL6030_BASEADD_MEM },
333         { SUB_CHIP_ID1, TWL6025_BASEADD_CHARGER },
334 };
335
336 /*----------------------------------------------------------------------*/
337
338 /* Exported Functions */
339
340 /**
341  * twl_i2c_write - Writes a n bit register in TWL4030/TWL5030/TWL60X0
342  * @mod_no: module number
343  * @value: an array of num_bytes+1 containing data to write
344  * @reg: register address (just offset will do)
345  * @num_bytes: number of bytes to transfer
346  *
347  * IMPORTANT: for 'value' parameter: Allocate value num_bytes+1 and
348  * valid data starts at Offset 1.
349  *
350  * Returns the result of operation - 0 is success
351  */
352 int twl_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
353 {
354         int ret;
355         int sid;
356         struct twl_client *twl;
357         struct i2c_msg *msg;
358
359         if (unlikely(mod_no > TWL_MODULE_LAST)) {
360                 pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
361                 return -EPERM;
362         }
363         if (unlikely(!inuse)) {
364                 pr_err("%s: not initialized\n", DRIVER_NAME);
365                 return -EPERM;
366         }
367         sid = twl_map[mod_no].sid;
368         if (unlikely(sid == SUB_CHIP_ID_INVAL)) {
369                 pr_err("%s: module %d is not part of the pmic\n",
370                        DRIVER_NAME, mod_no);
371                 return -EINVAL;
372         }
373         twl = &twl_modules[sid];
374
375         mutex_lock(&twl->xfer_lock);
376         /*
377          * [MSG1]: fill the register address data
378          * fill the data Tx buffer
379          */
380         msg = &twl->xfer_msg[0];
381         msg->addr = twl->address;
382         msg->len = num_bytes + 1;
383         msg->flags = 0;
384         msg->buf = value;
385         /* over write the first byte of buffer with the register address */
386         *value = twl_map[mod_no].base + reg;
387         ret = i2c_transfer(twl->client->adapter, twl->xfer_msg, 1);
388         mutex_unlock(&twl->xfer_lock);
389
390         /* i2c_transfer returns number of messages transferred */
391         if (ret != 1) {
392                 pr_err("%s: i2c_write failed to transfer all messages\n",
393                         DRIVER_NAME);
394                 if (ret < 0)
395                         return ret;
396                 else
397                         return -EIO;
398         } else {
399                 return 0;
400         }
401 }
402 EXPORT_SYMBOL(twl_i2c_write);
403
404 /**
405  * twl_i2c_read - Reads a n bit register in TWL4030/TWL5030/TWL60X0
406  * @mod_no: module number
407  * @value: an array of num_bytes containing data to be read
408  * @reg: register address (just offset will do)
409  * @num_bytes: number of bytes to transfer
410  *
411  * Returns result of operation - num_bytes is success else failure.
412  */
413 int twl_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
414 {
415         int ret;
416         u8 val;
417         int sid;
418         struct twl_client *twl;
419         struct i2c_msg *msg;
420
421         if (unlikely(mod_no > TWL_MODULE_LAST)) {
422                 pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
423                 return -EPERM;
424         }
425         if (unlikely(!inuse)) {
426                 pr_err("%s: not initialized\n", DRIVER_NAME);
427                 return -EPERM;
428         }
429         sid = twl_map[mod_no].sid;
430         if (unlikely(sid == SUB_CHIP_ID_INVAL)) {
431                 pr_err("%s: module %d is not part of the pmic\n",
432                        DRIVER_NAME, mod_no);
433                 return -EINVAL;
434         }
435         twl = &twl_modules[sid];
436
437         mutex_lock(&twl->xfer_lock);
438         /* [MSG1] fill the register address data */
439         msg = &twl->xfer_msg[0];
440         msg->addr = twl->address;
441         msg->len = 1;
442         msg->flags = 0; /* Read the register value */
443         val = twl_map[mod_no].base + reg;
444         msg->buf = &val;
445         /* [MSG2] fill the data rx buffer */
446         msg = &twl->xfer_msg[1];
447         msg->addr = twl->address;
448         msg->flags = I2C_M_RD;  /* Read the register value */
449         msg->len = num_bytes;   /* only n bytes */
450         msg->buf = value;
451         ret = i2c_transfer(twl->client->adapter, twl->xfer_msg, 2);
452         mutex_unlock(&twl->xfer_lock);
453
454         /* i2c_transfer returns number of messages transferred */
455         if (ret != 2) {
456                 pr_err("%s: i2c_read failed to transfer all messages\n",
457                         DRIVER_NAME);
458                 if (ret < 0)
459                         return ret;
460                 else
461                         return -EIO;
462         } else {
463                 return 0;
464         }
465 }
466 EXPORT_SYMBOL(twl_i2c_read);
467
468 /**
469  * twl_i2c_write_u8 - Writes a 8 bit register in TWL4030/TWL5030/TWL60X0
470  * @mod_no: module number
471  * @value: the value to be written 8 bit
472  * @reg: register address (just offset will do)
473  *
474  * Returns result of operation - 0 is success
475  */
476 int twl_i2c_write_u8(u8 mod_no, u8 value, u8 reg)
477 {
478
479         /* 2 bytes offset 1 contains the data offset 0 is used by i2c_write */
480         u8 temp_buffer[2] = { 0 };
481         /* offset 1 contains the data */
482         temp_buffer[1] = value;
483         return twl_i2c_write(mod_no, temp_buffer, reg, 1);
484 }
485 EXPORT_SYMBOL(twl_i2c_write_u8);
486
487 /**
488  * twl_i2c_read_u8 - Reads a 8 bit register from TWL4030/TWL5030/TWL60X0
489  * @mod_no: module number
490  * @value: the value read 8 bit
491  * @reg: register address (just offset will do)
492  *
493  * Returns result of operation - 0 is success
494  */
495 int twl_i2c_read_u8(u8 mod_no, u8 *value, u8 reg)
496 {
497         return twl_i2c_read(mod_no, value, reg, 1);
498 }
499 EXPORT_SYMBOL(twl_i2c_read_u8);
500
501 /*----------------------------------------------------------------------*/
502
503 /**
504  * twl_read_idcode_register - API to read the IDCODE register.
505  *
506  * Unlocks the IDCODE register and read the 32 bit value.
507  */
508 static int twl_read_idcode_register(void)
509 {
510         int err;
511
512         err = twl_i2c_write_u8(TWL4030_MODULE_INTBR, TWL_EEPROM_R_UNLOCK,
513                                                 REG_UNLOCK_TEST_REG);
514         if (err) {
515                 pr_err("TWL4030 Unable to unlock IDCODE registers -%d\n", err);
516                 goto fail;
517         }
518
519         err = twl_i2c_read(TWL4030_MODULE_INTBR, (u8 *)(&twl_idcode),
520                                                 REG_IDCODE_7_0, 4);
521         if (err) {
522                 pr_err("TWL4030: unable to read IDCODE -%d\n", err);
523                 goto fail;
524         }
525
526         err = twl_i2c_write_u8(TWL4030_MODULE_INTBR, 0x0, REG_UNLOCK_TEST_REG);
527         if (err)
528                 pr_err("TWL4030 Unable to relock IDCODE registers -%d\n", err);
529 fail:
530         return err;
531 }
532
533 /**
534  * twl_get_type - API to get TWL Si type.
535  *
536  * Api to get the TWL Si type from IDCODE value.
537  */
538 int twl_get_type(void)
539 {
540         return TWL_SIL_TYPE(twl_idcode);
541 }
542 EXPORT_SYMBOL_GPL(twl_get_type);
543
544 /**
545  * twl_get_version - API to get TWL Si version.
546  *
547  * Api to get the TWL Si version from IDCODE value.
548  */
549 int twl_get_version(void)
550 {
551         return TWL_SIL_REV(twl_idcode);
552 }
553 EXPORT_SYMBOL_GPL(twl_get_version);
554
555 static struct device *
556 add_numbered_child(unsigned chip, const char *name, int num,
557                 void *pdata, unsigned pdata_len,
558                 bool can_wakeup, int irq0, int irq1)
559 {
560         struct platform_device  *pdev;
561         struct twl_client       *twl = &twl_modules[chip];
562         int                     status;
563
564         pdev = platform_device_alloc(name, num);
565         if (!pdev) {
566                 dev_dbg(&twl->client->dev, "can't alloc dev\n");
567                 status = -ENOMEM;
568                 goto err;
569         }
570
571         pdev->dev.parent = &twl->client->dev;
572
573         if (pdata) {
574                 status = platform_device_add_data(pdev, pdata, pdata_len);
575                 if (status < 0) {
576                         dev_dbg(&pdev->dev, "can't add platform_data\n");
577                         goto err;
578                 }
579         }
580
581         if (irq0) {
582                 struct resource r[2] = {
583                         { .start = irq0, .flags = IORESOURCE_IRQ, },
584                         { .start = irq1, .flags = IORESOURCE_IRQ, },
585                 };
586
587                 status = platform_device_add_resources(pdev, r, irq1 ? 2 : 1);
588                 if (status < 0) {
589                         dev_dbg(&pdev->dev, "can't add irqs\n");
590                         goto err;
591                 }
592         }
593
594         status = platform_device_add(pdev);
595         if (status == 0)
596                 device_init_wakeup(&pdev->dev, can_wakeup);
597
598 err:
599         if (status < 0) {
600                 platform_device_put(pdev);
601                 dev_err(&twl->client->dev, "can't add %s dev\n", name);
602                 return ERR_PTR(status);
603         }
604         return &pdev->dev;
605 }
606
607 static inline struct device *add_child(unsigned chip, const char *name,
608                 void *pdata, unsigned pdata_len,
609                 bool can_wakeup, int irq0, int irq1)
610 {
611         return add_numbered_child(chip, name, -1, pdata, pdata_len,
612                 can_wakeup, irq0, irq1);
613 }
614
615 static struct device *
616 add_regulator_linked(int num, struct regulator_init_data *pdata,
617                 struct regulator_consumer_supply *consumers,
618                 unsigned num_consumers, unsigned long features)
619 {
620         unsigned sub_chip_id;
621         struct twl_regulator_driver_data drv_data;
622
623         /* regulator framework demands init_data ... */
624         if (!pdata)
625                 return NULL;
626
627         if (consumers) {
628                 pdata->consumer_supplies = consumers;
629                 pdata->num_consumer_supplies = num_consumers;
630         }
631
632         if (pdata->driver_data) {
633                 /* If we have existing drv_data, just add the flags */
634                 struct twl_regulator_driver_data *tmp;
635                 tmp = pdata->driver_data;
636                 tmp->features |= features;
637         } else {
638                 /* add new driver data struct, used only during init */
639                 drv_data.features = features;
640                 drv_data.set_voltage = NULL;
641                 drv_data.get_voltage = NULL;
642                 drv_data.data = NULL;
643                 pdata->driver_data = &drv_data;
644         }
645
646         /* NOTE:  we currently ignore regulator IRQs, e.g. for short circuits */
647         sub_chip_id = twl_map[TWL_MODULE_PM_MASTER].sid;
648         return add_numbered_child(sub_chip_id, "twl_reg", num,
649                 pdata, sizeof(*pdata), false, 0, 0);
650 }
651
652 static struct device *
653 add_regulator(int num, struct regulator_init_data *pdata,
654                 unsigned long features)
655 {
656         return add_regulator_linked(num, pdata, NULL, 0, features);
657 }
658
659 /*
660  * NOTE:  We know the first 8 IRQs after pdata->base_irq are
661  * for the PIH, and the next are for the PWR_INT SIH, since
662  * that's how twl_init_irq() sets things up.
663  */
664
665 static int
666 add_children(struct twl4030_platform_data *pdata, unsigned irq_base,
667                 unsigned long features)
668 {
669         struct device   *child;
670         unsigned sub_chip_id;
671
672         if (twl_has_gpio() && pdata->gpio) {
673                 child = add_child(SUB_CHIP_ID1, "twl4030_gpio",
674                                 pdata->gpio, sizeof(*pdata->gpio),
675                                 false, irq_base + GPIO_INTR_OFFSET, 0);
676                 if (IS_ERR(child))
677                         return PTR_ERR(child);
678         }
679
680         if (twl_has_keypad() && pdata->keypad) {
681                 child = add_child(SUB_CHIP_ID2, "twl4030_keypad",
682                                 pdata->keypad, sizeof(*pdata->keypad),
683                                 true, irq_base + KEYPAD_INTR_OFFSET, 0);
684                 if (IS_ERR(child))
685                         return PTR_ERR(child);
686         }
687
688         if (twl_has_madc() && pdata->madc) {
689                 child = add_child(2, "twl4030_madc",
690                                 pdata->madc, sizeof(*pdata->madc),
691                                 true, irq_base + MADC_INTR_OFFSET, 0);
692                 if (IS_ERR(child))
693                         return PTR_ERR(child);
694         }
695
696         if (twl_has_rtc()) {
697                 /*
698                  * REVISIT platform_data here currently might expose the
699                  * "msecure" line ... but for now we just expect board
700                  * setup to tell the chip "it's always ok to SET_TIME".
701                  * Eventually, Linux might become more aware of such
702                  * HW security concerns, and "least privilege".
703                  */
704                 sub_chip_id = twl_map[TWL_MODULE_RTC].sid;
705                 child = add_child(sub_chip_id, "twl_rtc",
706                                 NULL, 0,
707                                 true, irq_base + RTC_INTR_OFFSET, 0);
708                 if (IS_ERR(child))
709                         return PTR_ERR(child);
710         }
711
712         if (twl_has_usb() && pdata->usb && twl_class_is_4030()) {
713
714                 static struct regulator_consumer_supply usb1v5 = {
715                         .supply =       "usb1v5",
716                 };
717                 static struct regulator_consumer_supply usb1v8 = {
718                         .supply =       "usb1v8",
719                 };
720                 static struct regulator_consumer_supply usb3v1 = {
721                         .supply =       "usb3v1",
722                 };
723
724         /* First add the regulators so that they can be used by transceiver */
725                 if (twl_has_regulator()) {
726                         /* this is a template that gets copied */
727                         struct regulator_init_data usb_fixed = {
728                                 .constraints.valid_modes_mask =
729                                         REGULATOR_MODE_NORMAL
730                                         | REGULATOR_MODE_STANDBY,
731                                 .constraints.valid_ops_mask =
732                                         REGULATOR_CHANGE_MODE
733                                         | REGULATOR_CHANGE_STATUS,
734                         };
735
736                         child = add_regulator_linked(TWL4030_REG_VUSB1V5,
737                                                       &usb_fixed, &usb1v5, 1,
738                                                       features);
739                         if (IS_ERR(child))
740                                 return PTR_ERR(child);
741
742                         child = add_regulator_linked(TWL4030_REG_VUSB1V8,
743                                                       &usb_fixed, &usb1v8, 1,
744                                                       features);
745                         if (IS_ERR(child))
746                                 return PTR_ERR(child);
747
748                         child = add_regulator_linked(TWL4030_REG_VUSB3V1,
749                                                       &usb_fixed, &usb3v1, 1,
750                                                       features);
751                         if (IS_ERR(child))
752                                 return PTR_ERR(child);
753
754                 }
755
756                 child = add_child(0, "twl4030_usb",
757                                 pdata->usb, sizeof(*pdata->usb),
758                                 true,
759                                 /* irq0 = USB_PRES, irq1 = USB */
760                                 irq_base + USB_PRES_INTR_OFFSET,
761                                 irq_base + USB_INTR_OFFSET);
762
763                 if (IS_ERR(child))
764                         return PTR_ERR(child);
765
766                 /* we need to connect regulators to this transceiver */
767                 if (twl_has_regulator() && child) {
768                         usb1v5.dev_name = dev_name(child);
769                         usb1v8.dev_name = dev_name(child);
770                         usb3v1.dev_name = dev_name(child);
771                 }
772         }
773         if (twl_has_usb() && pdata->usb && twl_class_is_6030()) {
774
775                 static struct regulator_consumer_supply usb3v3;
776                 int regulator;
777
778                 if (twl_has_regulator()) {
779                         /* this is a template that gets copied */
780                         struct regulator_init_data usb_fixed = {
781                                 .constraints.valid_modes_mask =
782                                         REGULATOR_MODE_NORMAL
783                                         | REGULATOR_MODE_STANDBY,
784                                 .constraints.valid_ops_mask =
785                                         REGULATOR_CHANGE_MODE
786                                         | REGULATOR_CHANGE_STATUS,
787                         };
788
789                         if (features & TWL6025_SUBCLASS) {
790                                 usb3v3.supply = "ldousb";
791                                 regulator = TWL6025_REG_LDOUSB;
792                         } else {
793                                 usb3v3.supply = "vusb";
794                                 regulator = TWL6030_REG_VUSB;
795                         }
796                         child = add_regulator_linked(regulator, &usb_fixed,
797                                                         &usb3v3, 1,
798                                                         features);
799                         if (IS_ERR(child))
800                                 return PTR_ERR(child);
801                 }
802
803                 pdata->usb->features = features;
804
805                 child = add_child(0, "twl6030_usb",
806                         pdata->usb, sizeof(*pdata->usb),
807                         true,
808                         /* irq1 = VBUS_PRES, irq0 = USB ID */
809                         irq_base + USBOTG_INTR_OFFSET,
810                         irq_base + USB_PRES_INTR_OFFSET);
811
812                 if (IS_ERR(child))
813                         return PTR_ERR(child);
814                 /* we need to connect regulators to this transceiver */
815                 if (twl_has_regulator() && child)
816                         usb3v3.dev_name = dev_name(child);
817         } else if (twl_has_regulator() && twl_class_is_6030()) {
818                 if (features & TWL6025_SUBCLASS)
819                         child = add_regulator(TWL6025_REG_LDOUSB,
820                                                 pdata->ldousb, features);
821                 else
822                         child = add_regulator(TWL6030_REG_VUSB,
823                                                 pdata->vusb, features);
824
825                         if (IS_ERR(child))
826                                         return PTR_ERR(child);
827         }
828
829         if (twl_has_watchdog() && twl_class_is_4030()) {
830                 child = add_child(0, "twl4030_wdt", NULL, 0, false, 0, 0);
831                 if (IS_ERR(child))
832                         return PTR_ERR(child);
833         }
834
835         if (twl_has_pwrbutton() && twl_class_is_4030()) {
836                 child = add_child(1, "twl4030_pwrbutton",
837                                 NULL, 0, true, irq_base + 8 + 0, 0);
838                 if (IS_ERR(child))
839                         return PTR_ERR(child);
840         }
841
842         if (twl_has_codec() && pdata->audio && twl_class_is_4030()) {
843                 sub_chip_id = twl_map[TWL_MODULE_AUDIO_VOICE].sid;
844                 child = add_child(sub_chip_id, "twl4030-audio",
845                                 pdata->audio, sizeof(*pdata->audio),
846                                 false, 0, 0);
847                 if (IS_ERR(child))
848                         return PTR_ERR(child);
849         }
850
851         /* twl4030 regulators */
852         if (twl_has_regulator() && twl_class_is_4030()) {
853                 child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1,
854                                         features);
855                 if (IS_ERR(child))
856                         return PTR_ERR(child);
857
858                 child = add_regulator(TWL4030_REG_VIO, pdata->vio,
859                                         features);
860                 if (IS_ERR(child))
861                         return PTR_ERR(child);
862
863                 child = add_regulator(TWL4030_REG_VDD1, pdata->vdd1,
864                                         features);
865                 if (IS_ERR(child))
866                         return PTR_ERR(child);
867
868                 child = add_regulator(TWL4030_REG_VDD2, pdata->vdd2,
869                                         features);
870                 if (IS_ERR(child))
871                         return PTR_ERR(child);
872
873                 child = add_regulator(TWL4030_REG_VMMC1, pdata->vmmc1,
874                                         features);
875                 if (IS_ERR(child))
876                         return PTR_ERR(child);
877
878                 child = add_regulator(TWL4030_REG_VDAC, pdata->vdac,
879                                         features);
880                 if (IS_ERR(child))
881                         return PTR_ERR(child);
882
883                 child = add_regulator((features & TWL4030_VAUX2)
884                                         ? TWL4030_REG_VAUX2_4030
885                                         : TWL4030_REG_VAUX2,
886                                 pdata->vaux2, features);
887                 if (IS_ERR(child))
888                         return PTR_ERR(child);
889
890                 child = add_regulator(TWL4030_REG_VINTANA1, pdata->vintana1,
891                                         features);
892                 if (IS_ERR(child))
893                         return PTR_ERR(child);
894
895                 child = add_regulator(TWL4030_REG_VINTANA2, pdata->vintana2,
896                                         features);
897                 if (IS_ERR(child))
898                         return PTR_ERR(child);
899
900                 child = add_regulator(TWL4030_REG_VINTDIG, pdata->vintdig,
901                                         features);
902                 if (IS_ERR(child))
903                         return PTR_ERR(child);
904         }
905
906         /* maybe add LDOs that are omitted on cost-reduced parts */
907         if (twl_has_regulator() && !(features & TPS_SUBSET)
908           && twl_class_is_4030()) {
909                 child = add_regulator(TWL4030_REG_VPLL2, pdata->vpll2,
910                                         features);
911                 if (IS_ERR(child))
912                         return PTR_ERR(child);
913
914                 child = add_regulator(TWL4030_REG_VMMC2, pdata->vmmc2,
915                                         features);
916                 if (IS_ERR(child))
917                         return PTR_ERR(child);
918
919                 child = add_regulator(TWL4030_REG_VSIM, pdata->vsim,
920                                         features);
921                 if (IS_ERR(child))
922                         return PTR_ERR(child);
923
924                 child = add_regulator(TWL4030_REG_VAUX1, pdata->vaux1,
925                                         features);
926                 if (IS_ERR(child))
927                         return PTR_ERR(child);
928
929                 child = add_regulator(TWL4030_REG_VAUX3, pdata->vaux3,
930                                         features);
931                 if (IS_ERR(child))
932                         return PTR_ERR(child);
933
934                 child = add_regulator(TWL4030_REG_VAUX4, pdata->vaux4,
935                                         features);
936                 if (IS_ERR(child))
937                         return PTR_ERR(child);
938         }
939
940         /* twl6030 regulators */
941         if (twl_has_regulator() && twl_class_is_6030() &&
942                         !(features & TWL6025_SUBCLASS)) {
943                 child = add_regulator(TWL6030_REG_VDD1, pdata->vdd1,
944                                         features);
945                 if (IS_ERR(child))
946                         return PTR_ERR(child);
947
948                 child = add_regulator(TWL6030_REG_VDD2, pdata->vdd2,
949                                         features);
950                 if (IS_ERR(child))
951                         return PTR_ERR(child);
952
953                 child = add_regulator(TWL6030_REG_VDD3, pdata->vdd3,
954                                         features);
955                 if (IS_ERR(child))
956                         return PTR_ERR(child);
957
958                 child = add_regulator(TWL6030_REG_V1V8, pdata->v1v8,
959                                         features);
960                 if (IS_ERR(child))
961                         return PTR_ERR(child);
962
963                 child = add_regulator(TWL6030_REG_V2V1, pdata->v2v1,
964                                         features);
965                 if (IS_ERR(child))
966                         return PTR_ERR(child);
967
968                 child = add_regulator(TWL6030_REG_VMMC, pdata->vmmc,
969                                         features);
970                 if (IS_ERR(child))
971                         return PTR_ERR(child);
972
973                 child = add_regulator(TWL6030_REG_VPP, pdata->vpp,
974                                         features);
975                 if (IS_ERR(child))
976                         return PTR_ERR(child);
977
978                 child = add_regulator(TWL6030_REG_VUSIM, pdata->vusim,
979                                         features);
980                 if (IS_ERR(child))
981                         return PTR_ERR(child);
982
983                 child = add_regulator(TWL6030_REG_VCXIO, pdata->vcxio,
984                                         features);
985                 if (IS_ERR(child))
986                         return PTR_ERR(child);
987
988                 child = add_regulator(TWL6030_REG_VDAC, pdata->vdac,
989                                         features);
990                 if (IS_ERR(child))
991                         return PTR_ERR(child);
992
993                 child = add_regulator(TWL6030_REG_VAUX1_6030, pdata->vaux1,
994                                         features);
995                 if (IS_ERR(child))
996                         return PTR_ERR(child);
997
998                 child = add_regulator(TWL6030_REG_VAUX2_6030, pdata->vaux2,
999                                         features);
1000                 if (IS_ERR(child))
1001                         return PTR_ERR(child);
1002
1003                 child = add_regulator(TWL6030_REG_VAUX3_6030, pdata->vaux3,
1004                                         features);
1005                 if (IS_ERR(child))
1006                         return PTR_ERR(child);
1007
1008                 child = add_regulator(TWL6030_REG_CLK32KG, pdata->clk32kg,
1009                                         features);
1010                 if (IS_ERR(child))
1011                         return PTR_ERR(child);
1012         }
1013
1014         /* 6030 and 6025 share this regulator */
1015         if (twl_has_regulator() && twl_class_is_6030()) {
1016                 child = add_regulator(TWL6030_REG_VANA, pdata->vana,
1017                                         features);
1018                 if (IS_ERR(child))
1019                         return PTR_ERR(child);
1020         }
1021
1022         /* twl6025 regulators */
1023         if (twl_has_regulator() && twl_class_is_6030() &&
1024                         (features & TWL6025_SUBCLASS)) {
1025                 child = add_regulator(TWL6025_REG_LDO5, pdata->ldo5,
1026                                         features);
1027                 if (IS_ERR(child))
1028                         return PTR_ERR(child);
1029
1030                 child = add_regulator(TWL6025_REG_LDO1, pdata->ldo1,
1031                                         features);
1032                 if (IS_ERR(child))
1033                         return PTR_ERR(child);
1034
1035                 child = add_regulator(TWL6025_REG_LDO7, pdata->ldo7,
1036                                         features);
1037                 if (IS_ERR(child))
1038                         return PTR_ERR(child);
1039
1040                 child = add_regulator(TWL6025_REG_LDO6, pdata->ldo6,
1041                                         features);
1042                 if (IS_ERR(child))
1043                         return PTR_ERR(child);
1044
1045                 child = add_regulator(TWL6025_REG_LDOLN, pdata->ldoln,
1046                                         features);
1047                 if (IS_ERR(child))
1048                         return PTR_ERR(child);
1049
1050                 child = add_regulator(TWL6025_REG_LDO2, pdata->ldo2,
1051                                         features);
1052                 if (IS_ERR(child))
1053                         return PTR_ERR(child);
1054
1055                 child = add_regulator(TWL6025_REG_LDO4, pdata->ldo4,
1056                                         features);
1057                 if (IS_ERR(child))
1058                         return PTR_ERR(child);
1059
1060                 child = add_regulator(TWL6025_REG_LDO3, pdata->ldo3,
1061                                         features);
1062                 if (IS_ERR(child))
1063                         return PTR_ERR(child);
1064
1065                 child = add_regulator(TWL6025_REG_SMPS3, pdata->smps3,
1066                                         features);
1067                 if (IS_ERR(child))
1068                         return PTR_ERR(child);
1069
1070                 child = add_regulator(TWL6025_REG_SMPS4, pdata->smps4,
1071                                         features);
1072                 if (IS_ERR(child))
1073                         return PTR_ERR(child);
1074
1075                 child = add_regulator(TWL6025_REG_VIO, pdata->vio6025,
1076                                         features);
1077                 if (IS_ERR(child))
1078                         return PTR_ERR(child);
1079
1080         }
1081
1082         if (twl_has_bci() && pdata->bci &&
1083                         !(features & (TPS_SUBSET | TWL5031))) {
1084                 child = add_child(3, "twl4030_bci",
1085                                 pdata->bci, sizeof(*pdata->bci), false,
1086                                 /* irq0 = CHG_PRES, irq1 = BCI */
1087                                 irq_base + BCI_PRES_INTR_OFFSET,
1088                                 irq_base + BCI_INTR_OFFSET);
1089                 if (IS_ERR(child))
1090                         return PTR_ERR(child);
1091         }
1092
1093         return 0;
1094 }
1095
1096 /*----------------------------------------------------------------------*/
1097
1098 /*
1099  * These three functions initialize the on-chip clock framework,
1100  * letting it generate the right frequencies for USB, MADC, and
1101  * other purposes.
1102  */
1103 static inline int __init protect_pm_master(void)
1104 {
1105         int e = 0;
1106
1107         e = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0,
1108                         TWL4030_PM_MASTER_PROTECT_KEY);
1109         return e;
1110 }
1111
1112 static inline int __init unprotect_pm_master(void)
1113 {
1114         int e = 0;
1115
1116         e |= twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER,
1117                         TWL4030_PM_MASTER_KEY_CFG1,
1118                         TWL4030_PM_MASTER_PROTECT_KEY);
1119         e |= twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER,
1120                         TWL4030_PM_MASTER_KEY_CFG2,
1121                         TWL4030_PM_MASTER_PROTECT_KEY);
1122
1123         return e;
1124 }
1125
1126 static void clocks_init(struct device *dev,
1127                         struct twl4030_clock_init_data *clock)
1128 {
1129         int e = 0;
1130         struct clk *osc;
1131         u32 rate;
1132         u8 ctrl = HFCLK_FREQ_26_MHZ;
1133
1134 #if defined(CONFIG_ARCH_OMAP2) || defined(CONFIG_ARCH_OMAP3)
1135         if (cpu_is_omap2430())
1136                 osc = clk_get(dev, "osc_ck");
1137         else
1138                 osc = clk_get(dev, "osc_sys_ck");
1139
1140         if (IS_ERR(osc)) {
1141                 printk(KERN_WARNING "Skipping twl internal clock init and "
1142                                 "using bootloader value (unknown osc rate)\n");
1143                 return;
1144         }
1145
1146         rate = clk_get_rate(osc);
1147         clk_put(osc);
1148
1149 #else
1150         /* REVISIT for non-OMAP systems, pass the clock rate from
1151          * board init code, using platform_data.
1152          */
1153         osc = ERR_PTR(-EIO);
1154
1155         printk(KERN_WARNING "Skipping twl internal clock init and "
1156                "using bootloader value (unknown osc rate)\n");
1157
1158         return;
1159 #endif
1160
1161         switch (rate) {
1162         case 19200000:
1163                 ctrl = HFCLK_FREQ_19p2_MHZ;
1164                 break;
1165         case 26000000:
1166                 ctrl = HFCLK_FREQ_26_MHZ;
1167                 break;
1168         case 38400000:
1169                 ctrl = HFCLK_FREQ_38p4_MHZ;
1170                 break;
1171         }
1172
1173         ctrl |= HIGH_PERF_SQ;
1174         if (clock && clock->ck32k_lowpwr_enable)
1175                 ctrl |= CK32K_LOWPWR_EN;
1176
1177         e |= unprotect_pm_master();
1178         /* effect->MADC+USB ck en */
1179         e |= twl_i2c_write_u8(TWL_MODULE_PM_MASTER, ctrl, R_CFG_BOOT);
1180         e |= protect_pm_master();
1181
1182         if (e < 0)
1183                 pr_err("%s: clock init err [%d]\n", DRIVER_NAME, e);
1184 }
1185
1186 /*----------------------------------------------------------------------*/
1187
1188
1189 static int twl_remove(struct i2c_client *client)
1190 {
1191         unsigned i, num_slaves;
1192         int status;
1193
1194         if (twl_class_is_4030()) {
1195                 status = twl4030_exit_irq();
1196                 num_slaves = TWL_NUM_SLAVES;
1197         } else {
1198                 status = twl6030_exit_irq();
1199                 num_slaves = TWL_NUM_SLAVES - 1;
1200         }
1201
1202         if (status < 0)
1203                 return status;
1204
1205         for (i = 0; i < num_slaves; i++) {
1206                 struct twl_client       *twl = &twl_modules[i];
1207
1208                 if (twl->client && twl->client != client)
1209                         i2c_unregister_device(twl->client);
1210                 twl_modules[i].client = NULL;
1211         }
1212         inuse = false;
1213         return 0;
1214 }
1215
1216 /* NOTE: This driver only handles a single twl4030/tps659x0 chip */
1217 static int __devinit
1218 twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
1219 {
1220         struct twl4030_platform_data    *pdata = client->dev.platform_data;
1221         struct device_node              *node = client->dev.of_node;
1222         int                             irq_base = 0;
1223         int                             status;
1224         unsigned                        i, num_slaves;
1225
1226         if (node && !pdata) {
1227                 /*
1228                  * XXX: Temporary pdata until the information is correctly
1229                  * retrieved by every TWL modules from DT.
1230                  */
1231                 pdata = devm_kzalloc(&client->dev,
1232                                      sizeof(struct twl4030_platform_data),
1233                                      GFP_KERNEL);
1234                 if (!pdata)
1235                         return -ENOMEM;
1236         }
1237
1238         if (!pdata) {
1239                 dev_dbg(&client->dev, "no platform data?\n");
1240                 return -EINVAL;
1241         }
1242
1243         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
1244                 dev_dbg(&client->dev, "can't talk I2C?\n");
1245                 return -EIO;
1246         }
1247
1248         if (inuse) {
1249                 dev_dbg(&client->dev, "driver is already in use\n");
1250                 return -EBUSY;
1251         }
1252
1253         if ((id->driver_data) & TWL6030_CLASS) {
1254                 twl_id = TWL6030_CLASS_ID;
1255                 twl_map = &twl6030_map[0];
1256                 num_slaves = TWL_NUM_SLAVES - 1;
1257         } else {
1258                 twl_id = TWL4030_CLASS_ID;
1259                 twl_map = &twl4030_map[0];
1260                 num_slaves = TWL_NUM_SLAVES;
1261         }
1262
1263         for (i = 0; i < num_slaves; i++) {
1264                 struct twl_client *twl = &twl_modules[i];
1265
1266                 twl->address = client->addr + i;
1267                 if (i == 0) {
1268                         twl->client = client;
1269                 } else {
1270                         twl->client = i2c_new_dummy(client->adapter,
1271                                         twl->address);
1272                         if (!twl->client) {
1273                                 dev_err(&client->dev,
1274                                         "can't attach client %d\n", i);
1275                                 status = -ENOMEM;
1276                                 goto fail;
1277                         }
1278                 }
1279                 mutex_init(&twl->xfer_lock);
1280         }
1281
1282         inuse = true;
1283
1284         /* setup clock framework */
1285         clocks_init(&client->dev, pdata->clock);
1286
1287         /* read TWL IDCODE Register */
1288         if (twl_id == TWL4030_CLASS_ID) {
1289                 status = twl_read_idcode_register();
1290                 WARN(status < 0, "Error: reading twl_idcode register value\n");
1291         }
1292
1293         /* load power event scripts */
1294         if (twl_has_power() && pdata->power)
1295                 twl4030_power_init(pdata->power);
1296
1297         /* Maybe init the T2 Interrupt subsystem */
1298         if (client->irq) {
1299                 if (twl_class_is_4030()) {
1300                         twl4030_init_chip_irq(id->name);
1301                         irq_base = twl4030_init_irq(&client->dev, client->irq);
1302                 } else {
1303                         irq_base = twl6030_init_irq(&client->dev, client->irq);
1304                 }
1305
1306                 if (irq_base < 0) {
1307                         status = irq_base;
1308                         goto fail;
1309                 }
1310         }
1311
1312         /*
1313          * Disable TWL4030/TWL5030 I2C Pull-up on I2C1 and I2C4(SR) interface.
1314          * Program I2C_SCL_CTRL_PU(bit 0)=0, I2C_SDA_CTRL_PU (bit 2)=0,
1315          * SR_I2C_SCL_CTRL_PU(bit 4)=0 and SR_I2C_SDA_CTRL_PU(bit 6)=0.
1316          */
1317         if (twl_class_is_4030()) {
1318                 u8 temp;
1319
1320                 twl_i2c_read_u8(TWL4030_MODULE_INTBR, &temp, REG_GPPUPDCTR1);
1321                 temp &= ~(SR_I2C_SDA_CTRL_PU | SR_I2C_SCL_CTRL_PU | \
1322                         I2C_SDA_CTRL_PU | I2C_SCL_CTRL_PU);
1323                 twl_i2c_write_u8(TWL4030_MODULE_INTBR, temp, REG_GPPUPDCTR1);
1324         }
1325
1326         status = -ENODEV;
1327         if (node)
1328                 status = of_platform_populate(node, NULL, NULL, &client->dev);
1329         if (status)
1330                 status = add_children(pdata, irq_base, id->driver_data);
1331
1332 fail:
1333         if (status < 0)
1334                 twl_remove(client);
1335
1336         return status;
1337 }
1338
1339 static const struct i2c_device_id twl_ids[] = {
1340         { "twl4030", TWL4030_VAUX2 },   /* "Triton 2" */
1341         { "twl5030", 0 },               /* T2 updated */
1342         { "twl5031", TWL5031 },         /* TWL5030 updated */
1343         { "tps65950", 0 },              /* catalog version of twl5030 */
1344         { "tps65930", TPS_SUBSET },     /* fewer LDOs and DACs; no charger */
1345         { "tps65920", TPS_SUBSET },     /* fewer LDOs; no codec or charger */
1346         { "tps65921", TPS_SUBSET },     /* fewer LDOs; no codec, no LED
1347                                            and vibrator. Charger in USB module*/
1348         { "twl6030", TWL6030_CLASS },   /* "Phoenix power chip" */
1349         { "twl6025", TWL6030_CLASS | TWL6025_SUBCLASS }, /* "Phoenix lite" */
1350         { /* end of list */ },
1351 };
1352 MODULE_DEVICE_TABLE(i2c, twl_ids);
1353
1354 /* One Client Driver , 4 Clients */
1355 static struct i2c_driver twl_driver = {
1356         .driver.name    = DRIVER_NAME,
1357         .id_table       = twl_ids,
1358         .probe          = twl_probe,
1359         .remove         = twl_remove,
1360 };
1361
1362 static int __init twl_init(void)
1363 {
1364         return i2c_add_driver(&twl_driver);
1365 }
1366 subsys_initcall(twl_init);
1367
1368 static void __exit twl_exit(void)
1369 {
1370         i2c_del_driver(&twl_driver);
1371 }
1372 module_exit(twl_exit);
1373
1374 MODULE_AUTHOR("Texas Instruments, Inc.");
1375 MODULE_DESCRIPTION("I2C Core interface for TWL");
1376 MODULE_LICENSE("GPL");