drivers/power/wm831x_power.c

   1 /*
   2  * PMU driver for Wolfson Microelectronics wm831x PMICs
   3  *
   4  * Copyright 2009 Wolfson Microelectronics PLC.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/err.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/power_supply.h>
  15 #include <linux/slab.h>
  16
  17 #include <linux/mfd/wm831x/core.h>
  18 #include <linux/mfd/wm831x/auxadc.h>
  19 #include <linux/mfd/wm831x/pmu.h>
  20 #include <linux/mfd/wm831x/pdata.h>
  21 #include <linux/mfd/wm831x/irq.h>
  22
  23 #define WM831X_DEBUG
  24 #undef  WM831X_DEBUG
  25
  26 #ifdef WM831X_DEBUG
  27 #define WM_BATT_DBG(x...) printk(KERN_INFO x)
  28 #else
  29 #define WM_BATT_DBG(x...)  do {} while (0)
  30 #endif
  31
  32 #define WM831X_CHG_SYSLO_SHIFT   4
  33 #define WM831X_CHG_SYSOK_SHIFT   0
  34 #define WM831X_CHG_SYSLO_MASK  ~(0x7 << 4)
  35 #define WM831X_CHG_SYSOK_MASK  ~(0x7 << 0)
  36
  37 #define batt_num   52
  38
  39 static int batt_step_table[batt_num] = {
  40         3380,3405,3440,3475,3505,3525,
  41         3540,3557,3570,3580,3610,
  42         3630,3640,3652,3662,3672,
  43         3680,3687,3693,3699,3705,
  44         3710,3714,3718,3722,3726,
  45         3730,3734,3738,3742,3746,
  46         3750,3756,3764,3774,3786,
  47         3800,3808,3817,3827,3838,
  48         3950,3964,3982,4002,4026,
  49         4050,4074,4098,4123,4149,4178
  50 };
  51
  52 static int batt_disp_table[batt_num] = {
  53         0,1,2,3,5,7,
  54         9,11,13,15,17,
  55         19,21,23,25,27,
  56         29,31,33,35,37,
  57         39,41,43,45,47,
  58         49,51,53,55,57,
  59         59,61,63,65,67,
  60         69,71,73,75,77,
  61         79,81,83,85,87,
  62         89,91,93,95,97,100
  63 };
  64
  65 static int batt_chg_step_table[batt_num] = {
  66         3530,3565,3600,3635,3655,3680,//+160
  67         3700,3717,3734,3745,3755,//+150
  68         3770,3778,3786,3795,3803,//+140
  69         3810,3814,3818,3822,3825,//+130
  70         3830,3832,3834,3836,3837,//+120
  71         3840,3842,3844,3846,3847,//+110
  72         3850,3857,3864,3871,3876,//+100
  73         3890,3897,3904,3911,3918,//+90
  74         4030,4047,4064,4080,4096,//+80
  75         4120,4132,4144,4156,4170,4180//+70
  76 };
  77
  78
  79
  80 #define TIMER_MS_COUNTS 1000
  81 struct wm_batt_priv_data {
  82         int online;
  83         int status;
  84         int health;
  85         int level;
  86         int temp;
  87         int voltage;
  88 };
  89
  90 struct wm831x_power {
  91         struct wm831x *wm831x;
  92         struct power_supply wall;
  93         struct power_supply usb;
  94         struct power_supply battery;
  95         struct work_struct batt_work;
  96         struct timer_list timer;
  97         struct wm_batt_priv_data batt_info;
  98         int interval;
  99 };
 100
 101 struct wm831x_power *g_wm831x_power;
 102
 103 static int power_test_sysfs_init(void);
 104 extern void wm831x_batt_vol_level(struct wm831x_power *power, int batt_vol, int *level);
 105 static DEFINE_MUTEX(charging_mutex);
 106
 107 int wm831x_read_on_pin_status(void)
 108 {
 109         int ret;
 110
 111         if(!g_wm831x_power)
 112         {
 113                 printk("err:%s:g_wm831x_power address is 0\n",__FUNCTION__);
 114                 return -1;
 115         }
 116
 117         ret = wm831x_reg_read(g_wm831x_power->wm831x, WM831X_ON_PIN_CONTROL);
 118         if (ret < 0)
 119                 return ret;
 120
 121         return !(ret & WM831X_ON_PIN_STS) ? 1 : 0;
 122 }
 123
 124 static int wm831x_power_check_online(struct wm831x *wm831x, int supply,
 125                                      union power_supply_propval *val)
 126 {
 127         int ret;
 128
 129         ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
 130         if (ret < 0)
 131                 return ret;
 132
 133         if (ret & supply)
 134                 val->intval = 1;
 135         else
 136                 val->intval = 0;
 137
 138         return 0;
 139 }
 140
 141 int wm831x_read_chg_status(void)
 142 {
 143         int ret, usb_chg = 0, wall_chg = 0;
 144
 145         if(!g_wm831x_power)
 146         {
 147                 printk("err:%s:g_wm831x_power address is 0\n",__FUNCTION__);
 148                 return -1;
 149         }
 150
 151         ret = wm831x_reg_read(g_wm831x_power->wm831x, WM831X_SYSTEM_STATUS);
 152         if (ret < 0)
 153                 return ret;
 154
 155         if (ret & WM831X_PWR_USB)
 156                 usb_chg = 1;
 157         if (ret & WM831X_PWR_WALL)
 158                 wall_chg = 1;
 159
 160         return ((usb_chg | wall_chg) ? 1 : 0);
 161 }
 162
 163 static int wm831x_power_read_voltage(struct wm831x *wm831x,
 164                                      enum wm831x_auxadc src,
 165                                      union power_supply_propval *val)
 166 {
 167         int ret;
 168         ret = wm831x_auxadc_read_uv(wm831x, src);
 169         if (ret >= 0)
 170                 val->intval = ret / 1000;
 171
 172         return ret ;
 173 }
 174
 175 int wm831x_read_batt_voltage(void)
 176 {
 177         int ret = 0;
 178
 179         if(!g_wm831x_power)
 180         {
 181                 printk("err:%s:g_wm831x_power address is 0\n",__FUNCTION__);
 182                 return -1;
 183         }
 184
 185         ret = wm831x_auxadc_read_uv(g_wm831x_power->wm831x, WM831X_AUX_BATT);
 186         return ret / 1000;
 187 }
 188 //EXPORT_SYMBOL_GPL(wm831x_get_batt_voltage);
 189
 190 /*********************************************************************
 191  *              WALL Power
 192  *********************************************************************/
 193 static int wm831x_wall_get_prop(struct power_supply *psy,
 194                                 enum power_supply_property psp,
 195                                 union power_supply_propval *val)
 196 {
 197         struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
 198         struct wm831x *wm831x = wm831x_power->wm831x;
 199         int ret = 0;
 200
 201         switch (psp) {
 202         case POWER_SUPPLY_PROP_ONLINE:
 203                 ret = wm831x_power_check_online(wm831x, WM831X_PWR_WALL, val);
 204                 break;
 205         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 206                 ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_WALL, val);
 207                 break;
 208         default:
 209                 ret = -EINVAL;
 210                 break;
 211         }
 212
 213         return ret;
 214 }
 215
 216 static enum power_supply_property wm831x_wall_props[] = {
 217         POWER_SUPPLY_PROP_ONLINE,
 218         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 219 };
 220
 221 /*********************************************************************
 222  *              USB Power
 223  *********************************************************************/
 224 static int wm831x_usb_get_prop(struct power_supply *psy,
 225                                enum power_supply_property psp,
 226                                union power_supply_propval *val)
 227 {
 228         struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
 229         struct wm831x *wm831x = wm831x_power->wm831x;
 230         int ret = 0;
 231
 232         switch (psp) {
 233         case POWER_SUPPLY_PROP_ONLINE:
 234                 ret = wm831x_power_check_online(wm831x, WM831X_PWR_USB, val);
 235                 break;
 236         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 237                 ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_USB, val);
 238                 break;
 239         default:
 240                 ret = -EINVAL;
 241                 break;
 242         }
 243
 244         return ret;
 245 }
 246
 247 static enum power_supply_property wm831x_usb_props[] = {
 248         POWER_SUPPLY_PROP_ONLINE,
 249         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 250 };
 251
 252 /*********************************************************************
 253  *              Battery properties
 254  *********************************************************************/
 255
 256 struct chg_map {
 257         int val;
 258         int reg_val;
 259 };
 260
 261 static struct chg_map trickle_ilims[] = {
 262         {  50, 0 << WM831X_CHG_TRKL_ILIM_SHIFT },
 263         { 100, 1 << WM831X_CHG_TRKL_ILIM_SHIFT },
 264         { 150, 2 << WM831X_CHG_TRKL_ILIM_SHIFT },
 265         { 200, 3 << WM831X_CHG_TRKL_ILIM_SHIFT },
 266 };
 267
 268 static struct chg_map vsels[] = {
 269         { 4050, 0 << WM831X_CHG_VSEL_SHIFT },
 270         { 4100, 1 << WM831X_CHG_VSEL_SHIFT },
 271         { 4150, 2 << WM831X_CHG_VSEL_SHIFT },
 272         { 4200, 3 << WM831X_CHG_VSEL_SHIFT },
 273 };
 274
 275 static struct chg_map fast_ilims[] = {
 276         {    0,  0 << WM831X_CHG_FAST_ILIM_SHIFT },
 277         {   50,  1 << WM831X_CHG_FAST_ILIM_SHIFT },
 278         {  100,  2 << WM831X_CHG_FAST_ILIM_SHIFT },
 279         {  150,  3 << WM831X_CHG_FAST_ILIM_SHIFT },
 280         {  200,  4 << WM831X_CHG_FAST_ILIM_SHIFT },
 281         {  250,  5 << WM831X_CHG_FAST_ILIM_SHIFT },
 282         {  300,  6 << WM831X_CHG_FAST_ILIM_SHIFT },
 283         {  350,  7 << WM831X_CHG_FAST_ILIM_SHIFT },
 284         {  400,  8 << WM831X_CHG_FAST_ILIM_SHIFT },
 285         {  450,  9 << WM831X_CHG_FAST_ILIM_SHIFT },
 286         {  500, 10 << WM831X_CHG_FAST_ILIM_SHIFT },
 287         {  600, 11 << WM831X_CHG_FAST_ILIM_SHIFT },
 288         {  700, 12 << WM831X_CHG_FAST_ILIM_SHIFT },
 289         {  800, 13 << WM831X_CHG_FAST_ILIM_SHIFT },
 290         {  900, 14 << WM831X_CHG_FAST_ILIM_SHIFT },
 291         { 1000, 15 << WM831X_CHG_FAST_ILIM_SHIFT },
 292 };
 293
 294 static struct chg_map eoc_iterms[] = {
 295         { 20, 0 << WM831X_CHG_ITERM_SHIFT },
 296         { 30, 1 << WM831X_CHG_ITERM_SHIFT },
 297         { 40, 2 << WM831X_CHG_ITERM_SHIFT },
 298         { 50, 3 << WM831X_CHG_ITERM_SHIFT },
 299         { 60, 4 << WM831X_CHG_ITERM_SHIFT },
 300         { 70, 5 << WM831X_CHG_ITERM_SHIFT },
 301         { 80, 6 << WM831X_CHG_ITERM_SHIFT },
 302         { 90, 7 << WM831X_CHG_ITERM_SHIFT },
 303 };
 304
 305 static struct chg_map chg_times[] = {
 306         {  60,  0 << WM831X_CHG_TIME_SHIFT },
 307         {  90,  1 << WM831X_CHG_TIME_SHIFT },
 308         { 120,  2 << WM831X_CHG_TIME_SHIFT },
 309         { 150,  3 << WM831X_CHG_TIME_SHIFT },
 310         { 180,  4 << WM831X_CHG_TIME_SHIFT },
 311         { 210,  5 << WM831X_CHG_TIME_SHIFT },
 312         { 240,  6 << WM831X_CHG_TIME_SHIFT },
 313         { 270,  7 << WM831X_CHG_TIME_SHIFT },
 314         { 300,  8 << WM831X_CHG_TIME_SHIFT },
 315         { 330,  9 << WM831X_CHG_TIME_SHIFT },
 316         { 360, 10 << WM831X_CHG_TIME_SHIFT },
 317         { 390, 11 << WM831X_CHG_TIME_SHIFT },
 318         { 420, 12 << WM831X_CHG_TIME_SHIFT },
 319         { 450, 13 << WM831X_CHG_TIME_SHIFT },
 320         { 480, 14 << WM831X_CHG_TIME_SHIFT },
 321         { 510, 15 << WM831X_CHG_TIME_SHIFT },
 322 };
 323
 324 static struct chg_map chg_syslos[] = {
 325         { 2800, 0 << WM831X_CHG_SYSLO_SHIFT},
 326         { 2900, 1 << WM831X_CHG_SYSLO_SHIFT},
 327         { 3000, 2 << WM831X_CHG_SYSLO_SHIFT},
 328         { 3100, 3 << WM831X_CHG_SYSLO_SHIFT},
 329         { 3200, 4 << WM831X_CHG_SYSLO_SHIFT},
 330         { 3300, 5 << WM831X_CHG_SYSLO_SHIFT},
 331         { 3400, 6 << WM831X_CHG_SYSLO_SHIFT},
 332         { 3500, 7 << WM831X_CHG_SYSLO_SHIFT},
 333 };
 334
 335 static struct chg_map chg_sysoks[] = {
 336         { 2800, 0 << WM831X_CHG_SYSOK_SHIFT},
 337         { 2900, 1 << WM831X_CHG_SYSOK_SHIFT},
 338         { 3000, 2 << WM831X_CHG_SYSOK_SHIFT},
 339         { 3100, 3 << WM831X_CHG_SYSOK_SHIFT},
 340         { 3200, 4 << WM831X_CHG_SYSOK_SHIFT},
 341         { 3300, 5 << WM831X_CHG_SYSOK_SHIFT},
 342         { 3400, 6 << WM831X_CHG_SYSOK_SHIFT},
 343         { 3500, 7 << WM831X_CHG_SYSOK_SHIFT},
 344 };
 345
 346 static void wm831x_battey_apply_config(struct wm831x *wm831x,
 347                                        struct chg_map *map, int count, int val,
 348                                        int *reg, const char *name,
 349                                        const char *units)
 350 {
 351         int i;
 352         for (i = 0; i < count; i++)
 353                 if (val == map[i].val)
 354                         break;
 355         if (i == count) {
 356                 dev_err(wm831x->dev, "Invalid %s %d%s\n",
 357                         name, val, units);
 358         } else {
 359                 *reg |= map[i].reg_val;
 360                 dev_dbg(wm831x->dev, "Set %s of %d%s\n", name, val, units);
 361         }
 362 }
 363
 364 static void wm831x_config_battery(struct wm831x *wm831x)
 365 {
 366         struct wm831x_pdata *wm831x_pdata = wm831x->dev->platform_data;
 367         struct wm831x_battery_pdata *pdata;
 368         int ret, reg1, reg2, reg3;
 369
 370         if (!wm831x_pdata || !wm831x_pdata->battery) {
 371                 dev_warn(wm831x->dev,
 372                          "No battery charger configuration\n");
 373                 return;
 374         }
 375
 376         pdata = wm831x_pdata->battery;
 377
 378         reg1 = 0;
 379         reg2 = 0;
 380         reg3 = 0;
 381
 382         if (!pdata->enable) {
 383                 dev_info(wm831x->dev, "Battery charger disabled\n");
 384                 return;
 385         }
 386
 387         reg1 |= WM831X_CHG_ENA;
 388         if (pdata->off_mask)
 389                 reg2 |= WM831X_CHG_OFF_MSK;
 390         if (pdata->fast_enable)
 391                 reg1 |= WM831X_CHG_FAST;
 392
 393         wm831x_battey_apply_config(wm831x, trickle_ilims,
 394                                    ARRAY_SIZE(trickle_ilims),
 395                                    pdata->trickle_ilim, &reg2,
 396                                    "trickle charge current limit", "mA");
 397
 398         wm831x_battey_apply_config(wm831x, vsels, ARRAY_SIZE(vsels),
 399                                    pdata->vsel, &reg2,
 400                                    "target voltage", "mV");
 401
 402         wm831x_battey_apply_config(wm831x, fast_ilims, ARRAY_SIZE(fast_ilims),
 403                                    pdata->fast_ilim, &reg2,
 404                                    "fast charge current limit", "mA");
 405
 406         wm831x_battey_apply_config(wm831x, eoc_iterms, ARRAY_SIZE(eoc_iterms),
 407                                    pdata->eoc_iterm, &reg1,
 408                                    "end of charge current threshold", "mA");
 409
 410         wm831x_battey_apply_config(wm831x, chg_times, ARRAY_SIZE(chg_times),
 411                                    pdata->timeout, &reg2,
 412                                    "charger timeout", "min");
 413
 414         wm831x_battey_apply_config(wm831x, chg_syslos, ARRAY_SIZE(chg_syslos),
 415                                    pdata->syslo, &reg3,
 416                                    "syslo voltage", "mV");
 417
 418         wm831x_battey_apply_config(wm831x, chg_sysoks, ARRAY_SIZE(chg_sysoks),
 419                                    pdata->sysok, &reg3,
 420                                    "sysok voltage", "mV");
 421
 422         ret = wm831x_reg_unlock(wm831x);
 423         if (ret != 0) {
 424                 dev_err(wm831x->dev, "Failed to unlock registers: %d\n", ret);
 425                 return;
 426         }
 427
 428         ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_1,
 429                               WM831X_CHG_ENA_MASK |
 430                               WM831X_CHG_FAST_MASK |
 431                               WM831X_CHG_ITERM_MASK,
 432                               reg1);
 433         if (ret != 0) {
 434                 dev_err(wm831x->dev, "Failed to set charger control 1: %d\n",
 435                         ret);
 436         }
 437         ret = wm831x_set_bits(wm831x, WM831X_CHARGER_CONTROL_2,
 438                               WM831X_CHG_OFF_MSK |
 439                               WM831X_CHG_TIME_MASK |
 440                               WM831X_CHG_FAST_ILIM_MASK |
 441                               WM831X_CHG_TRKL_ILIM_MASK |
 442                               WM831X_CHG_VSEL_MASK,
 443                               reg2);
 444         if (ret != 0) {
 445                 dev_err(wm831x->dev, "Failed to set charger control 2: %d\n",
 446                         ret);
 447         }
 448
 449         ret = wm831x_set_bits(wm831x, WM831X_SYSVDD_CONTROL,
 450                                           WM831X_CHG_SYSLO_MASK |
 451                                                   WM831X_CHG_SYSOK_MASK,
 452                                                   reg3);
 453         if (ret < 0) {
 454                 dev_err(wm831x->dev, "Failed to set sysvdd control reg: %d\n",ret);
 455         }
 456
 457         wm831x_reg_lock(wm831x);
 458 }
 459
 460 static int wm831x_bat_check_status(struct wm831x *wm831x, int *status)
 461 {
 462         int ret;
 463
 464         ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
 465         if (ret < 0)
 466                 return ret;
 467
 468         if (ret & WM831X_PWR_SRC_BATT) {
 469                 *status = POWER_SUPPLY_STATUS_DISCHARGING;
 470                 return 0;
 471         }
 472
 473         ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
 474         if (ret < 0)
 475                 return ret;
 476
 477
 478         switch (ret & WM831X_CHG_STATE_MASK) {
 479         case WM831X_CHG_STATE_OFF:
 480                 *status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 481                 break;
 482         case WM831X_CHG_STATE_TRICKLE:
 483         case WM831X_CHG_STATE_FAST:
 484                 *status = POWER_SUPPLY_STATUS_CHARGING;
 485                 break;
 486
 487         default:
 488                 *status = POWER_SUPPLY_STATUS_UNKNOWN;
 489                 break;
 490         }
 491
 492         return 0;
 493 }
 494 int wm831x_read_bat_charging_status(void)
 495 {
 496         int ret, status;
 497
 498         if(!g_wm831x_power)
 499         {
 500                 printk("err:%s:g_wm831x_power address is 0\n",__FUNCTION__);
 501                 return -1;
 502         }
 503
 504         ret = wm831x_bat_check_status(g_wm831x_power->wm831x, &status);
 505         if (ret < 0)
 506                 return ret;
 507         if (status == POWER_SUPPLY_STATUS_CHARGING)
 508                 return 1;
 509         return 0;
 510 }
 511
 512 static int wm831x_bat_check_type(struct wm831x *wm831x, int *type)
 513 {
 514         int ret;
 515 #ifdef WM831X_DEBUG_0
 516         ret = wm831x_reg_read(wm831x, WM831X_POWER_STATE);
 517         if (ret < 0)
 518                 return ret;
 519         WM_BATT_DBG("%s: wm831x power status %#x\n", __FUNCTION__, ret);
 520
 521         ret = wm831x_reg_read(wm831x, WM831X_SYSTEM_STATUS);
 522         if (ret < 0)
 523                 return ret;
 524         WM_BATT_DBG("%s: wm831x system status %#x\n", __FUNCTION__, ret);
 525
 526         ret = wm831x_reg_read(wm831x, WM831X_CHARGER_CONTROL_1);
 527         if (ret < 0)
 528                 return ret;
 529         WM_BATT_DBG("%s: wm831x charger control1 %#x\n", __FUNCTION__, ret);
 530
 531         ret = wm831x_reg_read(wm831x, WM831X_CHARGER_CONTROL_2);
 532         if (ret < 0)
 533                 return ret;
 534         WM_BATT_DBG("%s: wm831x charger control2 %#x\n", __FUNCTION__, ret);
 535
 536         ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
 537         if (ret < 0)
 538                 return ret;
 539         WM_BATT_DBG("%s: wm831x charger status %#x\n\n", __FUNCTION__, ret);
 540 #endif
 541
 542         ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
 543         if (ret < 0)
 544                 return ret;
 545
 546         switch (ret & WM831X_CHG_STATE_MASK) {
 547         case WM831X_CHG_STATE_TRICKLE:
 548         case WM831X_CHG_STATE_TRICKLE_OT:
 549                 *type = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
 550                 break;
 551         case WM831X_CHG_STATE_FAST:
 552         case WM831X_CHG_STATE_FAST_OT:
 553                 *type = POWER_SUPPLY_CHARGE_TYPE_FAST;
 554                 break;
 555         default:
 556                 *type = POWER_SUPPLY_CHARGE_TYPE_NONE;
 557                 break;
 558         }
 559
 560         return 0;
 561 }
 562
 563 static int wm831x_bat_check_health(struct wm831x *wm831x, int *health)
 564 {
 565         int ret;
 566
 567         ret = wm831x_reg_read(wm831x, WM831X_CHARGER_STATUS);
 568         if (ret < 0)
 569                 return ret;
 570
 571         if (ret & WM831X_BATT_HOT_STS) {
 572                 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
 573                 return 0;
 574         }
 575
 576         if (ret & WM831X_BATT_COLD_STS) {
 577                 *health = POWER_SUPPLY_HEALTH_COLD;
 578                 return 0;
 579         }
 580
 581         if (ret & WM831X_BATT_OV_STS) {
 582                 *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 583                 return 0;
 584         }
 585
 586         switch (ret & WM831X_CHG_STATE_MASK) {
 587         case WM831X_CHG_STATE_TRICKLE_OT:
 588         case WM831X_CHG_STATE_FAST_OT:
 589                 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
 590                 break;
 591         case WM831X_CHG_STATE_DEFECTIVE:
 592                 *health = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
 593                 break;
 594         default:
 595                 *health = POWER_SUPPLY_HEALTH_GOOD;
 596                 break;
 597         }
 598
 599         return 0;
 600 }
 601
 602 static int wm831x_bat_get_prop(struct power_supply *psy,
 603                                enum power_supply_property psp,
 604                                union power_supply_propval *val)
 605 {
 606         struct wm831x_power *wm831x_power = dev_get_drvdata(psy->dev->parent);
 607         struct wm831x *wm831x = wm831x_power->wm831x;
 608         int  ret = 0;
 609
 610         switch (psp) {
 611         case POWER_SUPPLY_PROP_STATUS:
 612                 ret = wm831x_bat_check_status(wm831x, &val->intval);
 613                 //val->intval = wm831x_power->batt_info.status;
 614                 break;
 615         case POWER_SUPPLY_PROP_PRESENT:
 616         case POWER_SUPPLY_PROP_ONLINE:
 617                 //ret = wm831x_power_check_online(wm831x, WM831X_PWR_SRC_BATT, val);
 618                 val->intval = wm831x_power->batt_info.online;
 619                 break;
 620         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
 621                 //ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_BATT, val);
 622                 val->intval = wm831x_power->batt_info.voltage;
 623                 break;
 624         case POWER_SUPPLY_PROP_HEALTH:
 625                 //ret = wm831x_bat_check_health(wm831x, &val->intval);
 626                 val->intval = wm831x_power->batt_info.health;
 627                 break;
 628         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 629                 ret = wm831x_bat_check_type(wm831x, &val->intval);
 630                 break;
 631         case POWER_SUPPLY_PROP_CAPACITY:
 632                 //ret = wm831x_power_read_voltage(wm831x, WM831X_AUX_BATT, val);
 633                 //wm831x_batt_vol_level(wm831x_power, val->intval, &level);
 634                 //val->intval = level;
 635                 val->intval = wm831x_power->batt_info.level;
 636                 break;
 637         case POWER_SUPPLY_PROP_TEMP:
 638                 val->intval = 0;
 639                 break;
 640         case POWER_SUPPLY_PROP_TECHNOLOGY:
 641                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
 642                 break;
 643         default:
 644                 ret = -EINVAL;
 645                 break;
 646         }
 647
 648         return ret;
 649 }
 650
 651 static enum power_supply_property wm831x_bat_props[] = {
 652         POWER_SUPPLY_PROP_STATUS,
 653         POWER_SUPPLY_PROP_HEALTH,
 654         POWER_SUPPLY_PROP_PRESENT,
 655         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 656         POWER_SUPPLY_PROP_CAPACITY, /* in percents! */
 657         POWER_SUPPLY_PROP_TECHNOLOGY,
 658         POWER_SUPPLY_PROP_TEMP,
 659         POWER_SUPPLY_PROP_CHARGE_TYPE,
 660 };
 661
 662 #ifdef CONFIG_WM831X_WITH_BATTERY
 663 static const char *wm831x_bat_irqs[] = {
 664         "BATT HOT",
 665         "BATT COLD",
 666         "BATT FAIL",
 667         "OV",
 668         "END",
 669         "TO",
 670         "MODE",
 671         "START",
 672 };
 673
 674 static irqreturn_t wm831x_bat_irq(int irq, void *data)
 675 {
 676         struct wm831x_power *wm831x_power = data;
 677         struct wm831x *wm831x = wm831x_power->wm831x;
 678         int irq0;
 679
 680         irq0 = wm831x->irq_base + WM831X_IRQ_CHG_BATT_HOT + 1;
 681         dev_crit(wm831x->dev, "battery changed: i=%d\n", irq-irq0);
 682
 683         /* The battery charger is autonomous so we don't need to do
 684          * anything except kick user space */
 685         power_supply_changed(&wm831x_power->battery);
 686
 687         return IRQ_HANDLED;
 688 }
 689 #endif
 690
 691 /*********************************************************************
 692  *              Initialisation
 693  *********************************************************************/
 694
 695 static irqreturn_t wm831x_syslo_irq(int irq, void *data)
 696 {
 697         struct wm831x_power *wm831x_power = data;
 698         struct wm831x *wm831x = wm831x_power->wm831x;
 699
 700         /* Not much we can actually *do* but tell people for
 701          * posterity, we're probably about to run out of power. */
 702         dev_crit(wm831x->dev, "SYSVDD under voltage\n");
 703         return IRQ_HANDLED;
 704 }
 705
 706 static irqreturn_t wm831x_pwr_src_irq(int irq, void *data)
 707 {
 708         struct wm831x_power *wm831x_power = data;
 709         struct wm831x *wm831x = wm831x_power->wm831x;
 710
 711         dev_dbg(wm831x->dev, "Power source changed\n");
 712         WM_BATT_DBG("%s:Power source changed\n", __FUNCTION__);
 713         /* Just notify for everything - little harm in overnotifying. */
 714         power_supply_changed(&wm831x_power->battery);
 715         power_supply_changed(&wm831x_power->usb);
 716         power_supply_changed(&wm831x_power->wall);
 717
 718
 719         return IRQ_HANDLED;
 720 }
 721
 722 static void wm831x_batt_timer_handler(unsigned long data)
 723 {
 724         struct wm831x_power *wm831x_power = (struct wm831x_power*)data;
 725         schedule_work(&wm831x_power->batt_work);
 726         mod_timer(&wm831x_power->timer, jiffies + msecs_to_jiffies(wm831x_power->interval));
 727 }
 728
 729 void wm831x_batt_vol_level(struct wm831x_power *wm831x_power, int batt_vol, int *level)
 730 {
 731         int i, ret, status;
 732         static int count = 0;
 733         static int disp_plus = 100;
 734         static int disp_minus = 100;
 735         static int disp_curr = 0;
 736
 737         *level = wm831x_power->batt_info.level;
 738         ret = wm831x_bat_check_status(wm831x_power->wm831x, &status);
 739         if (ret < 0) {
 740                 printk("%s: check bat status failer...err = %d\n", __FUNCTION__, ret);
 741                 return;
 742         }
 743
 744         if (status == POWER_SUPPLY_STATUS_NOT_CHARGING
 745                         && batt_vol >= batt_step_table[batt_num-1]) {
 746                 *level = 100;
 747                 return;
 748         }
 749
 750         if (status == POWER_SUPPLY_STATUS_CHARGING) {
 751                 disp_plus = 0;
 752                 disp_minus = 0;
 753                 disp_curr = 0;
 754
 755                 for(i = 0; i < batt_num; i++){
 756                         if((batt_chg_step_table[i] <= batt_vol) &&
 757                                          (batt_chg_step_table[i+1] > batt_vol))
 758                                 break;
 759                 }
 760                 *level = batt_disp_table[i];
 761
 762                 if (batt_vol <= batt_chg_step_table[0])
 763                         *level = 0;
 764                 if (batt_vol >= batt_chg_step_table[batt_num - 1])
 765                         *level = 100;
 766
 767                 count++;
 768                 if (*level < wm831x_power->batt_info.level && count > 20)
 769                         *level = wm831x_power->batt_info.level;
 770
 771                 if (*level >= 100)
 772                         *level = 100;
 773                 if (*level < 0)
 774                         *level = 0;
 775         }
 776         else {
 777                 count = 0;
 778
 779                 for(i = 0; i < batt_num; i++){
 780                         if(batt_vol >= batt_step_table[i] &&
 781                                          batt_vol < batt_step_table[i+1])
 782                                 break;
 783                 }
 784                 *level = batt_disp_table[i];
 785
 786                 if (batt_vol <= batt_step_table[0])
 787                         *level = 0;
 788                 if (batt_vol >= batt_step_table[batt_num - 1])
 789                         *level = 100;
 790
 791                 // ³õÊ¼×´Ì¬
 792                 if ((disp_plus == 100) && (disp_minus == 100))
 793                 {
 794                         *level = *level;
 795                         disp_plus = 0;
 796                         disp_minus = 0;
 797                         disp_curr = 0;
 798                 }
 799                 else
 800                 {
 801                         if (*level <= (wm831x_power->batt_info.level-3))
 802                         {
 803                                 disp_plus = 0;
 804                                 disp_curr = 0;
 805
 806                                 if (++disp_minus > 4)
 807                                 {
 808                                         *level = wm831x_power->batt_info.level - 3;
 809                                         disp_minus = 0;
 810                                 }
 811                                 else
 812                                 {
 813                                         *level = wm831x_power->batt_info.level;
 814                                 }
 815                         }
 816                         else if (*level <= wm831x_power->batt_info.level)
 817                         {
 818                                 disp_plus = 0;
 819                                 disp_minus = 0;
 820
 821                                 if (++disp_curr > 4)
 822                                 {
 823                                         *level = *level;
 824                                         disp_curr = 0;
 825                                 }
 826                                 else
 827                                 {
 828                                         *level = wm831x_power->batt_info.level;
 829                                 }
 830                         }
 831                         else if (*level >= (wm831x_power->batt_info.level+3))
 832                         {
 833                                 disp_minus = 0;
 834                                 disp_curr = 0;
 835
 836                                 if (++disp_plus > 10)
 837                                 {
 838                                         *level = wm831x_power->batt_info.level + 3;
 839                                         disp_plus = 0;
 840                                 }
 841                                 else
 842                                 {
 843                                         *level = wm831x_power->batt_info.level;
 844                                 }
 845                         }
 846                         else
 847                         {
 848                                 disp_plus = 0;
 849                                 disp_minus = 0;
 850                                 disp_curr = 0;
 851                                 *level = wm831x_power->batt_info.level;
 852                         }
 853                 }
 854
 855                 if (*level >= 100)
 856                         *level = 100;
 857                 if (*level < 0)
 858                         *level = 0;
 859         }
 860 }
 861
 862 static void wm831x_batt_work(struct work_struct *work)
 863 {
 864         int online, status,health,level, ret;
 865     union power_supply_propval val;
 866         struct wm831x_power *power = container_of(work, struct wm831x_power, batt_work);
 867
 868         ret = wm831x_power_check_online(power->wm831x, WM831X_PWR_SRC_BATT, &val);
 869         if (ret < 0) {
 870                 printk("%s: check bat online failer...  err = %d\n", __FUNCTION__, ret);
 871                 return;
 872         }
 873         online = val.intval;
 874
 875         ret = wm831x_bat_check_status(power->wm831x, &status);
 876         if (ret < 0) {
 877                 printk("%s: check bat status failer...  err = %d\n", __FUNCTION__, ret);
 878                 return;
 879         }
 880
 881         ret = wm831x_bat_check_health(power->wm831x, &health);
 882         if (ret < 0) {
 883                 printk("%s: check bat health failer...  err = %d\n", __FUNCTION__, ret);
 884                 return;
 885         }
 886
 887         ret = wm831x_power_read_voltage(power->wm831x, WM831X_AUX_BATT, &val);
 888         if (ret < 0) {
 889                 printk("%s: read bat voltage failer...err = %d\n", __FUNCTION__, ret);
 890                 return;
 891         }
 892         power->batt_info.voltage = val.intval;
 893
 894         wm831x_batt_vol_level(power, val.intval, &level);
 895         //mod_timer(&power->timer, jiffies + msecs_to_jiffies(power->interval));
 896
 897         if (online != power->batt_info.online || status != power->batt_info.status
 898                         || health != power->batt_info.health || level != power->batt_info.level)
 899         {
 900                 power->batt_info.online = online;
 901                 power->batt_info.status = status;
 902                 power->batt_info.health = health;
 903                 power->batt_info.level  = level;
 904
 905                 power_supply_changed(&power->battery);
 906         }
 907
 908 }
 909
 910 static __devinit int wm831x_power_probe(struct platform_device *pdev)
 911 {
 912         struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
 913         struct wm831x_power *power;
 914         struct power_supply *usb;
 915         struct power_supply *battery;
 916         struct power_supply *wall;
 917         int ret, irq, i;
 918
 919         power = kzalloc(sizeof(struct wm831x_power), GFP_KERNEL);
 920         if (power == NULL)
 921                 return -ENOMEM;
 922
 923         power->wm831x = wm831x;
 924         platform_set_drvdata(pdev, power);
 925
 926         usb = &power->usb;
 927         battery = &power->battery;
 928         wall = &power->wall;
 929
 930         /* We ignore configuration failures since we can still read back
 931          * the status without enabling the charger.
 932          */
 933         wm831x_config_battery(wm831x);
 934
 935         wall->name = "wm831x-wall";
 936         wall->type = POWER_SUPPLY_TYPE_MAINS;
 937         wall->properties = wm831x_wall_props;
 938         wall->num_properties = ARRAY_SIZE(wm831x_wall_props);
 939         wall->get_property = wm831x_wall_get_prop;
 940         ret = power_supply_register(&pdev->dev, wall);
 941         if (ret)
 942                 goto err_kmalloc;
 943
 944         battery->name = "wm831x-battery";
 945         battery->properties = wm831x_bat_props;
 946         battery->num_properties = ARRAY_SIZE(wm831x_bat_props);
 947         battery->get_property = wm831x_bat_get_prop;
 948         battery->use_for_apm = 1;
 949         ret = power_supply_register(&pdev->dev, battery);
 950         if (ret)
 951                 goto err_wall;
 952
 953         usb->name = "wm831x-usb",
 954         usb->type = POWER_SUPPLY_TYPE_USB;
 955         usb->properties = wm831x_usb_props;
 956         usb->num_properties = ARRAY_SIZE(wm831x_usb_props);
 957         usb->get_property = wm831x_usb_get_prop;
 958         ret = power_supply_register(&pdev->dev, usb);
 959         if (ret)
 960                 goto err_battery;
 961
 962         irq = platform_get_irq_byname(pdev, "SYSLO");
 963         ret = request_threaded_irq(irq, NULL, wm831x_syslo_irq,
 964                                    IRQF_TRIGGER_RISING, "System power low",
 965                                    power);
 966         if (ret != 0) {
 967                 dev_err(&pdev->dev, "Failed to request SYSLO IRQ %d: %d\n",
 968                         irq, ret);
 969                 goto err_usb;
 970         }
 971
 972         irq = platform_get_irq_byname(pdev, "PWR SRC");
 973         ret = request_threaded_irq(irq, NULL, wm831x_pwr_src_irq,
 974                                    IRQF_TRIGGER_RISING, "Power source",
 975                                    power);
 976         if (ret != 0) {
 977                 dev_err(&pdev->dev, "Failed to request PWR SRC IRQ %d: %d\n",
 978                         irq, ret);
 979                 goto err_syslo;
 980         }
 981
 982 #ifdef CONFIG_WM831X_WITH_BATTERY
 983         for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
 984                 irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
 985                 ret = request_threaded_irq(irq, NULL, wm831x_bat_irq,
 986                                            IRQF_TRIGGER_RISING,
 987                                            wm831x_bat_irqs[i],
 988                                            power);
 989                 WM_BATT_DBG("%s: %s irq no %d\n", __FUNCTION__, wm831x_bat_irqs[i], irq);
 990                 if (ret != 0) {
 991                         dev_err(&pdev->dev,
 992                                 "Failed to request %s IRQ %d: %d\n",
 993                                 wm831x_bat_irqs[i], irq, ret);
 994                         goto err_bat_irq;
 995                 }
 996         }
 997 #endif
 998
 999         power->interval = TIMER_MS_COUNTS;
1000         power->batt_info.level = 100;
1001         power->batt_info.voltage   = 4200;
1002         power->batt_info.online    = 1;
1003         power->batt_info.status    = POWER_SUPPLY_STATUS_DISCHARGING;
1004         power->batt_info.health    = POWER_SUPPLY_HEALTH_GOOD;
1005
1006         INIT_WORK(&power->batt_work, wm831x_batt_work);
1007         setup_timer(&power->timer, wm831x_batt_timer_handler, (unsigned long)power);
1008         power->timer.expires = jiffies + msecs_to_jiffies(1000);
1009         add_timer(&power->timer);
1010
1011         g_wm831x_power = power;
1012         printk("%s:wm831x_power initialized\n",__FUNCTION__);
1013         power_test_sysfs_init();
1014         return ret;
1015
1016 #ifdef CONFIG_WM831X_WITH_BATTERY
1017 err_bat_irq:
1018         for (; i >= 0; i--) {
1019                 irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
1020                 free_irq(irq, power);
1021         }
1022         irq = platform_get_irq_byname(pdev, "PWR SRC");
1023         free_irq(irq, power);
1024 #endif
1025
1026 err_syslo:
1027         irq = platform_get_irq_byname(pdev, "SYSLO");
1028         free_irq(irq, power);
1029 err_usb:
1030         power_supply_unregister(usb);
1031 err_battery:
1032         power_supply_unregister(battery);
1033 err_wall:
1034         power_supply_unregister(wall);
1035 err_kmalloc:
1036         kfree(power);
1037         return ret;
1038 }
1039
1040 static __devexit int wm831x_power_remove(struct platform_device *pdev)
1041 {
1042         struct wm831x_power *wm831x_power = platform_get_drvdata(pdev);
1043         int irq, i;
1044 #ifdef CONFIG_WM831X_WITH_BATTERY
1045         for (i = 0; i < ARRAY_SIZE(wm831x_bat_irqs); i++) {
1046                 irq = platform_get_irq_byname(pdev, wm831x_bat_irqs[i]);
1047                 free_irq(irq, wm831x_power);
1048         }
1049 #endif
1050         irq = platform_get_irq_byname(pdev, "PWR SRC");
1051         free_irq(irq, wm831x_power);
1052
1053         irq = platform_get_irq_byname(pdev, "SYSLO");
1054         free_irq(irq, wm831x_power);
1055
1056         power_supply_unregister(&wm831x_power->battery);
1057         power_supply_unregister(&wm831x_power->wall);
1058         power_supply_unregister(&wm831x_power->usb);
1059         kfree(wm831x_power);
1060         return 0;
1061 }
1062
1063 #ifdef CONFIG_PM
1064 static int wm831x_battery_suspend(struct platform_device *dev, pm_message_t state)
1065 {
1066         struct wm831x_power *power = (struct wm831x_power *)platform_get_drvdata(dev);
1067         flush_scheduled_work();
1068         del_timer(&power->timer);
1069         return 0;
1070 }
1071
1072 static int wm831x_battery_resume(struct platform_device *dev)
1073 {
1074         struct wm831x_power *power = (struct wm831x_power *)platform_get_drvdata(dev);
1075         power->timer.expires = jiffies + msecs_to_jiffies(power->interval);
1076         add_timer(&power->timer);
1077         return 0;
1078 }
1079 #else
1080 #define wm831x_battery_suspend NULL
1081 #define wm831x_battery_resume  NULL
1082 #endif
1083
1084 static struct platform_driver wm831x_power_driver = {
1085         .probe = wm831x_power_probe,
1086         .remove = __devexit_p(wm831x_power_remove),
1087         .suspend = wm831x_battery_suspend,
1088         .resume = wm831x_battery_resume,
1089         .driver = {
1090                 .name = "wm831x-power",
1091         },
1092 };
1093 static int __init wm831x_power_init(void)
1094 {
1095         return platform_driver_register(&wm831x_power_driver);
1096 }
1097 module_init(wm831x_power_init);
1098
1099 static void __exit wm831x_power_exit(void)
1100 {
1101         platform_driver_unregister(&wm831x_power_driver);
1102 }
1103 module_exit(wm831x_power_exit);
1104
1105
1106 static ssize_t power_prop_show(struct device *dev,
1107                 struct device_attribute *attr, char *buf)
1108 {
1109         ssize_t ret = 0;
1110         int level, power_status, system_status, chg_ctl1, chg_ctl2, chg_status;
1111     union power_supply_propval val;
1112
1113         if (!g_wm831x_power)
1114                 return -1;
1115         power_status = wm831x_reg_read(g_wm831x_power->wm831x, WM831X_POWER_STATE);
1116         if (power_status < 0)
1117                 return power_status;
1118         //printk("wm831x power status %#x\n", ret);
1119
1120         system_status = wm831x_reg_read(g_wm831x_power->wm831x, WM831X_SYSTEM_STATUS);
1121         if (system_status < 0)
1122                 return system_status;
1123         //printk("wm831x system status %#x\n", ret);
1124
1125         chg_ctl1 = wm831x_reg_read(g_wm831x_power->wm831x, WM831X_CHARGER_CONTROL_1);
1126         if (chg_ctl1 < 0)
1127                 return chg_ctl1;
1128         //printk("wm831x charger control1 %#x\n", ret);
1129
1130         chg_ctl2 = wm831x_reg_read(g_wm831x_power->wm831x, WM831X_CHARGER_CONTROL_2);
1131         if (chg_ctl2 < 0)
1132                 return chg_ctl2;
1133         //printk("wm831x charger control2 %#x\n", ret);
1134
1135         chg_status = wm831x_reg_read(g_wm831x_power->wm831x, WM831X_CHARGER_STATUS);
1136         if (chg_status < 0)
1137                 return chg_status;
1138         //printk("wm831x charger status %#x\n", ret);
1139
1140         ret = wm831x_power_read_voltage(g_wm831x_power->wm831x, WM831X_AUX_BATT, &val);
1141         if (ret < 0)
1142                 return ret;
1143         wm831x_batt_vol_level(g_wm831x_power, val.intval, &level);
1144         //printk("batt_vol = %d batt_level = %d\n", val.intval, level);
1145         //
1146         sprintf(buf, "power_status=%#x\n"
1147                              "system_status=%#x\n"
1148                                  "chg_ctl1=%#x\n"
1149                                  "chg_ctl2=%#x\n"
1150                                  "chg_status=%#x\n"
1151                                  "batt_vol=%d\n"
1152                                  "batt_level=%d%%\n",
1153                                  power_status,
1154                                  system_status,
1155                                  chg_ctl1,
1156                                  chg_ctl2,
1157                                  chg_status,
1158                                  val.intval,
1159                                  level);
1160         ret = strlen(buf) + 1;
1161         return ret;
1162 }
1163
1164 static DEVICE_ATTR(prop, 0444, power_prop_show, NULL);
1165
1166 static struct kobject *power_test_kobj;
1167
1168 static int power_test_sysfs_init(void)
1169 {
1170         int ret ;
1171         power_test_kobj = kobject_create_and_add("power_test_prop", NULL);
1172         if (power_test_kobj == NULL) {
1173                 printk(KERN_ERR
1174                        "power_test_sysfs_init:"\
1175                        "subsystem_register failed\n");
1176                 ret = -ENOMEM;
1177                 goto err;
1178         }
1179         ret = sysfs_create_file(power_test_kobj, &dev_attr_prop.attr);
1180         if (ret) {
1181                 printk(KERN_ERR
1182                        "power_test_sysfs_init:"\
1183                        "sysfs_create_group failed\n");
1184                 goto err1;
1185         }
1186
1187         return 0 ;
1188 err1:
1189         kobject_del(power_test_kobj);
1190 err:
1191         return ret ;
1192 }
1193
1194
1195 MODULE_DESCRIPTION("Power supply driver for WM831x PMICs");
1196 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
1197 MODULE_LICENSE("GPL");
1198 MODULE_ALIAS("platform:wm831x-power");
1199