2 * twl_core.c - driver for TWL4030/TWL5030/TWL60X0/TPS659x0 PM
3 * and audio CODEC devices
5 * Copyright (C) 2005-2006 Texas Instruments, Inc.
7 * Modifications to defer interrupt handling to a kernel thread:
8 * Copyright (C) 2006 MontaVista Software, Inc.
10 * Based on tlv320aic23.c:
11 * Copyright (c) by Kai Svahn <kai.svahn@nokia.com>
13 * Code cleanup and modifications to IRQ handler.
14 * by syed khasim <x0khasim@ti.com>
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.
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.
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
31 #include <linux/init.h>
32 #include <linux/mutex.h>
33 #include <linux/module.h>
34 #include <linux/platform_device.h>
35 #include <linux/regmap.h>
36 #include <linux/clk.h>
37 #include <linux/err.h>
38 #include <linux/device.h>
40 #include <linux/of_irq.h>
41 #include <linux/of_platform.h>
42 #include <linux/irq.h>
43 #include <linux/irqdomain.h>
45 #include <linux/regulator/machine.h>
47 #include <linux/i2c.h>
48 #include <linux/i2c/twl.h>
53 * The TWL4030 "Triton 2" is one of a family of a multi-function "Power
54 * Management and System Companion Device" chips originally designed for
55 * use in OMAP2 and OMAP 3 based systems. Its control interfaces use I2C,
56 * often at around 3 Mbit/sec, including for interrupt handling.
58 * This driver core provides genirq support for the interrupts emitted,
59 * by the various modules, and exports register access primitives.
61 * FIXME this driver currently requires use of the first interrupt line
62 * (and associated registers).
65 #define DRIVER_NAME "twl"
67 /* Triton Core internal information (BEGIN) */
69 /* Base Address defns for twl4030_map[] */
71 /* subchip/slave 0 - USB ID */
72 #define TWL4030_BASEADD_USB 0x0000
74 /* subchip/slave 1 - AUD ID */
75 #define TWL4030_BASEADD_AUDIO_VOICE 0x0000
76 #define TWL4030_BASEADD_GPIO 0x0098
77 #define TWL4030_BASEADD_INTBR 0x0085
78 #define TWL4030_BASEADD_PIH 0x0080
79 #define TWL4030_BASEADD_TEST 0x004C
81 /* subchip/slave 2 - AUX ID */
82 #define TWL4030_BASEADD_INTERRUPTS 0x00B9
83 #define TWL4030_BASEADD_LED 0x00EE
84 #define TWL4030_BASEADD_MADC 0x0000
85 #define TWL4030_BASEADD_MAIN_CHARGE 0x0074
86 #define TWL4030_BASEADD_PRECHARGE 0x00AA
87 #define TWL4030_BASEADD_PWM 0x00F8
88 #define TWL4030_BASEADD_KEYPAD 0x00D2
90 #define TWL5031_BASEADD_ACCESSORY 0x0074 /* Replaces Main Charge */
91 #define TWL5031_BASEADD_INTERRUPTS 0x00B9 /* Different than TWL4030's
94 /* subchip/slave 3 - POWER ID */
95 #define TWL4030_BASEADD_BACKUP 0x0014
96 #define TWL4030_BASEADD_INT 0x002E
97 #define TWL4030_BASEADD_PM_MASTER 0x0036
98 #define TWL4030_BASEADD_PM_RECEIVER 0x005B
99 #define TWL4030_BASEADD_RTC 0x001C
100 #define TWL4030_BASEADD_SECURED_REG 0x0000
102 /* Triton Core internal information (END) */
105 /* subchip/slave 0 0x48 - POWER */
106 #define TWL6030_BASEADD_RTC 0x0000
107 #define TWL6030_BASEADD_SECURED_REG 0x0017
108 #define TWL6030_BASEADD_PM_MASTER 0x001F
109 #define TWL6030_BASEADD_PM_SLAVE_MISC 0x0030 /* PM_RECEIVER */
110 #define TWL6030_BASEADD_PM_MISC 0x00E2
111 #define TWL6030_BASEADD_PM_PUPD 0x00F0
113 /* subchip/slave 1 0x49 - FEATURE */
114 #define TWL6030_BASEADD_USB 0x0000
115 #define TWL6030_BASEADD_GPADC_CTRL 0x002E
116 #define TWL6030_BASEADD_AUX 0x0090
117 #define TWL6030_BASEADD_PWM 0x00BA
118 #define TWL6030_BASEADD_GASGAUGE 0x00C0
119 #define TWL6030_BASEADD_PIH 0x00D0
120 #define TWL6030_BASEADD_CHARGER 0x00E0
121 #define TWL6032_BASEADD_CHARGER 0x00DA
122 #define TWL6030_BASEADD_LED 0x00F4
124 /* subchip/slave 2 0x4A - DFT */
125 #define TWL6030_BASEADD_DIEID 0x00C0
127 /* subchip/slave 3 0x4B - AUDIO */
128 #define TWL6030_BASEADD_AUDIO 0x0000
129 #define TWL6030_BASEADD_RSV 0x0000
130 #define TWL6030_BASEADD_ZERO 0x0000
132 /* Few power values */
133 #define R_CFG_BOOT 0x05
135 /* some fields in R_CFG_BOOT */
136 #define HFCLK_FREQ_19p2_MHZ (1 << 0)
137 #define HFCLK_FREQ_26_MHZ (2 << 0)
138 #define HFCLK_FREQ_38p4_MHZ (3 << 0)
139 #define HIGH_PERF_SQ (1 << 3)
140 #define CK32K_LOWPWR_EN (1 << 7)
142 /*----------------------------------------------------------------------*/
144 /* Structure for each TWL4030/TWL6030 Slave */
146 struct i2c_client *client;
147 struct regmap *regmap;
150 /* mapping the module id to slave id and base address */
152 unsigned char sid; /* Slave ID */
153 unsigned char base; /* base address */
157 bool ready; /* The core driver is ready to be used */
158 u32 twl_idcode; /* TWL IDCODE Register value */
161 struct twl_mapping *twl_map;
162 struct twl_client *twl_modules;
165 static struct twl_private *twl_priv;
167 static struct twl_mapping twl4030_map[] = {
169 * NOTE: don't change this table without updating the
170 * <linux/i2c/twl.h> defines for TWL4030_MODULE_*
171 * so they continue to match the order in this table.
175 { 0, TWL4030_BASEADD_USB },
176 { 1, TWL4030_BASEADD_PIH },
177 { 2, TWL4030_BASEADD_MAIN_CHARGE },
178 { 3, TWL4030_BASEADD_PM_MASTER },
179 { 3, TWL4030_BASEADD_PM_RECEIVER },
181 { 3, TWL4030_BASEADD_RTC },
182 { 2, TWL4030_BASEADD_PWM },
183 { 2, TWL4030_BASEADD_LED },
184 { 3, TWL4030_BASEADD_SECURED_REG },
186 /* TWL4030 specific IPs */
187 { 1, TWL4030_BASEADD_AUDIO_VOICE },
188 { 1, TWL4030_BASEADD_GPIO },
189 { 1, TWL4030_BASEADD_INTBR },
190 { 1, TWL4030_BASEADD_TEST },
191 { 2, TWL4030_BASEADD_KEYPAD },
193 { 2, TWL4030_BASEADD_MADC },
194 { 2, TWL4030_BASEADD_INTERRUPTS },
195 { 2, TWL4030_BASEADD_PRECHARGE },
196 { 3, TWL4030_BASEADD_BACKUP },
197 { 3, TWL4030_BASEADD_INT },
199 { 2, TWL5031_BASEADD_ACCESSORY },
200 { 2, TWL5031_BASEADD_INTERRUPTS },
203 static struct regmap_config twl4030_regmap_config[4] = {
208 .max_register = 0xff,
214 .max_register = 0xff,
220 .max_register = 0xff,
226 .max_register = 0xff,
230 static struct twl_mapping twl6030_map[] = {
232 * NOTE: don't change this table without updating the
233 * <linux/i2c/twl.h> defines for TWL4030_MODULE_*
234 * so they continue to match the order in this table.
238 { 1, TWL6030_BASEADD_USB },
239 { 1, TWL6030_BASEADD_PIH },
240 { 1, TWL6030_BASEADD_CHARGER },
241 { 0, TWL6030_BASEADD_PM_MASTER },
242 { 0, TWL6030_BASEADD_PM_SLAVE_MISC },
244 { 0, TWL6030_BASEADD_RTC },
245 { 1, TWL6030_BASEADD_PWM },
246 { 1, TWL6030_BASEADD_LED },
247 { 0, TWL6030_BASEADD_SECURED_REG },
249 /* TWL6030 specific IPs */
250 { 0, TWL6030_BASEADD_ZERO },
251 { 1, TWL6030_BASEADD_ZERO },
252 { 2, TWL6030_BASEADD_ZERO },
253 { 1, TWL6030_BASEADD_GPADC_CTRL },
254 { 1, TWL6030_BASEADD_GASGAUGE },
257 static struct regmap_config twl6030_regmap_config[3] = {
262 .max_register = 0xff,
268 .max_register = 0xff,
274 .max_register = 0xff,
278 /*----------------------------------------------------------------------*/
280 static inline int twl_get_num_slaves(void)
282 if (twl_class_is_4030())
283 return 4; /* TWL4030 class have four slave address */
285 return 3; /* TWL6030 class have three slave address */
288 static inline int twl_get_last_module(void)
290 if (twl_class_is_4030())
291 return TWL4030_MODULE_LAST;
293 return TWL6030_MODULE_LAST;
296 /* Exported Functions */
298 unsigned int twl_rev(void)
300 return twl_priv ? twl_priv->twl_id : 0;
302 EXPORT_SYMBOL(twl_rev);
305 * twl_i2c_write - Writes a n bit register in TWL4030/TWL5030/TWL60X0
306 * @mod_no: module number
307 * @value: an array of num_bytes+1 containing data to write
308 * @reg: register address (just offset will do)
309 * @num_bytes: number of bytes to transfer
311 * Returns the result of operation - 0 is success
313 int twl_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
317 struct twl_client *twl;
319 if (unlikely(!twl_priv || !twl_priv->ready)) {
320 pr_err("%s: not initialized\n", DRIVER_NAME);
323 if (unlikely(mod_no >= twl_get_last_module())) {
324 pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
328 sid = twl_priv->twl_map[mod_no].sid;
329 twl = &twl_priv->twl_modules[sid];
331 ret = regmap_bulk_write(twl->regmap,
332 twl_priv->twl_map[mod_no].base + reg, value,
336 pr_err("%s: Write failed (mod %d, reg 0x%02x count %d)\n",
337 DRIVER_NAME, mod_no, reg, num_bytes);
341 EXPORT_SYMBOL(twl_i2c_write);
344 * twl_i2c_read - Reads a n bit register in TWL4030/TWL5030/TWL60X0
345 * @mod_no: module number
346 * @value: an array of num_bytes containing data to be read
347 * @reg: register address (just offset will do)
348 * @num_bytes: number of bytes to transfer
350 * Returns result of operation - num_bytes is success else failure.
352 int twl_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
356 struct twl_client *twl;
358 if (unlikely(!twl_priv || !twl_priv->ready)) {
359 pr_err("%s: not initialized\n", DRIVER_NAME);
362 if (unlikely(mod_no >= twl_get_last_module())) {
363 pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
367 sid = twl_priv->twl_map[mod_no].sid;
368 twl = &twl_priv->twl_modules[sid];
370 ret = regmap_bulk_read(twl->regmap,
371 twl_priv->twl_map[mod_no].base + reg, value,
375 pr_err("%s: Read failed (mod %d, reg 0x%02x count %d)\n",
376 DRIVER_NAME, mod_no, reg, num_bytes);
380 EXPORT_SYMBOL(twl_i2c_read);
382 /*----------------------------------------------------------------------*/
385 * twl_read_idcode_register - API to read the IDCODE register.
387 * Unlocks the IDCODE register and read the 32 bit value.
389 static int twl_read_idcode_register(void)
393 err = twl_i2c_write_u8(TWL4030_MODULE_INTBR, TWL_EEPROM_R_UNLOCK,
394 REG_UNLOCK_TEST_REG);
396 pr_err("TWL4030 Unable to unlock IDCODE registers -%d\n", err);
400 err = twl_i2c_read(TWL4030_MODULE_INTBR, (u8 *)(&twl_priv->twl_idcode),
403 pr_err("TWL4030: unable to read IDCODE -%d\n", err);
407 err = twl_i2c_write_u8(TWL4030_MODULE_INTBR, 0x0, REG_UNLOCK_TEST_REG);
409 pr_err("TWL4030 Unable to relock IDCODE registers -%d\n", err);
415 * twl_get_type - API to get TWL Si type.
417 * Api to get the TWL Si type from IDCODE value.
419 int twl_get_type(void)
421 return TWL_SIL_TYPE(twl_priv->twl_idcode);
423 EXPORT_SYMBOL_GPL(twl_get_type);
426 * twl_get_version - API to get TWL Si version.
428 * Api to get the TWL Si version from IDCODE value.
430 int twl_get_version(void)
432 return TWL_SIL_REV(twl_priv->twl_idcode);
434 EXPORT_SYMBOL_GPL(twl_get_version);
437 * twl_get_hfclk_rate - API to get TWL external HFCLK clock rate.
439 * Api to get the TWL HFCLK rate based on BOOT_CFG register.
441 int twl_get_hfclk_rate(void)
446 twl_i2c_read_u8(TWL_MODULE_PM_MASTER, &ctrl, R_CFG_BOOT);
448 switch (ctrl & 0x3) {
449 case HFCLK_FREQ_19p2_MHZ:
452 case HFCLK_FREQ_26_MHZ:
455 case HFCLK_FREQ_38p4_MHZ:
459 pr_err("TWL4030: HFCLK is not configured\n");
466 EXPORT_SYMBOL_GPL(twl_get_hfclk_rate);
468 static struct device *
469 add_numbered_child(unsigned mod_no, const char *name, int num,
470 void *pdata, unsigned pdata_len,
471 bool can_wakeup, int irq0, int irq1)
473 struct platform_device *pdev;
474 struct twl_client *twl;
477 if (unlikely(mod_no >= twl_get_last_module())) {
478 pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
479 return ERR_PTR(-EPERM);
481 sid = twl_priv->twl_map[mod_no].sid;
482 twl = &twl_priv->twl_modules[sid];
484 pdev = platform_device_alloc(name, num);
486 dev_dbg(&twl->client->dev, "can't alloc dev\n");
491 pdev->dev.parent = &twl->client->dev;
494 status = platform_device_add_data(pdev, pdata, pdata_len);
496 dev_dbg(&pdev->dev, "can't add platform_data\n");
502 struct resource r[2] = {
503 { .start = irq0, .flags = IORESOURCE_IRQ, },
504 { .start = irq1, .flags = IORESOURCE_IRQ, },
507 status = platform_device_add_resources(pdev, r, irq1 ? 2 : 1);
509 dev_dbg(&pdev->dev, "can't add irqs\n");
514 status = platform_device_add(pdev);
516 device_init_wakeup(&pdev->dev, can_wakeup);
520 platform_device_put(pdev);
521 dev_err(&twl->client->dev, "can't add %s dev\n", name);
522 return ERR_PTR(status);
527 static inline struct device *add_child(unsigned mod_no, const char *name,
528 void *pdata, unsigned pdata_len,
529 bool can_wakeup, int irq0, int irq1)
531 return add_numbered_child(mod_no, name, -1, pdata, pdata_len,
532 can_wakeup, irq0, irq1);
535 static struct device *
536 add_regulator_linked(int num, struct regulator_init_data *pdata,
537 struct regulator_consumer_supply *consumers,
538 unsigned num_consumers, unsigned long features)
540 struct twl_regulator_driver_data drv_data;
542 /* regulator framework demands init_data ... */
547 pdata->consumer_supplies = consumers;
548 pdata->num_consumer_supplies = num_consumers;
551 if (pdata->driver_data) {
552 /* If we have existing drv_data, just add the flags */
553 struct twl_regulator_driver_data *tmp;
554 tmp = pdata->driver_data;
555 tmp->features |= features;
557 /* add new driver data struct, used only during init */
558 drv_data.features = features;
559 drv_data.set_voltage = NULL;
560 drv_data.get_voltage = NULL;
561 drv_data.data = NULL;
562 pdata->driver_data = &drv_data;
565 /* NOTE: we currently ignore regulator IRQs, e.g. for short circuits */
566 return add_numbered_child(TWL_MODULE_PM_MASTER, "twl_reg", num,
567 pdata, sizeof(*pdata), false, 0, 0);
570 static struct device *
571 add_regulator(int num, struct regulator_init_data *pdata,
572 unsigned long features)
574 return add_regulator_linked(num, pdata, NULL, 0, features);
578 * NOTE: We know the first 8 IRQs after pdata->base_irq are
579 * for the PIH, and the next are for the PWR_INT SIH, since
580 * that's how twl_init_irq() sets things up.
584 add_children(struct twl4030_platform_data *pdata, unsigned irq_base,
585 unsigned long features)
587 struct device *child;
589 if (IS_ENABLED(CONFIG_GPIO_TWL4030) && pdata->gpio) {
590 child = add_child(TWL4030_MODULE_GPIO, "twl4030_gpio",
591 pdata->gpio, sizeof(*pdata->gpio),
592 false, irq_base + GPIO_INTR_OFFSET, 0);
594 return PTR_ERR(child);
597 if (IS_ENABLED(CONFIG_KEYBOARD_TWL4030) && pdata->keypad) {
598 child = add_child(TWL4030_MODULE_KEYPAD, "twl4030_keypad",
599 pdata->keypad, sizeof(*pdata->keypad),
600 true, irq_base + KEYPAD_INTR_OFFSET, 0);
602 return PTR_ERR(child);
605 if (IS_ENABLED(CONFIG_TWL4030_MADC) && pdata->madc &&
606 twl_class_is_4030()) {
607 child = add_child(TWL4030_MODULE_MADC, "twl4030_madc",
608 pdata->madc, sizeof(*pdata->madc),
609 true, irq_base + MADC_INTR_OFFSET, 0);
611 return PTR_ERR(child);
614 if (IS_ENABLED(CONFIG_RTC_DRV_TWL4030)) {
616 * REVISIT platform_data here currently might expose the
617 * "msecure" line ... but for now we just expect board
618 * setup to tell the chip "it's always ok to SET_TIME".
619 * Eventually, Linux might become more aware of such
620 * HW security concerns, and "least privilege".
622 child = add_child(TWL_MODULE_RTC, "twl_rtc", NULL, 0,
623 true, irq_base + RTC_INTR_OFFSET, 0);
625 return PTR_ERR(child);
628 if (IS_ENABLED(CONFIG_PWM_TWL)) {
629 child = add_child(TWL_MODULE_PWM, "twl-pwm", NULL, 0,
632 return PTR_ERR(child);
635 if (IS_ENABLED(CONFIG_PWM_TWL_LED)) {
636 child = add_child(TWL_MODULE_LED, "twl-pwmled", NULL, 0,
639 return PTR_ERR(child);
642 if (IS_ENABLED(CONFIG_TWL4030_USB) && pdata->usb &&
643 twl_class_is_4030()) {
645 static struct regulator_consumer_supply usb1v5 = {
648 static struct regulator_consumer_supply usb1v8 = {
651 static struct regulator_consumer_supply usb3v1[] = {
652 { .supply = "usb3v1" },
653 { .supply = "bci3v1" },
656 /* First add the regulators so that they can be used by transceiver */
657 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030)) {
658 /* this is a template that gets copied */
659 struct regulator_init_data usb_fixed = {
660 .constraints.valid_modes_mask =
661 REGULATOR_MODE_NORMAL
662 | REGULATOR_MODE_STANDBY,
663 .constraints.valid_ops_mask =
664 REGULATOR_CHANGE_MODE
665 | REGULATOR_CHANGE_STATUS,
668 child = add_regulator_linked(TWL4030_REG_VUSB1V5,
669 &usb_fixed, &usb1v5, 1,
672 return PTR_ERR(child);
674 child = add_regulator_linked(TWL4030_REG_VUSB1V8,
675 &usb_fixed, &usb1v8, 1,
678 return PTR_ERR(child);
680 child = add_regulator_linked(TWL4030_REG_VUSB3V1,
681 &usb_fixed, usb3v1, 2,
684 return PTR_ERR(child);
688 child = add_child(TWL_MODULE_USB, "twl4030_usb",
689 pdata->usb, sizeof(*pdata->usb), true,
690 /* irq0 = USB_PRES, irq1 = USB */
691 irq_base + USB_PRES_INTR_OFFSET,
692 irq_base + USB_INTR_OFFSET);
695 return PTR_ERR(child);
697 /* we need to connect regulators to this transceiver */
698 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) && child) {
699 usb1v5.dev_name = dev_name(child);
700 usb1v8.dev_name = dev_name(child);
701 usb3v1[0].dev_name = dev_name(child);
704 if (IS_ENABLED(CONFIG_TWL6030_USB) && pdata->usb &&
705 twl_class_is_6030()) {
707 static struct regulator_consumer_supply usb3v3;
710 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030)) {
711 /* this is a template that gets copied */
712 struct regulator_init_data usb_fixed = {
713 .constraints.valid_modes_mask =
714 REGULATOR_MODE_NORMAL
715 | REGULATOR_MODE_STANDBY,
716 .constraints.valid_ops_mask =
717 REGULATOR_CHANGE_MODE
718 | REGULATOR_CHANGE_STATUS,
721 if (features & TWL6032_SUBCLASS) {
722 usb3v3.supply = "ldousb";
723 regulator = TWL6032_REG_LDOUSB;
725 usb3v3.supply = "vusb";
726 regulator = TWL6030_REG_VUSB;
728 child = add_regulator_linked(regulator, &usb_fixed,
732 return PTR_ERR(child);
735 pdata->usb->features = features;
737 child = add_child(TWL_MODULE_USB, "twl6030_usb",
738 pdata->usb, sizeof(*pdata->usb), true,
739 /* irq1 = VBUS_PRES, irq0 = USB ID */
740 irq_base + USBOTG_INTR_OFFSET,
741 irq_base + USB_PRES_INTR_OFFSET);
744 return PTR_ERR(child);
745 /* we need to connect regulators to this transceiver */
746 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) && child)
747 usb3v3.dev_name = dev_name(child);
748 } else if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) &&
749 twl_class_is_6030()) {
750 if (features & TWL6032_SUBCLASS)
751 child = add_regulator(TWL6032_REG_LDOUSB,
752 pdata->ldousb, features);
754 child = add_regulator(TWL6030_REG_VUSB,
755 pdata->vusb, features);
758 return PTR_ERR(child);
761 if (IS_ENABLED(CONFIG_TWL4030_WATCHDOG) && twl_class_is_4030()) {
762 child = add_child(TWL_MODULE_PM_RECEIVER, "twl4030_wdt", NULL,
765 return PTR_ERR(child);
768 if (IS_ENABLED(CONFIG_INPUT_TWL4030_PWRBUTTON) && twl_class_is_4030()) {
769 child = add_child(TWL_MODULE_PM_MASTER, "twl4030_pwrbutton",
770 NULL, 0, true, irq_base + 8 + 0, 0);
772 return PTR_ERR(child);
775 if (IS_ENABLED(CONFIG_MFD_TWL4030_AUDIO) && pdata->audio &&
776 twl_class_is_4030()) {
777 child = add_child(TWL4030_MODULE_AUDIO_VOICE, "twl4030-audio",
778 pdata->audio, sizeof(*pdata->audio),
781 return PTR_ERR(child);
784 /* twl4030 regulators */
785 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) && twl_class_is_4030()) {
786 child = add_regulator(TWL4030_REG_VPLL1, pdata->vpll1,
789 return PTR_ERR(child);
791 child = add_regulator(TWL4030_REG_VIO, pdata->vio,
794 return PTR_ERR(child);
796 child = add_regulator(TWL4030_REG_VDD1, pdata->vdd1,
799 return PTR_ERR(child);
801 child = add_regulator(TWL4030_REG_VDD2, pdata->vdd2,
804 return PTR_ERR(child);
806 child = add_regulator(TWL4030_REG_VMMC1, pdata->vmmc1,
809 return PTR_ERR(child);
811 child = add_regulator(TWL4030_REG_VDAC, pdata->vdac,
814 return PTR_ERR(child);
816 child = add_regulator((features & TWL4030_VAUX2)
817 ? TWL4030_REG_VAUX2_4030
819 pdata->vaux2, features);
821 return PTR_ERR(child);
823 child = add_regulator(TWL4030_REG_VINTANA1, pdata->vintana1,
826 return PTR_ERR(child);
828 child = add_regulator(TWL4030_REG_VINTANA2, pdata->vintana2,
831 return PTR_ERR(child);
833 child = add_regulator(TWL4030_REG_VINTDIG, pdata->vintdig,
836 return PTR_ERR(child);
839 /* maybe add LDOs that are omitted on cost-reduced parts */
840 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) && !(features & TPS_SUBSET)
841 && twl_class_is_4030()) {
842 child = add_regulator(TWL4030_REG_VPLL2, pdata->vpll2,
845 return PTR_ERR(child);
847 child = add_regulator(TWL4030_REG_VMMC2, pdata->vmmc2,
850 return PTR_ERR(child);
852 child = add_regulator(TWL4030_REG_VSIM, pdata->vsim,
855 return PTR_ERR(child);
857 child = add_regulator(TWL4030_REG_VAUX1, pdata->vaux1,
860 return PTR_ERR(child);
862 child = add_regulator(TWL4030_REG_VAUX3, pdata->vaux3,
865 return PTR_ERR(child);
867 child = add_regulator(TWL4030_REG_VAUX4, pdata->vaux4,
870 return PTR_ERR(child);
873 /* twl6030 regulators */
874 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) && twl_class_is_6030() &&
875 !(features & TWL6032_SUBCLASS)) {
876 child = add_regulator(TWL6030_REG_VDD1, pdata->vdd1,
879 return PTR_ERR(child);
881 child = add_regulator(TWL6030_REG_VDD2, pdata->vdd2,
884 return PTR_ERR(child);
886 child = add_regulator(TWL6030_REG_VDD3, pdata->vdd3,
889 return PTR_ERR(child);
891 child = add_regulator(TWL6030_REG_V1V8, pdata->v1v8,
894 return PTR_ERR(child);
896 child = add_regulator(TWL6030_REG_V2V1, pdata->v2v1,
899 return PTR_ERR(child);
901 child = add_regulator(TWL6030_REG_VMMC, pdata->vmmc,
904 return PTR_ERR(child);
906 child = add_regulator(TWL6030_REG_VPP, pdata->vpp,
909 return PTR_ERR(child);
911 child = add_regulator(TWL6030_REG_VUSIM, pdata->vusim,
914 return PTR_ERR(child);
916 child = add_regulator(TWL6030_REG_VCXIO, pdata->vcxio,
919 return PTR_ERR(child);
921 child = add_regulator(TWL6030_REG_VDAC, pdata->vdac,
924 return PTR_ERR(child);
926 child = add_regulator(TWL6030_REG_VAUX1_6030, pdata->vaux1,
929 return PTR_ERR(child);
931 child = add_regulator(TWL6030_REG_VAUX2_6030, pdata->vaux2,
934 return PTR_ERR(child);
936 child = add_regulator(TWL6030_REG_VAUX3_6030, pdata->vaux3,
939 return PTR_ERR(child);
941 child = add_regulator(TWL6030_REG_CLK32KG, pdata->clk32kg,
944 return PTR_ERR(child);
947 /* 6030 and 6025 share this regulator */
948 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) && twl_class_is_6030()) {
949 child = add_regulator(TWL6030_REG_VANA, pdata->vana,
952 return PTR_ERR(child);
955 /* twl6032 regulators */
956 if (IS_ENABLED(CONFIG_REGULATOR_TWL4030) && twl_class_is_6030() &&
957 (features & TWL6032_SUBCLASS)) {
958 child = add_regulator(TWL6032_REG_LDO5, pdata->ldo5,
961 return PTR_ERR(child);
963 child = add_regulator(TWL6032_REG_LDO1, pdata->ldo1,
966 return PTR_ERR(child);
968 child = add_regulator(TWL6032_REG_LDO7, pdata->ldo7,
971 return PTR_ERR(child);
973 child = add_regulator(TWL6032_REG_LDO6, pdata->ldo6,
976 return PTR_ERR(child);
978 child = add_regulator(TWL6032_REG_LDOLN, pdata->ldoln,
981 return PTR_ERR(child);
983 child = add_regulator(TWL6032_REG_LDO2, pdata->ldo2,
986 return PTR_ERR(child);
988 child = add_regulator(TWL6032_REG_LDO4, pdata->ldo4,
991 return PTR_ERR(child);
993 child = add_regulator(TWL6032_REG_LDO3, pdata->ldo3,
996 return PTR_ERR(child);
998 child = add_regulator(TWL6032_REG_SMPS3, pdata->smps3,
1001 return PTR_ERR(child);
1003 child = add_regulator(TWL6032_REG_SMPS4, pdata->smps4,
1006 return PTR_ERR(child);
1008 child = add_regulator(TWL6032_REG_VIO, pdata->vio6025,
1011 return PTR_ERR(child);
1015 if (IS_ENABLED(CONFIG_CHARGER_TWL4030) && pdata->bci &&
1016 !(features & (TPS_SUBSET | TWL5031))) {
1017 child = add_child(TWL_MODULE_MAIN_CHARGE, "twl4030_bci",
1018 pdata->bci, sizeof(*pdata->bci), false,
1019 /* irq0 = CHG_PRES, irq1 = BCI */
1020 irq_base + BCI_PRES_INTR_OFFSET,
1021 irq_base + BCI_INTR_OFFSET);
1023 return PTR_ERR(child);
1026 if (IS_ENABLED(CONFIG_TWL4030_POWER) && pdata->power) {
1027 child = add_child(TWL_MODULE_PM_MASTER, "twl4030_power",
1028 pdata->power, sizeof(*pdata->power), false,
1031 return PTR_ERR(child);
1037 /*----------------------------------------------------------------------*/
1040 * These three functions initialize the on-chip clock framework,
1041 * letting it generate the right frequencies for USB, MADC, and
1044 static inline int __init protect_pm_master(void)
1048 e = twl_i2c_write_u8(TWL_MODULE_PM_MASTER, 0,
1049 TWL4030_PM_MASTER_PROTECT_KEY);
1053 static inline int __init unprotect_pm_master(void)
1057 e |= twl_i2c_write_u8(TWL_MODULE_PM_MASTER, TWL4030_PM_MASTER_KEY_CFG1,
1058 TWL4030_PM_MASTER_PROTECT_KEY);
1059 e |= twl_i2c_write_u8(TWL_MODULE_PM_MASTER, TWL4030_PM_MASTER_KEY_CFG2,
1060 TWL4030_PM_MASTER_PROTECT_KEY);
1065 static void clocks_init(struct device *dev,
1066 struct twl4030_clock_init_data *clock)
1071 u8 ctrl = HFCLK_FREQ_26_MHZ;
1073 osc = clk_get(dev, "fck");
1075 printk(KERN_WARNING "Skipping twl internal clock init and "
1076 "using bootloader value (unknown osc rate)\n");
1080 rate = clk_get_rate(osc);
1085 ctrl = HFCLK_FREQ_19p2_MHZ;
1088 ctrl = HFCLK_FREQ_26_MHZ;
1091 ctrl = HFCLK_FREQ_38p4_MHZ;
1095 ctrl |= HIGH_PERF_SQ;
1096 if (clock && clock->ck32k_lowpwr_enable)
1097 ctrl |= CK32K_LOWPWR_EN;
1099 e |= unprotect_pm_master();
1100 /* effect->MADC+USB ck en */
1101 e |= twl_i2c_write_u8(TWL_MODULE_PM_MASTER, ctrl, R_CFG_BOOT);
1102 e |= protect_pm_master();
1105 pr_err("%s: clock init err [%d]\n", DRIVER_NAME, e);
1108 /*----------------------------------------------------------------------*/
1111 static int twl_remove(struct i2c_client *client)
1113 unsigned i, num_slaves;
1116 if (twl_class_is_4030())
1117 status = twl4030_exit_irq();
1119 status = twl6030_exit_irq();
1124 num_slaves = twl_get_num_slaves();
1125 for (i = 0; i < num_slaves; i++) {
1126 struct twl_client *twl = &twl_priv->twl_modules[i];
1128 if (twl->client && twl->client != client)
1129 i2c_unregister_device(twl->client);
1132 twl_priv->ready = false;
1136 /* NOTE: This driver only handles a single twl4030/tps659x0 chip */
1138 twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
1140 struct twl4030_platform_data *pdata = dev_get_platdata(&client->dev);
1141 struct device_node *node = client->dev.of_node;
1142 struct platform_device *pdev;
1143 struct regmap_config *twl_regmap_config;
1146 unsigned i, num_slaves;
1148 if (!node && !pdata) {
1149 dev_err(&client->dev, "no platform data\n");
1154 dev_dbg(&client->dev, "only one instance of %s allowed\n",
1159 pdev = platform_device_alloc(DRIVER_NAME, -1);
1161 dev_err(&client->dev, "can't alloc pdev\n");
1165 status = platform_device_add(pdev);
1167 platform_device_put(pdev);
1171 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C) == 0) {
1172 dev_dbg(&client->dev, "can't talk I2C?\n");
1177 twl_priv = devm_kzalloc(&client->dev, sizeof(struct twl_private),
1184 if ((id->driver_data) & TWL6030_CLASS) {
1185 twl_priv->twl_id = TWL6030_CLASS_ID;
1186 twl_priv->twl_map = &twl6030_map[0];
1187 /* The charger base address is different in twl6032 */
1188 if ((id->driver_data) & TWL6032_SUBCLASS)
1189 twl_priv->twl_map[TWL_MODULE_MAIN_CHARGE].base =
1190 TWL6032_BASEADD_CHARGER;
1191 twl_regmap_config = twl6030_regmap_config;
1193 twl_priv->twl_id = TWL4030_CLASS_ID;
1194 twl_priv->twl_map = &twl4030_map[0];
1195 twl_regmap_config = twl4030_regmap_config;
1198 num_slaves = twl_get_num_slaves();
1199 twl_priv->twl_modules = devm_kzalloc(&client->dev,
1200 sizeof(struct twl_client) * num_slaves,
1202 if (!twl_priv->twl_modules) {
1207 for (i = 0; i < num_slaves; i++) {
1208 struct twl_client *twl = &twl_priv->twl_modules[i];
1211 twl->client = client;
1213 twl->client = i2c_new_dummy(client->adapter,
1216 dev_err(&client->dev,
1217 "can't attach client %d\n", i);
1223 twl->regmap = devm_regmap_init_i2c(twl->client,
1224 &twl_regmap_config[i]);
1225 if (IS_ERR(twl->regmap)) {
1226 status = PTR_ERR(twl->regmap);
1227 dev_err(&client->dev,
1228 "Failed to allocate regmap %d, err: %d\n", i,
1234 twl_priv->ready = true;
1236 /* setup clock framework */
1237 clocks_init(&pdev->dev, pdata ? pdata->clock : NULL);
1239 /* read TWL IDCODE Register */
1240 if (twl_class_is_4030()) {
1241 status = twl_read_idcode_register();
1242 WARN(status < 0, "Error: reading twl_idcode register value\n");
1245 /* Maybe init the T2 Interrupt subsystem */
1247 if (twl_class_is_4030()) {
1248 twl4030_init_chip_irq(id->name);
1249 irq_base = twl4030_init_irq(&client->dev, client->irq);
1251 irq_base = twl6030_init_irq(&client->dev, client->irq);
1261 * Disable TWL4030/TWL5030 I2C Pull-up on I2C1 and I2C4(SR) interface.
1262 * Program I2C_SCL_CTRL_PU(bit 0)=0, I2C_SDA_CTRL_PU (bit 2)=0,
1263 * SR_I2C_SCL_CTRL_PU(bit 4)=0 and SR_I2C_SDA_CTRL_PU(bit 6)=0.
1265 if (twl_class_is_4030()) {
1268 twl_i2c_read_u8(TWL4030_MODULE_INTBR, &temp, REG_GPPUPDCTR1);
1269 temp &= ~(SR_I2C_SDA_CTRL_PU | SR_I2C_SCL_CTRL_PU | \
1270 I2C_SDA_CTRL_PU | I2C_SCL_CTRL_PU);
1271 twl_i2c_write_u8(TWL4030_MODULE_INTBR, temp, REG_GPPUPDCTR1);
1275 status = of_platform_populate(node, NULL, NULL, &client->dev);
1277 status = add_children(pdata, irq_base, id->driver_data);
1284 platform_device_unregister(pdev);
1289 static const struct i2c_device_id twl_ids[] = {
1290 { "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */
1291 { "twl5030", 0 }, /* T2 updated */
1292 { "twl5031", TWL5031 }, /* TWL5030 updated */
1293 { "tps65950", 0 }, /* catalog version of twl5030 */
1294 { "tps65930", TPS_SUBSET }, /* fewer LDOs and DACs; no charger */
1295 { "tps65920", TPS_SUBSET }, /* fewer LDOs; no codec or charger */
1296 { "tps65921", TPS_SUBSET }, /* fewer LDOs; no codec, no LED
1297 and vibrator. Charger in USB module*/
1298 { "twl6030", TWL6030_CLASS }, /* "Phoenix power chip" */
1299 { "twl6032", TWL6030_CLASS | TWL6032_SUBCLASS }, /* "Phoenix lite" */
1300 { /* end of list */ },
1302 MODULE_DEVICE_TABLE(i2c, twl_ids);
1304 /* One Client Driver , 4 Clients */
1305 static struct i2c_driver twl_driver = {
1306 .driver.name = DRIVER_NAME,
1307 .id_table = twl_ids,
1309 .remove = twl_remove,
1312 module_i2c_driver(twl_driver);
1314 MODULE_AUTHOR("Texas Instruments, Inc.");
1315 MODULE_DESCRIPTION("I2C Core interface for TWL");
1316 MODULE_LICENSE("GPL");