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