drivers/power/rt5025-charger.c

   1 /*
   2  *  drivers/power/rt5025-charger.c
   3  *  Driver for Richtek RT5025 PMIC Charger driver
   4  *
   5  *  Copyright (C) 2014 Richtek Technology Corp.
   6  *  cy_huang <cy_huang@richtek.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/version.h>
  18 #include <linux/err.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/i2c.h>
  21 #include <linux/of.h>
  22 #include <linux/power_supply.h>
  23 #include <linux/workqueue.h>
  24 #include <linux/delay.h>
  25 #ifdef CONFIG_HAS_EARLYSUSPEND
  26 #include <linux/earlysuspend.h>
  27 #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
  28
  29 #include <linux/mfd/rt5025.h>
  30 #include <linux/power/rt5025-charger.h>
  31 #ifdef CONFIG_RT_POWER
  32 #include <linux/power/rt-power.h>
  33 #endif /* #ifdef CONFIG_RT_POWER */
  34
  35 static unsigned char chg_init_regval[] = {
  36         0x12, /*REG 0x02*/
  37         0x8C, /*REG 0x03*/
  38         0x03, /*REG 0x04*/
  39         0x20, /*REG 0x05*/
  40         0x14, /*REG 0x06*/
  41         0x40, /*REG 0x07*/
  42         0xDA, /*REG 0x30*/
  43         0xDA, /*REG 0x32*/
  44         0x43, /*REG 0x34*/
  45 };
  46
  47 static char *rtdef_chg_name = "rt-charger";
  48
  49 static char *rt_charger_supply_list[] = {
  50         "none",
  51 };
  52
  53 static enum power_supply_property rt_charger_props[] = {
  54         POWER_SUPPLY_PROP_STATUS,
  55         POWER_SUPPLY_PROP_ONLINE,
  56         POWER_SUPPLY_PROP_PRESENT,
  57         POWER_SUPPLY_PROP_TEMP,
  58         POWER_SUPPLY_PROP_CHARGE_NOW,
  59         POWER_SUPPLY_PROP_CURRENT_MAX,
  60         POWER_SUPPLY_PROP_CURRENT_AVG,
  61         POWER_SUPPLY_PROP_CURRENT_NOW,
  62         POWER_SUPPLY_PROP_VOLTAGE_NOW,
  63         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
  64         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
  65 };
  66
  67 static void rt_charger_set_batt_status(struct rt5025_charger_info *ci);
  68
  69 static int rt_charger_get_property(struct power_supply *psy, enum power_supply_property psp, \
  70                         union power_supply_propval *val)
  71 {
  72         struct rt5025_charger_info *ci = dev_get_drvdata(psy->dev->parent);
  73         int ret = 0;
  74         int regval = 0;
  75         #ifdef CONFIG_BATTERY_RT5025
  76         struct power_supply *bat_psy = power_supply_get_by_name(RT_BATT_NAME);
  77         union power_supply_propval pval;
  78         #endif
  79
  80         switch (psp) {
  81         case POWER_SUPPLY_PROP_ONLINE:
  82                 val->intval = ci->online;
  83                 break;
  84         case POWER_SUPPLY_PROP_STATUS:
  85                 val->intval = ci->chg_status;
  86                 break;
  87         case POWER_SUPPLY_PROP_PRESENT:
  88                 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL7);
  89                 if (regval < 0) {
  90                         ret = -EINVAL;
  91                 } else {
  92                         if (regval & RT5025_CHGCEN_MASK)
  93                                 val->intval = 1;
  94                         else
  95                                 val->intval = 0;
  96                 }
  97                 break;
  98         case POWER_SUPPLY_PROP_TEMP:
  99                 val->intval = 0;
 100                 #ifdef CONFIG_BATTERY_RT5025
 101                         if (bat_psy) {
 102                                 ret = bat_psy->get_property(bat_psy, POWER_SUPPLY_PROP_TEMP_AMBIENT,\
 103                                         &pval);
 104                                 if (ret < 0)
 105                                         dev_err(ci->dev, "get ic temp fail\n");
 106                                 else
 107                                         val->intval = pval.intval;
 108                         }
 109                 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 110                 break;
 111         case POWER_SUPPLY_PROP_CHARGE_NOW:
 112                 val->intval = ci->charger_cable;
 113                 break;
 114         case POWER_SUPPLY_PROP_CURRENT_MAX:
 115                 val->intval = 2000;
 116                 break;
 117         case POWER_SUPPLY_PROP_CURRENT_AVG:
 118                 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL4);
 119                 if (regval < 0) {
 120                         ret = -EINVAL;
 121                 } else {
 122                         regval &= RT5025_CHGAICR_MASK;
 123                         regval >>= RT5025_CHGAICR_SHFT;
 124                         switch (regval) {
 125                         case 0:
 126                                 val->intval = 100;
 127                                 break;
 128                         case 1:
 129                                 val->intval = 500;
 130                                 break;
 131                         case 2:
 132                                 val->intval = 1000;
 133                                 break;
 134                         case 3:
 135                                 val->intval = 0;
 136                                 break;
 137                         default:
 138                                 ret = -EINVAL;
 139                                 break;
 140                         }
 141                 }
 142                 break;
 143         case POWER_SUPPLY_PROP_CURRENT_NOW:
 144                 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL4);
 145                 if (regval < 0) {
 146                         ret = -EINVAL;
 147                 } else {
 148                         regval &= RT5025_CHGICC_MASK;
 149                         regval >>= RT5025_CHGICC_SHFT;
 150                         val->intval = 500 + regval * 100;
 151                         }
 152                 break;
 153         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 154                 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL3);
 155                 if (regval < 0) {
 156                                 ret = -EINVAL;
 157                 } else {
 158                                 regval &= RT5025_CHGCV_MASK;
 159                                 regval >>= RT5025_CHGCV_SHFT;
 160                                 val->intval = regval * 20 + 3500;
 161                 }
 162                 break;
 163         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 164                 val->intval = 3500;
 165                 break;
 166         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 167                 val->intval = 4440;
 168                 break;
 169         default:
 170                 ret = -EINVAL;
 171         }
 172         return ret;
 173 }
 174
 175 static int rt_charger_set_property(struct power_supply *psy, enum power_supply_property psp, \
 176                                 const union power_supply_propval *val)
 177 {
 178         struct rt5025_charger_info *ci = dev_get_drvdata(psy->dev->parent);
 179         int ret = 0;
 180         int regval = 0;
 181         RTINFO("prop = %d, val->intval = %d\n", psp, val->intval);
 182         switch (psp) {
 183         case POWER_SUPPLY_PROP_ONLINE:
 184                 ci->online = val->intval;
 185                 if (ci->online) {
 186                         if (ci->te_en) {
 187                                 ret = rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGTEEN_MASK);
 188                                 /*charger workaround*/
 189                                 mdelay(150);
 190                                 /*turn  on recharge irq enable*/
 191                                 chg_init_regval[8] |= RT5025_CHRCHGI_MASK;
 192                                 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN3, chg_init_regval[8]);
 193                                 /*turn on chterm irq enable*/
 194                                 chg_init_regval[7] |= RT5025_CHTERMI_MASK;
 195                                 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN2, chg_init_regval[7]);
 196                         }
 197                         ci->chg_status = POWER_SUPPLY_STATUS_CHARGING;
 198                         rt_charger_set_batt_status(ci);
 199                 } else {
 200                         if (ci->te_en) {
 201                                 ret = rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGTEEN_MASK);
 202                                 /*charger workaround*/
 203                                 /*turn off chterm irq enable*/
 204                                 chg_init_regval[7] &= ~RT5025_CHTERMI_MASK;
 205                                 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN2, chg_init_regval[7]);
 206                                 /*turn  off recharge irq enable*/
 207                                 chg_init_regval[8] &= ~RT5025_CHRCHGI_MASK;
 208                                 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN3, chg_init_regval[8]);
 209                         }
 210                         ci->chg_status = POWER_SUPPLY_STATUS_DISCHARGING;
 211                         rt_charger_set_batt_status(ci);
 212                 }
 213                 break;
 214         case POWER_SUPPLY_PROP_PRESENT:
 215                 if (ci->online && val->intval) {
 216                         int icc;
 217                         int battemp_icc;
 218                         int inttemp_icc;
 219                         union power_supply_propval pval;
 220
 221                         if (ci->charger_cable == POWER_SUPPLY_TYPE_MAINS)
 222                                 battemp_icc = inttemp_icc = (ci->screen_on ?\
 223                                         ci->screenon_icc:ci->acchg_icc);
 224                         else if (ci->charger_cable == POWER_SUPPLY_TYPE_USB_DCP)
 225                                 battemp_icc = inttemp_icc = (ci->screen_on ?\
 226                                         ci->screenon_icc:ci->usbtachg_icc);
 227                         else
 228                                 battemp_icc = inttemp_icc = (ci->screen_on ?\
 229                                         ci->screenon_icc:ci->usbchg_icc);
 230                         if (ci->battemp_region == RT5025_BATTEMP_COLD ||\
 231                                 ci->battemp_region == RT5025_BATTEMP_HOT)
 232                                 battemp_icc = 10;
 233                         else if (ci->battemp_region == RT5025_BATTEMP_COOL ||\
 234                                 ci->battemp_region == RT5025_BATTEMP_WARM)
 235                                 battemp_icc /= 2;
 236
 237                         if (ci->inttemp_region == RT5025_INTTEMP_WARM)
 238                                 inttemp_icc -= 300;
 239                         else if (ci->inttemp_region == RT5025_INTTEMP_HOT)
 240                                 inttemp_icc -= 800;
 241
 242                         if (inttemp_icc < 0)
 243                                 inttemp_icc = 10;
 244
 245                         icc = min(battemp_icc, inttemp_icc);
 246                         pval.intval = icc;
 247                         ret = psy->set_property(psy, POWER_SUPPLY_PROP_CURRENT_NOW, &pval);
 248                         if (ret < 0)
 249                                 dev_err(ci->dev, "set final icc fail\n");
 250                 }
 251                 break;
 252         case POWER_SUPPLY_PROP_CHARGE_NOW:
 253                 ci->charger_cable = val->intval;
 254                 break;
 255         case POWER_SUPPLY_PROP_CURRENT_AVG:
 256                 if (0 < val->intval && val->intval <= 100)
 257                         regval = 0;
 258                 else if (val->intval <= 500)
 259                         regval = 1;
 260                 else if (val->intval <= 1000)
 261                         regval = 2;
 262                 else
 263                         regval = 3;
 264                 if (!ci->batabs)
 265                         ret = rt5025_assign_bits(ci->i2c, RT5025_REG_CHGCTL4, \
 266                                 RT5025_CHGAICR_MASK, regval << RT5025_CHGAICR_SHFT);
 267                 break;
 268         case POWER_SUPPLY_PROP_CURRENT_NOW:
 269                 if (val->intval < 0) {
 270                         ci->otg_en = 1;
 271                         regval = -1;
 272                         #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN
 273                         ret = rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_VBUSHZ_MASK);
 274                         if (ret < 0)
 275                                 dev_err(ci->dev, "set vbus hz fail\n");
 276                         #else
 277                         ret = rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGBCEN_MASK);
 278                         if (ret < 0)
 279                                 dev_err(ci->dev, "shutdown chg buck fail\n");
 280                         #endif /* #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
 281                 } else if (val->intval == 0) {
 282                         ci->otg_en = 0;
 283                         regval = -1;
 284                         #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN
 285                         ret = rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_VBUSHZ_MASK);
 286                         if (ret < 0)
 287                                 dev_err(ci->dev, "clear vbus hz fail\n");
 288                         #else
 289                         ret = rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGBCEN_MASK);
 290                         if (ret < 0)
 291                                 dev_err(ci->dev, "turnon chg buck fail\n");
 292                         #endif /* #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
 293                 } else if (val->intval > 0 && val->intval < 500) {
 294                                 regval = 0;
 295                 } else if (val->intval > 2000) {
 296                                 regval = 15;
 297                 } else {
 298                                 regval = (val->intval - 500) / 100;
 299                 }
 300
 301                 if (regval >= 0)
 302                         ret = rt5025_assign_bits(ci->i2c, RT5025_REG_CHGCTL4, RT5025_CHGICC_MASK, \
 303                                         regval<<RT5025_CHGICC_SHFT);
 304
 305                 if (val->intval > 0 && val->intval < 500)
 306                         rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL7, RT5025_CHGCEN_MASK);
 307                 else
 308                         rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL7, RT5025_CHGCEN_MASK);
 309                 break;
 310         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 311                 if (val->intval < 3500)
 312                         regval = 0;
 313                 else if (val->intval > 4440)
 314                         regval = 0x3A;
 315                 else
 316                         regval = (val->intval - 3500) / 20;
 317                 ret = rt5025_assign_bits(ci->i2c, RT5025_REG_CHGCTL3, RT5025_CHGCV_MASK, \
 318                                         regval << RT5025_CHGCV_SHFT);
 319                 break;
 320         case POWER_SUPPLY_PROP_TEMP:
 321         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
 322         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
 323         case POWER_SUPPLY_PROP_CURRENT_MAX:
 324         case POWER_SUPPLY_PROP_STATUS:
 325         default:
 326                 ret = -EINVAL;
 327         }
 328         return ret;
 329 }
 330
 331 #ifdef CONFIG_BATTERY_RT5025
 332 static int rt5025_set_tempalrt(struct rt5025_charger_info *ci)
 333 {
 334         int rc = 0;
 335
 336         rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
 337                 RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0x00);
 338         if (ci->battemp_region == RT5025_BATTEMP_HOT) {
 339                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[6]);
 340                 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
 341                         RT5025_TALRTMX_MASK, 0xFF);
 342         } else if (ci->battemp_region == RT5025_BATTEMP_WARM) {
 343                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[4]);
 344                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[7]);
 345                 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
 346                         RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0xFF);
 347         } else if (ci->battemp_region == RT5025_BATTEMP_NORMAL) {
 348                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[2]);
 349                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[5]);
 350                 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
 351                         RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0xFF);
 352         } else if (ci->battemp_region == RT5025_BATTEMP_COOL) {
 353                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[0]);
 354                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[3]);
 355                 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
 356                         RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0xFF);
 357         } else {
 358                 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[1]);
 359                 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
 360                         RT5025_TALRTMN_MASK, 0xFF);
 361         }
 362         return rc;
 363 }
 364 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 365
 366 static void rt_charger_set_batt_status(struct rt5025_charger_info *ci)
 367 {
 368         #ifdef CONFIG_BATTERY_RT5025
 369         struct power_supply *psy = power_supply_get_by_name(RT_BATT_NAME);
 370         union power_supply_propval pval;
 371         int rc = 0;
 372
 373         if (!psy) {
 374                 dev_err(ci->dev, "can't get battery supply\n");
 375                 return;
 376         }
 377         pval.intval = ci->chg_status;
 378         rc = psy->set_property(psy, POWER_SUPPLY_PROP_STATUS, &pval);
 379         if (rc < 0)
 380                 dev_err(ci->dev, "set battery status fail\n");
 381         power_supply_changed(psy);
 382         #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 383 }
 384
 385 static int rt_charger_check_battery_present(struct rt5025_charger_info *ci)
 386 {
 387         int rc = 1;
 388         #ifdef CONFIG_BATTERY_RT5025
 389         struct power_supply *psy = power_supply_get_by_name(RT_BATT_NAME);
 390         union power_supply_propval pval;
 391
 392         if (!psy) {
 393                 dev_err(ci->dev, "can't get battery supply\n");
 394                 return rc;
 395         }
 396         rc = psy->get_property(psy, POWER_SUPPLY_PROP_VOLTAGE_NOW, &pval);
 397         if (rc < 0) {
 398                 dev_err(ci->dev, "get battery voltage fail\n");
 399         } else {
 400                 if (pval.intval < (ci->chg_volt - 200) * 1000)
 401                         rc = 0;
 402                 else
 403                         rc = 1;
 404         }
 405         #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 406         return rc;
 407 }
 408
 409 static void rt5025_batabs_irq_handler(void *info, int eventno)
 410 {
 411         struct rt5025_charger_info *ci = info;
 412         struct power_supply *psy = &ci->psy;
 413         union power_supply_propval pval;
 414         int rc = 0;
 415
 416         #ifdef CONFIG_BATTERY_RT5025
 417                 struct power_supply *bat_psy = power_supply_get_by_name(RT_BATT_NAME);
 418
 419                 pval.intval = 0;
 420                 if (!bat_psy) {
 421                         dev_err(ci->dev, "get rt-battery supply fail\n");
 422                 } else {
 423                         rc = bat_psy->set_property(bat_psy,
 424                                 POWER_SUPPLY_PROP_PRESENT, &pval);
 425                         if (rc < 0)
 426                                 dev_err(ci->dev, "set battery not present fail\n");
 427                         power_supply_changed(bat_psy);
 428                 }
 429         #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 430         /*set aicr to disable*/
 431         pval.intval = 2000;
 432         rc = psy->set_property(psy, POWER_SUPPLY_PROP_CURRENT_AVG, &pval);
 433         if (rc < 0)
 434                 dev_err(ci->dev, "set aicr to disable fail\n");
 435         /*set icc to 2000*/
 436         pval.intval = 2000;
 437         rc = psy->set_property(psy, POWER_SUPPLY_PROP_CURRENT_NOW, &pval);
 438         if (rc < 0)
 439                 dev_err(ci->dev, "set icc to 2000 fail\n");
 440         /*set online = 0, due to bat absense*/
 441         pval.intval = 0;
 442         rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
 443         if (rc < 0)
 444                 dev_err(ci->dev, "set charger offline fail\n");
 445         ci->batabs = 1;
 446         ci->te_en = 0;
 447 }
 448
 449 static void rt5025_acin_irq_handler(void *info, int eventno)
 450 {
 451         #ifdef CONFIG_RT_POWER
 452         struct rt5025_charger_info *ci = info;
 453         #ifndef CONFIG_RT_SUPPORT_ACUSB_DUALIN
 454         struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
 455         #else
 456         struct power_supply *psy = power_supply_get_by_name(RT_AC_NAME);
 457         #endif /* #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
 458         union power_supply_propval pval;
 459         int rc = 0;
 460
 461         if (!psy) {
 462                 dev_err(ci->dev, "could not get psy supply\n");
 463                 return;
 464         }
 465         pval.intval = 1;
 466         rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
 467         if (rc < 0)
 468                 dev_err(ci->dev, "set ac online fail\n");
 469         power_supply_changed(psy);
 470         dev_info(ci->dev, "%s\n", __func__);
 471         #endif /* #ifdef CONFIG_RT_POWER */
 472 }
 473
 474 static void rt5025_acout_irq_handler(void *info, int eventno)
 475 {
 476         #ifdef CONFIG_RT_POWER
 477         struct rt5025_charger_info *ci = info;
 478         #ifndef CONFIG_RT_SUPPORT_ACUSB_DUALIN
 479         struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
 480         #else
 481         struct power_supply *psy = power_supply_get_by_name(RT_AC_NAME);
 482         #endif /* ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
 483         union power_supply_propval pval;
 484         int rc = 0;
 485
 486         if (!psy) {
 487                 dev_err(ci->dev, "could not get rt-usb supply\n");
 488                 return;
 489         }
 490         pval.intval = 0;
 491         rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
 492         if (rc < 0)
 493                 dev_err(ci->dev, "set ac offline fail\n");
 494         power_supply_changed(psy);
 495         dev_info(ci->dev, "%s\n", __func__);
 496         #endif /* #ifdef CONFIG_RT_POWER */
 497 }
 498
 499 static void rt5025_usbin_irq_handler(void *info, int eventno)
 500 {
 501         #ifdef CONFIG_RT_POWER
 502         struct rt5025_charger_info *ci = info;
 503         struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
 504         union power_supply_propval pval;
 505         int rc = 0;
 506
 507         if (!psy) {
 508                 dev_err(ci->dev, "could not get rt-usb supply\n");
 509                 return;
 510         }
 511         if (!ci->otg_en) {
 512                 pval.intval = 1;
 513                 rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
 514                 if (rc < 0)
 515                         dev_err(ci->dev, "set ac online fail\n");
 516                 power_supply_changed(psy);
 517         }
 518         dev_info(ci->dev, "%s\n", __func__);
 519         #endif /* #ifdef CONFIG_RT_POWER */
 520 }
 521
 522 static void rt5025_usbout_irq_handler(void *info, int eventno)
 523 {
 524         #ifdef CONFIG_RT_POWER
 525         struct rt5025_charger_info *ci = info;
 526         struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
 527         union power_supply_propval pval;
 528         int rc = 0;
 529
 530         if (!psy) {
 531                 dev_err(ci->dev, "could not get rt-usb supply\n");
 532                 return;
 533         }
 534         if (!ci->otg_en) {
 535                 pval.intval = 0;
 536                 rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
 537                 if (rc < 0)
 538                         dev_err(ci->dev, "set ac offline fail\n");
 539                 power_supply_changed(psy);
 540         }
 541         dev_info(ci->dev, "%s\n", __func__);
 542         #endif /* #ifdef CONFIG_RT_POWER */
 543 }
 544
 545 static void rt5025_talrtmax_irq_handler(void *info, int eventno)
 546 {
 547         #ifdef CONFIG_BATTERY_RT5025
 548         struct rt5025_charger_info *ci = info;
 549         union power_supply_propval pval;
 550         int rc = 0;
 551
 552         switch (ci->battemp_region) {
 553         case RT5025_BATTEMP_COLD:
 554                 dev_warn(ci->dev, "cold than cold???\n");
 555                 break;
 556         case RT5025_BATTEMP_COOL:
 557                 dev_info(ci->dev, "cool-> cold\n");
 558                 ci->battemp_region = RT5025_BATTEMP_COLD;
 559                 rt5025_set_tempalrt(ci);
 560                 pval.intval = 1;
 561                 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
 562                         &pval);
 563                 if (rc < 0)
 564                         dev_err(ci->dev, "set present fail\n");
 565                 break;
 566         case RT5025_BATTEMP_NORMAL:
 567                 dev_info(ci->dev, "normal-> cool\n");
 568                 ci->battemp_region = RT5025_BATTEMP_COOL;
 569                 rt5025_set_tempalrt(ci);
 570                 pval.intval = 1;
 571                 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
 572                         &pval);
 573                 if (rc < 0)
 574                         dev_err(ci->dev, "set present fail\n");
 575                 break;
 576         case RT5025_BATTEMP_WARM:
 577                 dev_info(ci->dev, "warm-> normal\n");
 578                 ci->battemp_region = RT5025_BATTEMP_NORMAL;
 579                 rt5025_set_tempalrt(ci);
 580                 pval.intval = 1;
 581                 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
 582                         &pval);
 583                 if (rc < 0)
 584                         dev_err(ci->dev, "set present fail\n");
 585                 break;
 586         case RT5025_BATTEMP_HOT:
 587                 dev_info(ci->dev, "hot-> warm\n");
 588                 ci->battemp_region = RT5025_BATTEMP_WARM;
 589                 rt5025_set_tempalrt(ci);
 590                 pval.intval = 1;
 591                 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
 592                         &pval);
 593                 if (rc < 0)
 594                         dev_err(ci->dev, "set present fail\n");
 595                 break;
 596         default:
 597                 break;
 598         }
 599         #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 600 }
 601
 602 static void rt5025_talrtmin_irq_handler(void *info, int eventno)
 603 {
 604         #ifdef CONFIG_BATTERY_RT5025
 605         struct rt5025_charger_info *ci = info;
 606         union power_supply_propval pval;
 607         int rc = 0;
 608
 609         switch (ci->battemp_region) {
 610         case RT5025_BATTEMP_COLD:
 611                 dev_info(ci->dev, "cold-> cool\n");
 612                 ci->battemp_region = RT5025_BATTEMP_COOL;
 613                 rt5025_set_tempalrt(ci);
 614                 pval.intval = 1;
 615                 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
 616                         &pval);
 617                 if (rc < 0)
 618                         dev_err(ci->dev, "set present fail\n");
 619                 break;
 620         case RT5025_BATTEMP_COOL:
 621                 dev_info(ci->dev, "cool-> normal\n");
 622                 ci->battemp_region = RT5025_BATTEMP_NORMAL;
 623                 rt5025_set_tempalrt(ci);
 624                 pval.intval = 1;
 625                 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
 626                         &pval);
 627                 if (rc < 0)
 628                         dev_err(ci->dev, "set present fail\n");
 629                 break;
 630         case RT5025_BATTEMP_NORMAL:
 631                         dev_info(ci->dev, "normal-> warm\n");
 632                         ci->battemp_region = RT5025_BATTEMP_WARM;
 633                         rt5025_set_tempalrt(ci);
 634                         pval.intval = 1;
 635                         rc = ci->psy.set_property(&ci->psy,
 636                                 POWER_SUPPLY_PROP_PRESENT,\
 637                                 &pval);
 638                         if (rc < 0)
 639                                 dev_err(ci->dev, "set present fail\n");
 640                         break;
 641         case RT5025_BATTEMP_WARM:
 642                 dev_info(ci->dev, "warm-> hot\n");
 643                 ci->battemp_region = RT5025_BATTEMP_HOT;
 644                 rt5025_set_tempalrt(ci);
 645                 pval.intval = 1;
 646                 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
 647                         &pval);
 648                 if (rc < 0)
 649                         dev_err(ci->dev, "set present fail\n");
 650                 break;
 651         case RT5025_BATTEMP_HOT:
 652                 dev_warn(ci->dev, "hot than hot???\n");
 653                 break;
 654         default:
 655                 break;
 656         }
 657         #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 658 }
 659
 660 static void rt5025_general_irq_handler(void *info, int eventno)
 661 {
 662         struct rt5025_charger_info *ci = info;
 663
 664         RTINFO("eventno=%02d\n", eventno);
 665         switch (eventno) {
 666         case CHGEVENT_CHRCHGI:
 667                 if (!ci->online) {
 668                         dev_warn(ci->dev, "recharge false alarm\n");
 669                 } else {
 670                         union power_supply_propval pval;
 671
 672                         dev_info(ci->dev, "recharge occur\n");
 673                         ci->chg_status = POWER_SUPPLY_STATUS_CHARGING;
 674                         pval.intval = ci->chg_volt;
 675                         rt_charger_set_batt_status(ci);
 676                         ci->psy.set_property(&ci->psy,
 677                                 POWER_SUPPLY_PROP_VOLTAGE_NOW, &pval);
 678                 }
 679                 break;
 680         case CHGEVENT_CHTERMI:
 681                 if (!ci->online) {
 682                                 dev_warn(ci->dev, "eoc false alarm\n");
 683                 } else {
 684                         if (rt_charger_check_battery_present(ci)) {
 685                                 union power_supply_propval pval;
 686
 687                                 if (ci->chg_status == POWER_SUPPLY_STATUS_FULL)
 688                                         return;
 689                                 dev_info(ci->dev, "eoc really occur\n");
 690                                 ci->chg_status = POWER_SUPPLY_STATUS_FULL;
 691                                 rt_charger_set_batt_status(ci);
 692                                 pval.intval = ci->chg_volt-50;
 693                                 ci->psy.set_property(&ci->psy,
 694                                         POWER_SUPPLY_PROP_VOLTAGE_NOW, &pval);
 695                         } else {
 696                                 dev_info(ci->dev, "no battery condition\n");
 697                                 rt5025_batabs_irq_handler(ci, eventno);
 698                         }
 699                 }
 700                 break;
 701         case CHGEVENT_TALRTMAX:
 702                 #ifdef CONFIG_BATTERY_RT5025
 703                 rt5025_set_tempalrt(ci);
 704                 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 705                 break;
 706         case CHGEVENT_TALRTMIN:
 707                 #ifdef CONFIG_BATTERY_RT5025
 708                 rt5025_set_tempalrt(ci);
 709                 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 710                 break;
 711         default:
 712                 break;
 713         }
 714 }
 715
 716 static rt_irq_handler rt_chgirq_handler[CHGEVENT_MAX] = {
 717         [CHGEVENT_TIMEOUT_CC] = rt5025_general_irq_handler,
 718         [CHGEVENT_TIMEOUT_PC] = rt5025_general_irq_handler,
 719         [CHGEVENT_CHVSREGI] = rt5025_general_irq_handler,
 720         [CHGEVENT_CHTREGI] = rt5025_general_irq_handler,
 721         [CHGEVENT_CHRCHGI] = rt5025_general_irq_handler,
 722         [CHGEVENT_CHTERMI] = rt5025_general_irq_handler,
 723         [CHGEVENT_CHBATOVI] = rt5025_general_irq_handler,
 724         [CHGEVENT_CHGOODI_INUSB] = rt5025_general_irq_handler,
 725         [CHGEVENT_CHBADI_INUSB] = rt5025_general_irq_handler,
 726         [CHGEVENT_CHSLPI_INUSB] = rt5025_usbout_irq_handler,
 727         [CHGEVENT_CHGOODI_INAC] = rt5025_general_irq_handler,
 728         [CHGEVENT_CHBADI_INAC] = rt5025_general_irq_handler,
 729         [CHGEVENT_CHSLPI_INAC] = rt5025_acout_irq_handler,
 730         [CHGEVENT_BATABS] = rt5025_batabs_irq_handler,
 731         [CHGEVENT_INUSB_PLUGIN] = rt5025_usbin_irq_handler,
 732         [CHGEVENT_INUSBOVP] = rt5025_general_irq_handler,
 733         [CHGEVENT_INAC_PLUGIN] = rt5025_acin_irq_handler,
 734         [CHGEVENT_INACOVP] = rt5025_general_irq_handler,
 735         [CHGEVENT_TALRTMIN] = rt5025_talrtmin_irq_handler,
 736         [CHGEVENT_TALRTMAX] = rt5025_talrtmax_irq_handler,
 737 };
 738
 739 void rt5025_charger_irq_handler(struct rt5025_charger_info *ci, unsigned int irqevent)
 740 {
 741         int i;
 742         #ifdef CONFIG_BATTERY_RT5025
 743         unsigned int enable_irq_event = (RT5025_TALRTMX_MASK | RT5025_TALRTMN_MASK)<<24 | \
 744                         (chg_init_regval[6] << 16) | (chg_init_regval[7] << 8) |  chg_init_regval[8];
 745         #else
 746         unsigned int enable_irq_event = (chg_init_regval[6] << 16)
 747                 | (chg_init_regval[7] << 8)| \
 748                                 chg_init_regval[8];
 749         #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 750         unsigned int final_irq_event = irqevent&enable_irq_event;
 751
 752         /*charger workaround (TE+RECHARGE)*/
 753         if (final_irq_event & (1 << CHGEVENT_CHTERMI) && \
 754                 final_irq_event & (1 << CHGEVENT_CHRCHGI))
 755                 final_irq_event &= ~((1 << CHGEVENT_CHTERMI) | (1 << CHGEVENT_CHRCHGI));
 756         i = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL1);
 757         if (i < 0) {
 758                 dev_err(ci->dev, "read CHGCTL1 fail\n");
 759                 i = 0;
 760         }
 761         /*acin+acout*/
 762         if (final_irq_event & (1 << CHGEVENT_INAC_PLUGIN) && \
 763                 final_irq_event & (1 << CHGEVENT_CHSLPI_INAC)) {
 764                 if (i & RT5025_ACUSABLE_MASK)
 765                         final_irq_event &= ~(1<<CHGEVENT_CHSLPI_INAC);
 766                 else
 767                         final_irq_event &= ~(1<<CHGEVENT_INAC_PLUGIN);
 768         }
 769         /*usbin+usbout*/
 770         if (final_irq_event & (1 << CHGEVENT_INUSB_PLUGIN) && \
 771                 final_irq_event & (1 << CHGEVENT_CHSLPI_INUSB)) {
 772                 if (i & RT5025_USBUSABLE_MASK)
 773                         final_irq_event &= ~(1 << CHGEVENT_CHSLPI_INUSB);
 774                 else
 775                         final_irq_event &= ~(1 << CHGEVENT_INUSB_PLUGIN);
 776         }
 777         for (i = 0; i < CHGEVENT_MAX; i++) {
 778                 if ((final_irq_event & (1 << i)) && rt_chgirq_handler[i])
 779                         rt_chgirq_handler[i](ci, i);
 780         }
 781 }
 782 EXPORT_SYMBOL(rt5025_charger_irq_handler);
 783
 784 static void rt5025_tempmon_work(struct work_struct *work)
 785 {
 786         struct rt5025_charger_info *ci = container_of(work, \
 787                 struct rt5025_charger_info, tempmon_work.work);
 788         #ifdef CONFIG_BATTERY_RT5025
 789         struct power_supply *psy = power_supply_get_by_name(RT_BATT_NAME);
 790         union power_supply_propval pval;
 791         int inttemp_region;
 792         #endif
 793
 794         RTINFO("\n");
 795         #ifdef CONFIG_BATTERY_RT5025
 796                 if (!psy) {
 797                         dev_err(ci->dev, "could not get rt-battery psy\n");
 798                         return;
 799                 }
 800                 if (!ci->init_once) {
 801                         /*battemp init*/
 802                         int i = 0;
 803
 804                         pval.intval = 23; /* magic code*/
 805                         psy->get_property(psy, POWER_SUPPLY_PROP_TEMP, &pval);
 806                         for (i = 3; i >= 0; i--)
 807                                 if (pval.intval > ci->temp[i])
 808                                         break;
 809                         if (i == 3)
 810                                 ci->battemp_region = RT5025_BATTEMP_HOT;
 811                         else if (i == 2)
 812                                 ci->battemp_region = RT5025_BATTEMP_WARM;
 813                         else if (i == 1)
 814                                 ci->battemp_region = RT5025_BATTEMP_NORMAL;
 815                         else if (i == 0)
 816                                 ci->battemp_region = RT5025_BATTEMP_COOL;
 817                         else
 818                                 ci->battemp_region = RT5025_BATTEMP_COLD;
 819                         rt5025_set_tempalrt(ci);
 820                         ci->init_once = 1;
 821                 }
 822
 823                 psy->get_property(psy, POWER_SUPPLY_PROP_TEMP_AMBIENT, &pval);
 824                 if (pval.intval > 1000)
 825                         inttemp_region = RT5025_INTTEMP_HOT;
 826                 else if (pval.intval > 750)
 827                         inttemp_region = RT5025_INTTEMP_WARM;
 828                 else
 829                         inttemp_region = RT5025_INTTEMP_NORMAL;
 830
 831                 if (inttemp_region != ci->inttemp_region) {
 832                         ci->inttemp_region = inttemp_region;
 833                         pval.intval = 1;
 834                         rt_charger_set_property(&ci->psy,
 835                                 POWER_SUPPLY_PROP_PRESENT, &pval);
 836                 }
 837         #endif /* #ifdef CONFIG_BATTERY_RT5025 */
 838         if (!ci->suspend)
 839                 schedule_delayed_work(&ci->tempmon_work, 5*HZ);
 840 }
 841
 842 static int rt5025_charger_reginit(struct i2c_client *client)
 843 {
 844         rt5025_reg_block_write(client, RT5025_REG_CHGCTL2, 6, chg_init_regval);
 845         /*set all to be masked*/
 846         rt5025_reg_write(client, RT5025_REG_IRQEN1, 0x00);
 847         rt5025_reg_write(client, RT5025_REG_IRQEN2, 0x00);
 848         rt5025_reg_write(client, RT5025_REG_IRQEN3, 0x00);
 849         /*just clear the old irq event*/
 850         rt5025_reg_read(client, RT5025_REG_IRQSTAT1);
 851         rt5025_reg_read(client, RT5025_REG_IRQSTAT2);
 852         rt5025_reg_read(client, RT5025_REG_IRQSTAT3);
 853         /*set enable irqs as we want*/
 854         rt5025_reg_write(client, RT5025_REG_IRQEN1, chg_init_regval[6]);
 855         rt5025_reg_write(client, RT5025_REG_IRQEN2, chg_init_regval[7]);
 856         rt5025_reg_write(client, RT5025_REG_IRQEN3, chg_init_regval[8]);
 857         RTINFO("\n");
 858         return 0;
 859 }
 860
 861 static int rt_parse_dt(struct rt5025_charger_info *ci, struct device *dev)
 862 {
 863         #ifdef CONFIG_OF
 864         struct device_node *np = dev->of_node;
 865         u32 val;
 866
 867         if (of_property_read_bool(np, "rt,te_en"))
 868                 ci->te_en = 1;
 869
 870         if (of_property_read_u32(np, "rt,iprec", &val)) {
 871                 dev_info(dev, "no iprec property, use default value\n");
 872         } else{
 873                 if (val > RT5025_IPREC_MAX)
 874                         val = RT5025_IPREC_MAX;
 875                 chg_init_regval[4] &= (~RT5025_CHGIPREC_MASK);
 876                 chg_init_regval[4] |= (val << RT5025_CHGIPREC_SHFT);
 877         }
 878
 879         if (of_property_read_u32(np, "rt,ieoc", &val)) {
 880                 dev_info(dev, "no ieoc property, use the default value\n");
 881         } else {
 882                 if (val  > RT5025_IEOC_MAX)
 883                         val = RT5025_IEOC_MAX;
 884                 chg_init_regval[4] &= (~RT5025_CHGIEOC_MASK);
 885                 chg_init_regval[4] |= (val << RT5025_CHGIEOC_SHFT);
 886         }
 887
 888         if (of_property_read_u32(np, "rt,vprec", &val)) {
 889                 dev_info(dev, "no vprec property, use the default value\n");
 890         } else {
 891                 if (val > RT5025_VPREC_MAX)
 892                         val = RT5025_VPREC_MAX;
 893                 chg_init_regval[4] &= (~RT5025_CHGVPREC_MASK);
 894                 chg_init_regval[4] |= (val << RT5025_CHGVPREC_SHFT);
 895         }
 896
 897         if (of_property_read_u32(np, "rt,vdpm", &val)) {
 898                 dev_info(dev, "no vdpm property, use the default value\n");
 899         } else {
 900                 if (val > RT5025_VDPM_MAX)
 901                         val = RT5025_VDPM_MAX;
 902                 chg_init_regval[3] &= (~RT5025_CHGVDPM_MASK);
 903                 chg_init_regval[3] |= (val << RT5025_CHGVDPM_SHFT);
 904         }
 905
 906         if (of_property_read_u32(np, "rt,chg_volt", &val)) {
 907                 dev_info(dev, "no chg_volt property, use 4200 as the default value\n");
 908                 ci->chg_volt = 4200;
 909         } else {
 910                 ci->chg_volt = val;
 911         }
 912
 913         if (of_property_read_u32(np, "rt,acchg_icc", &val)) {
 914                 dev_info(dev, "no acchg_icc property, use 2000 as the default value\n");
 915                 ci->acchg_icc = 2000;
 916         } else {
 917                 ci->acchg_icc = val;
 918         }
 919
 920         if (of_property_read_u32(np, "rt,usbtachg_icc", &val)) {
 921                 dev_info(dev, "no usbtachg_icc property, use 2000 as the default value\n");
 922                 ci->usbtachg_icc = 2000;
 923         } else {
 924                 ci->usbtachg_icc = val;
 925         }
 926
 927         if (of_property_read_u32(np, "rt,usbchg_icc", &val)) {
 928                 dev_info(dev, "no usbchg_icc property, use 500 as the default value\n");
 929                 ci->usbchg_icc = 500;
 930         } else {
 931                 ci->usbchg_icc = val;
 932         }
 933
 934         if (of_property_read_u32(np, "rt,screenon_icc", &val)) {
 935                 dev_info(dev, "no screenon_icc property, use 500 as the default value\n");
 936                 ci->screenon_icc = 500;
 937         } else {
 938                 ci->screenon_icc = val;
 939         }
 940
 941         if (of_property_read_bool(np, "rt,screenon_adjust")) {
 942                 ci->screenon_adjust = 1;
 943                 ci->screen_on = 1;
 944         }
 945
 946         if (of_property_read_u32_array(np, "rt,temp",
 947                 ci->temp, 4)) {
 948                 dev_info(dev, "no temperature property, use default value\n");
 949                 ci->temp[0] = 0;
 950                 ci->temp[1] = 150;
 951                 ci->temp[2] = 500;
 952                 ci->temp[3] = 600;
 953         }
 954
 955         if (of_property_read_u32_array(np, "rt,temp_scalar",
 956                 ci->temp_scalar, 8)) {
 957                 dev_info(dev, "no temp_scalar property, use default value\n");
 958                 ci->temp_scalar[0] = 0x30;
 959                 ci->temp_scalar[1] = 0x2B;
 960                 ci->temp_scalar[2] = 0x28;
 961                 ci->temp_scalar[3] = 0x22;
 962                 ci->temp_scalar[4] = 0x15;
 963                 ci->temp_scalar[5] = 0x10;
 964                 ci->temp_scalar[6] = 0x10;
 965                 ci->temp_scalar[7] = 0x0D;
 966         }
 967         #endif /* #ifdef CONFIG_OF */
 968         rt5025_charger_reginit(ci->i2c);
 969         RTINFO("\n");
 970         return 0;
 971 }
 972
 973 static int rt_parse_pdata(struct rt5025_charger_info *ci, struct device *dev)
 974 {
 975         struct rt5025_charger_data *pdata = dev->platform_data;
 976         int i = 0;
 977
 978         if (pdata->te_en)
 979                 ci->te_en = 1;
 980
 981         chg_init_regval[4] &= (~RT5025_CHGIPREC_MASK);
 982         chg_init_regval[4] |= (pdata->iprec << RT5025_CHGIPREC_SHFT);
 983
 984         chg_init_regval[4] &= (~RT5025_CHGIEOC_MASK);
 985         chg_init_regval[4] |= (pdata->ieoc << RT5025_CHGIEOC_SHFT);
 986
 987         chg_init_regval[4] &= (~RT5025_CHGVPREC_MASK);
 988         chg_init_regval[4] |= (pdata->vprec << RT5025_CHGVPREC_SHFT);
 989
 990         chg_init_regval[3] &= (~RT5025_CHGVDPM_MASK);
 991         chg_init_regval[3] |= (pdata->vdpm << RT5025_CHGVDPM_SHFT);
 992
 993         ci->chg_volt = pdata->chg_volt;
 994         ci->acchg_icc = pdata->acchg_icc;
 995         ci->usbtachg_icc = pdata->usbtachg_icc;
 996         ci->usbchg_icc = pdata->usbchg_icc;
 997         ci->screenon_icc = pdata->screenon_icc;
 998         if (pdata->screenon_adjust) {
 999                 ci->screenon_adjust = 1;
1000                 /*default probe screen will on*/
1001                 ci->screen_on = 1;
1002         }
1003         for (i = 0; i < 4; i++)
1004                 ci->temp[i] = pdata->temp[i];
1005         for (i = 0; i < 8; i++)
1006                 ci->temp_scalar[i] = pdata->temp_scalar[i];
1007         rt5025_charger_reginit(ci->i2c);
1008         RTINFO("\n");
1009         return 0;
1010 }
1011
1012 #ifdef CONFIG_RT_POWER
1013 static struct platform_device rt_power_dev = {
1014         .name = "rt-power",
1015         .id = -1,
1016 };
1017 #endif /* #ifdef CONFIG_RT_POWER */
1018
1019 #ifdef CONFIG_HAS_EARLYSUSPEND
1020 static void rt5025_charger_earlysuspend(struct early_suspend *handler)
1021 {
1022         struct rt5025_charger_info *ci = container_of(handler, \
1023                 struct rt5025_charger_info, early_suspend);
1024         union power_supply_propval pval;
1025         int rc = 0;
1026
1027         if (ci->screenon_adjust) {
1028                 ci->screen_on = 0;
1029                 pval.intval = 1;
1030                 rc = ci->psy.set_property(&ci->psy,
1031                         POWER_SUPPLY_PROP_PRESENT, &pval);
1032                 if (rc < 0)
1033                         dev_err(ci->dev, "set charger present property fail\n");
1034         }
1035 }
1036
1037 static void rt5025_charger_earlyresume(struct early_suspend *handler)
1038 {
1039         struct rt5025_charger_info *ci = container_of(handler, \
1040                 struct rt5025_charger_info, early_suspend);
1041         union power_supply_propval pval;
1042         int rc = 0;
1043
1044         if (ci->screenon_adjust) {
1045                 ci->screen_on = 1;
1046                 pval.intval = 1;
1047                 rc = ci->psy.set_property(&ci->psy,
1048                         POWER_SUPPLY_PROP_PRESENT, &pval);
1049                 if (rc < 0)
1050                         dev_err(ci->dev, "set charger present property fail\n");
1051         }
1052 }
1053 #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
1054
1055 static int rt5025_charger_probe(struct platform_device *pdev)
1056 {
1057         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
1058         struct rt5025_platform_data *pdata =
1059                 (pdev->dev.parent)->platform_data;
1060         #ifdef CONFIG_RT_POWER
1061         struct rt_power_data *rt_power_pdata;
1062         #endif /* #ifdef CONFIG_RT_POWER */
1063         struct rt5025_charger_info *ci;
1064         bool use_dt = pdev->dev.of_node;
1065         int ret = 0;
1066
1067         ci = devm_kzalloc(chip->dev, sizeof(struct rt5025_charger_info), GFP_KERNEL);
1068         if (!ci)
1069                 return -ENOMEM;
1070
1071         ci->i2c = chip->i2c;
1072         ci->dev = &pdev->dev;
1073         ci->chg_status = POWER_SUPPLY_STATUS_DISCHARGING;
1074         ci->battemp_region = RT5025_BATTEMP_NORMAL;
1075         ci->inttemp_region = RT5025_INTTEMP_NORMAL;
1076         #ifdef CONFIG_RT_JEITA_REMOVE
1077         ci->init_once = 1;
1078         #endif /* #ifdef RT_JEITA_REMOVE */
1079
1080         if (use_dt) {
1081                 rt_parse_dt(ci, &pdev->dev);
1082         } else {
1083                 if (!pdata) {
1084                         ret = -EINVAL;
1085                         goto out_dev;
1086                 }
1087                 pdev->dev.platform_data = pdata->chg_pdata;
1088                 rt_parse_pdata(ci, &pdev->dev);
1089         }
1090         INIT_DELAYED_WORK(&ci->tempmon_work, rt5025_tempmon_work);
1091
1092         platform_set_drvdata(pdev, ci);
1093         /*power supply register*/
1094         ci->psy.name = rtdef_chg_name;
1095         #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0))
1096         ci->psy.type = POWER_SUPPLY_TYPE_UNKNOWN;
1097         #else
1098         ci->psy.type = -1;
1099         #endif /* #ifdef (LINUX_VERSION_CODE */
1100         ci->psy.supplied_to = rt_charger_supply_list;
1101         ci->psy.properties = rt_charger_props;
1102         ci->psy.num_properties = ARRAY_SIZE(rt_charger_props);
1103         ci->psy.get_property = rt_charger_get_property;
1104         ci->psy.set_property = rt_charger_set_property;
1105         ret = power_supply_register(&pdev->dev, &ci->psy);
1106         if (ret < 0) {
1107                 dev_err(&pdev->dev, "couldn't create power supply for rt-charger\n");
1108                 goto out_dev;
1109         }
1110
1111         #ifdef CONFIG_HAS_EARLYSUSPEND
1112         ci->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1;
1113         ci->early_suspend.suspend = rt5025_charger_earlysuspend;
1114         ci->early_suspend.resume = rt5025_charger_earlyresume;
1115         register_early_suspend(&ci->early_suspend);
1116         #endif /* CONFIG_HAS_EARLYSUSPEND */
1117
1118         #ifdef CONFIG_RT_POWER
1119         rt_power_pdata = devm_kzalloc(&pdev->dev,
1120                 sizeof(*rt_power_pdata), GFP_KERNEL);
1121         if (!rt_power_pdata) {
1122                 ret = -ENOMEM;
1123                 goto out_psy;
1124         }
1125         rt_power_pdata->chg_volt = ci->chg_volt;
1126         rt_power_pdata->acchg_icc = ci->acchg_icc;
1127         rt_power_pdata->usbtachg_icc = ci->usbtachg_icc;
1128         rt_power_pdata->usbchg_icc = ci->usbchg_icc;
1129
1130         rt_power_dev.dev.platform_data = rt_power_pdata;
1131         rt_power_dev.dev.parent = &pdev->dev;
1132         ret = platform_device_register(&rt_power_dev);
1133         if (ret < 0)
1134                 goto out_psy;
1135         #endif /* #ifdef CONFIG_RT_POWER */
1136
1137         chip->charger_info = ci;
1138         schedule_delayed_work(&ci->tempmon_work, 1*HZ);
1139         dev_info(&pdev->dev, "driver successfully loaded\n");
1140         return 0;
1141 #ifdef CONFIG_RT_POWER
1142 out_psy:
1143 #endif /* #ifdef CONFIG_RT_POWER */
1144         #ifdef CONFIG_HAS_EARLYSUSPEND
1145         unregister_early_suspend(&ci->early_suspend);
1146         #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
1147         power_supply_unregister(&ci->psy);
1148 out_dev:
1149         return ret;
1150 }
1151
1152 static int rt5025_charger_remove(struct platform_device *pdev)
1153 {
1154         struct rt5025_charger_info *ci = platform_get_drvdata(pdev);
1155
1156         power_supply_unregister(&ci->psy);
1157         #ifdef CONFIG_HAS_EARLYSUSPEND
1158         unregister_early_suspend(&ci->early_suspend);
1159         #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
1160         #ifdef CONFIG_RT_POWER
1161         platform_device_unregister(&rt_power_dev);
1162         #endif /* #ifdef CONFIG_RT_POWER */
1163         return 0;
1164 }
1165
1166 static int rt5025_charger_suspend(struct platform_device *pdev,
1167         pm_message_t state)
1168 {
1169         struct rt5025_charger_info *ci = platform_get_drvdata(pdev);
1170         union power_supply_propval pval;
1171
1172         ci->suspend = 1;
1173         cancel_delayed_work_sync(&ci->tempmon_work);
1174         /*force inttemp to normal temp*/
1175         ci->inttemp_region = RT5025_INTTEMP_NORMAL;
1176         pval.intval = 1;
1177         rt_charger_set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT, &pval);
1178         return 0;
1179 }
1180
1181 static int rt5025_charger_resume(struct platform_device *pdev)
1182 {
1183         struct rt5025_charger_info *ci = platform_get_drvdata(pdev);
1184
1185         ci->suspend = 0;
1186         schedule_delayed_work(&ci->tempmon_work, msecs_to_jiffies(50));
1187         return 0;
1188 }
1189
1190 static const struct of_device_id rt_match_table[] = {
1191         { .compatible = "rt,rt5025-charger",},
1192         {},
1193 };
1194
1195 static struct platform_driver rt5025_charger_driver = {
1196         .driver = {
1197                 .name = RT5025_DEV_NAME "-charger",
1198                 .owner = THIS_MODULE,
1199                 .of_match_table = rt_match_table,
1200         },
1201         .probe = rt5025_charger_probe,
1202         .remove = rt5025_charger_remove,
1203         .suspend = rt5025_charger_suspend,
1204         .resume = rt5025_charger_resume,
1205 };
1206
1207 static int rt5025_charger_init(void)
1208 {
1209         return platform_driver_register(&rt5025_charger_driver);
1210 }
1211 fs_initcall_sync(rt5025_charger_init);
1212
1213 static void rt5025_charger_exit(void)
1214 {
1215         platform_driver_unregister(&rt5025_charger_driver);
1216 }
1217
1218 module_exit(rt5025_charger_exit);
1219
1220 MODULE_LICENSE("GPL");
1221 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com>");
1222 MODULE_DESCRIPTION("Charger driver for RT5025");
1223 MODULE_ALIAS("platform:"RT5025_DEV_NAME "-charger");
1224 MODULE_VERSION(RT5025_DRV_VER);