drivers/battery/sec_battery.c

   1 /*
   2  *  sec_battery.c
   3  *  Samsung Mobile Battery Driver
   4  *
   5  *  Copyright (C) 2012 Samsung Electronics
   6  *
   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.
  11  */
  12
  13
  14 #include <linux/battery/sec_battery.h>
  15
  16 #ifdef CONFIG_SEC_BATTERY_PM_NOTIFY
  17 #include <linux/suspend.h>
  18 #endif
  19
  20 #ifdef CONFIG_SLEEP_MONITOR
  21 #include <linux/power/sleep_monitor.h>
  22 #endif
  23
  24 #if defined(CONFIG_MACH_CORSICA_VE) || defined(CONFIG_MACH_VIVALTO)
  25 extern int get_hw_rev();
  26 #endif
  27 //extern int sprdbat_creat_caliberate_attr(struct device *dev);
  28
  29 extern void sec_bat_initial_check(void);
  30
  31 static struct device_attribute sec_battery_attrs[] = {
  32         SEC_BATTERY_ATTR(batt_reset_soc),
  33         SEC_BATTERY_ATTR(batt_read_raw_soc),
  34         SEC_BATTERY_ATTR(batt_read_adj_soc),
  35         SEC_BATTERY_ATTR(batt_type),
  36         SEC_BATTERY_ATTR(batt_vfocv),
  37         SEC_BATTERY_ATTR(batt_vol_adc),
  38         SEC_BATTERY_ATTR(batt_vol_adc_cal),
  39         SEC_BATTERY_ATTR(batt_vol_aver),
  40         SEC_BATTERY_ATTR(batt_vol_adc_aver),
  41         SEC_BATTERY_ATTR(batt_current_ua_now),
  42         SEC_BATTERY_ATTR(batt_current_ua_avg),
  43         SEC_BATTERY_ATTR(batt_temp),
  44         SEC_BATTERY_ATTR(batt_temp_adc),
  45         SEC_BATTERY_ATTR(batt_temp_aver),
  46         SEC_BATTERY_ATTR(batt_temp_adc_aver),
  47         SEC_BATTERY_ATTR(batt_vf_adc),
  48         SEC_BATTERY_ATTR(batt_slate_mode),
  49
  50         SEC_BATTERY_ATTR(batt_lp_charging),
  51         SEC_BATTERY_ATTR(siop_activated),
  52         SEC_BATTERY_ATTR(siop_level),
  53         SEC_BATTERY_ATTR(batt_charging_source),
  54         SEC_BATTERY_ATTR(fg_reg_dump),
  55         SEC_BATTERY_ATTR(fg_reset_cap),
  56         SEC_BATTERY_ATTR(fg_capacity),
  57         SEC_BATTERY_ATTR(auth),
  58         SEC_BATTERY_ATTR(chg_current_adc),
  59         SEC_BATTERY_ATTR(wc_adc),
  60         SEC_BATTERY_ATTR(wc_status),
  61         SEC_BATTERY_ATTR(wc_enable),
  62         SEC_BATTERY_ATTR(factory_mode),
  63         SEC_BATTERY_ATTR(update),
  64         SEC_BATTERY_ATTR(test_mode),
  65
  66         SEC_BATTERY_ATTR(call),
  67         SEC_BATTERY_ATTR(2g_call),
  68         SEC_BATTERY_ATTR(talk_gsm),
  69         SEC_BATTERY_ATTR(3g_call),
  70         SEC_BATTERY_ATTR(talk_wcdma),
  71         SEC_BATTERY_ATTR(music),
  72         SEC_BATTERY_ATTR(video),
  73         SEC_BATTERY_ATTR(browser),
  74         SEC_BATTERY_ATTR(hotspot),
  75         SEC_BATTERY_ATTR(camera),
  76         SEC_BATTERY_ATTR(camcorger),
  77         SEC_BATTERY_ATTR(data_call),
  78         SEC_BATTERY_ATTR(wifi),
  79         SEC_BATTERY_ATTR(wibro),
  80         SEC_BATTERY_ATTR(lte),
  81         SEC_BATTERY_ATTR(lcd),
  82         SEC_BATTERY_ATTR(gps),
  83         SEC_BATTERY_ATTR(event),
  84 #if defined(CONFIG_SAMSUNG_BATTERY_ENG_TEST)
  85         SEC_BATTERY_ATTR(test_charge_current),
  86         SEC_BATTERY_ATTR(set_stability_test),
  87 #endif
  88 };
  89
  90 static enum power_supply_property sec_battery_props[] = {
  91         POWER_SUPPLY_PROP_STATUS,
  92         POWER_SUPPLY_PROP_CHARGE_TYPE,
  93         POWER_SUPPLY_PROP_HEALTH,
  94         POWER_SUPPLY_PROP_PRESENT,
  95         POWER_SUPPLY_PROP_ONLINE,
  96         POWER_SUPPLY_PROP_TECHNOLOGY,
  97         POWER_SUPPLY_PROP_VOLTAGE_NOW,
  98         POWER_SUPPLY_PROP_VOLTAGE_AVG,
  99         POWER_SUPPLY_PROP_CURRENT_NOW,
 100         POWER_SUPPLY_PROP_CURRENT_AVG,
 101         POWER_SUPPLY_PROP_CHARGE_NOW,
 102         POWER_SUPPLY_PROP_CAPACITY,
 103         POWER_SUPPLY_PROP_TEMP,
 104         POWER_SUPPLY_PROP_TEMP_AMBIENT,
 105 };
 106
 107 static enum power_supply_property sec_power_props[] = {
 108         POWER_SUPPLY_PROP_ONLINE,
 109 };
 110
 111 static enum power_supply_property sec_ps_props[] = {
 112         POWER_SUPPLY_PROP_STATUS,
 113         POWER_SUPPLY_PROP_ONLINE,
 114 };
 115
 116 static char *supply_list[] = {
 117         "battery",
 118 };
 119
 120 char *sec_bat_charging_mode_str[] = {
 121         "None",
 122         "Normal",
 123         "Additional",
 124         "Re-Charging",
 125         "ABS"
 126 };
 127
 128 char *sec_bat_status_str[] = {
 129         "Unknown",
 130         "Charging",
 131         "Discharging",
 132         "Not-charging",
 133         "Full"
 134 };
 135
 136 char *sec_bat_health_str[] = {
 137         "Unknown",
 138         "Good",
 139         "Overheat",
 140         "Warm",
 141         "Dead",
 142         "OverVoltage",
 143         "UnspecFailure",
 144         "Cold",
 145         "Cool",
 146         "Watchdog timer expier",
 147         "Safety timer expier",
 148         "UnderVoltage",
 149         "Overheatlimit"
 150 };
 151
 152 static int sec_bat_set_charge(
 153                                 struct sec_battery_info *battery,
 154                                 bool enable)
 155 {
 156         union power_supply_propval val;
 157
 158         struct timespec ts;
 159         ktime_t current_time;
 160
 161         val.intval = battery->status;
 162         psy_do_property(battery->pdata->charger_name, set,
 163                 POWER_SUPPLY_PROP_STATUS, val);
 164 #if defined(ANDROID_ALARM_ACTIVATED)
 165         current_time = alarm_get_elapsed_realtime();
 166         ts = ktime_to_timespec(current_time);
 167 #else
 168         current_time = ktime_get_boottime();
 169         ts = ktime_to_timespec(current_time);
 170 #endif
 171
 172         if (enable) {
 173                 val.intval = battery->cable_type;
 174                 /*Reset charging start time only in initial charging start */
 175                 if (battery->charging_start_time == 0) {
 176                         battery->charging_start_time =
 177                                 ts.tv_sec ? ts.tv_sec : 1;
 178                         battery->charging_next_time =
 179                                 battery->pdata->charging_reset_time;
 180                 }
 181         } else {
 182                 val.intval = POWER_SUPPLY_TYPE_BATTERY;
 183                 battery->charging_start_time = 0;
 184                 battery->charging_passed_time = 0;
 185                 battery->charging_next_time = 0;
 186                 battery->charging_fullcharged_time = 0;
 187                 battery->full_check_cnt = 0;
 188         }
 189
 190         battery->temp_high_cnt = 0;
 191         battery->temp_low_cnt = 0;
 192         battery->temp_recover_cnt = 0;
 193
 194         psy_do_property(battery->pdata->charger_name, set,
 195                 POWER_SUPPLY_PROP_ONLINE, val);
 196
 197         psy_do_property(battery->pdata->fuelgauge_name, set,
 198                 POWER_SUPPLY_PROP_ONLINE, val);
 199
 200         return 0;
 201 }
 202
 203 static int sec_bat_get_adc_data(struct sec_battery_info *battery,
 204                         int adc_ch, int count)
 205 {
 206         int adc_data;
 207         int adc_max;
 208         int adc_min;
 209         int adc_total;
 210         int i;
 211
 212         adc_data = 0;
 213         adc_max = 0;
 214         adc_min = 0;
 215         adc_total = 0;
 216
 217         for (i = 0; i < count; i++) {
 218                 mutex_lock(&battery->adclock);
 219 #ifdef CONFIG_OF
 220                 adc_data = adc_read(battery, adc_ch);
 221 #else
 222                 adc_data = adc_read(battery->pdata, adc_ch);
 223 #endif
 224                 mutex_unlock(&battery->adclock);
 225
 226                 if (adc_data < 0)
 227                         goto err;
 228
 229                 if (i != 0) {
 230                         if (adc_data > adc_max)
 231                                 adc_max = adc_data;
 232                         else if (adc_data < adc_min)
 233                                 adc_min = adc_data;
 234                 } else {
 235                         adc_max = adc_data;
 236                         adc_min = adc_data;
 237                 }
 238                 adc_total += adc_data;
 239         }
 240
 241         return (adc_total - adc_max - adc_min) / (count - 2);
 242 err:
 243         return adc_data;
 244 }
 245
 246 /*
 247 static unsigned long calculate_average_adc(
 248                         struct sec_battery_info *battery,
 249                         int channel, int adc)
 250 {
 251         unsigned int cnt = 0;
 252         int total_adc = 0;
 253         int average_adc = 0;
 254         int index = 0;
 255
 256         cnt = battery->adc_sample[channel].cnt;
 257         total_adc = battery->adc_sample[channel].total_adc;
 258
 259         if (adc < 0) {
 260                 dev_err(battery->dev,
 261                         "%s : Invalid ADC : %d\n", __func__, adc);
 262                 adc = battery->adc_sample[channel].average_adc;
 263         }
 264
 265         if (cnt < ADC_SAMPLE_COUNT) {
 266                 battery->adc_sample[channel].adc_arr[cnt] = adc;
 267                 battery->adc_sample[channel].index = cnt;
 268                 battery->adc_sample[channel].cnt = ++cnt;
 269
 270                 total_adc += adc;
 271                 average_adc = total_adc / cnt;
 272         } else {
 273                 index = battery->adc_sample[channel].index;
 274                 if (++index >= ADC_SAMPLE_COUNT)
 275                         index = 0;
 276
 277                 total_adc = total_adc -
 278                         battery->adc_sample[channel].adc_arr[index] + adc;
 279                 average_adc = total_adc / ADC_SAMPLE_COUNT;
 280
 281                 battery->adc_sample[channel].adc_arr[index] = adc;
 282                 battery->adc_sample[channel].index = index;
 283         }
 284
 285         battery->adc_sample[channel].total_adc = total_adc;
 286         battery->adc_sample[channel].average_adc = average_adc;
 287
 288         return average_adc;
 289 }
 290 */
 291
 292 static int sec_bat_get_adc_value(
 293                 struct sec_battery_info *battery, int channel)
 294 {
 295         int adc;
 296
 297         adc = sec_bat_get_adc_data(battery, channel,
 298                 battery->pdata->adc_check_count);
 299
 300         if (adc < 0) {
 301                 dev_err(battery->dev,
 302                         "%s: Error in ADC\n", __func__);
 303                 return adc;
 304         }
 305
 306         return adc;
 307 }
 308
 309 static int sec_bat_get_charger_type_adc
 310                                 (struct sec_battery_info *battery)
 311 {
 312         /* It is true something valid is
 313         connected to the device for charging.
 314         By default this something is considered to be USB.*/
 315         int result = POWER_SUPPLY_TYPE_USB;
 316
 317         int adc = 0;
 318         int i;
 319
 320         /* Do NOT check cable type when cable_switch_check() returns false
 321          * and keep current cable type
 322          */
 323         if (battery->pdata->cable_switch_check &&
 324             !battery->pdata->cable_switch_check())
 325                 return battery->cable_type;
 326
 327         adc = sec_bat_get_adc_value(battery,
 328                 SEC_BAT_ADC_CHANNEL_CABLE_CHECK);
 329
 330         /* Do NOT check cable type when cable_switch_normal() returns false
 331          * and keep current cable type
 332          */
 333         if (battery->pdata->cable_switch_normal &&
 334             !battery->pdata->cable_switch_normal())
 335                 return battery->cable_type;
 336
 337         for (i = 0; i < SEC_SIZEOF_POWER_SUPPLY_TYPE; i++)
 338                 if ((adc > battery->pdata->cable_adc_value[i].min) &&
 339                         (adc < battery->pdata->cable_adc_value[i].max))
 340                         break;
 341         if (i >= SEC_SIZEOF_POWER_SUPPLY_TYPE)
 342                 dev_err(battery->dev,
 343                         "%s : default USB\n", __func__);
 344         else
 345                 result = i;
 346
 347         dev_dbg(battery->dev, "%s : result(%d), adc(%d)\n",
 348                 __func__, result, adc);
 349
 350         return result;
 351 }
 352
 353 static bool sec_bat_check_vf_adc(struct sec_battery_info *battery)
 354 {
 355         int adc;
 356
 357         adc = sec_bat_get_adc_data(battery,
 358                 SEC_BAT_ADC_CHANNEL_BAT_CHECK,
 359                 battery->pdata->adc_check_count);
 360
 361         if (adc < 0) {
 362                 dev_err(battery->dev, "%s: VF ADC error\n", __func__);
 363                 adc = battery->check_adc_value;
 364         } else
 365                 battery->check_adc_value = adc;
 366
 367         if ((battery->check_adc_value < battery->pdata->check_adc_max) &&
 368                 (battery->check_adc_value >= battery->pdata->check_adc_min))
 369                 return true;
 370         else
 371                 return false;
 372 }
 373
 374 static bool sec_bat_check_by_psy(struct sec_battery_info *battery)
 375 {
 376         char *psy_name;
 377         union power_supply_propval value;
 378         bool ret;
 379         ret = true;
 380
 381         switch (battery->pdata->battery_check_type) {
 382         case SEC_BATTERY_CHECK_PMIC:
 383                 psy_name = battery->pdata->pmic_name;
 384                 break;
 385         case SEC_BATTERY_CHECK_FUELGAUGE:
 386                 psy_name = battery->pdata->fuelgauge_name;
 387                 break;
 388         case SEC_BATTERY_CHECK_CHARGER:
 389                 psy_name = battery->pdata->charger_name;
 390                 break;
 391         default:
 392                 dev_err(battery->dev,
 393                         "%s: Invalid Battery Check Type\n", __func__);
 394                 ret = false;
 395                 goto battery_check_error;
 396                 break;
 397         }
 398
 399         psy_do_property(psy_name, get,
 400                 POWER_SUPPLY_PROP_PRESENT, value);
 401         ret = (bool)value.intval;
 402
 403 battery_check_error:
 404         return ret;
 405 }
 406
 407 static bool sec_bat_check(struct sec_battery_info *battery)
 408 {
 409         bool ret;
 410         ret = true;
 411
 412         if (battery->pdata->check_jig_status) {
 413                 if (battery->factory_mode
 414                     || battery->pdata->check_jig_status()) {
 415                         dev_dbg(battery->dev, "%s: No need to check in factory mode\n",
 416                                 __func__);
 417                         return ret;
 418                 }
 419         } else if (battery->factory_mode) {
 420                 dev_dbg(battery->dev, "%s: No need to check in factory mode\n",
 421                         __func__);
 422                 return ret;
 423         }
 424
 425         if (battery->health != POWER_SUPPLY_HEALTH_GOOD &&
 426                 battery->health != POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
 427                 dev_dbg(battery->dev, "%s: No need to check\n", __func__);
 428                 return ret;
 429         }
 430
 431         switch (battery->pdata->battery_check_type) {
 432         case SEC_BATTERY_CHECK_ADC:
 433                 ret = sec_bat_check_vf_adc(battery);
 434                 break;
 435         case SEC_BATTERY_CHECK_INT:
 436         case SEC_BATTERY_CHECK_CALLBACK:
 437                 if(battery->cable_type == POWER_SUPPLY_TYPE_BATTERY) {
 438                         ret = battery->present;
 439                 } else {
 440                         if (battery->pdata->check_battery_callback)
 441                                 ret = battery->pdata->check_battery_callback(battery);
 442                 }
 443                 break;
 444         case SEC_BATTERY_CHECK_PMIC:
 445         case SEC_BATTERY_CHECK_FUELGAUGE:
 446         case SEC_BATTERY_CHECK_CHARGER:
 447                 ret = sec_bat_check_by_psy(battery);
 448                 break;
 449         case SEC_BATTERY_CHECK_NONE:
 450                 dev_info(battery->dev, "%s: No Check\n", __func__);
 451         default:
 452                 break;
 453         }
 454
 455         return ret;
 456 }
 457
 458 static bool sec_bat_get_cable_type(
 459                         struct sec_battery_info *battery,
 460                         int cable_source_type)
 461 {
 462         bool ret;
 463         int cable_type;
 464
 465         ret = false;
 466         cable_type = battery->cable_type;
 467
 468         if (cable_source_type & SEC_BATTERY_CABLE_SOURCE_CALLBACK) {
 469                 if (battery->pdata->check_cable_callback)
 470                         cable_type =
 471                                 battery->pdata->check_cable_callback(battery);
 472         }
 473
 474         if (cable_source_type & SEC_BATTERY_CABLE_SOURCE_ADC) {
 475                 if (gpio_get_value_cansleep(
 476                         battery->pdata->bat_gpio_ta_nconnected) ^
 477                         battery->pdata->bat_polarity_ta_nconnected)
 478                         cable_type = POWER_SUPPLY_TYPE_BATTERY;
 479                 else
 480                         cable_type =
 481                                 sec_bat_get_charger_type_adc(battery);
 482         }
 483
 484         if (battery->cable_type == cable_type) {
 485                 dev_dbg(battery->dev,
 486                         "%s: No need to change cable status\n", __func__);
 487         } else {
 488                 if (cable_type < POWER_SUPPLY_TYPE_BATTERY ||
 489                         cable_type >= SEC_SIZEOF_POWER_SUPPLY_TYPE) {
 490                         dev_err(battery->dev,
 491                                 "%s: Invalid cable type\n", __func__);
 492                 } else {
 493                         battery->cable_type = cable_type;
 494                         if (battery->pdata->check_cable_result_callback)
 495                                 battery->pdata->check_cable_result_callback(
 496                                         battery->cable_type);
 497
 498                         ret = true;
 499
 500                         dev_dbg(battery->dev, "%s: Cable Changed (%d)\n",
 501                                 __func__, battery->cable_type);
 502                 }
 503         }
 504
 505         return ret;
 506 }
 507
 508 static bool sec_bat_battery_cable_check(struct sec_battery_info *battery)
 509 {
 510         if (!sec_bat_check(battery)) {
 511                 if (battery->check_count < battery->pdata->check_count)
 512                         battery->check_count++;
 513                 else {
 514                         dev_err(battery->dev,
 515                                 "%s: Battery Disconnected\n", __func__);
 516                         battery->present = false;
 517                         battery->health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 518
 519                         if (battery->status !=
 520                                 POWER_SUPPLY_STATUS_DISCHARGING) {
 521                                 battery->status =
 522                                         POWER_SUPPLY_STATUS_NOT_CHARGING;
 523                                 sec_bat_set_charge(battery, false);
 524                         }
 525
 526                         if (battery->pdata->check_battery_result_callback)
 527                                 battery->pdata->
 528                                         check_battery_result_callback();
 529                         return false;
 530                 }
 531         } else
 532                 battery->check_count = 0;
 533
 534         battery->present = true;
 535
 536         if (battery->health == POWER_SUPPLY_HEALTH_UNSPEC_FAILURE) {
 537                 battery->health = POWER_SUPPLY_HEALTH_GOOD;
 538
 539                 if (battery->status == POWER_SUPPLY_STATUS_NOT_CHARGING) {
 540                         battery->status = POWER_SUPPLY_STATUS_CHARGING;
 541
 542                         sec_bat_set_charge(battery, true);
 543                 }
 544         }
 545
 546         dev_info(battery->dev, "%s: Battery Connected\n", __func__);
 547
 548         if (battery->pdata->cable_check_type &
 549                 SEC_BATTERY_CABLE_CHECK_POLLING) {
 550                 if (sec_bat_get_cable_type(battery,
 551                         battery->pdata->cable_source_type)) {
 552                         wake_lock(&battery->cable_wake_lock);
 553                         queue_work(battery->monitor_wqueue,
 554                                 &battery->cable_work);
 555                 }
 556         }
 557         return true;
 558 };
 559
 560 static int sec_bat_ovp_uvlo_by_psy(struct sec_battery_info *battery)
 561 {
 562         char *psy_name;
 563         union power_supply_propval value;
 564
 565         value.intval = POWER_SUPPLY_HEALTH_GOOD;
 566
 567         switch (battery->pdata->ovp_uvlo_check_type) {
 568         case SEC_BATTERY_OVP_UVLO_PMICPOLLING:
 569                 psy_name = battery->pdata->pmic_name;
 570                 break;
 571         case SEC_BATTERY_OVP_UVLO_CHGPOLLING:
 572                 psy_name = battery->pdata->charger_name;
 573                 break;
 574         default:
 575                 dev_err(battery->dev,
 576                         "%s: Invalid OVP/UVLO Check Type\n", __func__);
 577                 goto ovp_uvlo_check_error;
 578                 break;
 579         }
 580
 581         psy_do_property(psy_name, get,
 582                 POWER_SUPPLY_PROP_HEALTH, value);
 583
 584 ovp_uvlo_check_error:
 585         return value.intval;
 586 }
 587
 588 static bool sec_bat_ovp_uvlo_result(
 589                 struct sec_battery_info *battery, int health)
 590 {
 591         if (battery->health != health) {
 592                 battery->health = health;
 593                 switch (health) {
 594                 case POWER_SUPPLY_HEALTH_GOOD:
 595                         dev_info(battery->dev, "%s: Safe voltage\n", __func__);
 596                         dev_info(battery->dev, "%s: is_recharging : %d\n", __func__, battery->is_recharging);
 597                         if (battery->is_recharging)
 598                                 battery->status =
 599                                         POWER_SUPPLY_STATUS_FULL;
 600                         else    /* Normal Charging */
 601                                 battery->status =
 602                                         POWER_SUPPLY_STATUS_CHARGING;
 603                         break;
 604                 case POWER_SUPPLY_HEALTH_OVERVOLTAGE:
 605                 case POWER_SUPPLY_HEALTH_UNDERVOLTAGE:
 606                         dev_info(battery->dev,
 607                                 "%s: Unsafe voltage (%d)\n",
 608                                 __func__, health);
 609                         battery->status =
 610                                 POWER_SUPPLY_STATUS_NOT_CHARGING;
 611                         /* Take the wakelock during 10 seconds
 612                            when over-voltage status is detected  */
 613                         wake_lock_timeout(&battery->vbus_wake_lock, HZ * 10);
 614                         break;
 615                 }
 616                 power_supply_changed(&battery->psy_bat);
 617                 return true;
 618         }
 619
 620         return false;
 621 }
 622
 623 static bool sec_bat_ovp_uvlo(struct sec_battery_info *battery)
 624 {
 625         int health;
 626
 627         if (battery->pdata->check_jig_status) {
 628                 if (battery->factory_mode
 629                     || battery->pdata->check_jig_status()) {
 630                         dev_dbg(battery->dev,
 631                                 "%s: No need to check in factory mode\n",
 632                                 __func__);
 633                         return false;
 634                 }
 635         } else if (battery->factory_mode) {
 636                 dev_dbg(battery->dev, "%s: No need to check in factory mode\n",
 637                                 __func__);
 638                 return false;
 639         }
 640
 641         if (battery->health != POWER_SUPPLY_HEALTH_GOOD &&
 642                 battery->health != POWER_SUPPLY_HEALTH_OVERVOLTAGE &&
 643                 battery->health != POWER_SUPPLY_HEALTH_UNDERVOLTAGE) {
 644                 dev_dbg(battery->dev, "%s: No need to check\n", __func__);
 645                 return false;
 646         }
 647
 648         health = battery->health;
 649
 650         switch (battery->pdata->ovp_uvlo_check_type) {
 651         case SEC_BATTERY_OVP_UVLO_CALLBACK:
 652                 if (battery->pdata->ovp_uvlo_callback)
 653                         health = battery->pdata->ovp_uvlo_callback();
 654                 break;
 655         case SEC_BATTERY_OVP_UVLO_PMICPOLLING:
 656         case SEC_BATTERY_OVP_UVLO_CHGPOLLING:
 657                 health = sec_bat_ovp_uvlo_by_psy(battery);
 658                 break;
 659         case SEC_BATTERY_OVP_UVLO_PMICINT:
 660         case SEC_BATTERY_OVP_UVLO_CHGINT:
 661                 /* nothing for interrupt check */
 662         default:
 663                 break;
 664         }
 665
 666         return sec_bat_ovp_uvlo_result(battery, health);
 667 }
 668
 669 static bool sec_bat_check_recharge(struct sec_battery_info *battery)
 670 {
 671 #if defined(CONFIG_BATTERY_SWELLING)
 672         if (battery->swelling_mode == SEC_BATTERY_HIGH_SWELLING_MODE) {
 673                 if ((battery->charging_mode == SEC_BATTERY_CHARGING_NONE) ||
 674                         (battery->charging_mode == SEC_BATTERY_CHARGING_ABS)) {
 675                         if ((battery->pdata->recharge_condition_type &
 676                                                 SEC_BATTERY_RECHARGE_CONDITION_VCELL) &&
 677                                         (battery->voltage_now <=
 678                                          4150)) {
 679                                 dev_info(battery->dev,
 680                                                 "%s: Re-charging by VCELL in high swelling mode(%d)\n",
 681                                                 __func__, battery->voltage_now);
 682                                 battery->swelling_block = false;
 683                                 goto check_recharge_check_count;
 684                         }
 685                 }
 686         } else if (battery->swelling_mode == SEC_BATTERY_LOW_SWELLING_MODE) {
 687                 if ((battery->charging_mode == SEC_BATTERY_CHARGING_NONE) ||
 688                         (battery->charging_mode == SEC_BATTERY_CHARGING_ABS)) {
 689                         if ((battery->pdata->recharge_condition_type &
 690                                                 SEC_BATTERY_RECHARGE_CONDITION_VCELL) &&
 691                                         (battery->voltage_now <=
 692                                          4050)) {
 693                                 dev_info(battery->dev,
 694                                                 "%s: Re-charging by VCELL in low swelling mode(%d)\n",
 695                                                 __func__, battery->voltage_now);
 696                                 battery->swelling_block = false;
 697                                 goto check_recharge_check_count;
 698                         }
 699                 }
 700         } else
 701 #endif
 702         {
 703                 if ((battery->status == POWER_SUPPLY_STATUS_CHARGING) &&
 704                                 (battery->pdata->full_condition_type &
 705                                  SEC_BATTERY_FULL_CONDITION_NOTIMEFULL) &&
 706                                 (battery->charging_mode == SEC_BATTERY_CHARGING_NONE)) {
 707                         dev_info(battery->dev,
 708                                         "%s: Re-charging by NOTIMEFULL (%d)\n",
 709                                         __func__, battery->capacity);
 710                         goto check_recharge_check_count;
 711                 }
 712
 713                 if (battery->status == POWER_SUPPLY_STATUS_FULL &&
 714                                 battery->charging_mode == SEC_BATTERY_CHARGING_NONE) {
 715                         if ((battery->pdata->recharge_condition_type &
 716                                                 SEC_BATTERY_RECHARGE_CONDITION_SOC) &&
 717                                         (battery->capacity <=
 718                                          battery->pdata->recharge_condition_soc)) {
 719                                 dev_info(battery->dev,
 720                                                 "%s: Re-charging by SOC (%d)\n",
 721                                                 __func__, battery->capacity);
 722                                 goto check_recharge_check_count;
 723                         }
 724
 725                         if ((battery->pdata->recharge_condition_type &
 726                                                 SEC_BATTERY_RECHARGE_CONDITION_AVGVCELL) &&
 727                                         (battery->voltage_avg <=
 728                                          battery->pdata->recharge_condition_avgvcell)) {
 729                                 dev_info(battery->dev,
 730                                                 "%s: Re-charging by average VCELL (%d)\n",
 731                                                 __func__, battery->voltage_avg);
 732                                 goto check_recharge_check_count;
 733                         }
 734                         if ((battery->pdata->recharge_condition_type &
 735                                                 SEC_BATTERY_RECHARGE_CONDITION_VCELL) &&
 736                                         (battery->voltage_now <=
 737                                          battery->pdata->recharge_condition_vcell)) {
 738                                 dev_info(battery->dev,
 739                                                 "%s: Re-charging by VCELL (%d)\n",
 740                                                 __func__, battery->voltage_now);
 741                                 goto check_recharge_check_count;
 742                         }
 743                 }
 744         }
 745         battery->recharge_check_cnt = 0;
 746         return false;
 747
 748 check_recharge_check_count:
 749         if (battery->recharge_check_cnt <
 750                 battery->pdata->recharge_check_count)
 751                 battery->recharge_check_cnt++;
 752         dev_dbg(battery->dev,
 753                 "%s: recharge count = %d\n",
 754                 __func__, battery->recharge_check_cnt);
 755
 756         if (battery->recharge_check_cnt >=
 757                 battery->pdata->recharge_check_count)
 758                 return true;
 759         else
 760                 return false;
 761 }
 762
 763 static bool sec_bat_voltage_check(struct sec_battery_info *battery)
 764 {
 765         if (battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
 766                 dev_dbg(battery->dev,
 767                         "%s: Charging Disabled\n", __func__);
 768                 return true;
 769         }
 770
 771         /* OVP/UVLO check */
 772         if (sec_bat_ovp_uvlo(battery)) {
 773                 if (battery->pdata->ovp_uvlo_result_callback)
 774                         battery->pdata->
 775                                 ovp_uvlo_result_callback(battery->health);
 776                 return false;
 777         }
 778
 779         /* Re-Charging check */
 780         if (sec_bat_check_recharge(battery)) {
 781                 if (battery->pdata->full_check_type !=
 782                         SEC_BATTERY_FULLCHARGED_NONE)
 783                         battery->charging_mode = SEC_BATTERY_CHARGING_1ST;
 784                 else
 785                         battery->charging_mode = SEC_BATTERY_CHARGING_2ND;
 786                 battery->is_recharging = true;
 787                 sec_bat_set_charge(battery, true);
 788                 return false;
 789         }
 790
 791         return true;
 792 }
 793
 794 static bool sec_bat_get_temperature_by_adc(
 795                                 struct sec_battery_info *battery,
 796                                 enum power_supply_property psp,
 797                                 union power_supply_propval *value)
 798 {
 799         int temp = 0;
 800         int temp_adc;
 801         int low = 0;
 802         int high = 0;
 803         int mid = 0;
 804         int channel;
 805         const sec_bat_adc_table_data_t *temp_adc_table;
 806         unsigned int temp_adc_table_size;
 807
 808         switch (psp) {
 809         case POWER_SUPPLY_PROP_TEMP:
 810                 channel = SEC_BAT_ADC_CHANNEL_TEMP;
 811                 temp_adc_table = battery->pdata->temp_adc_table;
 812                 temp_adc_table_size =
 813                         battery->pdata->temp_adc_table_size;
 814                 break;
 815         case POWER_SUPPLY_PROP_TEMP_AMBIENT:
 816                 channel = SEC_BAT_ADC_CHANNEL_TEMP_AMBIENT;
 817                 temp_adc_table = battery->pdata->temp_amb_adc_table;
 818                 temp_adc_table_size =
 819                         battery->pdata->temp_amb_adc_table_size;
 820                 break;
 821         default:
 822                 dev_err(battery->dev,
 823                         "%s: Invalid Property\n", __func__);
 824                 return false;
 825         }
 826
 827         temp_adc = sec_bat_get_adc_value(battery, channel);
 828         if (temp_adc < 0)
 829                 return true;
 830
 831         switch (psp) {
 832         case POWER_SUPPLY_PROP_TEMP:
 833                 battery->temp_adc = temp_adc;
 834                 break;
 835         case POWER_SUPPLY_PROP_TEMP_AMBIENT:
 836                 battery->temp_ambient_adc = temp_adc;
 837                 break;
 838         default:
 839                 dev_err(battery->dev,
 840                         "%s: Invalid Property\n", __func__);
 841                 return false;
 842         }
 843
 844         if (temp_adc_table[0].adc >= temp_adc) {
 845                 temp = temp_adc_table[0].data;
 846                 goto temp_by_adc_goto;
 847         } else if (temp_adc_table[temp_adc_table_size-1].adc <= temp_adc) {
 848                 temp = temp_adc_table[temp_adc_table_size-1].data;
 849                 goto temp_by_adc_goto;
 850         }
 851
 852         high = temp_adc_table_size - 1;
 853
 854         while (low <= high) {
 855                 mid = (low + high) / 2;
 856                 if (temp_adc_table[mid].adc > temp_adc)
 857                         high = mid - 1;
 858                 else if (temp_adc_table[mid].adc < temp_adc)
 859                         low = mid + 1;
 860                 else {
 861                         temp = temp_adc_table[mid].data;
 862                         goto temp_by_adc_goto;
 863                 }
 864         }
 865
 866         temp = temp_adc_table[high].data;
 867         temp += (((int)temp_adc_table[low].data - (int)temp_adc_table[high].data) *
 868                  ((int)temp_adc - (int)temp_adc_table[high].adc)) /
 869                 ((int)temp_adc_table[low].adc - (int)temp_adc_table[high].adc);
 870
 871 temp_by_adc_goto:
 872         value->intval = temp;
 873
 874         dev_info(battery->dev,
 875                 "%s: Temp(%d), Temp-ADC(%d)\n",
 876                 __func__, temp, temp_adc);
 877
 878         return true;
 879 }
 880
 881 static bool sec_bat_temperature(
 882                                 struct sec_battery_info *battery)
 883 {
 884         bool ret;
 885         ret = true;
 886
 887         if (battery->pdata->event_check && battery->event) {
 888                 battery->temp_high_threshold =
 889                         battery->pdata->temp_high_threshold_event;
 890                 battery->temp_high_recovery =
 891                         battery->pdata->temp_high_recovery_event;
 892                 battery->temp_low_recovery =
 893                         battery->pdata->temp_low_recovery_event;
 894                 battery->temp_low_threshold =
 895                         battery->pdata->temp_low_threshold_event;
 896         } else if (battery->pdata->is_lpm && battery->pdata->is_lpm()) {
 897                 battery->temp_high_threshold =
 898                         battery->pdata->temp_high_threshold_lpm;
 899                 battery->temp_high_recovery =
 900                         battery->pdata->temp_high_recovery_lpm;
 901                 battery->temp_low_recovery =
 902                         battery->pdata->temp_low_recovery_lpm;
 903                 battery->temp_low_threshold =
 904                         battery->pdata->temp_low_threshold_lpm;
 905         } else {
 906                 battery->temp_high_threshold =
 907                         battery->pdata->temp_high_threshold_normal;
 908                 battery->temp_high_recovery =
 909                         battery->pdata->temp_high_recovery_normal;
 910                 battery->temp_low_recovery =
 911                         battery->pdata->temp_low_recovery_normal;
 912                 battery->temp_low_threshold =
 913                         battery->pdata->temp_low_threshold_normal;
 914         }
 915
 916         dev_info(battery->dev,
 917                 "%s: HT(%d), HR(%d), LT(%d), LR(%d)\n",
 918                 __func__, battery->temp_high_threshold,
 919                 battery->temp_high_recovery,
 920                 battery->temp_low_threshold,
 921                 battery->temp_low_recovery);
 922         return ret;
 923 }
 924
 925 #if defined(CONFIG_BATTERY_SWELLING)
 926 static void sec_bat_swelling_check(struct sec_battery_info *battery, int temperature)
 927 {
 928         union power_supply_propval val;
 929
 930         pr_info("%s: status(%d), swell_mode(%d), temp(%d), vnow(%d), block(%d)\n",
 931                         __func__, battery->status, battery->swelling_mode,
 932                         temperature, battery->voltage_now, battery->swelling_block);
 933
 934         /* swelling_mode
 935          *              under voltage over voltage, battery missing  */
 936         if (battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
 937                 pr_info("%s: DISCHARGING. stop swelling mode\n", __func__);
 938                 battery->swelling_mode = SEC_BATTERY_NORMAL_MODE;
 939                 battery->swelling_block = false;
 940                 if (battery->swelling_max_vbat == 4200) {
 941                         /* restore float voltage */
 942                         val.intval = battery->pdata->chg_float_voltage;
 943                         psy_do_property(battery->pdata->charger_name, set,
 944                                 POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
 945                         battery->swelling_max_vbat = val.intval;
 946                 }
 947                 goto skip_swelling_chek;
 948         }
 949
 950         switch (battery->swelling_mode) {
 951                 case SEC_BATTERY_NORMAL_MODE:
 952                         if (temperature >= battery->swelling_temp_high_threshold) {
 953                                 if (temperature >= battery->swelling_temp_dischg_threshold &&
 954                                         battery->voltage_now > 4235) {
 955                                                 pr_info("%s: self discharge mode start.\n", __func__);
 956                                                 if ((battery->voltage_now > 4235) &&
 957                                                         (battery->swelling_block == false)) {
 958                                                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
 959                                                         sec_bat_set_charge(battery, false);
 960                                                         battery->swelling_block = true;
 961                                                 }
 962
 963                                                 battery->swelling_mode = SEC_BATTERY_DISCHG_MODE;
 964 #if defined(CONFIG_BATTERY_DISCHG_IC)
 965                                                 /*enable discharge */
 966                                                 gpio_set_value(battery->pdata->dischg_test, 1);
 967                                                 pr_info ("%s: enable discharge\n", __func__);
 968 #endif
 969                                 } else {
 970                                         pr_info("%s: high swelling mode start.\n", __func__);
 971                                         if (battery->voltage_now < 4200) {
 972                                                 /* change to 4.20V float voltage */
 973                                                 val.intval = 4200;
 974                                                 psy_do_property(battery->pdata->charger_name, set,
 975                                                         POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
 976                                                 battery->swelling_max_vbat = val.intval;
 977                                         } else if ((battery->voltage_now > 4235) &&
 978                                                 (battery->swelling_block == false)) {
 979                                                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
 980                                                         sec_bat_set_charge(battery, false);
 981                                                         battery->swelling_block = true;
 982                                         }
 983
 984                                         battery->swelling_mode = SEC_BATTERY_HIGH_SWELLING_MODE;
 985                                         battery->swelling_full_check_cnt = 0;
 986                                 }
 987                         } else if (temperature <= battery->swelling_temp_low_threshold) {
 988                                         pr_info("%s: low swelling mode start.\n", __func__);
 989                                         if (battery->voltage_now < 4200) {
 990                                                 /* change to 4.20V float voltage */
 991                                                 val.intval = 4200;
 992                                                 psy_do_property(battery->pdata->charger_name, set,
 993                                                         POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
 994                                                 battery->swelling_max_vbat = val.intval;
 995                                         } else if ((battery->voltage_now > 4235) &&
 996                                                 (battery->swelling_block == false)) {
 997                                                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
 998                                                         sec_bat_set_charge(battery, false);
 999                                                         battery->swelling_block = true;
1000                                         }
1001
1002                                         battery->swelling_mode = SEC_BATTERY_LOW_SWELLING_MODE;
1003                                         battery->swelling_full_check_cnt = 0;
1004                         }
1005                         break;
1006                 case SEC_BATTERY_HIGH_SWELLING_MODE:
1007                         if (temperature < battery->swelling_temp_high_recovery) {
1008                                 pr_info("%s: high swelling mode end.\n", __func__);
1009
1010                                 /* restore float voltage */
1011                                 val.intval = battery->pdata->chg_float_voltage;
1012                                 psy_do_property(battery->pdata->charger_name, set,
1013                                         POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
1014                                 battery->swelling_max_vbat = val.intval;
1015                                 battery->charging_mode = SEC_BATTERY_CHARGING_1ST;
1016                                 sec_bat_set_charge(battery, true);
1017                                 battery->swelling_block = false;
1018
1019                                 battery->swelling_mode = SEC_BATTERY_NORMAL_MODE;
1020                         } else if (temperature >= battery->swelling_temp_high_recovery) {
1021                                 if (temperature >= battery->swelling_temp_dischg_threshold &&
1022                                         battery->voltage_now > 4235) {
1023                                                 pr_info("%s: self discharge mode start.\n", __func__);
1024                                                 if ((battery->voltage_now > 4235) &&
1025                                                         (battery->swelling_block == false)) {
1026                                                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1027                                                         sec_bat_set_charge(battery, false);
1028                                                         battery->swelling_block = true;
1029                                                 }
1030
1031                                                 battery->swelling_mode = SEC_BATTERY_DISCHG_MODE;
1032 #if defined(CONFIG_BATTERY_DISCHG_IC)
1033                                                 /*enable discharge */
1034                                                 gpio_set_value(battery->pdata->dischg_test, 1);
1035                                                 pr_info ("%s: enable discharge\n", __func__);
1036 #endif
1037                                 } else {
1038                                                 if ((battery->voltage_now < 4200) &&
1039                                                         (battery->swelling_max_vbat != 4200)) {
1040                                                         /* change to 4.20V float voltage */
1041                                                         val.intval = 4200;
1042                                                         psy_do_property(battery->pdata->charger_name, set,
1043                                                                 POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
1044                                                         battery->swelling_max_vbat = val.intval;
1045                                                 } else if ((battery->voltage_now > 4235) &&
1046                                                                 (battery->swelling_block == false)) {
1047                                                                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1048                                                                         sec_bat_set_charge(battery, false);
1049                                                                         battery->swelling_block = true;
1050                                                 }
1051                                         pr_info("%s: high swelling mode. Vbatt(%d)\n",
1052                                                 __func__, battery->voltage_now);
1053                                 }
1054                         }
1055                         break;
1056                 case SEC_BATTERY_LOW_SWELLING_MODE:
1057                         if (temperature > battery->swelling_temp_low_recovery) {
1058                                 pr_info("%s: low swelling mode end.\n", __func__);
1059
1060                                 /* restore float voltage */
1061                                 val.intval = battery->pdata->chg_float_voltage;
1062                                 psy_do_property(battery->pdata->charger_name, set,
1063                                         POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
1064                                 battery->swelling_max_vbat = val.intval;
1065                                 battery->charging_mode = SEC_BATTERY_CHARGING_1ST;
1066                                 sec_bat_set_charge(battery, true);
1067                                 battery->swelling_block = false;
1068
1069                                 battery->swelling_mode = SEC_BATTERY_NORMAL_MODE;
1070                         } else if (temperature <= battery->swelling_temp_low_recovery) {
1071                                         if ((battery->voltage_now < 4200) &&
1072                                                 (battery->swelling_max_vbat != 4200)) {
1073                                                 /* change to 4.20V float voltage */
1074                                                 val.intval = 4200;
1075                                                 psy_do_property(battery->pdata->charger_name, set,
1076                                                         POWER_SUPPLY_PROP_VOLTAGE_MAX, val);
1077                                                 battery->swelling_max_vbat = val.intval;
1078                                         } else if ((battery->voltage_now > 4235) &&
1079                                                 (battery->swelling_block == false)) {
1080                                                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1081                                                         sec_bat_set_charge(battery, false);
1082                                                         battery->swelling_block = true;
1083                                         }
1084                                         /* change to 0.5C charging current */
1085 #if 0 /* Orbis charging current is under 0.5C, thus no need to set */
1086                                         val.intval = 150;
1087                                         psy_do_property(battery->pdata->charger_name, set,
1088                                                 POWER_SUPPLY_PROP_CURRENT_AVG, val);
1089 #endif
1090                                         pr_info("%s: low swelling mode. Vbatt(%d)\n",
1091                                                 __func__, battery->voltage_now);
1092                         }
1093                         break;
1094                 case SEC_BATTERY_DISCHG_MODE:
1095                         if (temperature >= battery->swelling_temp_dischg_recovery) {
1096                                 pr_info ("%s: continue discharging... temperature is still high\n", __func__);
1097                                 if (battery->voltage_now < 4230) {
1098                                         /* cancel discharge mode, move to swelling mode */
1099                                         battery->swelling_mode = SEC_BATTERY_HIGH_SWELLING_MODE;
1100 #if defined(CONFIG_BATTERY_DISCHG_IC)
1101                                         /*disable discharge */
1102                                         gpio_set_value(battery->pdata->dischg_test, 0);
1103                                         pr_info ("%s: disable discharge\n", __func__);
1104 #endif
1105                                 }
1106                         } else if (temperature < battery->swelling_temp_dischg_recovery) {
1107                                 /* cancel discharge mode, move to swelling mode */
1108                                 battery->swelling_mode = SEC_BATTERY_HIGH_SWELLING_MODE;
1109 #if defined(CONFIG_BATTERY_DISCHG_IC)
1110                                 /*disable discharge */
1111                                 gpio_set_value(battery->pdata->dischg_test, 0);
1112                                 pr_info ("%s: disable discharge\n", __func__);
1113 #endif
1114                         }
1115                         pr_info("%s: the latest swelling mode[%d]\n", __func__, battery->swelling_mode);
1116                         break;
1117                 default:
1118                         pr_err("%s: unknown swelling mode[%d]\n", __func__, battery->swelling_mode);
1119                         break;
1120         }
1121 skip_swelling_chek:
1122         dev_dbg(battery->dev, "%s end\n", __func__);
1123 }
1124 #endif
1125
1126 static bool sec_bat_temperature_check(
1127                                 struct sec_battery_info *battery)
1128 {
1129         int temp_value;
1130         bool health_changed;
1131
1132         /* set health_changed true as default
1133          * this value will be changed after temperature check
1134          */
1135         health_changed = true;
1136
1137         if (battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
1138                 dev_dbg(battery->dev,
1139                         "%s: Charging Disabled\n", __func__);
1140                 return true;
1141         }
1142
1143         if (battery->health != POWER_SUPPLY_HEALTH_GOOD &&
1144                 battery->health != POWER_SUPPLY_HEALTH_OVERHEAT &&
1145                 battery->health != POWER_SUPPLY_HEALTH_COLD) {
1146                 dev_dbg(battery->dev, "%s: No need to check\n", __func__);
1147                 return false;
1148         }
1149
1150         sec_bat_temperature(battery);
1151
1152         switch (battery->pdata->temp_check_type) {
1153         case SEC_BATTERY_TEMP_CHECK_ADC:
1154                 temp_value = battery->temp_adc;
1155                 break;
1156         case SEC_BATTERY_TEMP_CHECK_TEMP:
1157                 temp_value = battery->temperature;
1158                 break;
1159         default:
1160                 dev_err(battery->dev,
1161                         "%s: Invalid Temp Check Type\n", __func__);
1162                 return true;
1163         }
1164
1165         if (temp_value >= battery->temp_high_threshold) {
1166                 if (battery->health != POWER_SUPPLY_HEALTH_OVERHEAT) {
1167                         if (battery->temp_high_cnt <
1168                                 battery->pdata->temp_check_count)
1169                                 battery->temp_high_cnt++;
1170                         dev_dbg(battery->dev,
1171                                 "%s: high count = %d\n",
1172                                 __func__, battery->temp_high_cnt);
1173                 }
1174         } else if ((temp_value <= battery->temp_high_recovery) &&
1175                                 (temp_value >= battery->temp_low_recovery)) {
1176                 if (battery->health == POWER_SUPPLY_HEALTH_OVERHEAT ||
1177                     battery->health == POWER_SUPPLY_HEALTH_COLD) {
1178                         if (battery->temp_recover_cnt <
1179                                 battery->pdata->temp_check_count)
1180                                 battery->temp_recover_cnt++;
1181                         dev_dbg(battery->dev,
1182                                 "%s: recovery count = %d\n",
1183                                 __func__, battery->temp_recover_cnt);
1184                 }
1185         } else if (temp_value <= battery->temp_low_threshold) {
1186                 if (battery->health != POWER_SUPPLY_HEALTH_COLD) {
1187                         if (battery->temp_low_cnt <
1188                                 battery->pdata->temp_check_count)
1189                                 battery->temp_low_cnt++;
1190                         dev_dbg(battery->dev,
1191                                 "%s: low count = %d\n",
1192                                 __func__, battery->temp_low_cnt);
1193                 }
1194         } else {
1195                 battery->temp_high_cnt = 0;
1196                 battery->temp_low_cnt = 0;
1197                 battery->temp_recover_cnt = 0;
1198         }
1199
1200         if (battery->temp_high_cnt >=
1201                 battery->pdata->temp_check_count)
1202                 battery->health = POWER_SUPPLY_HEALTH_OVERHEAT;
1203         else if (battery->temp_low_cnt >=
1204                 battery->pdata->temp_check_count)
1205                 battery->health = POWER_SUPPLY_HEALTH_COLD;
1206         else if (battery->temp_recover_cnt >=
1207                 battery->pdata->temp_check_count)
1208                 battery->health = POWER_SUPPLY_HEALTH_GOOD;
1209         else
1210                 health_changed = false;
1211
1212         if (health_changed) {
1213                 if ((battery->health == POWER_SUPPLY_HEALTH_OVERHEAT) ||
1214                         (battery->health == POWER_SUPPLY_HEALTH_COLD)) {
1215                         dev_info(battery->dev,
1216                                 "%s: Unsafe Temperature\n", __func__);
1217                         battery->status = POWER_SUPPLY_STATUS_NOT_CHARGING;
1218                         /* change charging current to battery (default 0mA) */
1219                         sec_bat_set_charge(battery, false);
1220                 } else {
1221                         dev_info(battery->dev,
1222                                 "%s: Safe Temperature\n", __func__);
1223                         /* if recovered from not charging */
1224                         if ((battery->health == POWER_SUPPLY_HEALTH_GOOD) &&
1225                                 (battery->status ==
1226                                  POWER_SUPPLY_STATUS_NOT_CHARGING)) {
1227                                 if (battery->is_recharging)
1228                                         battery->status =
1229                                                 POWER_SUPPLY_STATUS_FULL;
1230                                 else    /* Normal Charging */
1231                                         battery->status =
1232                                                 POWER_SUPPLY_STATUS_CHARGING;
1233                                 /* turn on charger by cable type */
1234                                 sec_bat_set_charge(battery, true);
1235                         }
1236                 }
1237                 return false;
1238         }
1239         return true;
1240 };
1241
1242 static void  sec_bat_event_program_alarm(
1243         struct sec_battery_info *battery, int seconds)
1244 {
1245 #if defined(ANDROID_ALARM_ACTIVATED)
1246         ktime_t low_interval = ktime_set(seconds - 10, 0);
1247         ktime_t slack = ktime_set(20, 0);
1248         ktime_t next;
1249
1250         next = ktime_add(battery->last_event_time, low_interval);
1251
1252         alarm_start_range(&battery->event_termination_alarm,
1253                 next, ktime_add(next, slack));
1254 #else
1255         alarm_start(&battery->event_termination_alarm,
1256                 ktime_add(battery->last_event_time, ktime_set(seconds - 10, 0)));
1257 #endif
1258 }
1259
1260 #if defined(ANDROID_ALARM_ACTIVATED)
1261 static void sec_bat_event_expired_timer_func(struct alarm *alarm)
1262 #else
1263 static enum alarmtimer_restart sec_bat_event_expired_timer_func(
1264         struct alarm *alarm, ktime_t now)
1265 #endif
1266 {
1267         struct sec_battery_info *battery =
1268                 container_of(alarm, struct sec_battery_info,
1269                         event_termination_alarm);
1270
1271         battery->event &= (~battery->event_wait);
1272         dev_info(battery->dev,
1273                 "%s: event expired (0x%x)\n", __func__, battery->event);
1274
1275 #if !defined(ANDROID_ALARM_ACTIVATED)
1276         return ALARMTIMER_NORESTART;
1277 #endif
1278 }
1279
1280 static void sec_bat_event_set(
1281         struct sec_battery_info *battery, int event, int enable)
1282 {
1283         if (!battery->pdata->event_check)
1284                 return;
1285
1286         /* ignore duplicated deactivation of same event
1287          * only if the event is one last event
1288          */
1289         if (!enable && (battery->event == battery->event_wait)) {
1290                 dev_info(battery->dev,
1291                         "%s: ignore duplicated deactivation of same event\n",
1292                         __func__);
1293                 return;
1294         }
1295
1296         alarm_cancel(&battery->event_termination_alarm);
1297         battery->event &= (~battery->event_wait);
1298
1299         if (enable) {
1300                 battery->event_wait = 0;
1301                 battery->event |= event;
1302
1303                 dev_info(battery->dev,
1304                         "%s: event set (0x%x)\n", __func__, battery->event);
1305         } else {
1306                 if (battery->event == 0) {
1307                         dev_dbg(battery->dev,
1308                                 "%s: nothing to clear\n", __func__);
1309                         return; /* nothing to clear */
1310                 }
1311                 battery->event_wait = event;
1312 #if defined(ANDROID_ALARM_ACTIVATED)
1313                 battery->last_event_time = alarm_get_elapsed_realtime();
1314 #else
1315                 battery->last_event_time = ktime_get_boottime();
1316 #endif
1317                 sec_bat_event_program_alarm(battery,
1318                         battery->pdata->event_waiting_time);
1319                 dev_info(battery->dev,
1320                         "%s: start timer (curr 0x%x, wait 0x%x)\n",
1321                         __func__, battery->event, battery->event_wait);
1322         }
1323 }
1324
1325 static bool sec_bat_check_fullcharged_condition(
1326                                         struct sec_battery_info *battery)
1327 {
1328         int full_check_type;
1329
1330         if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST)
1331                 full_check_type = battery->pdata->full_check_type;
1332         else
1333                 full_check_type = battery->pdata->full_check_type_2nd;
1334
1335         switch (full_check_type) {
1336         case SEC_BATTERY_FULLCHARGED_ADC:
1337         case SEC_BATTERY_FULLCHARGED_FG_CURRENT:
1338         case SEC_BATTERY_FULLCHARGED_SOC:
1339         case SEC_BATTERY_FULLCHARGED_CHGGPIO:
1340         case SEC_BATTERY_FULLCHARGED_CHGPSY:
1341                 break;
1342
1343         /* If these is NOT full check type or NONE full check type,
1344          * it is full-charged
1345          */
1346         case SEC_BATTERY_FULLCHARGED_CHGINT:
1347         case SEC_BATTERY_FULLCHARGED_TIME:
1348         case SEC_BATTERY_FULLCHARGED_NONE:
1349         default:
1350                 return true;
1351                 break;
1352         }
1353
1354 #if defined(CONFIG_BATTERY_SWELLING)
1355         if (battery->swelling_mode != SEC_BATTERY_NORMAL_MODE) {
1356                 if (battery->pdata->full_condition_type &
1357                         SEC_BATTERY_FULL_CONDITION_VCELL) {
1358                         if (battery->voltage_now <
1359                                 4150) {
1360                                 dev_dbg(battery->dev,
1361                                         "%s: Not enough VCELL (%dmV)\n",
1362                                         __func__, battery->voltage_now);
1363                                 return false;
1364                         }
1365                 }
1366         } else
1367 #endif
1368         {
1369                 if (battery->pdata->full_condition_type &
1370                         SEC_BATTERY_FULL_CONDITION_SOC) {
1371                         if (battery->capacity <
1372                                 battery->pdata->full_condition_soc) {
1373                                 dev_dbg(battery->dev,
1374                                         "%s: Not enough SOC (%d%%)\n",
1375                                         __func__, battery->capacity);
1376                                 return false;
1377                         }
1378                 }
1379
1380                 if (battery->pdata->full_condition_type &
1381                         SEC_BATTERY_FULL_CONDITION_VCELL) {
1382                         if (battery->voltage_now <
1383                                 battery->pdata->full_condition_vcell) {
1384                                 dev_dbg(battery->dev,
1385                                         "%s: Not enough VCELL (%dmV)\n",
1386                                         __func__, battery->voltage_now);
1387                                 return false;
1388                         }
1389                 }
1390
1391                 if (battery->pdata->full_condition_type &
1392                         SEC_BATTERY_FULL_CONDITION_AVGVCELL) {
1393                         if (battery->voltage_avg <
1394                                 battery->pdata->full_condition_avgvcell) {
1395                                 dev_dbg(battery->dev,
1396                                         "%s: Not enough AVGVCELL (%dmV)\n",
1397                                         __func__, battery->voltage_avg);
1398                                 return false;
1399                         }
1400                 }
1401
1402                 if (battery->pdata->full_condition_type &
1403                         SEC_BATTERY_FULL_CONDITION_OCV) {
1404                         if (battery->voltage_ocv <
1405                                 battery->pdata->full_condition_ocv) {
1406                                 dev_dbg(battery->dev,
1407                                         "%s: Not enough OCV (%dmV)\n",
1408                                         __func__, battery->voltage_ocv);
1409                                 return false;
1410                         }
1411                 }
1412         }
1413         return true;
1414 }
1415
1416 static void sec_bat_do_test_function(
1417                 struct sec_battery_info *battery)
1418 {
1419         union power_supply_propval value;
1420
1421         switch (battery->test_mode) {
1422                 case 1:
1423                         if (battery->status == POWER_SUPPLY_STATUS_CHARGING) {
1424                                 sec_bat_set_charge(battery, false);
1425                                 battery->status =
1426                                         POWER_SUPPLY_STATUS_DISCHARGING;
1427                         }
1428                         break;
1429                 case 2:
1430                         if(battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
1431                                 sec_bat_set_charge(battery, true);
1432                                 psy_do_property(battery->pdata->charger_name, get,
1433                                                 POWER_SUPPLY_PROP_STATUS, value);
1434                                 battery->status = value.intval;
1435                         }
1436                         battery->test_mode = 0;
1437                         break;
1438                 case 3: // clear temp block
1439                         battery->health = POWER_SUPPLY_HEALTH_GOOD;
1440                         battery->status = POWER_SUPPLY_STATUS_DISCHARGING;
1441                         break;
1442                 case 4:
1443                         if(battery->status == POWER_SUPPLY_STATUS_DISCHARGING) {
1444                                 sec_bat_set_charge(battery, true);
1445                                 psy_do_property(battery->pdata->charger_name, get,
1446                                                 POWER_SUPPLY_PROP_STATUS, value);
1447                                 battery->status = value.intval;
1448                         }
1449                         break;
1450                 default:
1451                         pr_info("%s: error test: unknown state\n", __func__);
1452                         break;
1453         }
1454 }
1455
1456 static bool sec_bat_time_management(
1457                                 struct sec_battery_info *battery)
1458 {
1459         unsigned long charging_time;
1460         struct timespec ts;
1461 #if defined(ANDROID_ALARM_ACTIVATED)
1462         ktime_t current_time;
1463
1464         current_time = alarm_get_elapsed_realtime();
1465         ts = ktime_to_timespec(current_time);
1466 #else
1467         get_monotonic_boottime(&ts);
1468 #endif
1469
1470         if (battery->charging_start_time == 0) {
1471                 dev_dbg(battery->dev,
1472                         "%s: Charging Disabled\n", __func__);
1473                 return true;
1474         }
1475
1476         if (ts.tv_sec >= battery->charging_start_time)
1477                 charging_time = ts.tv_sec - battery->charging_start_time;
1478         else
1479                 charging_time = 0xFFFFFFFF - battery->charging_start_time
1480                     + ts.tv_sec;
1481
1482         battery->charging_passed_time = charging_time;
1483
1484         dev_dbg(battery->dev,
1485                 "%s: Charging Time : %ld secs\n", __func__,
1486                 battery->charging_passed_time);
1487
1488         switch (battery->status) {
1489         case POWER_SUPPLY_STATUS_FULL:
1490                 if (battery->is_recharging && (charging_time >
1491                         battery->pdata->recharging_total_time)) {
1492                         dev_info(battery->dev,
1493                                 "%s: Recharging Timer Expired\n", __func__);
1494                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1495                         battery->is_recharging = false;
1496                         if (sec_bat_set_charge(battery, false)) {
1497                                 dev_err(battery->dev,
1498                                         "%s: Fail to Set Charger\n", __func__);
1499                                 return true;
1500                         }
1501
1502                         return false;
1503                 }
1504                 break;
1505         case POWER_SUPPLY_STATUS_CHARGING:
1506                 if ((battery->pdata->full_condition_type &
1507                         SEC_BATTERY_FULL_CONDITION_NOTIMEFULL) &&
1508                         (battery->is_recharging && (charging_time >
1509                         battery->pdata->recharging_total_time))) {
1510                         dev_info(battery->dev,
1511                         "%s: Recharging Timer Expired\n", __func__);
1512                         if (battery->capacity >= 100)
1513                                 battery->status = POWER_SUPPLY_STATUS_FULL;
1514                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1515                         battery->is_recharging = false;
1516                         if (sec_bat_set_charge(battery, false)) {
1517                                 dev_err(battery->dev,
1518                                         "%s: Fail to Set Charger\n", __func__);
1519                                 return true;
1520                         }
1521                         return false;
1522                 } else if (!battery->is_recharging &&
1523                         (charging_time > battery->pdata->charging_total_time)) {
1524                         dev_info(battery->dev,
1525                                 "%s: Charging Timer Expired\n", __func__);
1526                         if (battery->pdata->full_condition_type &
1527                                 SEC_BATTERY_FULL_CONDITION_NOTIMEFULL) {
1528                                 if (battery->capacity >= 100)
1529                                         battery->status =
1530                                                 POWER_SUPPLY_STATUS_FULL;
1531                         } else
1532                                 battery->status = POWER_SUPPLY_STATUS_FULL;
1533                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1534                         if (sec_bat_set_charge(battery, false)) {
1535                                 dev_err(battery->dev,
1536                                         "%s: Fail to Set Charger\n", __func__);
1537                                 return true;
1538                         }
1539
1540                         return false;
1541                 }
1542                 if (battery->pdata->charging_reset_time) {
1543                         if (charging_time > battery->charging_next_time) {
1544                                 /*reset current in charging status */
1545                                 battery->charging_next_time =
1546                                         battery->charging_passed_time +
1547                                         (battery->pdata->charging_reset_time);
1548
1549                                 dev_dbg(battery->dev,
1550                                         "%s: Reset charging current\n",
1551                                         __func__);
1552                                 if (sec_bat_set_charge(battery, true)) {
1553                                         dev_err(battery->dev,
1554                                                 "%s: Fail to Set Charger\n",
1555                                                 __func__);
1556                                         return true;
1557                                 }
1558                         }
1559                 }
1560                 break;
1561         default:
1562                 dev_err(battery->dev,
1563                         "%s: Undefine Battery Status\n", __func__);
1564                 return true;
1565         }
1566
1567         return true;
1568 }
1569
1570 static bool sec_bat_check_fullcharged(
1571                                 struct sec_battery_info *battery)
1572 {
1573         union power_supply_propval value;
1574         int current_adc;
1575         int full_check_type;
1576         bool ret;
1577         int err;
1578
1579         ret = false;
1580
1581         if (!sec_bat_check_fullcharged_condition(battery))
1582                 goto not_full_charged;
1583
1584         if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST)
1585                 full_check_type = battery->pdata->full_check_type;
1586         else
1587                 full_check_type = battery->pdata->full_check_type_2nd;
1588
1589         pr_info("%s:full check type[%d], current_avg[%d]", __func__,
1590                 full_check_type, battery->current_avg);
1591         switch (full_check_type) {
1592         case SEC_BATTERY_FULLCHARGED_ADC:
1593                 current_adc =
1594                         sec_bat_get_adc_value(battery,
1595                         SEC_BAT_ADC_CHANNEL_FULL_CHECK);
1596
1597                 dev_dbg(battery->dev,
1598                         "%s: Current ADC (%d)\n",
1599                         __func__, current_adc);
1600
1601                 if (current_adc < 0)
1602                         break;
1603                 battery->current_adc = current_adc;
1604
1605                 if (battery->current_adc <
1606                         (battery->charging_mode ==
1607                         SEC_BATTERY_CHARGING_1ST ?
1608                         battery->pdata->charging_current[
1609                         battery->cable_type].full_check_current_1st :
1610                         battery->pdata->charging_current[
1611                         battery->cable_type].full_check_current_2nd)) {
1612                         battery->full_check_cnt++;
1613                         dev_dbg(battery->dev,
1614                                 "%s: Full Check ADC (%d)\n",
1615                                 __func__,
1616                                 battery->full_check_cnt);
1617                 } else
1618                         battery->full_check_cnt = 0;
1619                 break;
1620
1621         case SEC_BATTERY_FULLCHARGED_FG_CURRENT:
1622                 if ((battery->current_now > 20 && battery->current_now <
1623                         battery->pdata->charging_current[
1624                         battery->cable_type].full_check_current_1st) &&
1625                         (battery->current_avg > 20 && battery->current_avg <
1626                         (battery->charging_mode ==
1627                         SEC_BATTERY_CHARGING_1ST ?
1628                         battery->pdata->charging_current[
1629                         battery->cable_type].full_check_current_1st :
1630                         battery->pdata->charging_current[
1631                         battery->cable_type].full_check_current_2nd))) {
1632                                 battery->full_check_cnt++;
1633                                 dev_info(battery->dev,
1634                                 "%s: Full Check Current (%d)\n",
1635                                 __func__,
1636                                 battery->full_check_cnt);
1637                 } else
1638                         battery->full_check_cnt = 0;
1639                 break;
1640
1641         case SEC_BATTERY_FULLCHARGED_TIME:
1642                 if ((battery->charging_mode ==
1643                         SEC_BATTERY_CHARGING_2ND ?
1644                         (battery->charging_passed_time -
1645                         battery->charging_fullcharged_time) :
1646                         battery->charging_passed_time) >
1647                         (battery->charging_mode ==
1648                         SEC_BATTERY_CHARGING_1ST ?
1649                         battery->pdata->charging_current[
1650                         battery->cable_type].full_check_current_1st :
1651                         battery->pdata->charging_current[
1652                         battery->cable_type].full_check_current_2nd)) {
1653                         battery->full_check_cnt++;
1654                         dev_dbg(battery->dev,
1655                                 "%s: Full Check Time (%d)\n",
1656                                 __func__,
1657                                 battery->full_check_cnt);
1658                 } else
1659                         battery->full_check_cnt = 0;
1660                 break;
1661
1662         case SEC_BATTERY_FULLCHARGED_SOC:
1663                 if (battery->capacity <=
1664                         (battery->charging_mode ==
1665                         SEC_BATTERY_CHARGING_1ST ?
1666                         battery->pdata->charging_current[
1667                         battery->cable_type].full_check_current_1st :
1668                         battery->pdata->charging_current[
1669                         battery->cable_type].full_check_current_2nd)) {
1670                         battery->full_check_cnt++;
1671                         dev_dbg(battery->dev,
1672                                 "%s: Full Check SOC (%d)\n",
1673                                 __func__,
1674                                 battery->full_check_cnt);
1675                 } else
1676                         battery->full_check_cnt = 0;
1677                 break;
1678
1679         case SEC_BATTERY_FULLCHARGED_CHGGPIO:
1680                 err = gpio_request(
1681                         battery->pdata->chg_gpio_full_check,
1682                         "GPIO_CHG_FULL");
1683                 if (err) {
1684                         dev_err(battery->dev,
1685                                 "%s: Error in Request of GPIO\n", __func__);
1686                         break;
1687                 }
1688                 if (!(gpio_get_value_cansleep(
1689                         battery->pdata->chg_gpio_full_check) ^
1690                         !battery->pdata->chg_polarity_full_check)) {
1691                         battery->full_check_cnt++;
1692                         dev_dbg(battery->dev,
1693                                 "%s: Full Check GPIO (%d)\n",
1694                                 __func__, battery->full_check_cnt);
1695                 } else
1696                         battery->full_check_cnt = 0;
1697                 gpio_free(battery->pdata->chg_gpio_full_check);
1698                 break;
1699
1700         case SEC_BATTERY_FULLCHARGED_CHGINT:
1701         case SEC_BATTERY_FULLCHARGED_CHGPSY:
1702                 {
1703                         psy_do_property(battery->pdata->charger_name, get,
1704                                 POWER_SUPPLY_PROP_STATUS, value);
1705
1706                         if (value.intval == POWER_SUPPLY_STATUS_FULL) {
1707                                 battery->full_check_cnt++;
1708                                 dev_info(battery->dev,
1709                                         "%s: Full Check Charger (%d)\n",
1710                                         __func__, battery->full_check_cnt);
1711                         } else {
1712                                 battery->full_check_cnt = 0;
1713                         }
1714                 }
1715                 break;
1716
1717         /* If these is NOT full check type or NONE full check type,
1718          * it is full-charged
1719          */
1720         case SEC_BATTERY_FULLCHARGED_NONE:
1721                 battery->full_check_cnt = 0;
1722                 ret = true;
1723                 break;
1724         default:
1725                 dev_err(battery->dev,
1726                         "%s: Invalid Full Check\n", __func__);
1727                 break;
1728         }
1729
1730         if (battery->full_check_cnt >=
1731                 battery->pdata->full_check_count) {
1732                 battery->full_check_cnt = 0;
1733                 ret = true;
1734         }
1735
1736 not_full_charged:
1737         return ret;
1738 }
1739
1740 static void sec_bat_do_fullcharged(
1741                                 struct sec_battery_info *battery)
1742 {
1743         union power_supply_propval value;
1744
1745 #if defined(CONFIG_BATTERY_SWELLING)
1746         if (battery->swelling_mode != SEC_BATTERY_NORMAL_MODE) {
1747                 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1748                 battery->is_recharging = false;
1749                 sec_bat_set_charge(battery, false);
1750                 battery->swelling_block = true;
1751                 pr_info("%s: stop charging (full) in swelling mode[%d]",
1752                         __func__, battery->swelling_mode);
1753         } else
1754 #endif
1755         {
1756                 /* To let charger/fuel gauge know the full status,
1757                  * set status before calling sec_bat_set_charge()
1758                  */
1759                 battery->status = POWER_SUPPLY_STATUS_FULL;
1760
1761                 if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST) {
1762                         battery->charging_mode = SEC_BATTERY_CHARGING_2ND;
1763                         battery->charging_fullcharged_time =
1764                                 battery->charging_passed_time;
1765                         sec_bat_set_charge(battery, true);
1766                 } else {
1767                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
1768                         battery->is_recharging = false;
1769                         sec_bat_set_charge(battery, false);
1770
1771                         value.intval = POWER_SUPPLY_STATUS_FULL;
1772                         psy_do_property(battery->pdata->fuelgauge_name, set,
1773                                 POWER_SUPPLY_PROP_STATUS, value);
1774                 }
1775         }
1776         /* platform can NOT get information of battery
1777          * because wakeup time is too short to check uevent
1778          * To make sure that target is wakeup if full-charged,
1779          * activated wake lock in a few seconds
1780          */
1781         if (battery->pdata->polling_type == SEC_BATTERY_MONITOR_ALARM)
1782                 wake_lock_timeout(&battery->vbus_wake_lock, HZ * 10);
1783 }
1784
1785 static bool sec_bat_fullcharged_check(
1786                                 struct sec_battery_info *battery)
1787 {
1788         if ((battery->charging_mode == SEC_BATTERY_CHARGING_NONE) ||
1789                 (battery->status == POWER_SUPPLY_STATUS_NOT_CHARGING)) {
1790                 dev_dbg(battery->dev,
1791                         "%s: No Need to Check Full-Charged\n", __func__);
1792                 return true;
1793         }
1794
1795         if (sec_bat_check_fullcharged(battery))
1796                 sec_bat_do_fullcharged(battery);
1797
1798         dev_info(battery->dev,
1799                 "%s: Charging Mode : %s\n", __func__,
1800                 battery->is_recharging ?
1801                 sec_bat_charging_mode_str[SEC_BATTERY_CHARGING_RECHARGING] :
1802                 sec_bat_charging_mode_str[battery->charging_mode]);
1803
1804         return true;
1805 }
1806
1807 #if defined(CONFIG_TOUCHSCREEN_IST30XXA)
1808 int battery_temp;
1809 #endif
1810
1811 static void sec_bat_get_battery_info(
1812                                 struct sec_battery_info *battery)
1813 {
1814         union power_supply_propval value;
1815
1816         psy_do_property(battery->pdata->fuelgauge_name, get,
1817                 POWER_SUPPLY_PROP_VOLTAGE_NOW, value);
1818         battery->voltage_now = value.intval;
1819
1820         value.intval = SEC_BATTEY_VOLTAGE_AVERAGE;
1821         psy_do_property(battery->pdata->fuelgauge_name, get,
1822                 POWER_SUPPLY_PROP_VOLTAGE_AVG, value);
1823         battery->voltage_avg = value.intval;
1824
1825         value.intval = SEC_BATTEY_VOLTAGE_OCV;
1826         psy_do_property(battery->pdata->fuelgauge_name, get,
1827                 POWER_SUPPLY_PROP_VOLTAGE_AVG, value);
1828         battery->voltage_ocv = value.intval;
1829
1830         value.intval = SEC_BATTEY_CURRENT_MA;
1831         psy_do_property(battery->pdata->fuelgauge_name, get,
1832                 POWER_SUPPLY_PROP_CURRENT_NOW, value);
1833         battery->current_now = value.intval;
1834
1835         value.intval = SEC_BATTEY_CURRENT_MA;
1836         psy_do_property(battery->pdata->fuelgauge_name, get,
1837                 POWER_SUPPLY_PROP_CURRENT_AVG, value);
1838         battery->current_avg = value.intval;
1839
1840         /* input current limit in charger */
1841         psy_do_property(battery->pdata->charger_name, get,
1842                 POWER_SUPPLY_PROP_CURRENT_MAX, value);
1843         battery->current_max = value.intval;
1844
1845         /* To get SOC value (NOT raw SOC), need to reset value */
1846         value.intval = 0;
1847         psy_do_property(battery->pdata->fuelgauge_name, get,
1848                 POWER_SUPPLY_PROP_CAPACITY, value);
1849         battery->capacity = value.intval;
1850 #if defined(CONFIG_MACH_CORSICA_VE)
1851         if (get_hw_rev() < 0x2) {
1852                 dev_info(battery->dev,
1853                                 "%s: get_hw_rev (%d)\n",
1854                                 __func__, get_hw_rev());
1855                 battery->capacity = 50;
1856                 battery->voltage_ocv = 4000;
1857                 battery->voltage_avg = 4000;
1858                 battery->voltage_now = 4000;
1859         }
1860 #endif
1861
1862         switch (battery->pdata->thermal_source) {
1863         case SEC_BATTERY_THERMAL_SOURCE_FG:
1864                 psy_do_property(battery->pdata->fuelgauge_name, get,
1865                         POWER_SUPPLY_PROP_TEMP, value);
1866                 battery->temperature = value.intval;
1867
1868                 psy_do_property(battery->pdata->fuelgauge_name, get,
1869                         POWER_SUPPLY_PROP_TEMP_AMBIENT, value);
1870                 battery->temper_amb = value.intval;
1871                 break;
1872         case SEC_BATTERY_THERMAL_SOURCE_CALLBACK:
1873                 if (battery->pdata->get_temperature_callback) {
1874                         battery->pdata->get_temperature_callback(
1875                                 POWER_SUPPLY_PROP_TEMP, &value);
1876                         battery->temperature = value.intval;
1877                         psy_do_property(battery->pdata->fuelgauge_name, set,
1878                                         POWER_SUPPLY_PROP_TEMP, value);
1879
1880                         battery->pdata->get_temperature_callback(
1881                                 POWER_SUPPLY_PROP_TEMP_AMBIENT, &value);
1882                         battery->temper_amb = value.intval;
1883                         psy_do_property(battery->pdata->fuelgauge_name, set,
1884                                         POWER_SUPPLY_PROP_TEMP_AMBIENT, value);
1885                 }
1886                 break;
1887         case SEC_BATTERY_THERMAL_SOURCE_ADC:
1888                 sec_bat_get_temperature_by_adc(battery,
1889                         POWER_SUPPLY_PROP_TEMP, &value);
1890                 battery->temperature = value.intval;
1891                 psy_do_property(battery->pdata->fuelgauge_name, set,
1892                         POWER_SUPPLY_PROP_TEMP, value);
1893
1894                 sec_bat_get_temperature_by_adc(battery,
1895                         POWER_SUPPLY_PROP_TEMP_AMBIENT, &value);
1896                 battery->temper_amb = value.intval;
1897                 psy_do_property(battery->pdata->fuelgauge_name, set,
1898                         POWER_SUPPLY_PROP_TEMP_AMBIENT, value);
1899                 break;
1900         default:
1901                 break;
1902         }
1903
1904 #if defined(CONFIG_TOUCHSCREEN_IST30XXA)
1905         battery_temp = battery->temperature;
1906 #endif
1907
1908         dev_info(battery->dev,
1909                 "%s:Vnow(%dmV),Inow(%dmA),Imax(%dmA),SOC(%d%%),Tbat(%d)\n",
1910                 __func__,
1911                 battery->voltage_now, battery->current_now,
1912                 battery->current_max, battery->capacity, battery->temperature);
1913         dev_dbg(battery->dev,
1914                 "%s,Vavg(%dmV),Vocv(%dmV),Tamb(%d),"
1915                 "Iavg(%dmA),Iadc(%d)\n",
1916                 battery->present ? "Connected" : "Disconnected",
1917                 battery->voltage_avg, battery->voltage_ocv,
1918                 battery->temper_amb,
1919                 battery->current_avg, battery->current_adc);
1920 }
1921
1922 static void sec_bat_polling_work(struct work_struct *work)
1923 {
1924         struct sec_battery_info *battery = container_of(
1925                 work, struct sec_battery_info, polling_work.work);
1926
1927         wake_lock(&battery->monitor_wake_lock);
1928         queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
1929         dev_dbg(battery->dev, "%s: Activated\n", __func__);
1930 }
1931
1932 static void sec_bat_program_alarm(
1933                                 struct sec_battery_info *battery, int seconds)
1934 {
1935 #if defined(ANDROID_ALARM_ACTIVATED)
1936         ktime_t low_interval = ktime_set(seconds, 0);
1937         ktime_t slack = ktime_set(10, 0);
1938         ktime_t next;
1939
1940         next = ktime_add(battery->last_poll_time, low_interval);
1941         alarm_start_range(&battery->polling_alarm,
1942                 next, ktime_add(next, slack));
1943 #else
1944         alarm_start(&battery->polling_alarm,
1945                     ktime_add(battery->last_poll_time, ktime_set(seconds, 0)));
1946 #endif
1947 }
1948
1949
1950 static unsigned int sec_bat_get_polling_time(
1951         struct sec_battery_info *battery)
1952 {
1953         if (battery->status ==
1954                 POWER_SUPPLY_STATUS_FULL)
1955                 battery->polling_time =
1956                         battery->pdata->polling_time[
1957                         POWER_SUPPLY_STATUS_CHARGING];
1958         else
1959                 battery->polling_time =
1960                         battery->pdata->polling_time[
1961                         battery->status];
1962
1963         battery->polling_short = true;
1964
1965         switch (battery->status) {
1966         case POWER_SUPPLY_STATUS_CHARGING:
1967                 if (battery->polling_in_sleep)
1968                         battery->polling_short = false;
1969                 break;
1970         case POWER_SUPPLY_STATUS_DISCHARGING:
1971                 if (battery->polling_in_sleep)
1972                         battery->polling_time =
1973                                 battery->pdata->polling_time[
1974                                 SEC_BATTERY_POLLING_TIME_SLEEP];
1975                 else
1976                         battery->polling_time =
1977                                 battery->pdata->polling_time[
1978                                 battery->status];
1979                 battery->polling_short = false;
1980                 break;
1981         case POWER_SUPPLY_STATUS_FULL:
1982                 if (battery->polling_in_sleep) {
1983                         if (!(battery->pdata->full_condition_type &
1984                                 SEC_BATTERY_FULL_CONDITION_NOSLEEPINFULL) &&
1985                                 battery->charging_mode ==
1986                                 SEC_BATTERY_CHARGING_NONE)
1987                                 battery->polling_time =
1988                                         battery->pdata->polling_time[
1989                                                 SEC_BATTERY_POLLING_TIME_SLEEP];
1990                         battery->polling_short = false;
1991                 } else {
1992                         if (battery->charging_mode ==
1993                                 SEC_BATTERY_CHARGING_NONE)
1994                                 battery->polling_short = false;
1995                 }
1996                 break;
1997         }
1998
1999         if (battery->polling_short)
2000                 return battery->pdata->polling_time[
2001                         SEC_BATTERY_POLLING_TIME_BASIC];
2002         else
2003                 return battery->polling_time;
2004 }
2005
2006 static bool sec_bat_is_short_polling(
2007         struct sec_battery_info *battery)
2008 {
2009         /* Change the full and short monitoring sequence
2010          * Originally, full monitoring was the last time of polling_count
2011          * But change full monitoring to first time
2012          * because temperature check is too late
2013          */
2014         if (!battery->polling_short || battery->polling_count == 1)
2015                 return false;
2016         else
2017                 return true;
2018 }
2019
2020 static void sec_bat_update_polling_count(
2021         struct sec_battery_info *battery)
2022 {
2023         /* do NOT change polling count in sleep
2024          * even though it is short polling
2025          * to keep polling count along sleep/wakeup
2026          */
2027         if (battery->polling_short && battery->polling_in_sleep)
2028                 return;
2029
2030         if (battery->polling_short &&
2031                 ((battery->polling_time /
2032                 battery->pdata->polling_time[
2033                 SEC_BATTERY_POLLING_TIME_BASIC])
2034                 > battery->polling_count))
2035                 battery->polling_count++;
2036         else
2037                 battery->polling_count = 1;     /* initial value = 1 */
2038 }
2039
2040 static void sec_bat_set_polling(
2041         struct sec_battery_info *battery)
2042 {
2043         unsigned int polling_time_temp;
2044
2045         dev_dbg(battery->dev, "%s: Start\n", __func__);
2046
2047         polling_time_temp = sec_bat_get_polling_time(battery);
2048
2049         dev_dbg(battery->dev,
2050                 "%s: Status:%s, Sleep:%s, Charging:%s, Short Poll:%s\n",
2051                 __func__, sec_bat_status_str[battery->status],
2052                 battery->polling_in_sleep ? "Yes" : "No",
2053                 (battery->charging_mode ==
2054                 SEC_BATTERY_CHARGING_NONE) ? "No" : "Yes",
2055                 battery->polling_short ? "Yes" : "No");
2056         dev_dbg(battery->dev,
2057                 "%s: Polling time %d/%d sec.\n", __func__,
2058                 battery->polling_short ?
2059                 (polling_time_temp * battery->polling_count) :
2060                 polling_time_temp, battery->polling_time);
2061
2062         /* To sync with log above,
2063          * change polling count after log is displayed
2064          * Do NOT update polling count in initial monitor
2065          */
2066         if (!battery->pdata->monitor_initial_count)
2067                 sec_bat_update_polling_count(battery);
2068         else
2069                 dev_dbg(battery->dev,
2070                         "%s: Initial monitor %d times left.\n", __func__,
2071                         battery->pdata->monitor_initial_count);
2072
2073         switch (battery->pdata->polling_type) {
2074         case SEC_BATTERY_MONITOR_WORKQUEUE:
2075                 if (battery->pdata->monitor_initial_count) {
2076                         battery->pdata->monitor_initial_count--;
2077                         schedule_delayed_work(&battery->polling_work, HZ);
2078                 } else
2079                         schedule_delayed_work(&battery->polling_work,
2080                                 polling_time_temp * HZ);
2081                 break;
2082         case SEC_BATTERY_MONITOR_ALARM:
2083 #if defined(ANDROID_ALARM_ACTIVATED)
2084                 battery->last_poll_time = alarm_get_elapsed_realtime();
2085 #else
2086                 battery->last_poll_time = ktime_get_boottime();
2087 #endif
2088
2089                 if (battery->pdata->monitor_initial_count) {
2090                         battery->pdata->monitor_initial_count--;
2091                         sec_bat_program_alarm(battery, 1);
2092                 } else
2093                         sec_bat_program_alarm(battery, polling_time_temp);
2094                 break;
2095         case SEC_BATTERY_MONITOR_TIMER:
2096                 break;
2097         default:
2098                 break;
2099         }
2100         dev_dbg(battery->dev, "%s: End\n", __func__);
2101 }
2102
2103 static void sec_bat_monitor_work(
2104                                 struct work_struct *work)
2105 {
2106         struct sec_battery_info *battery =
2107                 container_of(work, struct sec_battery_info,
2108                 monitor_work.work);
2109
2110         dev_dbg(battery->dev, "%s: Start\n", __func__);
2111
2112 /*#if !defined(ANDROID_ALARM_ACTIVATED)
2113         alarm_cancel(&battery->polling_alarm);
2114 #endif *//* ANDROID_ALARM_ACTIVATED */
2115
2116         /* monitor once after wakeup */
2117         if (battery->polling_in_sleep)
2118                 battery->polling_in_sleep = false;
2119
2120         sec_bat_get_battery_info(battery);
2121
2122         /* 0. test mode */
2123         if (battery->test_mode) {
2124                 dev_dbg(battery->dev, "%s: Test Mode\n", __func__);
2125                 sec_bat_do_test_function(battery);
2126                 if (battery->test_mode != 0)
2127                         goto continue_monitor;
2128         }
2129
2130         /* 1. battery check */
2131         if (!sec_bat_battery_cable_check(battery))
2132                 goto continue_monitor;
2133
2134         /* 2. voltage check */
2135         if (!sec_bat_voltage_check(battery))
2136                 goto continue_monitor;
2137
2138         /* monitor short routine in initial monitor */
2139         if (battery->pdata->monitor_initial_count ||
2140                 sec_bat_is_short_polling(battery))
2141                 goto continue_monitor;
2142
2143         /* 3. time management */
2144         if (!sec_bat_time_management(battery))
2145                 goto continue_monitor;
2146
2147         /* 4. temperature check */
2148         if (!sec_bat_temperature_check(battery))
2149                 goto continue_monitor;
2150
2151 #if defined(CONFIG_BATTERY_SWELLING)
2152         sec_bat_swelling_check(battery, battery->temperature);
2153 #endif
2154
2155         /* 5. full charging check */
2156         sec_bat_fullcharged_check(battery);
2157
2158         /* 6. additional check */
2159         if (battery->pdata->monitor_additional_check)
2160                 battery->pdata->monitor_additional_check();
2161
2162 continue_monitor:
2163         dev_info(battery->dev,
2164                 "%s: Status(%s), mode(%s), Health(%s), Cable(%d), siop_level(%d)\n",
2165                 __func__,
2166                 sec_bat_status_str[battery->status],
2167                 sec_bat_charging_mode_str[battery->charging_mode],
2168                 sec_bat_health_str[battery->health],
2169                 battery->cable_type, battery->siop_level);
2170
2171 #if defined(CONFIG_SAMSUNG_BATTERY_ENG_TEST)
2172         dev_info(battery->dev,
2173                         "%s: battery->stability_test(%d), battery->eng_not_full_status(%d)\n",
2174                         __func__, battery->stability_test, battery->eng_not_full_status);
2175 #endif
2176         power_supply_changed(&battery->psy_bat);
2177
2178         sec_bat_set_polling(battery);
2179
2180         if (battery->capacity <= 0)
2181                 wake_lock_timeout(&battery->monitor_wake_lock, HZ * 5);
2182         else
2183                 wake_unlock(&battery->monitor_wake_lock);
2184
2185         dev_dbg(battery->dev, "%s: End\n", __func__);
2186
2187         return;
2188 }
2189
2190 #if defined(ANDROID_ALARM_ACTIVATED)
2191 static void sec_bat_alarm(struct alarm *alarm)
2192 #else
2193 static enum alarmtimer_restart sec_bat_alarm(
2194         struct alarm *alarm, ktime_t now)
2195
2196 #endif
2197 {
2198         struct sec_battery_info *battery = container_of(alarm,
2199                                 struct sec_battery_info, polling_alarm);
2200
2201         dev_dbg(battery->dev,
2202                         "%s\n", __func__);
2203
2204         /* In wake up, monitor work will be queued in complete function
2205          * To avoid duplicated queuing of monitor work,
2206          * do NOT queue monitor work in wake up by polling alarm
2207          */
2208         if (!battery->polling_in_sleep) {
2209                 wake_lock(&battery->monitor_wake_lock);
2210                 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
2211                 dev_dbg(battery->dev, "%s: Activated\n", __func__);
2212         }
2213 #if !defined(ANDROID_ALARM_ACTIVATED)
2214         return ALARMTIMER_NORESTART;
2215 #endif
2216 }
2217
2218
2219 static void sec_bat_cable_work(struct work_struct *work)
2220 {
2221         struct sec_battery_info *battery = container_of(work,
2222                                 struct sec_battery_info, cable_work);
2223         union power_supply_propval val;
2224         int wl_cur, wr_cur, current_cable_type;
2225
2226         dev_info(battery->dev, "%s: Start\n", __func__);
2227
2228         wl_cur = battery->pdata->charging_current[
2229                 POWER_SUPPLY_TYPE_WIRELESS].input_current_limit;
2230         wr_cur = battery->pdata->charging_current[
2231                 battery->wire_status].input_current_limit;
2232         if (battery->wc_status && battery->wc_enable &&
2233                         (wl_cur > wr_cur))
2234                 current_cable_type = POWER_SUPPLY_TYPE_WIRELESS;
2235         else
2236                 current_cable_type = battery->wire_status;
2237
2238         if (current_cable_type == battery->cable_type) {
2239                 dev_info(battery->dev,
2240                                 "%s: Cable is NOT Changed(%d)\n",
2241                                 __func__, battery->cable_type);
2242                 /* Do NOT activate cable work for NOT changed */
2243                 goto end_of_cable_work;
2244         }
2245
2246         battery->cable_type = current_cable_type;
2247         if (battery->pdata->check_cable_result_callback)
2248                 battery->pdata->check_cable_result_callback(
2249                         battery->cable_type);
2250         /* platform can NOT get information of cable connection
2251          * because wakeup time is too short to check uevent
2252          * To make sure that target is wakeup
2253          * if cable is connected and disconnected,
2254          * activated wake lock in a few seconds
2255          */
2256         wake_lock_timeout(&battery->vbus_wake_lock, HZ * 10);
2257
2258         if (battery->cable_type == POWER_SUPPLY_TYPE_BATTERY ||
2259                 ((battery->pdata->cable_check_type &
2260                 SEC_BATTERY_CABLE_CHECK_NOINCOMPATIBLECHARGE) &&
2261                 battery->cable_type == POWER_SUPPLY_TYPE_UNKNOWN)) {
2262                 if (battery->status == POWER_SUPPLY_STATUS_FULL) {
2263                         val.intval = POWER_SUPPLY_TYPE_BATTERY;
2264                         psy_do_property(battery->pdata->fuelgauge_name, set,
2265                                         POWER_SUPPLY_PROP_CHARGE_FULL, val);
2266                         /* To get SOC value (NOT raw SOC), need to reset value */
2267                         val.intval = 0;
2268                         psy_do_property(battery->pdata->fuelgauge_name, get,
2269                                         POWER_SUPPLY_PROP_CAPACITY, val);
2270                         battery->capacity = val.intval;
2271                 }
2272                 battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
2273                 battery->is_recharging = false;
2274                 battery->status = POWER_SUPPLY_STATUS_DISCHARGING;
2275                 battery->health = POWER_SUPPLY_HEALTH_GOOD;
2276
2277                 if (sec_bat_set_charge(battery, false))
2278                         goto end_of_cable_work;
2279         } else {
2280                 /* Do NOT display the charging icon when OTG is enabled */
2281                 if (battery->cable_type == POWER_SUPPLY_TYPE_OTG) {
2282                         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
2283                         battery->status = POWER_SUPPLY_STATUS_DISCHARGING;
2284                 } else {
2285                         if (battery->pdata->full_check_type !=
2286                                 SEC_BATTERY_FULLCHARGED_NONE)
2287                                 battery->charging_mode =
2288                                         SEC_BATTERY_CHARGING_1ST;
2289                         else
2290                                 battery->charging_mode =
2291                                         SEC_BATTERY_CHARGING_2ND;
2292                         battery->status = POWER_SUPPLY_STATUS_CHARGING;
2293                 }
2294
2295                 if (sec_bat_set_charge(battery, true))
2296                         goto end_of_cable_work;
2297
2298 #if defined(ANDROID_ALARM_ACTIVATED)
2299                 /* No need for wakelock in Alarm */
2300                 if (battery->pdata->polling_type != SEC_BATTERY_MONITOR_ALARM)
2301                         wake_lock(&battery->vbus_wake_lock);
2302 #endif
2303         }
2304
2305         /* polling time should be reset when cable is changed
2306          * polling_in_sleep should be reset also
2307          * before polling time is re-calculated
2308          * to prevent from counting 1 for events
2309          * right after cable is connected
2310          */
2311         battery->polling_in_sleep = false;
2312         sec_bat_get_polling_time(battery);
2313
2314         dev_info(battery->dev,
2315                 "%s: Status:%s, Sleep:%s, Charging:%s, Short Poll:%s\n",
2316                 __func__, sec_bat_status_str[battery->status],
2317                 battery->polling_in_sleep ? "Yes" : "No",
2318                 (battery->charging_mode ==
2319                 SEC_BATTERY_CHARGING_NONE) ? "No" : "Yes",
2320                 battery->polling_short ? "Yes" : "No");
2321         dev_info(battery->dev,
2322                 "%s: Polling time is reset to %d sec.\n", __func__,
2323                 battery->polling_time);
2324
2325         battery->polling_count = 1;     /* initial value = 1 */
2326
2327         wake_lock(&battery->monitor_wake_lock);
2328         queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work,
2329                                         msecs_to_jiffies(500));
2330         power_supply_changed(&battery->psy_bat);
2331 end_of_cable_work:
2332         wake_unlock(&battery->cable_wake_lock);
2333         dev_dbg(battery->dev, "%s: End\n", __func__);
2334 }
2335
2336 ssize_t sec_bat_show_attrs(struct device *dev,
2337                                   struct device_attribute *attr, char *buf)
2338 {
2339         struct power_supply *psy = dev_get_drvdata(dev);
2340         struct sec_battery_info *battery =
2341                 container_of(psy, struct sec_battery_info, psy_bat);
2342         const ptrdiff_t offset = attr - sec_battery_attrs;
2343         union power_supply_propval value;
2344         int i = 0;
2345
2346         switch (offset) {
2347         case BATT_RESET_SOC:
2348                 break;
2349         case BATT_READ_RAW_SOC:
2350                 {
2351                         union power_supply_propval value;
2352
2353                         value.intval =
2354                                 SEC_FUELGAUGE_CAPACITY_TYPE_RAW;
2355                         psy_do_property(battery->pdata->fuelgauge_name, get,
2356                                 POWER_SUPPLY_PROP_CAPACITY, value);
2357
2358                         i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2359                                 value.intval);
2360                 }
2361                 break;
2362         case BATT_READ_ADJ_SOC:
2363                 break;
2364         case BATT_TYPE:
2365                 i += scnprintf(buf + i, PAGE_SIZE - i, "%s\n",
2366                         battery->pdata->vendor);
2367                 break;
2368         case BATT_VFOCV:
2369                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2370                         battery->voltage_ocv);
2371                 break;
2372         case BATT_VOL_ADC:
2373                 break;
2374         case BATT_VOL_ADC_CAL:
2375                 break;
2376         case BATT_VOL_AVER:
2377                 break;
2378         case BATT_VOL_ADC_AVER:
2379                 break;
2380
2381         case BATT_CURRENT_UA_NOW:
2382                 {
2383                         union power_supply_propval value;
2384
2385                         value.intval = SEC_BATTEY_CURRENT_UA;
2386                         psy_do_property(battery->pdata->fuelgauge_name, get,
2387                                 POWER_SUPPLY_PROP_CURRENT_NOW, value);
2388
2389                         i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2390                                 value.intval);
2391                 }
2392                 break;
2393         case BATT_CURRENT_UA_AVG:
2394                 {
2395                         union power_supply_propval value;
2396
2397                         value.intval = SEC_BATTEY_CURRENT_UA;
2398                         psy_do_property(battery->pdata->fuelgauge_name, get,
2399                                 POWER_SUPPLY_PROP_CURRENT_AVG, value);
2400
2401                         i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2402                                 value.intval);
2403                 }
2404                 break;
2405
2406         case BATT_TEMP:
2407                 switch (battery->pdata->thermal_source) {
2408                 case SEC_BATTERY_THERMAL_SOURCE_FG:
2409                         psy_do_property(battery->pdata->fuelgauge_name, get,
2410                                 POWER_SUPPLY_PROP_TEMP, value);
2411                         break;
2412                 case SEC_BATTERY_THERMAL_SOURCE_CALLBACK:
2413                         if (battery->pdata->get_temperature_callback) {
2414                                 battery->pdata->get_temperature_callback(
2415                                         POWER_SUPPLY_PROP_TEMP, &value);
2416                         }
2417                         break;
2418                 case SEC_BATTERY_THERMAL_SOURCE_ADC:
2419                         sec_bat_get_temperature_by_adc(battery,
2420                                 POWER_SUPPLY_PROP_TEMP, &value);
2421                         break;
2422                 default:
2423                         break;
2424                 }
2425                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2426                         value.intval);
2427                 break;
2428         case BATT_TEMP_ADC:
2429                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2430                         battery->temp_adc);
2431                 break;
2432         case BATT_TEMP_AVER:
2433                 break;
2434         case BATT_TEMP_ADC_AVER:
2435                 break;
2436         case BATT_VF_ADC:
2437                 break;
2438         case BATT_SLATE_MODE:
2439                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2440                         battery->slate_mode);
2441                 break;
2442
2443         case BATT_LP_CHARGING:
2444                 if (battery->pdata->is_lpm) {
2445                         i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2446                                        battery->pdata->is_lpm() ? 1 : 0);
2447                 }
2448                 break;
2449         case SIOP_ACTIVATED:
2450                 break;
2451         case SIOP_LEVEL:
2452                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2453                         battery->siop_level);
2454                 break;
2455         case BATT_CHARGING_SOURCE:
2456                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2457                         battery->cable_type);
2458                 break;
2459         case FG_REG_DUMP:
2460                 break;
2461         case FG_RESET_CAP:
2462                 break;
2463         case FG_CAPACITY:
2464         {
2465                 union power_supply_propval value;
2466
2467                 value.intval =
2468                         SEC_BATTEY_CAPACITY_DESIGNED;
2469                 psy_do_property(battery->pdata->fuelgauge_name, get,
2470                         POWER_SUPPLY_PROP_ENERGY_NOW, value);
2471
2472                 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x ",
2473                         value.intval);
2474
2475                 value.intval =
2476                         SEC_BATTEY_CAPACITY_ABSOLUTE;
2477                 psy_do_property(battery->pdata->fuelgauge_name, get,
2478                         POWER_SUPPLY_PROP_ENERGY_NOW, value);
2479
2480                 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x ",
2481                         value.intval);
2482
2483                 value.intval =
2484                         SEC_BATTEY_CAPACITY_TEMPERARY;
2485                 psy_do_property(battery->pdata->fuelgauge_name, get,
2486                         POWER_SUPPLY_PROP_ENERGY_NOW, value);
2487
2488                 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x ",
2489                         value.intval);
2490
2491                 value.intval =
2492                         SEC_BATTEY_CAPACITY_CURRENT;
2493                 psy_do_property(battery->pdata->fuelgauge_name, get,
2494                         POWER_SUPPLY_PROP_ENERGY_NOW, value);
2495
2496                 i += scnprintf(buf + i, PAGE_SIZE - i, "0x%04x\n",
2497                         value.intval);
2498         }
2499                 break;
2500         case AUTH:
2501                 break;
2502         case CHG_CURRENT_ADC:
2503                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2504                         battery->current_adc);
2505                 break;
2506         case WC_ADC:
2507                 break;
2508         case WC_STATUS:
2509                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2510                         (battery->cable_type == POWER_SUPPLY_TYPE_WIRELESS));
2511                 break;
2512         case WC_ENABLE:
2513                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2514                         battery->wc_enable);
2515                 break;
2516         case FACTORY_MODE:
2517                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2518                         battery->factory_mode);
2519                 break;
2520         case UPDATE:
2521                 break;
2522         case TEST_MODE:
2523                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2524                         battery->test_mode);
2525                 break;
2526
2527         case BATT_EVENT_CALL:
2528         case BATT_EVENT_2G_CALL:
2529         case BATT_EVENT_TALK_GSM:
2530                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2531                         (battery->event & EVENT_2G_CALL) ? 1 : 0);
2532                 break;
2533         case BATT_EVENT_3G_CALL:
2534         case BATT_EVENT_TALK_WCDMA:
2535                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2536                         (battery->event & EVENT_3G_CALL) ? 1 : 0);
2537                 break;
2538         case BATT_EVENT_MUSIC:
2539                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2540                         (battery->event & EVENT_MUSIC) ? 1 : 0);
2541                 break;
2542         case BATT_EVENT_VIDEO:
2543                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2544                         (battery->event & EVENT_VIDEO) ? 1 : 0);
2545                 break;
2546         case BATT_EVENT_BROWSER:
2547                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2548                         (battery->event & EVENT_BROWSER) ? 1 : 0);
2549                 break;
2550         case BATT_EVENT_HOTSPOT:
2551                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2552                         (battery->event & EVENT_HOTSPOT) ? 1 : 0);
2553                 break;
2554         case BATT_EVENT_CAMERA:
2555                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2556                         (battery->event & EVENT_CAMERA) ? 1 : 0);
2557                 break;
2558         case BATT_EVENT_CAMCORDER:
2559                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2560                         (battery->event & EVENT_CAMCORDER) ? 1 : 0);
2561                 break;
2562         case BATT_EVENT_DATA_CALL:
2563                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2564                         (battery->event & EVENT_DATA_CALL) ? 1 : 0);
2565                 break;
2566         case BATT_EVENT_WIFI:
2567                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2568                         (battery->event & EVENT_WIFI) ? 1 : 0);
2569                 break;
2570         case BATT_EVENT_WIBRO:
2571                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2572                         (battery->event & EVENT_WIBRO) ? 1 : 0);
2573                 break;
2574         case BATT_EVENT_LTE:
2575                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2576                         (battery->event & EVENT_LTE) ? 1 : 0);
2577                 break;
2578         case BATT_EVENT_LCD:
2579                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2580                         (battery->event & EVENT_LCD) ? 1 : 0);
2581                 break;
2582         case BATT_EVENT_GPS:
2583                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2584                         (battery->event & EVENT_GPS) ? 1 : 0);
2585                 break;
2586         case BATT_EVENT:
2587                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2588                         battery->event);
2589                 break;
2590 #if defined(CONFIG_SAMSUNG_BATTERY_ENG_TEST)
2591         case BATT_TEST_CHARGE_CURRENT:
2592                 {
2593                         union power_supply_propval value;
2594
2595                         psy_do_property(battery->pdata->charger_name, get,
2596                                 POWER_SUPPLY_PROP_CURRENT_NOW, value);
2597                         i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2598                                         value.intval);
2599                 }
2600                 break;
2601         case BATT_STABILITY_TEST:
2602                 i += scnprintf(buf + i, PAGE_SIZE - i, "%d\n",
2603                         battery->stability_test);
2604                 break;
2605 #endif
2606         default:
2607                 i = -EINVAL;
2608         }
2609
2610         return i;
2611 }
2612
2613 ssize_t sec_bat_store_attrs(
2614                                         struct device *dev,
2615                                         struct device_attribute *attr,
2616                                         const char *buf, size_t count)
2617 {
2618         struct power_supply *psy = dev_get_drvdata(dev);
2619         struct sec_battery_info *battery =
2620                 container_of(psy, struct sec_battery_info, psy_bat);
2621         const ptrdiff_t offset = attr - sec_battery_attrs;
2622         int ret = -EINVAL;
2623         int x = 0;
2624
2625         switch (offset) {
2626         case BATT_RESET_SOC:
2627                 /* Do NOT reset fuel gauge in charging mode */
2628                 if (battery->pdata->check_cable_callback &&
2629                     battery->pdata->check_jig_status) {
2630                         if ((battery->pdata->check_cable_callback(battery) ==
2631                              POWER_SUPPLY_TYPE_BATTERY) ||
2632                             battery->pdata->check_jig_status()) {
2633                                 union power_supply_propval value;
2634                                 battery->voltage_now = 1234;
2635                                 battery->voltage_avg = 1234;
2636                                 power_supply_changed(&battery->psy_bat);
2637
2638                                 value.intval =
2639                                         SEC_FUELGAUGE_CAPACITY_TYPE_RESET;
2640                                 psy_do_property(battery->pdata->fuelgauge_name, set,
2641                                                 POWER_SUPPLY_PROP_CAPACITY, value);
2642                                 dev_info(battery->dev,"do reset SOC\n");
2643                                 /* update battery info */
2644                                 sec_bat_get_battery_info(battery);
2645                         }
2646                 }
2647                 ret = count;
2648                 break;
2649         case BATT_READ_RAW_SOC:
2650                 break;
2651         case BATT_READ_ADJ_SOC:
2652                 break;
2653         case BATT_TYPE:
2654                 break;
2655         case BATT_VFOCV:
2656                 break;
2657         case BATT_VOL_ADC:
2658                 break;
2659         case BATT_VOL_ADC_CAL:
2660                 break;
2661         case BATT_VOL_AVER:
2662                 break;
2663         case BATT_VOL_ADC_AVER:
2664                 break;
2665         case BATT_CURRENT_UA_NOW:
2666                 break;
2667         case BATT_CURRENT_UA_AVG:
2668                 break;
2669         case BATT_TEMP:
2670                 break;
2671         case BATT_TEMP_ADC:
2672                 break;
2673         case BATT_TEMP_AVER:
2674                 break;
2675         case BATT_TEMP_ADC_AVER:
2676                 break;
2677         case BATT_VF_ADC:
2678                 break;
2679         case BATT_SLATE_MODE:
2680                 if (sscanf(buf, "%d\n", &x) == 1) {
2681                         union power_supply_propval value;
2682                         if (x == 1) {
2683                                 value.intval = POWER_SUPPLY_TYPE_BATTERY;
2684                                 battery->slate_mode = true;
2685                         } else if (x == 0) {
2686                                 value.intval = POWER_SUPPLY_TYPE_USB;
2687                                 battery->slate_mode = false;
2688                         } else {
2689                                 dev_info(battery->dev,
2690                                         "%s: SLATE MODE unknown command\n",
2691                                         __func__);
2692                                 return -EINVAL;
2693                         }
2694                         psy_do_property("battery", set,
2695                                         POWER_SUPPLY_PROP_ONLINE, value);
2696                         if (battery->slate_mode) {
2697                                 value.intval = 0;
2698                                 psy_do_property(battery->pdata->charger_name, set,
2699                                         POWER_SUPPLY_PROP_CURRENT_NOW,
2700                                         value);
2701                         }
2702                         ret = count;
2703                 }
2704                 break;
2705
2706         case BATT_LP_CHARGING:
2707                 break;
2708         case SIOP_ACTIVATED:
2709                 break;
2710         case SIOP_LEVEL:
2711                 if (sscanf(buf, "%d\n", &x) == 1) {
2712                         union power_supply_propval value;
2713                         dev_info(battery->dev,
2714                                 "%s: siop level: %d\n", __func__, x);
2715                         if (x >= 0 && x <= 100)
2716                                 battery->siop_level = x;
2717                         else
2718                                 battery->siop_level = 100;
2719                         value.intval = battery->siop_level;
2720                                 psy_do_property(battery->pdata->charger_name, set,
2721                                         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, value);
2722                                 ret = count;
2723                 }
2724                 break;
2725         case BATT_CHARGING_SOURCE:
2726                 break;
2727         case FG_REG_DUMP:
2728                 break;
2729         case FG_RESET_CAP:
2730                 break;
2731         case FG_CAPACITY:
2732                 break;
2733         case AUTH:
2734                 break;
2735         case CHG_CURRENT_ADC:
2736                 break;
2737         case WC_ADC:
2738                 break;
2739         case WC_STATUS:
2740                 break;
2741         case WC_ENABLE:
2742                 if (sscanf(buf, "%d\n", &x) == 1) {
2743                         if (x == 0) {
2744                                 battery->wc_enable = false;
2745                         } else if (x == 1) {
2746                                 battery->wc_enable = true;
2747                         } else {
2748                                 dev_info(battery->dev,
2749                                         "%s: WPC ENABLE unknown command\n",
2750                                         __func__);
2751                                 return -EINVAL;
2752                         }
2753                         wake_lock(&battery->cable_wake_lock);
2754                         queue_work(battery->monitor_wqueue,
2755                                         &battery->cable_work);
2756                         ret = count;
2757                 }
2758                 break;
2759         case FACTORY_MODE:
2760                 if (sscanf(buf, "%d\n", &x) == 1) {
2761                         battery->factory_mode = x ? true : false;
2762                         ret = count;
2763                 }
2764                 break;
2765         case UPDATE:
2766                 if (sscanf(buf, "%d\n", &x) == 1) {
2767                         /* update battery info */
2768                         sec_bat_get_battery_info(battery);
2769                         ret = count;
2770                 }
2771                 break;
2772         case TEST_MODE:
2773                 if (sscanf(buf, "%d\n", &x) == 1) {
2774                         battery->test_mode = x;
2775                         wake_lock(&battery->monitor_wake_lock);
2776                         queue_delayed_work(battery->monitor_wqueue,
2777                                 &battery->monitor_work, 0);
2778                         ret = count;
2779                 }
2780                 break;
2781
2782         case BATT_EVENT_CALL:
2783         case BATT_EVENT_2G_CALL:
2784         case BATT_EVENT_TALK_GSM:
2785                 if (sscanf(buf, "%d\n", &x) == 1) {
2786                         sec_bat_event_set(battery, EVENT_2G_CALL, x);
2787                         ret = count;
2788                 }
2789                 break;
2790         case BATT_EVENT_3G_CALL:
2791         case BATT_EVENT_TALK_WCDMA:
2792                 if (sscanf(buf, "%d\n", &x) == 1) {
2793                         sec_bat_event_set(battery, EVENT_3G_CALL, x);
2794                         ret = count;
2795                 }
2796                 break;
2797         case BATT_EVENT_MUSIC:
2798                 if (sscanf(buf, "%d\n", &x) == 1) {
2799                         sec_bat_event_set(battery, EVENT_MUSIC, x);
2800                         ret = count;
2801                 }
2802                 break;
2803         case BATT_EVENT_VIDEO:
2804                 if (sscanf(buf, "%d\n", &x) == 1) {
2805                         sec_bat_event_set(battery, EVENT_VIDEO, x);
2806                         ret = count;
2807                 }
2808                 break;
2809         case BATT_EVENT_BROWSER:
2810                 if (sscanf(buf, "%d\n", &x) == 1) {
2811                         sec_bat_event_set(battery, EVENT_BROWSER, x);
2812                         ret = count;
2813                 }
2814                 break;
2815         case BATT_EVENT_HOTSPOT:
2816                 if (sscanf(buf, "%d\n", &x) == 1) {
2817                         sec_bat_event_set(battery, EVENT_HOTSPOT, x);
2818                         ret = count;
2819                 }
2820                 break;
2821         case BATT_EVENT_CAMERA:
2822                 if (sscanf(buf, "%d\n", &x) == 1) {
2823                         sec_bat_event_set(battery, EVENT_CAMERA, x);
2824                         ret = count;
2825                 }
2826                 break;
2827         case BATT_EVENT_CAMCORDER:
2828                 if (sscanf(buf, "%d\n", &x) == 1) {
2829                         sec_bat_event_set(battery, EVENT_CAMCORDER, x);
2830                         ret = count;
2831                 }
2832                 break;
2833         case BATT_EVENT_DATA_CALL:
2834                 if (sscanf(buf, "%d\n", &x) == 1) {
2835                         sec_bat_event_set(battery, EVENT_DATA_CALL, x);
2836                         ret = count;
2837                 }
2838                 break;
2839         case BATT_EVENT_WIFI:
2840                 if (sscanf(buf, "%d\n", &x) == 1) {
2841                         sec_bat_event_set(battery, EVENT_WIFI, x);
2842                         ret = count;
2843                 }
2844                 break;
2845         case BATT_EVENT_WIBRO:
2846                 if (sscanf(buf, "%d\n", &x) == 1) {
2847                         sec_bat_event_set(battery, EVENT_WIBRO, x);
2848                         ret = count;
2849                 }
2850                 break;
2851         case BATT_EVENT_LTE:
2852                 if (sscanf(buf, "%d\n", &x) == 1) {
2853                         sec_bat_event_set(battery, EVENT_LTE, x);
2854                         ret = count;
2855                 }
2856                 break;
2857         case BATT_EVENT_LCD:
2858                 if (sscanf(buf, "%d\n", &x) == 1) {
2859                         /* we need to test
2860                         sec_bat_event_set(battery, EVENT_LCD, x);
2861                         */
2862                         ret = count;
2863                 }
2864                 break;
2865         case BATT_EVENT_GPS:
2866                 if (sscanf(buf, "%d\n", &x) == 1) {
2867                         sec_bat_event_set(battery, EVENT_GPS, x);
2868                         ret = count;
2869                 }
2870                 break;
2871 #if defined(CONFIG_SAMSUNG_BATTERY_ENG_TEST)
2872         case BATT_TEST_CHARGE_CURRENT:
2873                 if (sscanf(buf, "%d\n", &x) == 1) {
2874                         if (x >= 0 && x <= 2000) {
2875                                 union power_supply_propval value;
2876                                 dev_err(battery->dev,
2877                                         "%s: BATT_TEST_CHARGE_CURRENT(%d)\n", __func__, x);
2878                                 battery->pdata->charging_current[
2879                                         POWER_SUPPLY_TYPE_USB].input_current_limit = x;
2880                                 battery->pdata->charging_current[
2881                                         POWER_SUPPLY_TYPE_USB].fast_charging_current = x;
2882                                 if (x > 500) {
2883                                         battery->eng_not_full_status = true;
2884                                         battery->pdata->temp_check_type =
2885                                                 SEC_BATTERY_TEMP_CHECK_NONE;
2886                                         battery->pdata->charging_total_time =
2887                                                 10000 * 60 * 60;
2888                                 }
2889                                 if (battery->cable_type == POWER_SUPPLY_TYPE_USB) {
2890                                         value.intval = x;
2891                                         psy_do_property(battery->pdata->charger_name, set,
2892                                                 POWER_SUPPLY_PROP_CURRENT_NOW,
2893                                                 value);
2894                                 }
2895                         }
2896                         ret = count;
2897                 }
2898                 break;
2899         case BATT_STABILITY_TEST:
2900                 if (sscanf(buf, "%d\n", &x) == 1) {
2901                         union power_supply_propval value;
2902                         dev_err(battery->dev,
2903                                 "%s: BATT_STABILITY_TEST(%d)\n", __func__, x);
2904                         if (x) {
2905                                 battery->stability_test = true;
2906                                 battery->eng_not_full_status = true;
2907                                 value.intval = POWER_SUPPLY_TYPE_WIRELESS;
2908                                 psy_do_property(battery->pdata->charger_name, set,
2909                                         POWER_SUPPLY_PROP_CHARGE_TYPE, value);
2910                                 psy_do_property("battery", set,
2911                                                 POWER_SUPPLY_PROP_ONLINE, value);
2912                         }
2913                         else {
2914                                 battery->stability_test = false;
2915                                 value.intval = POWER_SUPPLY_TYPE_MAINS;
2916                                 psy_do_property(battery->pdata->charger_name, set,
2917                                         POWER_SUPPLY_PROP_CHARGE_TYPE, value);
2918                         }
2919                 }
2920                 break;
2921 #endif
2922         default:
2923                 ret = -EINVAL;
2924         }
2925
2926         return ret;
2927 }
2928
2929 static int sec_bat_create_attrs(struct device *dev)
2930 {
2931         int i, rc;
2932
2933         for (i = 0; i < ARRAY_SIZE(sec_battery_attrs); i++) {
2934                 rc = device_create_file(dev, &sec_battery_attrs[i]);
2935                 if (rc)
2936                         goto create_attrs_failed;
2937         }
2938         goto create_attrs_succeed;
2939
2940 create_attrs_failed:
2941         while (i--)
2942                 device_remove_file(dev, &sec_battery_attrs[i]);
2943 create_attrs_succeed:
2944         return rc;
2945 }
2946
2947 static int sec_bat_set_property(struct power_supply *psy,
2948                                 enum power_supply_property psp,
2949                                 const union power_supply_propval *val)
2950 {
2951         struct sec_battery_info *battery =
2952                 container_of(psy, struct sec_battery_info, psy_bat);
2953         int current_cable_type;
2954         int full_check_type;
2955         union power_supply_propval value;
2956
2957         dev_dbg(battery->dev,
2958                 "%s: (%d,%d)\n", __func__, psp, val->intval);
2959
2960         switch (psp) {
2961         case POWER_SUPPLY_PROP_STATUS:
2962                 if (battery->charging_mode == SEC_BATTERY_CHARGING_1ST)
2963                         full_check_type = battery->pdata->full_check_type;
2964                 else
2965                         full_check_type = battery->pdata->full_check_type_2nd;
2966                 if ((full_check_type == SEC_BATTERY_FULLCHARGED_CHGINT) &&
2967                         (val->intval == POWER_SUPPLY_STATUS_FULL))
2968                         sec_bat_do_fullcharged(battery);
2969                 battery->status = val->intval;
2970                 break;
2971         case POWER_SUPPLY_PROP_HEALTH:
2972                 sec_bat_ovp_uvlo_result(battery, val->intval);
2973                 break;
2974         case POWER_SUPPLY_PROP_ONLINE:
2975                         current_cable_type = val->intval;
2976
2977                 if (current_cable_type < 0) {
2978                         dev_info(battery->dev,
2979                                         "%s: ignore event(%d)\n",
2980                                         __func__, current_cable_type);
2981                 } else if (current_cable_type == POWER_SUPPLY_TYPE_OTG) {
2982                         value.intval = current_cable_type;
2983                         psy_do_property(battery->pdata->charger_name, set,
2984                                         POWER_SUPPLY_PROP_ONLINE, value);
2985                         wake_lock(&battery->monitor_wake_lock);
2986                         queue_delayed_work(battery->monitor_wqueue,
2987                                            &battery->monitor_work, 0);
2988
2989                         break;
2990 #if 0
2991                 } else if (current_cable_type == POWER_SUPPLY_TYPE_WIRELESS) {
2992                         battery->wc_status = true;
2993                 } else if (current_cable_type == POWER_SUPPLY_TYPE_WIRELESS_REMOVE) {
2994                         battery->wc_status = false;
2995                         if (battery->wire_status != POWER_SUPPLY_TYPE_BATTERY)
2996                                 current_cable_type = battery->wire_status;
2997 #endif
2998                 } else {
2999                         battery->wire_status = current_cable_type;
3000                         if ((battery->wire_status == POWER_SUPPLY_TYPE_BATTERY)
3001                                         && battery->wc_status)
3002                                 current_cable_type = POWER_SUPPLY_TYPE_WIRELESS;
3003
3004                         if (current_cable_type == POWER_SUPPLY_TYPE_BATTERY) {
3005                                 wake_lock(&battery->cable_wake_lock);
3006                                 value.intval = current_cable_type;
3007                                 psy_do_property(battery->pdata->charger_name,
3008                                         set,POWER_SUPPLY_PROP_ONLINE, value);
3009                                 queue_work(battery->monitor_wqueue,
3010                                         &battery->cable_work);
3011                         }
3012                 }
3013                 dev_info(battery->dev,
3014                                 "%s: current_cable(%d), wc_status(%d), wire_status(%d)\n",
3015                                 __func__, current_cable_type, battery->wc_status,
3016                                 battery->wire_status);
3017
3018                 /* cable is attached or detached
3019                  * if current_cable_type is minus value,
3020                  * check cable by sec_bat_get_cable_type()
3021                  * although SEC_BATTERY_CABLE_SOURCE_EXTERNAL is set
3022                  * (0 is POWER_SUPPLY_TYPE_UNKNOWN)
3023                  */
3024                 if ((current_cable_type >= 0) &&
3025                         (current_cable_type <= SEC_SIZEOF_POWER_SUPPLY_TYPE) &&
3026                         (battery->pdata->cable_source_type &
3027                         SEC_BATTERY_CABLE_SOURCE_EXTERNAL ||
3028                         battery->pdata->cable_source_type &
3029                         SEC_BATTERY_CABLE_SOURCE_EXTENDED)) {
3030
3031                                 wake_lock(&battery->cable_wake_lock);
3032                                 queue_work(battery->monitor_wqueue,
3033                                         &battery->cable_work);
3034                         } else {
3035                         if (sec_bat_get_cable_type(battery,
3036                                 battery->pdata->cable_source_type)) {
3037                                 wake_lock(&battery->cable_wake_lock);
3038                                 queue_work(battery->monitor_wqueue,
3039                                         &battery->cable_work);
3040                         }
3041                 }
3042                 break;
3043         case POWER_SUPPLY_PROP_CAPACITY:
3044                 battery->capacity = val->intval;
3045                 power_supply_changed(&battery->psy_bat);
3046                 break;
3047         case POWER_SUPPLY_PROP_PRESENT:
3048                 cancel_delayed_work(&battery->monitor_work);
3049                 wake_lock(&battery->monitor_wake_lock);
3050                 queue_delayed_work_on(0, battery->monitor_wqueue,
3051                                 &battery->monitor_work, 0);
3052                 break;
3053         default:
3054                 return -EINVAL;
3055         }
3056
3057         return 0;
3058 }
3059
3060 static int sec_bat_get_property(struct power_supply *psy,
3061                                 enum power_supply_property psp,
3062                                 union power_supply_propval *val)
3063 {
3064         struct sec_battery_info *battery =
3065                 container_of(psy, struct sec_battery_info, psy_bat);
3066         union power_supply_propval value;
3067
3068         switch (psp) {
3069         case POWER_SUPPLY_PROP_STATUS:
3070                 if ((battery->health == POWER_SUPPLY_HEALTH_OVERVOLTAGE) ||
3071                         (battery->health == POWER_SUPPLY_HEALTH_UNDERVOLTAGE)) {
3072                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
3073                 } else {
3074                         if ((battery->pdata->cable_check_type &
3075                                         SEC_BATTERY_CABLE_CHECK_NOUSBCHARGE) &&
3076                                         (battery->pdata->is_lpm &&
3077                                         !battery->pdata->is_lpm())) {
3078                                 switch (battery->cable_type) {
3079                                 case POWER_SUPPLY_TYPE_USB:
3080                                 case POWER_SUPPLY_TYPE_USB_DCP:
3081                                 case POWER_SUPPLY_TYPE_USB_CDP:
3082                                 case POWER_SUPPLY_TYPE_USB_ACA:
3083                                         val->intval =
3084                                                 POWER_SUPPLY_STATUS_DISCHARGING;
3085                                         return 0;
3086                                 }
3087                         }
3088                         val->intval = battery->status;
3089                 }
3090                 break;
3091         case POWER_SUPPLY_PROP_CHARGE_TYPE:
3092                 psy_do_property(battery->pdata->charger_name, get,
3093                         POWER_SUPPLY_PROP_CHARGE_TYPE, value);
3094                 if (value.intval == POWER_SUPPLY_CHARGE_TYPE_UNKNOWN)
3095                         /* if error in CHARGE_TYPE of charger
3096                          * set CHARGE_TYPE as NONE
3097                          */
3098                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
3099                 else
3100                         val->intval = value.intval;
3101                 break;
3102         case POWER_SUPPLY_PROP_HEALTH:
3103                 val->intval = battery->health;
3104                 break;
3105         case POWER_SUPPLY_PROP_PRESENT:
3106                 val->intval = battery->present;
3107                 break;
3108         case POWER_SUPPLY_PROP_ONLINE:
3109                 val->intval = battery->cable_type;
3110                 break;
3111         case POWER_SUPPLY_PROP_TECHNOLOGY:
3112                 val->intval = battery->pdata->technology;
3113                 break;
3114         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
3115                 if (battery->pdata->check_jig_status) {
3116                         psy_do_property(battery->pdata->fuelgauge_name, get,
3117                                         POWER_SUPPLY_PROP_VOLTAGE_NOW, value);
3118                         battery->voltage_now = value.intval;
3119                         dev_err(battery->dev,
3120                                 "%s: voltage now(%d)\n", __func__, battery->voltage_now);
3121                 }
3122                 /* voltage value should be in uV */
3123                 val->intval = battery->voltage_now * 1000;
3124                 break;
3125         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
3126 #ifdef CONFIG_SEC_FACTORY
3127                 value.intval = SEC_BATTEY_VOLTAGE_AVERAGE;
3128                 psy_do_property(battery->pdata->fuelgauge_name, get,
3129                                 POWER_SUPPLY_PROP_VOLTAGE_AVG, value);
3130                 battery->voltage_avg = value.intval;
3131                 dev_err(battery->dev,
3132                         "%s: voltage avg(%d)\n", __func__, battery->voltage_avg);
3133 #endif
3134                 /* voltage value should be in uV */
3135                 val->intval = battery->voltage_avg * 1000;
3136                 break;
3137         case POWER_SUPPLY_PROP_CURRENT_NOW:
3138                 val->intval = battery->current_now;
3139                 break;
3140         case POWER_SUPPLY_PROP_CURRENT_AVG:
3141                 val->intval = battery->current_avg;
3142                 break;
3143         /* charging mode (differ from power supply) */
3144         case POWER_SUPPLY_PROP_CHARGE_NOW:
3145                 val->intval = battery->charging_mode;
3146                 break;
3147         case POWER_SUPPLY_PROP_CAPACITY:
3148 #if defined(CONFIG_SAMSUNG_BATTERY_ENG_TEST)
3149                 if (battery->status == POWER_SUPPLY_STATUS_FULL) {
3150                         if(battery->eng_not_full_status == true)
3151                                 val->intval = battery->capacity;
3152                         else
3153                                 val->intval = 100;
3154                 } else {
3155                         val->intval = battery->capacity;
3156                 }
3157 #else
3158                 /* In full-charged status, SOC is always 100% */
3159                 if (battery->status == POWER_SUPPLY_STATUS_FULL)
3160                         val->intval = 100;
3161                 else
3162                         val->intval = battery->capacity;
3163 #endif
3164                 break;
3165         case POWER_SUPPLY_PROP_TEMP:
3166                 val->intval = battery->temperature;
3167                 break;
3168         case POWER_SUPPLY_PROP_TEMP_AMBIENT:
3169                 val->intval = battery->temper_amb;
3170                 break;
3171         default:
3172                 return -EINVAL;
3173         }
3174         return 0;
3175 }
3176
3177 static int sec_usb_get_property(struct power_supply *psy,
3178                                 enum power_supply_property psp,
3179                                 union power_supply_propval *val)
3180 {
3181         struct sec_battery_info *battery =
3182                 container_of(psy, struct sec_battery_info, psy_usb);
3183
3184         if (psp != POWER_SUPPLY_PROP_ONLINE)
3185                 return -EINVAL;
3186
3187         if ((battery->health == POWER_SUPPLY_HEALTH_OVERVOLTAGE) ||
3188                         (battery->health == POWER_SUPPLY_HEALTH_UNDERVOLTAGE)) {
3189                 val->intval = 0;
3190                 return 0;
3191         }
3192         /* Set enable=1 only if the USB charger is connected */
3193         switch (battery->wire_status) {
3194         case POWER_SUPPLY_TYPE_USB:
3195         case POWER_SUPPLY_TYPE_USB_DCP:
3196         case POWER_SUPPLY_TYPE_USB_CDP:
3197         case POWER_SUPPLY_TYPE_USB_ACA:
3198         case POWER_SUPPLY_TYPE_MHL_USB:
3199                 val->intval = 1;
3200                 break;
3201         default:
3202                 val->intval = 0;
3203                 break;
3204         }
3205
3206         return 0;
3207 }
3208
3209 static int sec_ac_get_property(struct power_supply *psy,
3210                                enum power_supply_property psp,
3211                                union power_supply_propval *val)
3212 {
3213         struct sec_battery_info *battery =
3214                 container_of(psy, struct sec_battery_info, psy_ac);
3215
3216         if (psp != POWER_SUPPLY_PROP_ONLINE)
3217                 return -EINVAL;
3218
3219         if ((battery->health == POWER_SUPPLY_HEALTH_OVERVOLTAGE) ||
3220                 (battery->health == POWER_SUPPLY_HEALTH_UNDERVOLTAGE)) {
3221                         val->intval = 0;
3222                         return 0;
3223         }
3224
3225         /* Set enable=1 only if the AC charger is connected */
3226         switch (battery->cable_type) {
3227         case POWER_SUPPLY_TYPE_MAINS:
3228         case POWER_SUPPLY_TYPE_HV_MAINS:
3229         case POWER_SUPPLY_TYPE_MISC:
3230         case POWER_SUPPLY_TYPE_CARDOCK:
3231         case POWER_SUPPLY_TYPE_UARTOFF:
3232         case POWER_SUPPLY_TYPE_LAN_HUB:
3233         case POWER_SUPPLY_TYPE_UNKNOWN:
3234         case POWER_SUPPLY_TYPE_MHL_500:
3235         case POWER_SUPPLY_TYPE_MHL_900:
3236         case POWER_SUPPLY_TYPE_MHL_1500:
3237         case POWER_SUPPLY_TYPE_SMART_OTG:
3238         case POWER_SUPPLY_TYPE_SMART_NOTG:
3239                 val->intval = 1;
3240                 break;
3241         default:
3242                 val->intval = 0;
3243                 break;
3244         }
3245
3246         return 0;
3247 }
3248
3249 static int sec_wireless_get_property(struct power_supply *psy,
3250                                enum power_supply_property psp,
3251                                union power_supply_propval *val)
3252 {
3253         struct sec_battery_info *battery =
3254                 container_of(psy, struct sec_battery_info, psy_wireless);
3255
3256         if (psp != POWER_SUPPLY_PROP_ONLINE)
3257                 return -EINVAL;
3258
3259         if (battery->wc_status)
3260                 val->intval = 1;
3261         else
3262                 val->intval = 0;
3263
3264         return 0;
3265 }
3266
3267 static int sec_wireless_set_property(struct power_supply *psy,
3268                                 enum power_supply_property psp,
3269                                 const union power_supply_propval *val)
3270 {
3271         struct sec_battery_info *battery =
3272                 container_of(psy, struct sec_battery_info, psy_wireless);
3273
3274         if (psp != POWER_SUPPLY_PROP_ONLINE)
3275                 return -EINVAL;
3276
3277         battery->wc_status = val->intval;
3278
3279         wake_lock(&battery->cable_wake_lock);
3280         queue_work(battery->monitor_wqueue, &battery->cable_work);
3281
3282         return 0;
3283 }
3284
3285 static int sec_ps_set_property(struct power_supply *psy,
3286                                 enum power_supply_property psp,
3287                                 const union power_supply_propval *val)
3288 {
3289         struct sec_battery_info *battery =
3290                 container_of(psy, struct sec_battery_info, psy_ps);
3291         union power_supply_propval value;
3292
3293         switch (psp) {
3294         case POWER_SUPPLY_PROP_STATUS:
3295         if ((val->intval == 0) || (val->intval ==1)) {
3296                 battery->ps_enable = val->intval;
3297                         dev_info(battery->dev,
3298                                 "%s: power sharing cable set (%d)\n", __func__, battery->ps_enable);
3299                 value.intval = POWER_SUPPLY_TYPE_POWER_SHARING;
3300                 psy_do_property(battery->pdata->charger_name, set,
3301                         POWER_SUPPLY_PROP_ONLINE, value);
3302         } else {
3303                 dev_err(battery->dev,
3304                         "%s: invalid setting (%d)\n", __func__, val->intval);
3305         }
3306                 break;
3307         case POWER_SUPPLY_PROP_ONLINE:
3308                 if (val->intval == POWER_SUPPLY_TYPE_POWER_SHARING) {
3309                         battery->ps_status = true;
3310                         dev_info(battery->dev,
3311                                 "%s: power sharing cable plugin (%d)\n", __func__, battery->ps_status);
3312                         wake_lock(&battery->monitor_wake_lock);
3313                         queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
3314                 } else {
3315                         battery->ps_status = false;
3316                         dev_info(battery->dev,
3317                                 "%s: power sharing cable plugout (%d)\n", __func__, battery->ps_status);
3318                         wake_lock(&battery->monitor_wake_lock);
3319                         queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
3320                 }
3321                 break;
3322         default:
3323                 return -EINVAL;
3324         }
3325
3326         return 0;
3327 }
3328
3329 static int sec_ps_get_property(struct power_supply *psy,
3330                                enum power_supply_property psp,
3331                                union power_supply_propval *val)
3332 {
3333         struct sec_battery_info *battery =
3334                 container_of(psy, struct sec_battery_info, psy_ps);
3335
3336         switch (psp) {
3337         case POWER_SUPPLY_PROP_STATUS:
3338                 if (battery->ps_enable)
3339                         val->intval = 1;
3340                 else
3341                         val->intval = 0;
3342                 break;
3343         case POWER_SUPPLY_PROP_ONLINE:
3344                 if (battery->ps_status)
3345                         val->intval = 1;
3346                 else
3347                         val->intval = 0;
3348                 break;
3349         default:
3350                 return -EINVAL;
3351         }
3352
3353         return 0;
3354 }
3355
3356 /* TODO unused */
3357 #if 0
3358 static irqreturn_t sec_bat_irq_thread(int irq, void *irq_data)
3359 {
3360         struct sec_battery_info *battery = irq_data;
3361
3362         dev_info(battery->dev, "%s:(bat_irq occured_start\n", __func__);
3363
3364         if (battery->pdata->cable_check_type &
3365                 SEC_BATTERY_CABLE_CHECK_INT) {
3366                 if (battery->pdata->is_interrupt_cable_check_possible &&
3367                         !battery->pdata->is_interrupt_cable_check_possible(
3368                         battery->extended_cable_type))
3369                                 goto no_cable_check;
3370                 else {
3371                 if (sec_bat_get_cable_type(battery,
3372                         battery->pdata->cable_source_type)) {
3373                         wake_lock(&battery->cable_wake_lock);
3374                         queue_work(battery->monitor_wqueue,
3375                                 &battery->cable_work);
3376                 }
3377         }
3378         }
3379
3380 no_cable_check:
3381         if (battery->pdata->battery_check_type ==
3382                 SEC_BATTERY_CHECK_INT) {
3383                 if (battery_pdata->check_battery_callback)
3384                         battery->present = battery->pdata->check_battery_callback();
3385
3386                 wake_lock(&battery->monitor_wake_lock);
3387                 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
3388         }
3389
3390         return IRQ_HANDLED;
3391 }
3392 #endif
3393
3394 #if defined(CONFIG_MUIC_NOTIFIER)
3395 static int sec_bat_cable_check(struct sec_battery_info *battery,
3396                                 muic_attached_dev_t attached_dev)
3397 {
3398         int current_cable_type = POWER_SUPPLY_TYPE_UNKNOWN;
3399
3400         pr_info("[%s]ATTACHED(%d)\n", __func__, attached_dev);
3401
3402         switch (attached_dev)
3403         {
3404         case ATTACHED_DEV_JIG_UART_OFF_MUIC:
3405         case ATTACHED_DEV_SMARTDOCK_MUIC:
3406                 current_cable_type = POWER_SUPPLY_TYPE_BATTERY;
3407                 break;
3408         case ATTACHED_DEV_OTG_MUIC:
3409                 current_cable_type = POWER_SUPPLY_TYPE_OTG;
3410                 break;
3411         case ATTACHED_DEV_USB_MUIC:
3412         case ATTACHED_DEV_JIG_USB_OFF_MUIC:
3413         case ATTACHED_DEV_JIG_USB_ON_MUIC:
3414         case ATTACHED_DEV_SMARTDOCK_USB_MUIC:
3415                 current_cable_type = POWER_SUPPLY_TYPE_USB;
3416                 break;
3417         case ATTACHED_DEV_JIG_UART_OFF_VB_MUIC:
3418                 current_cable_type = POWER_SUPPLY_TYPE_UARTOFF;
3419                 break;
3420         case ATTACHED_DEV_TA_MUIC:
3421         case ATTACHED_DEV_CARDOCK_MUIC:
3422         case ATTACHED_DEV_DESKDOCK_MUIC:
3423         case ATTACHED_DEV_SMARTDOCK_TA_MUIC:
3424                 current_cable_type = POWER_SUPPLY_TYPE_MAINS;
3425                 break;
3426         case ATTACHED_DEV_CDP_MUIC:
3427                 current_cable_type = POWER_SUPPLY_TYPE_USB_CDP;
3428                 break;
3429         case ATTACHED_DEV_HV_MUIC:
3430                 current_cable_type = POWER_SUPPLY_TYPE_HV_MAINS;
3431                 break;
3432         default:
3433                 pr_err("%s: invalid type for charger:%d\n",
3434                         __func__, attached_dev);
3435         }
3436
3437         return current_cable_type;
3438
3439 }
3440
3441 static int batt_handle_notification(struct notifier_block *nb,
3442                 unsigned long action, void *data)
3443 {
3444         muic_attached_dev_t attached_dev = *(muic_attached_dev_t *)data;
3445         const char *cmd;
3446         int cable_type;
3447         struct sec_battery_info *battery =
3448                 container_of(nb, struct sec_battery_info,
3449                              batt_nb);
3450
3451         switch (action) {
3452         case MUIC_NOTIFY_CMD_DETACH:
3453         case MUIC_NOTIFY_CMD_LOGICALLY_DETACH:
3454                 cmd = "DETACH";
3455                 cable_type = POWER_SUPPLY_TYPE_BATTERY;
3456                 break;
3457         case MUIC_NOTIFY_CMD_ATTACH:
3458         case MUIC_NOTIFY_CMD_LOGICALLY_ATTACH:
3459                 cmd = "ATTACH";
3460                 cable_type = sec_bat_cable_check(battery, attached_dev);
3461                 break;
3462         default:
3463                 cmd = "ERROR";
3464                 cable_type = POWER_SUPPLY_TYPE_UNKNOWN;
3465                 break;
3466         }
3467
3468         if (cable_type < 0) {
3469                 dev_info(battery->dev, "%s: ignore event(%d)\n",
3470                         __func__, cable_type);
3471         } else if (cable_type == POWER_SUPPLY_TYPE_POWER_SHARING) {
3472                 battery->ps_status = true;
3473                 dev_info(battery->dev,
3474                         "%s: power sharing cable plugin (%d)\n", __func__, battery->ps_status);
3475         } else if (cable_type == POWER_SUPPLY_TYPE_WIRELESS) {
3476                 battery->wc_status = true;
3477 #if 0
3478         } else if (cable_type == POWER_SUPPLY_TYPE_WIRELESS_REMOVE) {
3479                 battery->wc_status = false;
3480                 if (battery->wire_status != POWER_SUPPLY_TYPE_BATTERY)
3481                         cable_type = battery->wire_status;
3482 #endif
3483         } else {
3484                 battery->wire_status = cable_type;
3485                 if ((battery->wire_status == POWER_SUPPLY_TYPE_BATTERY)
3486                                 && battery->wc_status && !battery->ps_status)
3487                         cable_type = POWER_SUPPLY_TYPE_WIRELESS;
3488         }
3489         dev_info(battery->dev,
3490                         "%s: current_cable(%d), wc_status(%d), wire_status(%d)\n",
3491                         __func__, cable_type, battery->wc_status,
3492                         battery->wire_status);
3493
3494         if ((cable_type >= 0) &&
3495             cable_type <= SEC_SIZEOF_POWER_SUPPLY_TYPE) {
3496                 if (cable_type == POWER_SUPPLY_TYPE_POWER_SHARING) {
3497                         wake_lock(&battery->monitor_wake_lock);
3498                         queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
3499                 } else if((cable_type == POWER_SUPPLY_TYPE_BATTERY)
3500                                         && battery->ps_status) {
3501                         battery->ps_status = false;
3502                         dev_info(battery->dev,
3503                                 "%s: power sharing cable plugout (%d)\n", __func__, battery->ps_status);
3504                         wake_lock(&battery->monitor_wake_lock);
3505                         queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
3506                 } else if(cable_type != battery->cable_type) {
3507                         wake_lock(&battery->cable_wake_lock);
3508                         queue_work(battery->monitor_wqueue, &battery->cable_work);
3509                 } else {
3510                         dev_info(battery->dev,
3511                                 "%s: Cable is Not Changed(%d)\n",
3512                                 __func__, battery->cable_type);
3513                 }
3514         }
3515
3516         pr_info("%s: CMD=%s, attached_dev=%d\n", __func__, cmd, attached_dev);
3517
3518         return 0;
3519 }
3520 #endif /* CONFIG_MUIC_NOTIFIER */
3521
3522 #ifdef CONFIG_OF
3523 static int sec_bat_parse_dt(struct device *dev,
3524                 struct sec_battery_info *battery)
3525 {
3526         struct device_node *np = dev->of_node;
3527         sec_battery_platform_data_t *pdata = battery->pdata;
3528         int ret, len;
3529         unsigned int i;
3530         const u32 *p;
3531
3532         if (!np) {
3533                 pr_info("%s: np NULL\n", __func__);
3534                 return 1;
3535         }
3536
3537         ret = of_property_read_string(np,
3538                 "battery,vendor", (char const **)&pdata->vendor);
3539         if (ret)
3540                 pr_info("%s: Vendor is Empty\n", __func__);
3541
3542         ret = of_property_read_string(np,
3543                 "battery,charger_name", (char const **)&pdata->charger_name);
3544         if (ret)
3545                 pr_info("%s: Vendor is Empty\n", __func__);
3546
3547         ret = of_property_read_string(np,
3548                 "battery,fuelgauge_name", (char const **)&pdata->fuelgauge_name);
3549         if (ret)
3550                 pr_info("%s: Vendor is Empty\n", __func__);
3551
3552         ret = of_property_read_string(np,
3553                 "battery,chip_vendor", (char const **)&pdata->chip_vendor);
3554         if (ret)
3555                 pr_info("%s: Vendor is Empty\n", __func__);
3556
3557         ret = of_property_read_u32(np, "battery,technology",
3558                 &pdata->technology);
3559
3560         ret = of_property_read_u32(np, "battery,battery_check_type",
3561                         &pdata->battery_check_type);
3562
3563         p = of_get_property(np, "battery,polling_time", &len);
3564
3565         len = len / sizeof(u32);
3566
3567         pdata->polling_time = kzalloc(sizeof(*pdata->polling_time) * len, GFP_KERNEL);
3568
3569         ret = of_property_read_u32_array(np, "battery,polling_time",
3570                                          pdata->polling_time, len);
3571
3572         p = of_get_property(np, "battery,temp_table_adc", &len);
3573
3574         len = len / sizeof(u32);
3575
3576         pdata->temp_adc_table_size = len;
3577         pdata->temp_amb_adc_table_size = len;
3578
3579         pdata->temp_adc_table = kzalloc(sizeof(sec_bat_adc_table_data_t) *
3580                                        pdata->temp_adc_table_size, GFP_KERNEL);
3581         pdata->temp_amb_adc_table = kzalloc(sizeof(sec_bat_adc_table_data_t) *
3582                                        pdata->temp_adc_table_size, GFP_KERNEL);
3583
3584         for(i = 0; i < pdata->temp_adc_table_size; i++) {
3585                 ret = of_property_read_u32_index(np, "battery,temp_table_adc", i,
3586                                                  &pdata->temp_adc_table[i].adc);
3587                 ret = of_property_read_u32_index(np, "battery,temp_table_data", i,
3588                                                  &pdata->temp_adc_table[i].data);
3589                 ret = of_property_read_u32_index(np, "battery,temp_table_adc", i,
3590                                                  &pdata->temp_amb_adc_table[i].adc);
3591                 ret = of_property_read_u32_index(np, "battery,temp_table_data", i,
3592                                                  &pdata->temp_amb_adc_table[i].data);
3593         }
3594
3595         p = of_get_property(np, "battery,input_current_limit", &len);
3596
3597         len = len / sizeof(u32);
3598
3599         pdata->charging_current = kzalloc(sizeof(sec_charging_current_t) * len,
3600                                           GFP_KERNEL);
3601
3602         for(i = 0; i < len; i++) {
3603                 ret = of_property_read_u32_index(np,
3604                                  "battery,input_current_limit", i,
3605                                  &pdata->charging_current[i].input_current_limit);
3606                 ret = of_property_read_u32_index(np,
3607                                  "battery,fast_charging_current", i,
3608                                  &pdata->charging_current[i].fast_charging_current);
3609                 ret = of_property_read_u32_index(np,
3610                                  "battery,full_check_current_1st", i,
3611                                  &pdata->charging_current[i].full_check_current_1st);
3612                 ret = of_property_read_u32_index(np,
3613                                  "battery,full_check_current_2nd", i,
3614                                  &pdata->charging_current[i].full_check_current_2nd);
3615         }
3616
3617         ret = of_property_read_u32(np, "battery,adc_check_count",
3618                 &pdata->adc_check_count);
3619
3620         ret = of_property_read_u32(np, "battery,temp_adc_type",
3621                 &pdata->temp_adc_type);
3622
3623         ret = of_property_read_u32(np, "battery,cable_check_type",
3624                 &pdata->cable_check_type);
3625
3626         ret = of_property_read_u32(np, "battery,cable_source_type",
3627                 &pdata->cable_source_type);
3628
3629         ret = of_property_read_u32(np, "battery,event_waiting_time",
3630                 &pdata->event_waiting_time);
3631
3632         ret = of_property_read_u32(np, "battery,polling_type",
3633                 &pdata->polling_type);
3634
3635         ret = of_property_read_u32(np, "battery,monitor_initial_count",
3636                 &pdata->monitor_initial_count);
3637
3638         ret = of_property_read_u32(np, "battery,check_count",
3639                 &pdata->check_count);
3640
3641         ret = of_property_read_u32(np, "battery,check_adc_max",
3642                 &pdata->check_adc_max);
3643
3644         ret = of_property_read_u32(np, "battery,check_adc_min",
3645                 &pdata->check_adc_min);
3646
3647         ret = of_property_read_u32(np, "battery,ovp_uvlo_check_type",
3648                 &pdata->ovp_uvlo_check_type);
3649
3650         ret = of_property_read_u32(np, "battery,thermal_source",
3651                 &pdata->thermal_source);
3652
3653         ret = of_property_read_u32(np, "battery,temp_check_type",
3654                 &pdata->temp_check_type);
3655
3656         ret = of_property_read_u32(np, "battery,temp_check_count",
3657                 &pdata->temp_check_count);
3658
3659         ret = of_property_read_u32(np, "battery,temp_high_threshold_event",
3660                 &pdata->temp_high_threshold_event);
3661
3662         ret = of_property_read_u32(np, "battery,temp_high_recovery_event",
3663                 &pdata->temp_high_recovery_event);
3664
3665         ret = of_property_read_u32(np, "battery,temp_low_threshold_event",
3666                 &pdata->temp_low_threshold_event);
3667
3668         ret = of_property_read_u32(np, "battery,temp_low_recovery_event",
3669                 &pdata->temp_low_recovery_event);
3670
3671         ret = of_property_read_u32(np, "battery,temp_high_threshold_event",
3672                 &pdata->temp_high_threshold_normal);
3673
3674         ret = of_property_read_u32(np, "battery,temp_high_recovery_event",
3675                 &pdata->temp_high_recovery_normal);
3676
3677         ret = of_property_read_u32(np, "battery,temp_low_threshold_event",
3678                 &pdata->temp_low_threshold_normal);
3679
3680         ret = of_property_read_u32(np, "battery,temp_low_recovery_event",
3681                 &pdata->temp_low_recovery_normal);
3682
3683         ret = of_property_read_u32(np, "battery,temp_high_threshold_event",
3684                 &pdata->temp_high_threshold_lpm);
3685
3686         ret = of_property_read_u32(np, "battery,temp_high_recovery_event",
3687                 &pdata->temp_high_recovery_lpm);
3688
3689         ret = of_property_read_u32(np, "battery,temp_low_threshold_event",
3690                 &pdata->temp_low_threshold_lpm);
3691
3692         ret = of_property_read_u32(np, "battery,temp_low_recovery_event",
3693                 &pdata->temp_low_recovery_lpm);
3694
3695         ret = of_property_read_u32(np, "battery,full_check_type",
3696                 &pdata->full_check_type);
3697
3698         ret = of_property_read_u32(np, "battery,full_check_type_2nd",
3699                 &pdata->full_check_type_2nd);
3700
3701         ret = of_property_read_u32(np, "battery,full_check_count",
3702                 &pdata->full_check_count);
3703
3704         ret = of_property_read_u32(np, "battery,chg_gpio_full_check",
3705                 &pdata->chg_gpio_full_check);
3706
3707         ret = of_property_read_u32(np, "battery,chg_polarity_full_check",
3708                 &pdata->chg_polarity_full_check);
3709
3710         ret = of_property_read_u32(np, "battery,full_condition_type",
3711                 &pdata->full_condition_type);
3712
3713         ret = of_property_read_u32(np, "battery,full_condition_soc",
3714                 &pdata->full_condition_soc);
3715
3716         ret = of_property_read_u32(np, "battery,full_condition_vcell",
3717                 &pdata->full_condition_vcell);
3718
3719         ret = of_property_read_u32(np, "battery,recharge_check_count",
3720                 &pdata->recharge_check_count);
3721
3722         ret = of_property_read_u32(np, "battery,recharge_condition_type",
3723                 &pdata->recharge_condition_type);
3724
3725         ret = of_property_read_u32(np, "battery,recharge_condition_soc",
3726                 &pdata->recharge_condition_soc);
3727
3728         ret = of_property_read_u32(np, "battery,recharge_condition_vcell",
3729                 &pdata->recharge_condition_vcell);
3730
3731         ret = of_property_read_u32(np, "battery,charging_total_time",
3732                 (unsigned int *)&pdata->charging_total_time);
3733
3734         ret = of_property_read_u32(np, "battery,recharging_total_time",
3735                 (unsigned int *)&pdata->recharging_total_time);
3736
3737         ret = of_property_read_u32(np, "battery,charging_reset_time",
3738                 (unsigned int *)&pdata->charging_reset_time);
3739
3740         ret = of_property_read_u32(np, "battery,charging_reset_time",
3741                 (unsigned int *)&pdata->charging_reset_time);
3742
3743         ret = of_property_read_u32(np, "charger,chg_float_voltage",
3744                 (unsigned int *)&pdata->chg_float_voltage);
3745
3746         pr_info("%s: vendor : %s, technology : %d, cable_check_type : %d\n"
3747                 "cable_source_type : %d, event_waiting_time : %d\n"
3748                 "polling_type : %d, initial_count : %d, check_count : %d\n"
3749                 "check_adc_max : %d, check_adc_min : %d\n"
3750                 "ovp_uvlo_check_type : %d, thermal_source : %d\n"
3751                 "temp_check_type : %d, temp_check_count : %d\n"
3752                 "temp_high_threshold_even : %d, temp_high_recovery_event : %d\n"
3753                 "chg_float_voltage : %d\n",
3754                 __func__,
3755                 pdata->vendor, pdata->technology,pdata->cable_check_type,
3756                 pdata->cable_source_type, pdata->event_waiting_time,
3757                 pdata->polling_type, pdata->monitor_initial_count,
3758                 pdata->check_count, pdata->check_adc_max, pdata->check_adc_min,
3759                 pdata->ovp_uvlo_check_type, pdata->thermal_source,
3760                 pdata->temp_check_type, pdata->temp_check_count,
3761                 pdata->temp_high_threshold_event, pdata->temp_high_recovery_event,
3762                 pdata->chg_float_voltage);
3763
3764         return ret;
3765 }
3766 #endif
3767
3768 #ifdef CONFIG_OF
3769 extern sec_battery_platform_data_t sec_battery_pdata;
3770 #endif
3771
3772 #ifdef CONFIG_SEC_BATTERY_PM_NOTIFY
3773 static int sec_battery_pm_notifier(struct notifier_block *nb,
3774                         unsigned long pm_event, void *unused)
3775 {
3776         struct sec_battery_info *battery;
3777
3778         battery = container_of(nb, struct sec_battery_info, pm_nb);
3779
3780         dev_info(battery->dev, "%s: Start\n", __func__);
3781
3782         switch (pm_event) {
3783         case PM_SUSPEND_PREPARE:
3784                 switch (battery->pdata->polling_type) {
3785                 case SEC_BATTERY_MONITOR_WORKQUEUE:
3786                         cancel_delayed_work(&battery->polling_work);
3787                         break;
3788                 case SEC_BATTERY_MONITOR_ALARM:
3789                         alarm_cancel(&battery->polling_alarm);
3790                         break;
3791                 default:
3792                         break;
3793                 }
3794                 cancel_delayed_work_sync(&battery->monitor_work);
3795
3796                 battery->polling_in_sleep = true;
3797
3798                 sec_bat_set_polling(battery);
3799
3800                 /* cancel work for polling
3801                  * that is set in sec_bat_set_polling()
3802                  * no need for polling in sleep
3803                  */
3804                 if (battery->pdata->polling_type ==
3805                         SEC_BATTERY_MONITOR_WORKQUEUE)
3806                         cancel_delayed_work(&battery->polling_work);
3807                 break;
3808         case PM_POST_SUSPEND:
3809                 break;
3810         default:
3811                 break;
3812         }
3813
3814         dev_dbg(battery->dev, "%s: End\n", __func__);
3815
3816         return 0;
3817 }
3818 #endif
3819
3820 #ifdef CONFIG_SLEEP_MONITOR
3821 int bat_get_sleep_monitor_cb(void *priv, unsigned int *raw_val,
3822         int check_level, int caller_type)
3823 {
3824         union power_supply_propval val;
3825         unsigned int temp_res= 0;
3826         int ret;
3827
3828         if (check_level == SLEEP_MONITOR_CHECK_HARD) {
3829                 psy_do_property("sec-fuelgauge", get, POWER_SUPPLY_PROP_CAPACITY, val);
3830         }
3831         else
3832                 sec_bat_get_property(priv, POWER_SUPPLY_PROP_CAPACITY, &val);
3833         temp_res = val.intval;
3834
3835         sec_bat_get_property(priv, POWER_SUPPLY_PROP_STATUS, &val);
3836         ret = val.intval;
3837         temp_res |= val.intval << 8;
3838
3839         sec_bat_get_property(priv, POWER_SUPPLY_PROP_HEALTH, &val);
3840         temp_res |= val.intval << 12;
3841
3842         sec_bat_get_property(priv, POWER_SUPPLY_PROP_ONLINE, &val);
3843         temp_res |= val.intval << 16;
3844
3845         *raw_val = temp_res;
3846
3847         return ret;
3848 }
3849
3850 static struct sleep_monitor_ops bat_sleep_monitor_ops = {
3851         .read_cb_func = bat_get_sleep_monitor_cb,
3852 };
3853 #endif
3854
3855 static int sec_battery_probe(struct platform_device *pdev)
3856 {
3857         sec_battery_platform_data_t *pdata = NULL;
3858         struct sec_battery_info *battery;
3859         int ret = 0;
3860 #ifndef CONFIG_OF
3861         int i;
3862 #endif
3863
3864         union power_supply_propval value;
3865
3866         dev_dbg(&pdev->dev,
3867                 "%s: SEC Battery Driver Loading\n", __func__);
3868
3869         battery = kzalloc(sizeof(*battery), GFP_KERNEL);
3870         if (!battery)
3871                 return -ENOMEM;
3872
3873         if (pdev->dev.of_node) {
3874                 pdata = devm_kzalloc(&pdev->dev,
3875                                 sizeof(sec_battery_platform_data_t),
3876                                 GFP_KERNEL);
3877                 if (!pdata) {
3878                         dev_err(&pdev->dev, "Failed to allocate memory\n");
3879                         ret = -ENOMEM;
3880                         goto err_bat_free;
3881                 }
3882
3883                 battery->pdata = pdata;
3884 #ifdef CONFIG_OF
3885                 if (sec_bat_parse_dt(&pdev->dev, battery))
3886                         dev_err(&pdev->dev,
3887                                 "%s: Failed to get battery init\n", __func__);
3888 #endif
3889         } else {
3890                 pdata = dev_get_platdata(&pdev->dev);
3891                 battery->pdata = pdata;
3892         }
3893
3894         platform_set_drvdata(pdev, battery);
3895
3896         battery->dev = &pdev->dev;
3897
3898         mutex_init(&battery->adclock);
3899
3900         dev_dbg(battery->dev, "%s: ADC init\n", __func__);
3901
3902 #ifdef CONFIG_OF
3903         // adc_init(pdev, battery);
3904 #else
3905         for (i = 0; i < SEC_BAT_ADC_CHANNEL_FULL_CHECK; i++)
3906                 adc_init(pdev, pdata, i);
3907 #endif
3908
3909         wake_lock_init(&battery->monitor_wake_lock, WAKE_LOCK_SUSPEND,
3910                        "sec-battery-monitor");
3911         wake_lock_init(&battery->cable_wake_lock, WAKE_LOCK_SUSPEND,
3912                        "sec-battery-cable");
3913         wake_lock_init(&battery->vbus_wake_lock, WAKE_LOCK_SUSPEND,
3914                        "sec-battery-vbus");
3915
3916         /* initialization of battery info */
3917         battery->status = POWER_SUPPLY_STATUS_DISCHARGING;
3918         battery->health = POWER_SUPPLY_HEALTH_GOOD;
3919         battery->present = true;
3920
3921         battery->polling_count = 1;     /* initial value = 1 */
3922         battery->polling_time = pdata->polling_time[
3923                 SEC_BATTERY_POLLING_TIME_DISCHARGING];
3924         battery->polling_in_sleep = false;
3925         battery->polling_short = false;
3926
3927         battery->check_count = 0;
3928         battery->check_adc_count = 0;
3929         battery->check_adc_value = 0;
3930
3931         battery->charging_start_time = 0;
3932         battery->charging_passed_time = 0;
3933         battery->charging_next_time = 0;
3934         battery->charging_fullcharged_time = 0;
3935         battery->siop_level = 100;
3936         battery->wc_enable = 1;
3937 #if defined(CONFIG_SAMSUNG_BATTERY_ENG_TEST)
3938         battery->stability_test = 0;
3939         battery->eng_not_full_status = 0;
3940 #endif
3941         battery->wc_status = 0;
3942         battery->ps_status= 0;
3943         battery->wire_status = POWER_SUPPLY_TYPE_BATTERY;
3944
3945 #if defined(CONFIG_BATTERY_SWELLING)
3946         battery->swelling_mode = SEC_BATTERY_NORMAL_MODE;
3947         battery->swelling_max_vbat = 4340;
3948         battery->swelling_temp_dischg_threshold = BATT_SWELLING_DISCHG_TEMP;
3949         battery->swelling_temp_dischg_recovery = BATT_SWELLING_DISCHG_TEMP_RECOV;
3950         battery->swelling_temp_high_threshold = BATT_SWELLING_HIGH_TEMP_BLOCK;
3951         battery->swelling_temp_high_recovery = BATT_SWELLING_HIGH_TEMP_RECOV;
3952         battery->swelling_temp_low_threshold = BATT_SWELLING_LOW_TEMP_BLOCK;
3953         battery->swelling_temp_low_recovery = BATT_SWELLING_LOW_TEMP_RECOV;
3954         battery->swelling_recharge_voltage = BATT_SWELLING_RECHG_VOLTAGE;
3955         battery->swelling_block_time = BATT_SWELLING_BLOCK_TIME;
3956 #endif
3957 #if defined(CONFIG_BATTERY_DISCHG_IC)
3958         battery->dischg_test = pdata->dischg_test;
3959 #endif
3960
3961 #if defined(ANDROID_ALARM_ACTIVATED)
3962         alarm_init(&battery->event_termination_alarm,
3963                         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
3964                         sec_bat_event_expired_timer_func);
3965 #else
3966         alarm_init(&battery->event_termination_alarm,
3967                         ALARM_BOOTTIME,
3968                         sec_bat_event_expired_timer_func);
3969 #endif
3970
3971         battery->temp_high_threshold =
3972                 pdata->temp_high_threshold_normal;
3973         battery->temp_high_recovery =
3974                 pdata->temp_high_recovery_normal;
3975         battery->temp_low_recovery =
3976                 pdata->temp_low_recovery_normal;
3977         battery->temp_low_threshold =
3978                 pdata->temp_low_threshold_normal;
3979         battery->temperature = 255;
3980
3981         battery->charging_mode = SEC_BATTERY_CHARGING_NONE;
3982         battery->is_recharging = false;
3983         battery->cable_type = POWER_SUPPLY_TYPE_BATTERY;
3984         battery->test_mode = 0;
3985         battery->factory_mode = false;
3986         battery->slate_mode = false;
3987
3988         battery->psy_bat.name = "battery",
3989         battery->psy_bat.type = POWER_SUPPLY_TYPE_BATTERY,
3990         battery->psy_bat.properties = sec_battery_props,
3991         battery->psy_bat.num_properties = ARRAY_SIZE(sec_battery_props),
3992         battery->psy_bat.get_property = sec_bat_get_property,
3993         battery->psy_bat.set_property = sec_bat_set_property,
3994         battery->psy_usb.name = "usb",
3995         battery->psy_usb.type = POWER_SUPPLY_TYPE_USB,
3996         battery->psy_usb.supplied_to = supply_list,
3997         battery->psy_usb.num_supplicants = ARRAY_SIZE(supply_list),
3998         battery->psy_usb.properties = sec_power_props,
3999         battery->psy_usb.num_properties = ARRAY_SIZE(sec_power_props),
4000         battery->psy_usb.get_property = sec_usb_get_property,
4001         battery->psy_ac.name = "ac",
4002         battery->psy_ac.type = POWER_SUPPLY_TYPE_MAINS,
4003         battery->psy_ac.supplied_to = supply_list,
4004         battery->psy_ac.num_supplicants = ARRAY_SIZE(supply_list),
4005         battery->psy_ac.properties = sec_power_props,
4006         battery->psy_ac.num_properties = ARRAY_SIZE(sec_power_props),
4007         battery->psy_ac.get_property = sec_ac_get_property;
4008         battery->psy_wireless.name = "wireless",
4009         battery->psy_wireless.type = POWER_SUPPLY_TYPE_WIRELESS,
4010         battery->psy_wireless.supplied_to = supply_list,
4011         battery->psy_wireless.num_supplicants = ARRAY_SIZE(supply_list),
4012         battery->psy_wireless.properties = sec_power_props,
4013         battery->psy_wireless.num_properties = ARRAY_SIZE(sec_power_props),
4014         battery->psy_wireless.get_property = sec_wireless_get_property;
4015         battery->psy_wireless.set_property = sec_wireless_set_property;
4016         battery->psy_ps.name = "ps",
4017         battery->psy_ps.type = POWER_SUPPLY_TYPE_POWER_SHARING,
4018         battery->psy_ps.supplied_to = supply_list,
4019         battery->psy_ps.num_supplicants = ARRAY_SIZE(supply_list),
4020         battery->psy_ps.properties = sec_ps_props,
4021         battery->psy_ps.num_properties = ARRAY_SIZE(sec_ps_props),
4022         battery->psy_ps.get_property = sec_ps_get_property;
4023         battery->psy_ps.set_property = sec_ps_set_property;
4024
4025         /* create work queue */
4026         battery->monitor_wqueue =
4027             create_singlethread_workqueue(dev_name(&pdev->dev));
4028         if (!battery->monitor_wqueue) {
4029                 dev_err(battery->dev,
4030                         "%s: Fail to Create Workqueue\n", __func__);
4031                 goto err_wake_lock;
4032         }
4033
4034         INIT_DELAYED_WORK(&battery->monitor_work, sec_bat_monitor_work);
4035         INIT_WORK(&battery->cable_work, sec_bat_cable_work);
4036
4037         switch (pdata->polling_type) {
4038         case SEC_BATTERY_MONITOR_WORKQUEUE:
4039                 INIT_DELAYED_WORK(&battery->polling_work,
4040                         sec_bat_polling_work);
4041                 break;
4042         case SEC_BATTERY_MONITOR_ALARM:
4043 #if defined(ANDROID_ALARM_ACTIVATED)
4044                 battery->last_poll_time = alarm_get_elapsed_realtime();
4045                 alarm_init(&battery->polling_alarm,
4046                         ANDROID_ALARM_ELAPSED_REALTIME_WAKEUP,
4047                         sec_bat_alarm);
4048 #else
4049                 battery->last_poll_time = ktime_get_boottime();
4050                 alarm_init(&battery->polling_alarm, ALARM_BOOTTIME,
4051                         sec_bat_alarm);
4052 #endif
4053                 break;
4054
4055         default:
4056                 break;
4057         }
4058
4059         /* init power supplier framework */
4060         ret = power_supply_register(&pdev->dev, &battery->psy_ps);
4061         if (ret) {
4062                 dev_err(battery->dev,
4063                         "%s: Failed to Register psy_ps\n", __func__);
4064                 goto err_workqueue;
4065         }
4066
4067         ret = power_supply_register(&pdev->dev, &battery->psy_wireless);
4068         if (ret) {
4069                 dev_err(battery->dev,
4070                         "%s: Failed to Register psy_wireless\n", __func__);
4071                 goto err_supply_unreg_ps;
4072         }
4073
4074         ret = power_supply_register(&pdev->dev, &battery->psy_usb);
4075         if (ret) {
4076                 dev_err(battery->dev,
4077                         "%s: Failed to Register psy_usb\n", __func__);
4078                 goto err_supply_unreg_wireless;
4079         }
4080
4081         ret = power_supply_register(&pdev->dev, &battery->psy_ac);
4082         if (ret) {
4083                 dev_err(battery->dev,
4084                         "%s: Failed to Register psy_ac\n", __func__);
4085                 goto err_supply_unreg_usb;
4086         }
4087
4088         ret = power_supply_register(&pdev->dev, &battery->psy_bat);
4089         if (ret) {
4090                 dev_err(battery->dev,
4091                         "%s: Failed to Register psy_bat\n", __func__);
4092                 goto err_supply_unreg_ac;
4093         }
4094
4095         if (battery->pdata->bat_gpio_init && !battery->pdata->bat_gpio_init()) {
4096                 dev_err(battery->dev,
4097                         "%s: Failed to Initialize GPIO\n", __func__);
4098                 goto err_supply_unreg_bat;
4099         }
4100 #if 0
4101         if (battery->pdata->bat_irq) {
4102                 ret = request_threaded_irq(battery->pdata->bat_irq,
4103                                 NULL, sec_bat_irq_thread,
4104                                 battery->pdata->bat_irq_attr,
4105                                 "battery-irq", battery);
4106                 if (ret) {
4107                         dev_err(battery->dev,
4108                                 "%s: Failed to Request IRQ, %d, %d\n", __func__, battery->pdata->bat_irq, ret);
4109                         goto err_supply_unreg_ac;
4110                 }
4111
4112                 ret = enable_irq_wake(battery->pdata->bat_irq);
4113                 if (ret < 0)
4114                         dev_err(battery->dev,
4115                         "%s: Failed to Enable Wakeup Source(%d)\n",
4116                         __func__, ret);
4117         }
4118 #endif
4119
4120         ret = sec_bat_create_attrs(battery->psy_bat.dev);
4121         if (ret) {
4122                 dev_err(battery->dev,
4123                         "%s : Failed to create_attrs\n", __func__);
4124                 goto err_req_irq;
4125         }
4126         //sprdbat_creat_caliberate_attr(battery->psy_bat.dev);
4127
4128 #if defined(CONFIG_MUIC_NOTIFIER)
4129         muic_notifier_register(&battery->batt_nb,
4130                                batt_handle_notification,
4131                                MUIC_NOTIFY_DEV_CHARGER);
4132 #endif
4133
4134         if (pdata->initial_check)
4135                 pdata->initial_check(battery);
4136         else
4137                 sec_bat_initial_check();
4138
4139         psy_do_property("battery", get,
4140                                 POWER_SUPPLY_PROP_ONLINE, value);
4141
4142         if (value.intval == POWER_SUPPLY_TYPE_BATTERY) {
4143                 dev_info(&pdev->dev,
4144                 "%s: SEC Battery Driver Monitorwork\n", __func__);
4145                 wake_lock(&battery->monitor_wake_lock);
4146                 queue_delayed_work(battery->monitor_wqueue, &battery->monitor_work, 0);
4147         }
4148
4149         if (battery->pdata->check_battery_callback)
4150                 battery->present = battery->pdata->check_battery_callback(battery);
4151
4152 #ifdef CONFIG_SEC_BATTERY_PM_NOTIFY
4153         battery->pm_nb.notifier_call = sec_battery_pm_notifier;
4154
4155         register_pm_notifier(&battery->pm_nb);
4156 #endif
4157
4158 #ifdef CONFIG_SLEEP_MONITOR
4159         sleep_monitor_register_ops(&battery->psy_bat,
4160                 &bat_sleep_monitor_ops, SLEEP_MONITOR_BATTERY);
4161 #endif
4162
4163         dev_info(battery->dev,
4164                 "%s: SEC Battery Driver Loaded\n", __func__);
4165         //sec_bat_set_charge(battery, true);
4166         return 0;
4167
4168 err_req_irq:
4169         if (battery->pdata->bat_irq)
4170                 free_irq(battery->pdata->bat_irq, battery);
4171 err_supply_unreg_ac:
4172         power_supply_unregister(&battery->psy_ac);
4173 err_supply_unreg_usb:
4174         power_supply_unregister(&battery->psy_usb);
4175 err_supply_unreg_bat:
4176         power_supply_unregister(&battery->psy_bat);
4177 err_supply_unreg_wireless:
4178         power_supply_unregister(&battery->psy_wireless);
4179 err_supply_unreg_ps:
4180         power_supply_unregister(&battery->psy_ps);
4181 err_workqueue:
4182         destroy_workqueue(battery->monitor_wqueue);
4183 err_wake_lock:
4184         wake_lock_destroy(&battery->monitor_wake_lock);
4185         wake_lock_destroy(&battery->cable_wake_lock);
4186         wake_lock_destroy(&battery->vbus_wake_lock);
4187         mutex_destroy(&battery->adclock);
4188         kfree(pdata);
4189 err_bat_free:
4190         kfree(battery);
4191
4192         return ret;
4193 }
4194
4195 static int sec_battery_remove(struct platform_device *pdev)
4196 {
4197         struct sec_battery_info *battery = platform_get_drvdata(pdev);
4198 #ifndef CONFIG_OF
4199         int i;
4200 #endif
4201
4202         dev_dbg(battery->dev, "%s: Start\n", __func__);
4203
4204         switch (battery->pdata->polling_type) {
4205         case SEC_BATTERY_MONITOR_WORKQUEUE:
4206                 cancel_delayed_work(&battery->polling_work);
4207                 break;
4208         case SEC_BATTERY_MONITOR_ALARM:
4209                 alarm_cancel(&battery->polling_alarm);
4210                 break;
4211         default:
4212                 break;
4213         }
4214
4215         alarm_cancel(&battery->event_termination_alarm);
4216         flush_workqueue(battery->monitor_wqueue);
4217         destroy_workqueue(battery->monitor_wqueue);
4218         wake_lock_destroy(&battery->monitor_wake_lock);
4219         wake_lock_destroy(&battery->cable_wake_lock);
4220         wake_lock_destroy(&battery->vbus_wake_lock);
4221
4222         mutex_destroy(&battery->adclock);
4223 #ifdef CONFIG_OF
4224         // adc_exit(battery);
4225 #else
4226         for (i = 0; i < SEC_BAT_ADC_CHANNEL_FULL_CHECK; i++)
4227                 adc_exit(battery->pdata, i);
4228 #endif
4229
4230         power_supply_unregister(&battery->psy_ps);
4231         power_supply_unregister(&battery->psy_wireless);
4232         power_supply_unregister(&battery->psy_ac);
4233         power_supply_unregister(&battery->psy_usb);
4234         power_supply_unregister(&battery->psy_bat);
4235
4236 #ifdef CONFIG_SEC_BATTERY_PM_NOTIFY
4237         unregister_pm_notifier(&battery->pm_nb);
4238 #endif
4239
4240 #ifdef CONFIG_SLEEP_MONITOR
4241         sleep_monitor_unregister_ops(SLEEP_MONITOR_BATTERY);
4242 #endif
4243
4244         dev_dbg(battery->dev, "%s: End\n", __func__);
4245         kfree(battery);
4246
4247         return 0;
4248 }
4249
4250 static int sec_battery_prepare(struct device *dev)
4251 {
4252 #ifndef CONFIG_SEC_BATTERY_PM_NOTIFY
4253         struct sec_battery_info *battery
4254                 = dev_get_drvdata(dev);
4255
4256         dev_dbg(battery->dev, "%s: Start\n", __func__);
4257
4258         switch (battery->pdata->polling_type) {
4259         case SEC_BATTERY_MONITOR_WORKQUEUE:
4260                 cancel_delayed_work(&battery->polling_work);
4261                 break;
4262         case SEC_BATTERY_MONITOR_ALARM:
4263                 alarm_cancel(&battery->polling_alarm);
4264                 break;
4265         default:
4266                 break;
4267         }
4268         cancel_delayed_work_sync(&battery->monitor_work);
4269
4270         battery->polling_in_sleep = true;
4271
4272         sec_bat_set_polling(battery);
4273
4274         /* cancel work for polling
4275          * that is set in sec_bat_set_polling()
4276          * no need for polling in sleep
4277          */
4278         if (battery->pdata->polling_type ==
4279                 SEC_BATTERY_MONITOR_WORKQUEUE)
4280                 cancel_delayed_work(&battery->polling_work);
4281
4282         dev_dbg(battery->dev, "%s: End\n", __func__);
4283 #endif
4284         return 0;
4285 }
4286
4287 static int sec_battery_suspend(struct device *dev)
4288 {
4289         return 0;
4290 }
4291
4292 static int sec_battery_resume(struct device *dev)
4293 {
4294         return 0;
4295 }
4296
4297 static void sec_battery_complete(struct device *dev)
4298 {
4299         struct sec_battery_info *battery
4300                 = dev_get_drvdata(dev);
4301
4302         dev_dbg(battery->dev, "%s: Start\n", __func__);
4303
4304         /* cancel current alarm and reset after monitor work */
4305         if (battery->pdata->polling_type == SEC_BATTERY_MONITOR_ALARM)
4306                 alarm_cancel(&battery->polling_alarm);
4307
4308         wake_lock(&battery->monitor_wake_lock);
4309         queue_delayed_work(battery->monitor_wqueue,
4310                 &battery->monitor_work, msecs_to_jiffies(500));
4311
4312         dev_dbg(battery->dev, "%s: End\n", __func__);
4313
4314         return;
4315 }
4316
4317 static void sec_battery_shutdown(struct device *dev)
4318 {
4319 }
4320
4321 #ifdef CONFIG_OF
4322 static struct of_device_id sec_battery_dt_ids[] = {
4323         { .compatible = "samsung,sec-battery" },
4324         { }
4325 };
4326 MODULE_DEVICE_TABLE(of, sec_battery_dt_ids);
4327 #endif /* CONFIG_OF */
4328
4329 static const struct dev_pm_ops sec_battery_pm_ops = {
4330         .prepare = sec_battery_prepare,
4331         .suspend = sec_battery_suspend,
4332         .resume = sec_battery_resume,
4333         .complete = sec_battery_complete,
4334 };
4335
4336 static struct platform_driver sec_battery_driver = {
4337         .driver = {
4338                 .name = "sec-battery",
4339                 .owner = THIS_MODULE,
4340                 .pm = &sec_battery_pm_ops,
4341                 .shutdown = sec_battery_shutdown,
4342 #ifdef CONFIG_OF
4343                 .of_match_table = sec_battery_dt_ids,
4344 #endif
4345         },
4346         .probe = sec_battery_probe,
4347         .remove = sec_battery_remove,
4348 };
4349
4350 static int __init sec_battery_init(void)
4351 {
4352         return platform_driver_register(&sec_battery_driver);
4353 }
4354
4355 static void __exit sec_battery_exit(void)
4356 {
4357         platform_driver_unregister(&sec_battery_driver);
4358 }
4359
4360 late_initcall(sec_battery_init);
4361 module_exit(sec_battery_exit);
4362
4363 MODULE_DESCRIPTION("Samsung Battery Driver");
4364 MODULE_AUTHOR("Samsung Electronics");
4365 MODULE_LICENSE("GPL");