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