lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

mfd: Rename all twl4030_i2c*

Browse Source 
This patch renames function names like twl4030_i2c_write_u8,
twl4030_i2c_read_u8 to twl_i2c_write_u8, twl_i2c_read_u8
and also common variable in twl-core.c

Signed-off-by: Rajendra Nayak <rnayak@ti.com>
Signed-off-by: Balaji T K <balajitk@ti.com>
Signed-off-by: Santosh Shilimkar <santosh.shilimkar@ti.com>
Acked-by: Kevin Hilman <khilman@deeprootsystems.com>
Signed-off-by: Samuel Ortiz <sameo@linux.intel.com>
This commit is contained in:
Balaji T K
2009-12-13 21:23:33 +01:00
committed by Samuel Ortiz
parent b07682b605
commit fc7b92fca4
13 changed files with 187 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
drivers/gpio/twl4030-gpio.c
View File

@@ -80,7 +80,7 @@ static unsigned int gpio_usage_count;
*/ */
static inline int gpio_twl4030_write(u8 address, u8 data) static inline int gpio_twl4030_write(u8 address, u8 data)
{ {
return twl4030_i2c_write_u8(TWL4030_MODULE_GPIO, data, address); return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address);
} }
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
@@ -117,7 +117,7 @@ static inline int gpio_twl4030_read(u8 address)
u8 data; u8 data;
int ret = 0; int ret = 0;
ret = twl4030_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address); ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address);
return (ret < 0) ? ret : data; return (ret < 0) ? ret : data;
} }
@@ -142,7 +142,7 @@ static void twl4030_led_set_value(int led, int value)
cached_leden &= ~mask; cached_leden &= ~mask;
else else
cached_leden |= mask; cached_leden |= mask;
status = twl4030_i2c_write_u8(TWL4030_MODULE_LED, cached_leden, status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden,
TWL4030_LED_LEDEN); TWL4030_LED_LEDEN);
mutex_unlock(&gpio_lock); mutex_unlock(&gpio_lock);
} }
@@ -223,23 +223,23 @@ static int twl_request(struct gpio_chip *chip, unsigned offset)
} }
/* initialize PWM to always-drive */ /* initialize PWM to always-drive */
status = twl4030_i2c_write_u8(module, 0x7f, status = twl_i2c_write_u8(module, 0x7f,
TWL4030_PWMx_PWMxOFF); TWL4030_PWMx_PWMxOFF);
if (status < 0) if (status < 0)
goto done; goto done;
status = twl4030_i2c_write_u8(module, 0x7f, status = twl_i2c_write_u8(module, 0x7f,
TWL4030_PWMx_PWMxON); TWL4030_PWMx_PWMxON);
if (status < 0) if (status < 0)
goto done; goto done;
/* init LED to not-driven (high) */ /* init LED to not-driven (high) */
module = TWL4030_MODULE_LED; module = TWL4030_MODULE_LED;
status = twl4030_i2c_read_u8(module, &cached_leden, status = twl_i2c_read_u8(module, &cached_leden,
TWL4030_LED_LEDEN); TWL4030_LED_LEDEN);
if (status < 0) if (status < 0)
goto done; goto done;
cached_leden &= ~ledclr_mask; cached_leden &= ~ledclr_mask;
status = twl4030_i2c_write_u8(module, cached_leden, status = twl_i2c_write_u8(module, cached_leden,
TWL4030_LED_LEDEN); TWL4030_LED_LEDEN);
if (status < 0) if (status < 0)
goto done; goto done;
@@ -370,7 +370,7 @@ static int __devinit gpio_twl4030_pulls(u32 ups, u32 downs)
message[i] = bit_mask; message[i] = bit_mask;
} }
return twl4030_i2c_write(TWL4030_MODULE_GPIO, message, return twl_i2c_write(TWL4030_MODULE_GPIO, message,
REG_GPIOPUPDCTR1, 5); REG_GPIOPUPDCTR1, 5);
} }
@@ -387,7 +387,7 @@ static int __devinit gpio_twl4030_debounce(u32 debounce, u8 mmc_cd)
debounce >>= 8; debounce >>= 8;
message[3] = (debounce & 0x03); message[3] = (debounce & 0x03);
return twl4030_i2c_write(TWL4030_MODULE_GPIO, message, return twl_i2c_write(TWL4030_MODULE_GPIO, message,
REG_GPIO_DEBEN1, 3); REG_GPIO_DEBEN1, 3);
} }

4
drivers/input/keyboard/twl4030_keypad.c
View File

@@ -133,7 +133,7 @@ struct twl4030_keypad {
static int twl4030_kpread(struct twl4030_keypad *kp, static int twl4030_kpread(struct twl4030_keypad *kp,
u8 *data, u32 reg, u8 num_bytes) u8 *data, u32 reg, u8 num_bytes)
{ {
int ret = twl4030_i2c_read(TWL4030_MODULE_KEYPAD, data, reg, num_bytes); int ret = twl_i2c_read(TWL4030_MODULE_KEYPAD, data, reg, num_bytes);
if (ret < 0) if (ret < 0)
dev_warn(kp->dbg_dev, dev_warn(kp->dbg_dev,
@@ -145,7 +145,7 @@ static int twl4030_kpread(struct twl4030_keypad *kp,
static int twl4030_kpwrite_u8(struct twl4030_keypad *kp, u8 data, u32 reg) static int twl4030_kpwrite_u8(struct twl4030_keypad *kp, u8 data, u32 reg)
{ {
int ret = twl4030_i2c_write_u8(TWL4030_MODULE_KEYPAD, data, reg); int ret = twl_i2c_write_u8(TWL4030_MODULE_KEYPAD, data, reg);
if (ret < 0) if (ret < 0)
dev_warn(kp->dbg_dev, dev_warn(kp->dbg_dev,

2
drivers/input/misc/twl4030-pwrbutton.c
View File

@@ -49,7 +49,7 @@ static irqreturn_t powerbutton_irq(int irq, void *_pwr)
local_irq_enable(); local_irq_enable();
#endif #endif
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &value, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &value,
STS_HW_CONDITIONS); STS_HW_CONDITIONS);
if (!err) { if (!err) {
input_report_key(pwr, KEY_POWER, value & PWR_PWRON_IRQ); input_report_key(pwr, KEY_POWER, value & PWR_PWRON_IRQ);

136
drivers/mfd/twl-core.c
View File

@@ -1,5 +1,6 @@
/* /*
* twl4030_core.c - driver for TWL4030/TPS659x0 PM and audio CODEC devices * twl_core.c - driver for TWL4030/TWL5030/TWL60X0/TPS659x0 PM
* and audio CODEC devices
* *
* Copyright (C) 2005-2006 Texas Instruments, Inc. * Copyright (C) 2005-2006 Texas Instruments, Inc.
* *
@@ -55,7 +56,7 @@
* (and associated registers). * (and associated registers).
*/ */
#define DRIVER_NAME "twl4030" #define DRIVER_NAME "twl"
#if defined(CONFIG_TWL4030_BCI_BATTERY) || \ #if defined(CONFIG_TWL4030_BCI_BATTERY) || \
defined(CONFIG_TWL4030_BCI_BATTERY_MODULE) defined(CONFIG_TWL4030_BCI_BATTERY_MODULE)
@@ -125,7 +126,7 @@
/* Last - for index max*/ /* Last - for index max*/
#define TWL4030_MODULE_LAST TWL4030_MODULE_SECURED_REG #define TWL4030_MODULE_LAST TWL4030_MODULE_SECURED_REG
#define TWL4030_NUM_SLAVES 4 #define TWL_NUM_SLAVES 4
#if defined(CONFIG_INPUT_TWL4030_PWRBUTTON) \ #if defined(CONFIG_INPUT_TWL4030_PWRBUTTON) \
|| defined(CONFIG_INPUT_TWL4030_PWBUTTON_MODULE) || defined(CONFIG_INPUT_TWL4030_PWBUTTON_MODULE)
@@ -134,6 +135,13 @@
#define twl_has_pwrbutton() false #define twl_has_pwrbutton() false
#endif #endif
#define SUB_CHIP_ID0 0
#define SUB_CHIP_ID1 1
#define SUB_CHIP_ID2 2
#define SUB_CHIP_ID3 3
#define TWL_MODULE_LAST TWL4030_MODULE_LAST
/* Base Address defns for twl4030_map[] */ /* Base Address defns for twl4030_map[] */
/* subchip/slave 0 - USB ID */ /* subchip/slave 0 - USB ID */
@@ -201,7 +209,7 @@
static bool inuse; static bool inuse;
/* Structure for each TWL4030 Slave */ /* Structure for each TWL4030 Slave */
struct twl4030_client { struct twl_client {
struct i2c_client *client; struct i2c_client *client;
u8 address; u8 address;
@@ -212,16 +220,16 @@ struct twl4030_client {
struct mutex xfer_lock; struct mutex xfer_lock;
}; };
static struct twl4030_client twl4030_modules[TWL4030_NUM_SLAVES]; static struct twl_client twl_modules[TWL_NUM_SLAVES];
/* mapping the module id to slave id and base address */ /* mapping the module id to slave id and base address */
struct twl4030mapping { struct twl_mapping {
unsigned char sid; /* Slave ID */ unsigned char sid; /* Slave ID */
unsigned char base; /* base address */ unsigned char base; /* base address */
}; };
static struct twl4030mapping twl4030_map[TWL4030_MODULE_LAST + 1] = { static struct twl_mapping twl4030_map[TWL4030_MODULE_LAST + 1] = {
/* /*
* NOTE: don't change this table without updating the * NOTE: don't change this table without updating the
* <linux/i2c/twl4030.h> defines for TWL4030_MODULE_* * <linux/i2c/twl4030.h> defines for TWL4030_MODULE_*
@@ -262,7 +270,7 @@ static struct twl4030mapping twl4030_map[TWL4030_MODULE_LAST + 1] = {
/* Exported Functions */ /* Exported Functions */
/** /**
* twl4030_i2c_write - Writes a n bit register in TWL4030 * twl_i2c_write - Writes a n bit register in TWL4030/TWL5030/TWL60X0
* @mod_no: module number * @mod_no: module number
* @value: an array of num_bytes+1 containing data to write * @value: an array of num_bytes+1 containing data to write
* @reg: register address (just offset will do) * @reg: register address (just offset will do)
@@ -273,19 +281,19 @@ static struct twl4030mapping twl4030_map[TWL4030_MODULE_LAST + 1] = {
* *
* Returns the result of operation - 0 is success * Returns the result of operation - 0 is success
*/ */
int twl4030_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes) int twl_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
{ {
int ret; int ret;
int sid; int sid;
struct twl4030_client *twl; struct twl_client *twl;
struct i2c_msg *msg; struct i2c_msg *msg;
if (unlikely(mod_no > TWL4030_MODULE_LAST)) { if (unlikely(mod_no > TWL_MODULE_LAST)) {
pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no); pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
return -EPERM; return -EPERM;
} }
sid = twl4030_map[mod_no].sid; sid = twl4030_map[mod_no].sid;
twl = &twl4030_modules[sid]; twl = &twl_modules[sid];
if (unlikely(!inuse)) { if (unlikely(!inuse)) {
pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid); pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid);
@@ -318,10 +326,10 @@ int twl4030_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
return 0; return 0;
} }
} }
EXPORT_SYMBOL(twl4030_i2c_write); EXPORT_SYMBOL(twl_i2c_write);
/** /**
* twl4030_i2c_read - Reads a n bit register in TWL4030 * twl_i2c_read - Reads a n bit register in TWL4030/TWL5030/TWL60X0
* @mod_no: module number * @mod_no: module number
* @value: an array of num_bytes containing data to be read * @value: an array of num_bytes containing data to be read
* @reg: register address (just offset will do) * @reg: register address (just offset will do)
@@ -329,20 +337,20 @@ EXPORT_SYMBOL(twl4030_i2c_write);
* *
* Returns result of operation - num_bytes is success else failure. * Returns result of operation - num_bytes is success else failure.
*/ */
int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes) int twl_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
{ {
int ret; int ret;
u8 val; u8 val;
int sid; int sid;
struct twl4030_client *twl; struct twl_client *twl;
struct i2c_msg *msg; struct i2c_msg *msg;
if (unlikely(mod_no > TWL4030_MODULE_LAST)) { if (unlikely(mod_no > TWL_MODULE_LAST)) {
pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no); pr_err("%s: invalid module number %d\n", DRIVER_NAME, mod_no);
return -EPERM; return -EPERM;
} }
sid = twl4030_map[mod_no].sid; sid = twl4030_map[mod_no].sid;
twl = &twl4030_modules[sid]; twl = &twl_modules[sid];
if (unlikely(!inuse)) { if (unlikely(!inuse)) {
pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid); pr_err("%s: client %d is not initialized\n", DRIVER_NAME, sid);
@@ -377,40 +385,40 @@ int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes)
return 0; return 0;
} }
} }
EXPORT_SYMBOL(twl4030_i2c_read); EXPORT_SYMBOL(twl_i2c_read);
/** /**
* twl4030_i2c_write_u8 - Writes a 8 bit register in TWL4030 * twl_i2c_write_u8 - Writes a 8 bit register in TWL4030/TWL5030/TWL60X0
* @mod_no: module number * @mod_no: module number
* @value: the value to be written 8 bit * @value: the value to be written 8 bit
* @reg: register address (just offset will do) * @reg: register address (just offset will do)
* *
* Returns result of operation - 0 is success * Returns result of operation - 0 is success
*/ */
int twl4030_i2c_write_u8(u8 mod_no, u8 value, u8 reg) int twl_i2c_write_u8(u8 mod_no, u8 value, u8 reg)
{ {
/* 2 bytes offset 1 contains the data offset 0 is used by i2c_write */ /* 2 bytes offset 1 contains the data offset 0 is used by i2c_write */
u8 temp_buffer[2] = { 0 }; u8 temp_buffer[2] = { 0 };
/* offset 1 contains the data */ /* offset 1 contains the data */
temp_buffer[1] = value; temp_buffer[1] = value;
return twl4030_i2c_write(mod_no, temp_buffer, reg, 1); return twl_i2c_write(mod_no, temp_buffer, reg, 1);
} }
EXPORT_SYMBOL(twl4030_i2c_write_u8); EXPORT_SYMBOL(twl_i2c_write_u8);
/** /**
* twl4030_i2c_read_u8 - Reads a 8 bit register from TWL4030 * twl_i2c_read_u8 - Reads a 8 bit register from TWL4030/TWL5030/TWL60X0
* @mod_no: module number * @mod_no: module number
* @value: the value read 8 bit * @value: the value read 8 bit
* @reg: register address (just offset will do) * @reg: register address (just offset will do)
* *
* Returns result of operation - 0 is success * Returns result of operation - 0 is success
*/ */
int twl4030_i2c_read_u8(u8 mod_no, u8 *value, u8 reg) int twl_i2c_read_u8(u8 mod_no, u8 *value, u8 reg)
{ {
return twl4030_i2c_read(mod_no, value, reg, 1); return twl_i2c_read(mod_no, value, reg, 1);
} }
EXPORT_SYMBOL(twl4030_i2c_read_u8); EXPORT_SYMBOL(twl_i2c_read_u8);
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
@@ -420,7 +428,7 @@ add_numbered_child(unsigned chip, const char *name, int num,
bool can_wakeup, int irq0, int irq1) bool can_wakeup, int irq0, int irq1)
{ {
struct platform_device *pdev; struct platform_device *pdev;
struct twl4030_client *twl = &twl4030_modules[chip]; struct twl_client *twl = &twl_modules[chip];
int status; int status;
pdev = platform_device_alloc(name, num); pdev = platform_device_alloc(name, num);
@@ -515,23 +523,24 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
pdata->bci, sizeof(*pdata->bci), pdata->bci, sizeof(*pdata->bci),
false, false,
/* irq0 = CHG_PRES, irq1 = BCI */ /* irq0 = CHG_PRES, irq1 = BCI */
pdata->irq_base + 8 + 1, pdata->irq_base + 2); pdata->irq_base + BCI_PRES_INTR_OFFSET,
pdata->irq_base + BCI_INTR_OFFSET);
if (IS_ERR(child)) if (IS_ERR(child))
return PTR_ERR(child); return PTR_ERR(child);
} }
if (twl_has_gpio() && pdata->gpio) { if (twl_has_gpio() && pdata->gpio) {
child = add_child(1, "twl4030_gpio", child = add_child(SUB_CHIP_ID1, "twl4030_gpio",
pdata->gpio, sizeof(*pdata->gpio), pdata->gpio, sizeof(*pdata->gpio),
false, pdata->irq_base + 0, 0); false, pdata->irq_base + GPIO_INTR_OFFSET, 0);
if (IS_ERR(child)) if (IS_ERR(child))
return PTR_ERR(child); return PTR_ERR(child);
} }
if (twl_has_keypad() && pdata->keypad) { if (twl_has_keypad() && pdata->keypad) {
child = add_child(2, "twl4030_keypad", child = add_child(SUB_CHIP_ID2, "twl4030_keypad",
pdata->keypad, sizeof(*pdata->keypad), pdata->keypad, sizeof(*pdata->keypad),
true, pdata->irq_base + 1, 0); true, pdata->irq_base + KEYPAD_INTR_OFFSET, 0);
if (IS_ERR(child)) if (IS_ERR(child))
return PTR_ERR(child); return PTR_ERR(child);
} }
@@ -539,7 +548,7 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
if (twl_has_madc() && pdata->madc) { if (twl_has_madc() && pdata->madc) {
child = add_child(2, "twl4030_madc", child = add_child(2, "twl4030_madc",
pdata->madc, sizeof(*pdata->madc), pdata->madc, sizeof(*pdata->madc),
true, pdata->irq_base + 3, 0); true, pdata->irq_base + MADC_INTR_OFFSET, 0);
if (IS_ERR(child)) if (IS_ERR(child))
return PTR_ERR(child); return PTR_ERR(child);
} }
@@ -554,7 +563,7 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
*/ */
child = add_child(3, "twl4030_rtc", child = add_child(3, "twl4030_rtc",
NULL, 0, NULL, 0,
true, pdata->irq_base + 8 + 3, 0); true, pdata->irq_base + RTC_INTR_OFFSET, 0);
if (IS_ERR(child)) if (IS_ERR(child))
return PTR_ERR(child); return PTR_ERR(child);
} }
@@ -604,7 +613,8 @@ add_children(struct twl4030_platform_data *pdata, unsigned long features)
pdata->usb, sizeof(*pdata->usb), pdata->usb, sizeof(*pdata->usb),
true, true,
/* irq0 = USB_PRES, irq1 = USB */ /* irq0 = USB_PRES, irq1 = USB */
pdata->irq_base + 8 + 2, pdata->irq_base + 4); pdata->irq_base + USB_PRES_INTR_OFFSET,
pdata->irq_base + USB_INTR_OFFSET);
if (IS_ERR(child)) if (IS_ERR(child))
return PTR_ERR(child); return PTR_ERR(child);
@@ -724,7 +734,7 @@ static inline int __init protect_pm_master(void)
{ {
int e = 0; int e = 0;
e = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_LOCK, e = twl_i2c_write_u8(TWL_MODULE_PM_MASTER, KEY_LOCK,
R_PROTECT_KEY); R_PROTECT_KEY);
return e; return e;
} }
@@ -733,9 +743,9 @@ static inline int __init unprotect_pm_master(void)
{ {
int e = 0; int e = 0;
e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_UNLOCK1, e |= twl_i2c_write_u8(TWL_MODULE_PM_MASTER, KEY_UNLOCK1,
R_PROTECT_KEY); R_PROTECT_KEY);
e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, KEY_UNLOCK2, e |= twl_i2c_write_u8(TWL_MODULE_PM_MASTER, KEY_UNLOCK2,
R_PROTECT_KEY); R_PROTECT_KEY);
return e; return e;
} }
@@ -755,7 +765,7 @@ static void clocks_init(struct device *dev,
osc = clk_get(dev, "osc_sys_ck"); osc = clk_get(dev, "osc_sys_ck");
if (IS_ERR(osc)) { if (IS_ERR(osc)) {
printk(KERN_WARNING "Skipping twl4030 internal clock init and " printk(KERN_WARNING "Skipping twl internal clock init and "
"using bootloader value (unknown osc rate)\n"); "using bootloader value (unknown osc rate)\n");
return; return;
} }
@@ -769,7 +779,7 @@ static void clocks_init(struct device *dev,
*/ */
osc = ERR_PTR(-EIO); osc = ERR_PTR(-EIO);
printk(KERN_WARNING "Skipping twl4030 internal clock init and " printk(KERN_WARNING "Skipping twl internal clock init and "
"using bootloader value (unknown osc rate)\n"); "using bootloader value (unknown osc rate)\n");
return; return;
@@ -793,7 +803,7 @@ static void clocks_init(struct device *dev,
e |= unprotect_pm_master(); e |= unprotect_pm_master();
/* effect->MADC+USB ck en */ /* effect->MADC+USB ck en */
e |= twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, ctrl, R_CFG_BOOT); e |= twl_i2c_write_u8(TWL_MODULE_PM_MASTER, ctrl, R_CFG_BOOT);
e |= protect_pm_master(); e |= protect_pm_master();
if (e < 0) if (e < 0)
@@ -806,7 +816,7 @@ int twl_init_irq(int irq_num, unsigned irq_base, unsigned irq_end);
int twl_exit_irq(void); int twl_exit_irq(void);
int twl_init_chip_irq(const char *chip); int twl_init_chip_irq(const char *chip);
static int twl4030_remove(struct i2c_client *client) static int twl_remove(struct i2c_client *client)
{ {
unsigned i; unsigned i;
int status; int status;
@@ -815,12 +825,12 @@ static int twl4030_remove(struct i2c_client *client)
if (status < 0) if (status < 0)
return status; return status;
for (i = 0; i < TWL4030_NUM_SLAVES; i++) { for (i = 0; i < TWL_NUM_SLAVES; i++) {
struct twl4030_client *twl = &twl4030_modules[i]; struct twl_client *twl = &twl_modules[i];
if (twl->client && twl->client != client) if (twl->client && twl->client != client)
i2c_unregister_device(twl->client); i2c_unregister_device(twl->client);
twl4030_modules[i].client = NULL; twl_modules[i].client = NULL;
} }
inuse = false; inuse = false;
return 0; return 0;
@@ -828,7 +838,7 @@ static int twl4030_remove(struct i2c_client *client)
/* NOTE: this driver only handles a single twl4030/tps659x0 chip */ /* NOTE: this driver only handles a single twl4030/tps659x0 chip */
static int __init static int __init
twl4030_probe(struct i2c_client *client, const struct i2c_device_id *id) twl_probe(struct i2c_client *client, const struct i2c_device_id *id)
{ {
int status; int status;
unsigned i; unsigned i;
@@ -849,8 +859,8 @@ twl4030_probe(struct i2c_client *client, const struct i2c_device_id *id)
return -EBUSY; return -EBUSY;
} }
for (i = 0; i < TWL4030_NUM_SLAVES; i++) { for (i = 0; i < TWL_NUM_SLAVES; i++) {
struct twl4030_client *twl = &twl4030_modules[i]; struct twl_client *twl = &twl_modules[i];
twl->address = client->addr + i; twl->address = client->addr + i;
if (i == 0) if (i == 0)
@@ -889,11 +899,11 @@ twl4030_probe(struct i2c_client *client, const struct i2c_device_id *id)
status = add_children(pdata, id->driver_data); status = add_children(pdata, id->driver_data);
fail: fail:
if (status < 0) if (status < 0)
twl4030_remove(client); twl_remove(client);
return status; return status;
} }
static const struct i2c_device_id twl4030_ids[] = { static const struct i2c_device_id twl_ids[] = {
{ "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */ { "twl4030", TWL4030_VAUX2 }, /* "Triton 2" */
{ "twl5030", 0 }, /* T2 updated */ { "twl5030", 0 }, /* T2 updated */
{ "twl5031", TWL5031 }, /* TWL5030 updated */ { "twl5031", TWL5031 }, /* TWL5030 updated */
@@ -902,28 +912,28 @@ static const struct i2c_device_id twl4030_ids[] = {
{ "tps65920", TPS_SUBSET }, /* fewer LDOs; no codec or charger */ { "tps65920", TPS_SUBSET }, /* fewer LDOs; no codec or charger */
{ /* end of list */ }, { /* end of list */ },
}; };
MODULE_DEVICE_TABLE(i2c, twl4030_ids); MODULE_DEVICE_TABLE(i2c, twl_ids);
/* One Client Driver , 4 Clients */ /* One Client Driver , 4 Clients */
static struct i2c_driver twl4030_driver = { static struct i2c_driver twl_driver = {
.driver.name = DRIVER_NAME, .driver.name = DRIVER_NAME,
.id_table = twl4030_ids, .id_table = twl_ids,
.probe = twl4030_probe, .probe = twl_probe,
.remove = twl4030_remove, .remove = twl_remove,
}; };
static int __init twl4030_init(void) static int __init twl_init(void)
{ {
return i2c_add_driver(&twl4030_driver); return i2c_add_driver(&twl_driver);
} }
subsys_initcall(twl4030_init); subsys_initcall(twl_init);
static void __exit twl4030_exit(void) static void __exit twl_exit(void)
{ {
i2c_del_driver(&twl4030_driver); i2c_del_driver(&twl_driver);
} }
module_exit(twl4030_exit); module_exit(twl_exit);
MODULE_AUTHOR("Texas Instruments, Inc."); MODULE_AUTHOR("Texas Instruments, Inc.");
MODULE_DESCRIPTION("I2C Core interface for TWL4030"); MODULE_DESCRIPTION("I2C Core interface for TWL");
MODULE_LICENSE("GPL"); MODULE_LICENSE("GPL");

18
drivers/mfd/twl4030-irq.c
View File

@@ -296,7 +296,7 @@ static int twl4030_irq_thread(void *data)
/* Wait for IRQ, then read PIH irq status (also blocking) */ /* Wait for IRQ, then read PIH irq status (also blocking) */
wait_for_completion_interruptible(&irq_event); wait_for_completion_interruptible(&irq_event);
ret = twl4030_i2c_read_u8(TWL4030_MODULE_PIH, &pih_isr, ret = twl_i2c_read_u8(TWL4030_MODULE_PIH, &pih_isr,
REG_PIH_ISR_P1); REG_PIH_ISR_P1);
if (ret) { if (ret) {
pr_warning("twl4030: I2C error %d reading PIH ISR\n", pr_warning("twl4030: I2C error %d reading PIH ISR\n",
@@ -396,7 +396,7 @@ static int twl4030_init_sih_modules(unsigned line)
if (sih->irq_lines <= line) if (sih->irq_lines <= line)
continue; continue;
status = twl4030_i2c_write(sih->module, buf, status = twl_i2c_write(sih->module, buf,
sih->mask[line].imr_offset, sih->bytes_ixr); sih->mask[line].imr_offset, sih->bytes_ixr);
if (status < 0) if (status < 0)
pr_err("twl4030: err %d initializing %s %s\n", pr_err("twl4030: err %d initializing %s %s\n",
@@ -410,7 +410,7 @@ static int twl4030_init_sih_modules(unsigned line)
* And for PWR_INT it's not documented... * And for PWR_INT it's not documented...
*/ */
if (sih->set_cor) { if (sih->set_cor) {
status = twl4030_i2c_write_u8(sih->module, status = twl_i2c_write_u8(sih->module,
TWL4030_SIH_CTRL_COR_MASK, TWL4030_SIH_CTRL_COR_MASK,
sih->control_offset); sih->control_offset);
if (status < 0) if (status < 0)
@@ -438,14 +438,14 @@ static int twl4030_init_sih_modules(unsigned line)
* uncommon with PWR_INT.PWRON. * uncommon with PWR_INT.PWRON.
*/ */
for (j = 0; j < 2; j++) { for (j = 0; j < 2; j++) {
status = twl4030_i2c_read(sih->module, rxbuf, status = twl_i2c_read(sih->module, rxbuf,
sih->mask[line].isr_offset, sih->bytes_ixr); sih->mask[line].isr_offset, sih->bytes_ixr);
if (status < 0) if (status < 0)
pr_err("twl4030: err %d initializing %s %s\n", pr_err("twl4030: err %d initializing %s %s\n",
status, sih->name, "ISR"); status, sih->name, "ISR");
if (!sih->set_cor) if (!sih->set_cor)
status = twl4030_i2c_write(sih->module, buf, status = twl_i2c_write(sih->module, buf,
sih->mask[line].isr_offset, sih->mask[line].isr_offset,
sih->bytes_ixr); sih->bytes_ixr);
/* else COR=1 means read sufficed. /* else COR=1 means read sufficed.
@@ -514,7 +514,7 @@ static void twl4030_sih_do_mask(struct work_struct *work)
return; return;
/* write the whole mask ... simpler than subsetting it */ /* write the whole mask ... simpler than subsetting it */
status = twl4030_i2c_write(sih->module, imr.bytes, status = twl_i2c_write(sih->module, imr.bytes,
sih->mask[irq_line].imr_offset, sih->bytes_ixr); sih->mask[irq_line].imr_offset, sih->bytes_ixr);
if (status) if (status)
pr_err("twl4030: %s, %s --> %d\n", __func__, pr_err("twl4030: %s, %s --> %d\n", __func__,
@@ -545,7 +545,7 @@ static void twl4030_sih_do_edge(struct work_struct *work)
* any processor on the other IRQ line, EDR registers are * any processor on the other IRQ line, EDR registers are
* shared. * shared.
*/ */
status = twl4030_i2c_read(sih->module, bytes + 1, status = twl_i2c_read(sih->module, bytes + 1,
sih->edr_offset, sih->bytes_edr); sih->edr_offset, sih->bytes_edr);
if (status) { if (status) {
pr_err("twl4030: %s, %s --> %d\n", __func__, pr_err("twl4030: %s, %s --> %d\n", __func__,
@@ -579,7 +579,7 @@ static void twl4030_sih_do_edge(struct work_struct *work)
} }
/* Write */ /* Write */
status = twl4030_i2c_write(sih->module, bytes, status = twl_i2c_write(sih->module, bytes,
sih->edr_offset, sih->bytes_edr); sih->edr_offset, sih->bytes_edr);
if (status) if (status)
pr_err("twl4030: %s, %s --> %d\n", __func__, pr_err("twl4030: %s, %s --> %d\n", __func__,
@@ -664,7 +664,7 @@ static inline int sih_read_isr(const struct sih *sih)
/* FIXME need retry-on-error ... */ /* FIXME need retry-on-error ... */
isr.word = 0; isr.word = 0;
status = twl4030_i2c_read(sih->module, isr.bytes, status = twl_i2c_read(sih->module, isr.bytes,
sih->mask[irq_line].isr_offset, sih->bytes_ixr); sih->mask[irq_line].isr_offset, sih->bytes_ixr);
return (status < 0) ? status : le32_to_cpu(isr.word); return (status < 0) ? status : le32_to_cpu(isr.word);

68
drivers/mfd/twl4030-power.c
View File

@@ -131,11 +131,11 @@ static int __init twl4030_write_script_byte(u8 address, u8 byte)
{ {
int err; int err;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
R_MEMORY_ADDRESS); R_MEMORY_ADDRESS);
if (err) if (err)
goto out; goto out;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, byte, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, byte,
R_MEMORY_DATA); R_MEMORY_DATA);
out: out:
return err; return err;
@@ -192,18 +192,18 @@ static int __init twl4030_config_wakeup3_sequence(u8 address)
u8 data; u8 data;
/* Set SLEEP to ACTIVE SEQ address for P3 */ /* Set SLEEP to ACTIVE SEQ address for P3 */
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
R_SEQ_ADD_S2A3); R_SEQ_ADD_S2A3);
if (err) if (err)
goto out; goto out;
/* P3 LVL_WAKEUP should be on LEVEL */ /* P3 LVL_WAKEUP should be on LEVEL */
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
R_P3_SW_EVENTS); R_P3_SW_EVENTS);
if (err) if (err)
goto out; goto out;
data |= LVL_WAKEUP; data |= LVL_WAKEUP;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
R_P3_SW_EVENTS); R_P3_SW_EVENTS);
out: out:
if (err) if (err)
@@ -217,42 +217,42 @@ static int __init twl4030_config_wakeup12_sequence(u8 address)
u8 data; u8 data;
/* Set SLEEP to ACTIVE SEQ address for P1 and P2 */ /* Set SLEEP to ACTIVE SEQ address for P1 and P2 */
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
R_SEQ_ADD_S2A12); R_SEQ_ADD_S2A12);
if (err) if (err)
goto out; goto out;
/* P1/P2 LVL_WAKEUP should be on LEVEL */ /* P1/P2 LVL_WAKEUP should be on LEVEL */
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
R_P1_SW_EVENTS); R_P1_SW_EVENTS);
if (err) if (err)
goto out; goto out;
data |= LVL_WAKEUP; data |= LVL_WAKEUP;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
R_P1_SW_EVENTS); R_P1_SW_EVENTS);
if (err) if (err)
goto out; goto out;
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
R_P2_SW_EVENTS); R_P2_SW_EVENTS);
if (err) if (err)
goto out; goto out;
data |= LVL_WAKEUP; data |= LVL_WAKEUP;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data,
R_P2_SW_EVENTS); R_P2_SW_EVENTS);
if (err) if (err)
goto out; goto out;
if (machine_is_omap_3430sdp() || machine_is_omap_ldp()) { if (machine_is_omap_3430sdp() || machine_is_omap_ldp()) {
/* Disabling AC charger effect on sleep-active transitions */ /* Disabling AC charger effect on sleep-active transitions */
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &data,
R_CFG_P1_TRANSITION); R_CFG_P1_TRANSITION);
if (err) if (err)
goto out; goto out;
data &= ~(1<<1); data &= ~(1<<1);
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data , err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, data ,
R_CFG_P1_TRANSITION); R_CFG_P1_TRANSITION);
if (err) if (err)
goto out; goto out;
@@ -270,7 +270,7 @@ static int __init twl4030_config_sleep_sequence(u8 address)
int err; int err;
/* Set ACTIVE to SLEEP SEQ address in T2 memory*/ /* Set ACTIVE to SLEEP SEQ address in T2 memory*/
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
R_SEQ_ADD_A2S); R_SEQ_ADD_A2S);
if (err) if (err)
@@ -285,41 +285,41 @@ static int __init twl4030_config_warmreset_sequence(u8 address)
u8 rd_data; u8 rd_data;
/* Set WARM RESET SEQ address for P1 */ /* Set WARM RESET SEQ address for P1 */
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, address,
R_SEQ_ADD_WARM); R_SEQ_ADD_WARM);
if (err) if (err)
goto out; goto out;
/* P1/P2/P3 enable WARMRESET */ /* P1/P2/P3 enable WARMRESET */
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
R_P1_SW_EVENTS); R_P1_SW_EVENTS);
if (err) if (err)
goto out; goto out;
rd_data |= ENABLE_WARMRESET; rd_data |= ENABLE_WARMRESET;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
R_P1_SW_EVENTS); R_P1_SW_EVENTS);
if (err) if (err)
goto out; goto out;
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
R_P2_SW_EVENTS); R_P2_SW_EVENTS);
if (err) if (err)
goto out; goto out;
rd_data |= ENABLE_WARMRESET; rd_data |= ENABLE_WARMRESET;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
R_P2_SW_EVENTS); R_P2_SW_EVENTS);
if (err) if (err)
goto out; goto out;
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data, err = twl_i2c_read_u8(TWL4030_MODULE_PM_MASTER, &rd_data,
R_P3_SW_EVENTS); R_P3_SW_EVENTS);
if (err) if (err)
goto out; goto out;
rd_data |= ENABLE_WARMRESET; rd_data |= ENABLE_WARMRESET;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, rd_data,
R_P3_SW_EVENTS); R_P3_SW_EVENTS);
out: out:
if (err) if (err)
@@ -344,8 +344,8 @@ static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
rconfig_addr = res_config_addrs[rconfig->resource]; rconfig_addr = res_config_addrs[rconfig->resource];
/* Set resource group */ /* Set resource group */
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &grp, err = twl_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &grp,
rconfig_addr + DEV_GRP_OFFSET); rconfig_addr + DEV_GRP_OFFSET);
if (err) { if (err) {
pr_err("TWL4030 Resource %d group could not be read\n", pr_err("TWL4030 Resource %d group could not be read\n",
rconfig->resource); rconfig->resource);
@@ -355,8 +355,8 @@ static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
if (rconfig->devgroup != TWL4030_RESCONFIG_UNDEF) { if (rconfig->devgroup != TWL4030_RESCONFIG_UNDEF) {
grp &= ~DEV_GRP_MASK; grp &= ~DEV_GRP_MASK;
grp |= rconfig->devgroup << DEV_GRP_SHIFT; grp |= rconfig->devgroup << DEV_GRP_SHIFT;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, err = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
grp, rconfig_addr + DEV_GRP_OFFSET); grp, rconfig_addr + DEV_GRP_OFFSET);
if (err < 0) { if (err < 0) {
pr_err("TWL4030 failed to program devgroup\n"); pr_err("TWL4030 failed to program devgroup\n");
return err; return err;
@@ -364,7 +364,7 @@ static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
} }
/* Set resource types */ /* Set resource types */
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &type, err = twl_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &type,
rconfig_addr + TYPE_OFFSET); rconfig_addr + TYPE_OFFSET);
if (err < 0) { if (err < 0) {
pr_err("TWL4030 Resource %d type could not be read\n", pr_err("TWL4030 Resource %d type could not be read\n",
@@ -382,7 +382,7 @@ static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
type |= rconfig->type2 << TYPE2_SHIFT; type |= rconfig->type2 << TYPE2_SHIFT;
} }
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, err = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
type, rconfig_addr + TYPE_OFFSET); type, rconfig_addr + TYPE_OFFSET);
if (err < 0) { if (err < 0) {
pr_err("TWL4030 failed to program resource type\n"); pr_err("TWL4030 failed to program resource type\n");
@@ -390,8 +390,8 @@ static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
} }
/* Set remap states */ /* Set remap states */
err = twl4030_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &remap, err = twl_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, &remap,
rconfig_addr + REMAP_OFFSET); rconfig_addr + REMAP_OFFSET);
if (err < 0) { if (err < 0) {
pr_err("TWL4030 Resource %d remap could not be read\n", pr_err("TWL4030 Resource %d remap could not be read\n",
rconfig->resource); rconfig->resource);
@@ -408,9 +408,9 @@ static int __init twl4030_configure_resource(struct twl4030_resconfig *rconfig)
remap |= rconfig->remap_off << SLEEP_STATE_SHIFT; remap |= rconfig->remap_off << SLEEP_STATE_SHIFT;
} }
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, err = twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
remap, remap,
rconfig_addr + REMAP_OFFSET); rconfig_addr + REMAP_OFFSET);
if (err < 0) { if (err < 0) {
pr_err("TWL4030 failed to program remap\n"); pr_err("TWL4030 failed to program remap\n");
return err; return err;
@@ -468,12 +468,12 @@ void __init twl4030_power_init(struct twl4030_power_data *twl4030_scripts)
struct twl4030_resconfig *resconfig; struct twl4030_resconfig *resconfig;
u8 address = twl4030_start_script_address; u8 address = twl4030_start_script_address;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_1, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_1,
R_PROTECT_KEY); R_PROTECT_KEY);
if (err) if (err)
goto unlock; goto unlock;
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_2, err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, R_KEY_2,
R_PROTECT_KEY); R_PROTECT_KEY);
if (err) if (err)
goto unlock; goto unlock;
@@ -496,7 +496,7 @@ void __init twl4030_power_init(struct twl4030_power_data *twl4030_scripts)
} }
} }
err = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY); err = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, R_PROTECT_KEY);
if (err) if (err)
pr_err("TWL4030 Unable to relock registers\n"); pr_err("TWL4030 Unable to relock registers\n");
return; return;

8
drivers/regulator/twl-regulator.c
View File

@@ -64,7 +64,7 @@ twl4030reg_read(struct twlreg_info *info, unsigned offset)
u8 value; u8 value;
int status; int status;
status = twl4030_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER, status = twl_i2c_read_u8(TWL4030_MODULE_PM_RECEIVER,
&value, info->base + offset); &value, info->base + offset);
return (status < 0) ? status : value; return (status < 0) ? status : value;
} }
@@ -72,7 +72,7 @@ twl4030reg_read(struct twlreg_info *info, unsigned offset)
static inline int static inline int
twl4030reg_write(struct twlreg_info *info, unsigned offset, u8 value) twl4030reg_write(struct twlreg_info *info, unsigned offset, u8 value)
{ {
return twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, return twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER,
value, info->base + offset); value, info->base + offset);
} }
@@ -171,12 +171,12 @@ static int twl4030reg_set_mode(struct regulator_dev *rdev, unsigned mode)
if (!(status & (P3_GRP | P2_GRP | P1_GRP))) if (!(status & (P3_GRP | P2_GRP | P1_GRP)))
return -EACCES; return -EACCES;
status = twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, status = twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER,
message >> 8, 0x15 /* PB_WORD_MSB */ ); message >> 8, 0x15 /* PB_WORD_MSB */ );
if (status >= 0) if (status >= 0)
return status; return status;
return twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, return twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER,
message, 0x16 /* PB_WORD_LSB */ ); message, 0x16 /* PB_WORD_LSB */ );
} }

14
drivers/rtc/rtc-twl.c
View File

@@ -92,7 +92,7 @@ static int twl4030_rtc_read_u8(u8 *data, u8 reg)
{ {
int ret; int ret;
ret = twl4030_i2c_read_u8(TWL4030_MODULE_RTC, data, reg); ret = twl_i2c_read_u8(TWL4030_MODULE_RTC, data, reg);
if (ret < 0) if (ret < 0)
pr_err("twl4030_rtc: Could not read TWL4030" pr_err("twl4030_rtc: Could not read TWL4030"
"register %X - error %d\n", reg, ret); "register %X - error %d\n", reg, ret);
@@ -106,7 +106,7 @@ static int twl4030_rtc_write_u8(u8 data, u8 reg)
{ {
int ret; int ret;
ret = twl4030_i2c_write_u8(TWL4030_MODULE_RTC, data, reg); ret = twl_i2c_write_u8(TWL4030_MODULE_RTC, data, reg);
if (ret < 0) if (ret < 0)
pr_err("twl4030_rtc: Could not write TWL4030" pr_err("twl4030_rtc: Could not write TWL4030"
"register %X - error %d\n", reg, ret); "register %X - error %d\n", reg, ret);
@@ -201,7 +201,7 @@ static int twl4030_rtc_read_time(struct device *dev, struct rtc_time *tm)
if (ret < 0) if (ret < 0)
return ret; return ret;
ret = twl4030_i2c_read(TWL4030_MODULE_RTC, rtc_data, ret = twl_i2c_read(TWL4030_MODULE_RTC, rtc_data,
REG_SECONDS_REG, ALL_TIME_REGS); REG_SECONDS_REG, ALL_TIME_REGS);
if (ret < 0) { if (ret < 0) {
@@ -243,7 +243,7 @@ static int twl4030_rtc_set_time(struct device *dev, struct rtc_time *tm)
goto out; goto out;
/* update all the time registers in one shot */ /* update all the time registers in one shot */
ret = twl4030_i2c_write(TWL4030_MODULE_RTC, rtc_data, ret = twl_i2c_write(TWL4030_MODULE_RTC, rtc_data,
REG_SECONDS_REG, ALL_TIME_REGS); REG_SECONDS_REG, ALL_TIME_REGS);
if (ret < 0) { if (ret < 0) {
dev_err(dev, "rtc_set_time error %d\n", ret); dev_err(dev, "rtc_set_time error %d\n", ret);
@@ -266,7 +266,7 @@ static int twl4030_rtc_read_alarm(struct device *dev, struct rtc_wkalrm *alm)
unsigned char rtc_data[ALL_TIME_REGS + 1]; unsigned char rtc_data[ALL_TIME_REGS + 1];
int ret; int ret;
ret = twl4030_i2c_read(TWL4030_MODULE_RTC, rtc_data, ret = twl_i2c_read(TWL4030_MODULE_RTC, rtc_data,
REG_ALARM_SECONDS_REG, ALL_TIME_REGS); REG_ALARM_SECONDS_REG, ALL_TIME_REGS);
if (ret < 0) { if (ret < 0) {
dev_err(dev, "rtc_read_alarm error %d\n", ret); dev_err(dev, "rtc_read_alarm error %d\n", ret);
@@ -305,7 +305,7 @@ static int twl4030_rtc_set_alarm(struct device *dev, struct rtc_wkalrm *alm)
alarm_data[6] = bin2bcd(alm->time.tm_year - 100); alarm_data[6] = bin2bcd(alm->time.tm_year - 100);
/* update all the alarm registers in one shot */ /* update all the alarm registers in one shot */
ret = twl4030_i2c_write(TWL4030_MODULE_RTC, alarm_data, ret = twl_i2c_write(TWL4030_MODULE_RTC, alarm_data,
REG_ALARM_SECONDS_REG, ALL_TIME_REGS); REG_ALARM_SECONDS_REG, ALL_TIME_REGS);
if (ret) { if (ret) {
dev_err(dev, "rtc_set_alarm error %d\n", ret); dev_err(dev, "rtc_set_alarm error %d\n", ret);
@@ -363,7 +363,7 @@ static irqreturn_t twl4030_rtc_interrupt(int irq, void *rtc)
* risk wrongly clearing status for some other IRQ (losing * risk wrongly clearing status for some other IRQ (losing
* the interrupt). Be smarter about handling RTC_UF ... * the interrupt). Be smarter about handling RTC_UF ...
*/ */
res = twl4030_i2c_read_u8(TWL4030_MODULE_INT, res = twl_i2c_read_u8(TWL4030_MODULE_INT,
&rd_reg, TWL4030_INT_PWR_ISR1); &rd_reg, TWL4030_INT_PWR_ISR1);
if (res) if (res)
goto out; goto out;

36
drivers/usb/otg/twl4030-usb.c
View File

@@ -276,16 +276,16 @@ static int twl4030_i2c_write_u8_verify(struct twl4030_usb *twl,
{ {
u8 check; u8 check;
if ((twl4030_i2c_write_u8(module, data, address) >= 0) && if ((twl_i2c_write_u8(module, data, address) >= 0) &&
(twl4030_i2c_read_u8(module, &check, address) >= 0) && (twl_i2c_read_u8(module, &check, address) >= 0) &&
(check == data)) (check == data))
return 0; return 0;
dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n", dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n",
1, module, address, check, data); 1, module, address, check, data);
/* Failed once: Try again */ /* Failed once: Try again */
if ((twl4030_i2c_write_u8(module, data, address) >= 0) && if ((twl_i2c_write_u8(module, data, address) >= 0) &&
(twl4030_i2c_read_u8(module, &check, address) >= 0) && (twl_i2c_read_u8(module, &check, address) >= 0) &&
(check == data)) (check == data))
return 0; return 0;
dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n", dev_dbg(twl->dev, "Write%d[%d,0x%x] wrote %02x but read %02x\n",
@@ -303,7 +303,7 @@ static inline int twl4030_usb_write(struct twl4030_usb *twl,
{ {
int ret = 0; int ret = 0;
ret = twl4030_i2c_write_u8(TWL4030_MODULE_USB, data, address); ret = twl_i2c_write_u8(TWL4030_MODULE_USB, data, address);
if (ret < 0) if (ret < 0)
dev_dbg(twl->dev, dev_dbg(twl->dev,
"TWL4030:USB:Write[0x%x] Error %d\n", address, ret); "TWL4030:USB:Write[0x%x] Error %d\n", address, ret);
@@ -315,7 +315,7 @@ static inline int twl4030_readb(struct twl4030_usb *twl, u8 module, u8 address)
u8 data; u8 data;
int ret = 0; int ret = 0;
ret = twl4030_i2c_read_u8(module, &data, address); ret = twl_i2c_read_u8(module, &data, address);
if (ret >= 0) if (ret >= 0)
ret = data; ret = data;
else else
@@ -462,7 +462,7 @@ static void twl4030_phy_power(struct twl4030_usb *twl, int on)
* SLEEP. We work around this by clearing the bit after usv3v1 * SLEEP. We work around this by clearing the bit after usv3v1
* is re-activated. This ensures that VUSB3V1 is really active. * is re-activated. This ensures that VUSB3V1 is really active.
*/ */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0,
VUSB_DEDICATED2); VUSB_DEDICATED2);
regulator_enable(twl->usb1v5); regulator_enable(twl->usb1v5);
pwr &= ~PHY_PWR_PHYPWD; pwr &= ~PHY_PWR_PHYPWD;
@@ -505,44 +505,44 @@ static void twl4030_phy_resume(struct twl4030_usb *twl)
static int twl4030_usb_ldo_init(struct twl4030_usb *twl) static int twl4030_usb_ldo_init(struct twl4030_usb *twl)
{ {
/* Enable writing to power configuration registers */ /* Enable writing to power configuration registers */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0xC0, PROTECT_KEY); twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0xC0, PROTECT_KEY);
twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0x0C, PROTECT_KEY); twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0x0C, PROTECT_KEY);
/* put VUSB3V1 LDO in active state */ /* put VUSB3V1 LDO in active state */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB_DEDICATED2);
/* input to VUSB3V1 LDO is from VBAT, not VBUS */ /* input to VUSB3V1 LDO is from VBAT, not VBUS */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x14, VUSB_DEDICATED1);
/* Initialize 3.1V regulator */ /* Initialize 3.1V regulator */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_DEV_GRP); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_DEV_GRP);
twl->usb3v1 = regulator_get(twl->dev, "usb3v1"); twl->usb3v1 = regulator_get(twl->dev, "usb3v1");
if (IS_ERR(twl->usb3v1)) if (IS_ERR(twl->usb3v1))
return -ENODEV; return -ENODEV;
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB3V1_TYPE);
/* Initialize 1.5V regulator */ /* Initialize 1.5V regulator */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_DEV_GRP); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_DEV_GRP);
twl->usb1v5 = regulator_get(twl->dev, "usb1v5"); twl->usb1v5 = regulator_get(twl->dev, "usb1v5");
if (IS_ERR(twl->usb1v5)) if (IS_ERR(twl->usb1v5))
goto fail1; goto fail1;
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V5_TYPE);
/* Initialize 1.8V regulator */ /* Initialize 1.8V regulator */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_DEV_GRP); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_DEV_GRP);
twl->usb1v8 = regulator_get(twl->dev, "usb1v8"); twl->usb1v8 = regulator_get(twl->dev, "usb1v8");
if (IS_ERR(twl->usb1v8)) if (IS_ERR(twl->usb1v8))
goto fail2; goto fail2;
twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE); twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0, VUSB1V8_TYPE);
/* disable access to power configuration registers */ /* disable access to power configuration registers */
twl4030_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, PROTECT_KEY); twl_i2c_write_u8(TWL4030_MODULE_PM_MASTER, 0, PROTECT_KEY);
return 0; return 0;

2
drivers/video/omap/lcd_2430sdp.c
View File

@@ -52,7 +52,7 @@ static unsigned enable_gpio;
#define TWL4030_VPLL2_DEV_GRP 0x33 #define TWL4030_VPLL2_DEV_GRP 0x33
#define TWL4030_VPLL2_DEDICATED 0x36 #define TWL4030_VPLL2_DEDICATED 0x36
#define t2_out(c, r, v) twl4030_i2c_write_u8(c, r, v) #define t2_out(c, r, v) twl_i2c_write_u8(c, r, v)
static int sdp2430_panel_init(struct lcd_panel *panel, static int sdp2430_panel_init(struct lcd_panel *panel,

2
drivers/watchdog/twl4030_wdt.c
View File

@@ -48,7 +48,7 @@ MODULE_PARM_DESC(nowayout, "Watchdog cannot be stopped once started "
static int twl4030_wdt_write(unsigned char val) static int twl4030_wdt_write(unsigned char val)
{ {
return twl4030_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, val, return twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, val,
TWL4030_WATCHDOG_CFG_REG_OFFS); TWL4030_WATCHDOG_CFG_REG_OFFS);
} }

31
include/linux/i2c/twl.h
View File

@@ -22,8 +22,8 @@
* *
*/ */
#ifndef __TWL4030_H_ #ifndef __TWL_H_
#define __TWL4030_H_ #define __TWL_H_
#include <linux/types.h> #include <linux/types.h>
#include <linux/input/matrix_keypad.h> #include <linux/input/matrix_keypad.h>
@@ -72,20 +72,37 @@
#define TWL4030_MODULE_RTC 0x16 #define TWL4030_MODULE_RTC 0x16
#define TWL4030_MODULE_SECURED_REG 0x17 #define TWL4030_MODULE_SECURED_REG 0x17
#define TWL_MODULE_USB TWL4030_MODULE_USB
#define TWL_MODULE_AUDIO_VOICE TWL4030_MODULE_AUDIO_VOICE
#define TWL_MODULE_PIH TWL4030_MODULE_PIH
#define TWL_MODULE_MADC TWL4030_MODULE_MADC
#define TWL_MODULE_MAIN_CHARGE TWL4030_MODULE_MAIN_CHARGE
#define TWL_MODULE_PM_MASTER TWL4030_MODULE_PM_MASTER
#define TWL_MODULE_PM_RECEIVER TWL4030_MODULE_PM_RECEIVER
#define TWL_MODULE_RTC TWL4030_MODULE_RTC
#define GPIO_INTR_OFFSET 0
#define KEYPAD_INTR_OFFSET 1
#define BCI_INTR_OFFSET 2
#define MADC_INTR_OFFSET 3
#define USB_INTR_OFFSET 4
#define BCI_PRES_INTR_OFFSET 9
#define USB_PRES_INTR_OFFSET 10
#define RTC_INTR_OFFSET 11
/* /*
* Read and write single 8-bit registers * Read and write single 8-bit registers
*/ */
int twl4030_i2c_write_u8(u8 mod_no, u8 val, u8 reg); int twl_i2c_write_u8(u8 mod_no, u8 val, u8 reg);
int twl4030_i2c_read_u8(u8 mod_no, u8 *val, u8 reg); int twl_i2c_read_u8(u8 mod_no, u8 *val, u8 reg);
/* /*
* Read and write several 8-bit registers at once. * Read and write several 8-bit registers at once.
* *
* IMPORTANT: For twl4030_i2c_write(), allocate num_bytes + 1 * IMPORTANT: For twl_i2c_write(), allocate num_bytes + 1
* for the value, and populate your data starting at offset 1. * for the value, and populate your data starting at offset 1.
*/ */
int twl4030_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes); int twl_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes);
int twl4030_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes); int twl_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes);
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/

8
sound/soc/codecs/twl4030.c
View File

@@ -175,7 +175,7 @@ static int twl4030_write(struct snd_soc_codec *codec,
{ {
twl4030_write_reg_cache(codec, reg, value); twl4030_write_reg_cache(codec, reg, value);
if (likely(reg < TWL4030_REG_SW_SHADOW)) if (likely(reg < TWL4030_REG_SW_SHADOW))
return twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value, return twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, value,
reg); reg);
else else
return 0; return 0;
@@ -261,7 +261,7 @@ static void twl4030_power_up(struct snd_soc_codec *codec)
do { do {
/* this takes a little while, so don't slam i2c */ /* this takes a little while, so don't slam i2c */
udelay(2000); udelay(2000);
twl4030_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte, twl_i2c_read_u8(TWL4030_MODULE_AUDIO_VOICE, &byte,
TWL4030_REG_ANAMICL); TWL4030_REG_ANAMICL);
} while ((i++ < 100) && } while ((i++ < 100) &&
((byte & TWL4030_CNCL_OFFSET_START) == ((byte & TWL4030_CNCL_OFFSET_START) ==
@@ -542,7 +542,7 @@ static int pin_name##pga_event(struct snd_soc_dapm_widget *w, \
break; \ break; \
case SND_SOC_DAPM_POST_PMD: \ case SND_SOC_DAPM_POST_PMD: \
reg_val = twl4030_read_reg_cache(w->codec, reg); \ reg_val = twl4030_read_reg_cache(w->codec, reg); \
twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, \ twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, \
reg_val & (~mask), \ reg_val & (~mask), \
reg); \ reg); \
break; \ break; \
@@ -679,7 +679,7 @@ static void headset_ramp(struct snd_soc_codec *codec, int ramp)
mdelay((ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] / mdelay((ramp_base[(hs_pop & TWL4030_RAMP_DELAY) >> 2] /
twl4030->sysclk) + 1); twl4030->sysclk) + 1);
/* Bypass the reg_cache to mute the headset */ /* Bypass the reg_cache to mute the headset */
twl4030_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE, twl_i2c_write_u8(TWL4030_MODULE_AUDIO_VOICE,
hs_gain & (~0x0f), hs_gain & (~0x0f),
TWL4030_REG_HS_GAIN_SET); TWL4030_REG_HS_GAIN_SET);