rk31:pmu:rt5025:updata drivers,modify charger & fg bug,support otg

diff --git a/arch/arm/mach-rk30/board-pmu-rt5025.c b/arch/arm/mach-rk30/board-pmu-rt5025.c
index 95dac82ea75d7f6a6368ad7fa67f96f5e2828a9d..852e326a07858a660b0df4e76862b15ce0a75828 100644 (file)
--- a/arch/arm/mach-rk30/board-pmu-rt5025.c
+++ b/arch/arm/mach-rk30/board-pmu-rt5025.c
@@ -82,6 +82,16 @@ static int rt5025_post_init(void)
        
        return 0;
 }
+
+ int rt5025_set_otg_enable(int enable)
+{
+       if (enable)
+               rt5025_ext_set_charging_buck(0);
+       else
+               rt5025_ext_set_charging_buck(1);
+       return 0;
+}
+
 static struct regulator_consumer_supply rt5025_dcdc1_supply[] = {
        {
                .supply = "rt5025-dcdc1",

diff --git a/drivers/mfd/rt5025-irq.c b/drivers/mfd/rt5025-irq.c
index 161aefa787ce5ed1c1aefd4592044d1f8e3465a5..8bf1bea23b37655900a434ea43858e147ed7f8df 100644 (file)
--- a/drivers/mfd/rt5025-irq.c
+++ b/drivers/mfd/rt5025-irq.c
@@ -16,6 +16,8 @@
 #include <linux/i2c.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
+#include <linux/wakelock.h>
+#include <linux/delay.h>
 
 #include <linux/gpio.h>
 #include <linux/irq.h>
@@ -32,8 +34,10 @@ struct rt5025_irq_info {
        struct workqueue_struct *wq;
        struct rt5025_event_callback *event_cb;
        struct delayed_work delayed_work;
+       struct wake_lock irq_wake_lock;
        int intr_pin;
        int irq;
+       int suspend;
 };
 
 static void rt5025_work_func(struct work_struct *work)
@@ -41,8 +45,16 @@ static void rt5025_work_func(struct work_struct *work)
        struct delayed_work *delayed_work = (struct delayed_work *)container_of(work, struct delayed_work, work);
        struct rt5025_irq_info *ii = (struct rt5025_irq_info *)container_of(delayed_work, struct rt5025_irq_info, delayed_work);
        unsigned char irq_stat[6] = {0};
+       unsigned char irq_enable[6] = {0};
        uint32_t chg_event = 0, pwr_event = 0;
 
+       //Add this to prevent i2c xfer before i2c chip is in suspend mode
+       if (ii->suspend)
+       {
+               queue_delayed_work(ii->wq, &ii->delayed_work, msecs_to_jiffies(1));
+               return;
+       }
+
        #ifdef CONFIG_POWER_RT5025
        if (!ii->chip->power_info || !ii->chip->jeita_info || !ii->chip->battery_info)
        {
@@ -55,6 +67,21 @@ static void rt5025_work_func(struct work_struct *work)
        if (rt5025_reg_block_read(ii->i2c, RT5025_REG_IRQEN1, 10, irq_stat) >= 0)
        {
        #endif
+               /* backup the irq enable bit */
+               irq_enable[0] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN1);
+               irq_enable[1] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN2);
+               irq_enable[2] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN3);
+               irq_enable[3] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN4);
+               irq_enable[4] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN5);
+               irq_enable[5] = rt5025_reg_read(ii->i2c, RT5025_REG_GAUGEIRQEN);
+               /* disable all irq enable bit first */
+               rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN1, irq_enable[0]&RT5025_ADAPIRQ_MASK);
+               rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, 0x00);
+               rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN3, 0x00);
+               rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN4, 0x00);
+               rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN5, 0x00);
+               rt5025_reg_write(ii->i2c, RT5025_REG_GAUGEIRQEN, 0x00);
+               /* read irq status bit */
                irq_stat[0] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS1);
                irq_stat[1] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS2);
                irq_stat[2] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS3);
@@ -68,11 +95,38 @@ static void rt5025_work_func(struct work_struct *work)
                chg_event = irq_stat[0]<<16 | irq_stat[1]<<8 | irq_stat[2];
                pwr_event = irq_stat[3]<<8 | irq_stat[4];
                #ifdef CONFIG_POWER_RT5025
-               if (chg_event & CHARGER_DETECT_MASK)
+               if ((chg_event & CHARGER_DETECT_MASK) && ii->chip->power_info->otg_en == 0)
                {
                        if (chg_event & CHG_EVENT_CHTERMI)
+                       {
                                ii->chip->power_info->chg_term++;
-                       rt5025_power_charge_detect(ii->chip->power_info);
+                               if (ii->chip->power_info->chg_term > 3)
+                                       ii->chip->power_info->chg_term = 4;
+                       }
+
+                       if (chg_event & CHG_EVENT_CHRCHGI)
+                               ii->chip->power_info->chg_term = 0;
+
+                       if (chg_event & (CHG_EVENT_CHSLPI_INAC | CHG_EVENT_CHSLPI_INUSB))
+                       {
+                               ii->chip->power_info->chg_term = 0;
+                       }
+
+                       if (chg_event & (CHG_EVENT_INAC_PLUGIN | CHG_EVENT_INUSB_PLUGIN))
+                       {
+                               rt5025_set_charging_buck(ii->i2c, 0);
+                               mdelay(50);
+                               rt5025_set_charging_buck(ii->i2c, 1);
+                               mdelay(100);
+                               rt5025_set_charging_buck(ii->i2c, 0);
+                               mdelay(50);
+                               rt5025_set_charging_buck(ii->i2c, 1);
+                               mdelay(200);
+                       }
+
+                       if (ii->chip->power_info->chg_term <= 3)
+                               rt5025_power_charge_detect(ii->chip->power_info);
+
                }
                #endif /* CONFIG_POWER_RT5025 */
                if (ii->event_cb)
@@ -96,6 +150,15 @@ static void rt5025_work_func(struct work_struct *work)
                rt5025_gauge_irq_handler(ii->chip->battery_info, irq_stat[5] & RT5025_FLG_VOLT);
        #endif /* CONFIG_POWER_RT5025 */
 
+       /* restore all irq enable bit */
+       rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN1, irq_enable[0]);
+       rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, irq_enable[1]);
+       rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN3, irq_enable[2]);
+       rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN4, irq_enable[3]);
+       rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN5, irq_enable[4]);
+       if (rt5025_reg_read(ii->i2c, RT5025_REG_GAUGEIRQEN) == 0)
+               rt5025_reg_write(ii->i2c, RT5025_REG_GAUGEIRQEN, irq_enable[5]);
+
        //enable_irq(ii->irq);
 }
 
@@ -104,6 +167,7 @@ static irqreturn_t rt5025_interrupt(int irqno, void *param)
        struct rt5025_irq_info *ii = (struct rt5025_irq_info *)param;
 
        //disable_irq_nosync(ii->irq);
+       wake_lock_timeout(&ii->irq_wake_lock, 1*HZ);
        queue_delayed_work(ii->wq, &ii->delayed_work, 0);
        return IRQ_HANDLED;
 }
@@ -193,11 +257,13 @@ static int __devinit rt5025_irq_probe(struct platform_device *pdev)
        ii->irq = chip->irq;//gpio_to_irq(pdata->intr_pin);
        if (pdata->cb)
                ii->event_cb = pdata->cb;
+       wake_lock_init(&ii->irq_wake_lock, WAKE_LOCK_SUSPEND, "rt_irq_wake");
 
        rt5025_irq_reg_init(ii, pdata->irq_data);
        rt5025_interrupt_init(ii);
 
        platform_set_drvdata(pdev, ii);
+       RTINFO("\n");
        return 0;
 }
 
@@ -205,8 +271,11 @@ static int __devexit rt5025_irq_remove(struct platform_device *pdev)
 {
        struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
 
+       wake_lock_destroy(&ii->irq_wake_lock);
        rt5025_interrupt_deinit(ii);
        platform_set_drvdata(pdev, NULL);
+       kfree(ii);
+       RTINFO("\n");
        return 0;
 }
 
@@ -222,6 +291,25 @@ static void rt5025_irq_shutdown(struct platform_device *pdev)
                cancel_delayed_work_sync(&ii->delayed_work);
                flush_workqueue(ii->wq);
        }
+       RTINFO("\n");
+}
+
+static int rt5025_irq_suspend(struct platform_device *pdev, pm_message_t state)
+{
+       struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
+
+       RTINFO("\n");
+       ii->suspend = 1;
+       return 0;
+}
+
+static int rt5025_irq_resume(struct platform_device *pdev)
+{
+       struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
+
+       RTINFO("\n");
+       ii->suspend = 0;
+       return 0;
 }
 
 static struct platform_driver rt5025_irq_driver = 
@@ -233,6 +321,8 @@ static struct platform_driver rt5025_irq_driver =
        .probe = rt5025_irq_probe,
        .remove = __devexit_p(rt5025_irq_remove),
        .shutdown = rt5025_irq_shutdown,
+       .suspend = rt5025_irq_suspend,
+       .resume = rt5025_irq_resume,
 };
 
 static int __init rt5025_irq_init(void)

diff --git a/drivers/power/rt5025-battery.c b/drivers/power/rt5025-battery.c
index 1759263ed506e18f5b9c3db0d1bc0f31073c5311..ba7cb2061a350fefa0d3014f86ad515b383fbe7e 100644 (file)
--- a/drivers/power/rt5025-battery.c
+++ b/drivers/power/rt5025-battery.c
@@ -956,6 +956,7 @@ static void rt5025_get_soc(struct rt5025_battery_info *bi)
 #endif
   }
 #if RT5025_CSV
+       RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);
  // pr_info("%d,%d,%d,%d,%d", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);
 #else  
        RTINFO("soc=%d, permille=%d, rm=%d, fcc=%d, smooth_flag=%d\n", bi->soc,bi->permille,bi->rm,bi->fcc,bi->smooth_flag);

diff --git a/drivers/power/rt5025-power.c b/drivers/power/rt5025-power.c
index f9cf2588bd210cf67a9cdcfe82e159cc195f5b80..bfbc2c245bea699fa2d28930980a1f02f39c8ecc 100644 (file)
--- a/drivers/power/rt5025-power.c
+++ b/drivers/power/rt5025-power.c
@@ -24,6 +24,8 @@
 #include <linux/power/rt5025-power.h>
 #include <linux/delay.h>
 
+static struct platform_device *dev_ptr;
+
 
 static enum power_supply_property rt5025_adap_props[] = {
        POWER_SUPPLY_PROP_ONLINE,
@@ -34,8 +36,7 @@ static char *rt5025_supply_list[] = {
 };
 
 
-#if 0
-static int rt5025_set_charging_current_switch (struct i2c_client *i2c, int onoff)
+int rt5025_set_charging_current_switch (struct i2c_client *i2c, int onoff)
 {
        int ret;
        if (onoff)
@@ -44,8 +45,9 @@ static int rt5025_set_charging_current_switch (struct i2c_client *i2c, int onoff
                ret = rt5025_clr_bits(i2c, RT5025_REG_CHGCTL7, RT5025_CHGCEN_MASK);
        return ret;
 }
+EXPORT_SYMBOL(rt5025_set_charging_current_switch);
 
-static int rt5025_set_charging_buck(struct i2c_client *i2c, int onoff)
+int rt5025_set_charging_buck(struct i2c_client *i2c, int onoff)
 {
        int ret;
        if (onoff)
@@ -54,7 +56,27 @@ static int rt5025_set_charging_buck(struct i2c_client *i2c, int onoff)
                ret = rt5025_clr_bits(i2c, RT5025_REG_CHGCTL2, RT5025_CHGBUCKEN_MASK);
        return ret;
 }
-#endif
+EXPORT_SYMBOL(rt5025_set_charging_buck);
+
+int rt5025_ext_set_charging_buck(int onoff)
+{
+       struct rt5025_power_info *pi = platform_get_drvdata(dev_ptr);
+       int ret;
+       if (onoff)
+       {
+               pi->otg_en = 0;
+               ret = rt5025_set_bits(pi->i2c, RT5025_REG_CHGCTL2, RT5025_CHGBUCKEN_MASK);
+               msleep(100);
+       }
+       else
+       {
+               pi->otg_en = 1;
+               ret = rt5025_clr_bits(pi->i2c, RT5025_REG_CHGCTL2, RT5025_CHGBUCKEN_MASK);
+               msleep(100);
+       }
+       return ret;
+}
+EXPORT_SYMBOL(rt5025_ext_set_charging_buck);
 
 static int rt5025_set_charging_current(struct i2c_client *i2c, int cur_value)
 {
@@ -98,14 +120,15 @@ static int rt5025_chgstat_changed(struct rt5025_power_info *info, unsigned new_v
                        #if 1
                        if (info->chip->battery_info)
                        {
-                               if (info->chg_term == 0)
+                               if (info->chg_term <= 1)
                                        rt5025_gauge_set_status(info->chip->battery_info, POWER_SUPPLY_STATUS_CHARGING);
-                               else if (info->chg_term > 0)
+                               else if (info->chg_term == 2)
                                {
                                        rt5025_gauge_set_status(info->chip->battery_info, POWER_SUPPLY_STATUS_FULL);
-                                       info->chg_term = 0;
+                                       //info->chg_term = 0;
                                }
-                               
+                               else if (info->chg_term > 2)
+                                       ;
                        }
                        #else
                        if (info->event_callback)
@@ -151,13 +174,15 @@ static int rt5025_chgstat_changed(struct rt5025_power_info *info, unsigned new_v
                        #if 1
                        if (info->chip->battery_info)
                        {
-                               if (info->chg_term == 0)
+                               if (info->chg_term <= 1)
                                        rt5025_gauge_set_status(info->chip->battery_info, POWER_SUPPLY_STATUS_CHARGING);
-                               else if (info->chg_term > 1)
+                               else if (info->chg_term == 2)
                                {
                                        rt5025_gauge_set_status(info->chip->battery_info, POWER_SUPPLY_STATUS_FULL);
-                                       info->chg_term = 0;
+                                       //info->chg_term = 0;
                                }
+                               else if (info->chg_term > 2)
+                                       ;
                        }
                        #else
                        if (info->event_callback)
@@ -190,7 +215,7 @@ int rt5025_power_charge_detect(struct rt5025_power_info *info)
        old_usbval = info->usb_online;
        old_chgval = info->chg_stat;
 
-       mdelay(10);
+       mdelay(50);
        
        ret = rt5025_reg_read(info->i2c, RT5025_REG_CHGSTAT);
        if (ret<0)
@@ -199,6 +224,7 @@ int rt5025_power_charge_detect(struct rt5025_power_info *info)
                return ret;
        }
        chgstatval = ret;
+       RTINFO("chgstat = 0x%02x\n", chgstatval);
 
        new_acval = (chgstatval&RT5025_CHG_ACONLINE)>>RT5025_CHG_ACSHIFT;
        if (old_acval != new_acval)
@@ -386,6 +412,7 @@ static int __devinit rt5025_power_probe(struct platform_device *pdev)
        #endif
 
        platform_set_drvdata(pdev, pi);
+       dev_ptr = pdev;
 
        pi->ac.name = "rt5025-dc";
        pi->ac.type = POWER_SUPPLY_TYPE_MAINS;
@@ -410,6 +437,8 @@ static int __devinit rt5025_power_probe(struct platform_device *pdev)
        rt5025_init_charger(pi, pdata->power_data);
        chip->power_info = pi;
 
+       pr_info("rt5025-power driver is successfully loaded\n");
+
        return ret;
 out_usb:
        power_supply_unregister(&pi->ac);
@@ -456,6 +485,7 @@ static int __devexit rt5025_power_remove(struct platform_device *pdev)
        power_supply_unregister(&pi->ac);
        chip->power_info = NULL;
        kfree(pi);
+       RTINFO("\n");
 
        return 0;
 }
@@ -476,7 +506,7 @@ static int __init rt5025_power_init(void)
 {
        return platform_driver_register(&rt5025_power_driver);
 }
-late_initcall_sync(rt5025_power_init);
+fs_initcall_sync(rt5025_power_init);
 
 static void __exit rt5025_power_exit(void)
 {

diff --git a/include/linux/mfd/rt5025-irq.h b/include/linux/mfd/rt5025-irq.h
index 2355d8cb073854be46325db653d32c0da49199f2..8e9070029d37858608a7b0fb3f34edb83d4e9b6b 100644 (file)
--- a/include/linux/mfd/rt5025-irq.h
+++ b/include/linux/mfd/rt5025-irq.h
@@ -26,6 +26,11 @@
 #define RT5025_REG_IRQEN5      0x38
 #define RT5025_REG_IRQSTATUS5  0x39
 
+#define RT5025_INACIRQ_MASK    0x40
+#define RT5025_INUSBIRQ_MASK   0x08
+#define RT5025_ADAPIRQ_MASK    (RT5025_INACIRQ_MASK|RT5025_INUSBIRQ_MASK)
+
+#define RT5025_REG_GAUGEIRQEN  0x50
 #define RT5025_REG_GAUGEIRQFLG 0x51
 #define RT5025_FLG_TEMP                0x30
 #define RT5025_FLG_VOLT                0x07

diff --git a/include/linux/mfd/rt5025-misc.h b/include/linux/mfd/rt5025-misc.h
old mode 100755 (executable)
new mode 100644 (file)
index 7bb506b..20cadd2
--- a/include/linux/mfd/rt5025-misc.h
+++ b/include/linux/mfd/rt5025-misc.h
@@ -2,12 +2,13 @@
  *  include/linux/mfd/rt5025-misc.h
  *  Include header file for Richtek RT5025 PMIC Misc
  *
- *  Copyright (C) 2013 Richtek Electronics
+ *  Copyright (C) 2013 Richtek Technology Corp.
  *  cy_huang <cy_huang@richtek.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
+ * published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
  */
 
 #ifndef __LINUX_RT5025_MISC_H

diff --git a/include/linux/mfd/rt5025.h b/include/linux/mfd/rt5025.h
index bec9cb055b166dabd4e2a8e2c1cddf451678dda6..a7a8fe7c15f42271ad11ec8a914ca13d88054404 100644 (file)
--- a/include/linux/mfd/rt5025.h
+++ b/include/linux/mfd/rt5025.h
@@ -17,7 +17,7 @@
 #include <linux/android_alarm.h>
 
 #define RT5025_DEVICE_NAME "RT5025"
-#define RT5025_DRV_VER    "1.0.2_R"
+#define RT5025_DRV_VER    "1.0.4_R"
 
 enum {
        RT5025_RSTDELAY1_100MS,
@@ -422,6 +422,7 @@ struct rt5025_power_info {
        struct delayed_work usb_detect_work;
        int usb_cnt;
        int chg_term;
+       int otg_en;
        unsigned                ac_online:1;
        unsigned                usb_online:1;
        unsigned                chg_stat:3;
@@ -612,6 +613,7 @@ struct rt5025_platform_data {
        int (*pre_init)(struct rt5025_chip *rt5025_chip);
        /** Called after subdevices are set up */
        int (*post_init)(void);
+       int (*set_otg_enable)(int);
        int intr_pin;
 };
 
@@ -620,6 +622,9 @@ extern void rt5025_power_off(void);
 #endif /* CONFIG_MFD_RT5025_MISC */
 
 #ifdef CONFIG_POWER_RT5025
+extern int rt5025_ext_set_charging_buck(int);
+extern int rt5025_set_charging_buck(struct i2c_client *, int);
+extern int rt5025_set_charging_current_switch(struct i2c_client *, int);
 extern void rt5025_gauge_set_status(struct rt5025_battery_info *, int);
 extern void rt5025_gauge_set_online(struct rt5025_battery_info *, bool);
 extern void rt5025_gauge_irq_handler(struct rt5025_battery_info *, u8);