drivers/power/smb328_charger.c

   1 /*
   2  *  smb328_charger.c
   3  *
   4  *  Copyright (C) 2011 Samsung Electronics
   5  *  Ikkeun Kim <iks.kim@samsung.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/power/smb328_charger.h>
  13 #include <linux/regulator/driver.h>
  14 #include <plat/gpio-core.h>
  15 #include <linux/switch.h>
  16 #define DEBUG
  17
  18 #define SMB328_USB_MAX_CURRENT  450000
  19 #define SMB328_TA_TYP_CURRENT   650000
  20
  21 enum cable_type_t {
  22         CABLE_TYPE_NONE = 0,
  23         CABLE_TYPE_USB,
  24         CABLE_TYPE_AC,
  25         CABLE_TYPE_MISC,
  26         CABLE_TYPE_OTG,
  27 };
  28
  29 static int smb328_i2c_read(struct i2c_client *client, u8 reg, u8 *data)
  30 {
  31         int ret = 0;
  32
  33         if(!client)
  34                 return -ENODEV;
  35
  36         ret = i2c_smbus_read_byte_data(client, reg);
  37         if (ret < 0)
  38                 return -EIO;
  39
  40         *data = ret & 0xff;
  41         return *data;
  42 }
  43
  44 static int smb328_i2c_write(struct i2c_client *client, u8 reg, u8 data)
  45 {
  46         if(!client)
  47                 return -ENODEV;
  48
  49         return i2c_smbus_write_byte_data(client, reg, data);
  50 }
  51
  52 static void smb328_test_read(struct i2c_client *client)
  53 {
  54         struct smb328_chip * chg = i2c_get_clientdata(client);
  55         u8 data = 0;
  56         u32 addr = 0;
  57
  58         for(addr=0;addr<0x0c;addr++)
  59         {
  60                 smb328_i2c_read(chg->client, addr, &data);
  61                 dev_info(&client->dev, "smb328 addr : 0x%02x data : 0x%02x\n", addr,data);
  62         }
  63
  64         for(addr=0x31;addr<0x3D;addr++)
  65         {
  66                 smb328_i2c_read(chg->client, addr, &data);
  67                 dev_info(&client->dev, "smb328 addr : 0x%02x data : 0x%02x\n", addr,data);
  68         }
  69 }
  70
  71 static int smb328_get_charging_status(struct i2c_client *client)
  72 {
  73         struct smb328_chip *chg = i2c_get_clientdata(client);
  74         int status = POWER_SUPPLY_STATUS_UNKNOWN;
  75         u8 data_a = 0;
  76         u8 data_b = 0;
  77         u8 data_c = 0;
  78
  79         smb328_i2c_read(chg->client, SMB328A_BATTERY_CHARGING_STATUS_A, &data_a);
  80         dev_info(&client->dev, "%s : charging status A(0x%02x)\n",
  81                 __func__, data_a);
  82         smb328_i2c_read(chg->client, SMB328A_BATTERY_CHARGING_STATUS_B, &data_b);
  83         dev_info(&client->dev, "%s : charging status B(0x%02x)\n",
  84                 __func__, data_b);
  85         smb328_i2c_read(chg->client, SMB328A_BATTERY_CHARGING_STATUS_C, &data_c);
  86         dev_info(&client->dev, "%s : charging status C(0x%02x)\n",
  87                 __func__, data_c);
  88
  89         /* At least one charge cycle terminated, Charge current < Termination Current */
  90         if ((data_c & 0xc0) == 0xc0) {
  91                 status = POWER_SUPPLY_STATUS_FULL;      /* top-off by full charging */
  92                 goto charging_status_end;
  93         }
  94
  95         /* Is enabled ? */
  96         if (data_c & 0x01) {
  97                 /* check for 0x30 : 'safety timer' (0b01 or 0b10) or 'waiting to begin charging' (0b11) */
  98                 /* check for 0x06 : no charging (0b00) */
  99                 if ((data_c & 0x30) || !(data_c & 0x06))  { /* not charging */
 100                         status = POWER_SUPPLY_STATUS_NOT_CHARGING;
 101                         goto charging_status_end;
 102                 } else {
 103                         status = POWER_SUPPLY_STATUS_CHARGING;
 104                         goto charging_status_end;
 105                 }
 106         } else
 107                 status = POWER_SUPPLY_STATUS_DISCHARGING;
 108
 109 charging_status_end:
 110         return (int)status;
 111 }
 112
 113 static int smb328_get_charging_health(struct i2c_client *client)
 114 {
 115         struct smb328_chip *chg = i2c_get_clientdata(client);
 116         int health = POWER_SUPPLY_HEALTH_GOOD;
 117         u8 data_a = 0;
 118         u8 data_b = 0;
 119         u8 data_c = 0;
 120
 121         smb328_i2c_read(chg->client, SMB328A_BATTERY_CHARGING_STATUS_A, &data_a);
 122         dev_info(&client->dev, "%s : charging status A(0x%02x)\n",
 123                 __func__, data_a);
 124         smb328_i2c_read(chg->client, SMB328A_BATTERY_CHARGING_STATUS_B, &data_b);
 125         dev_info(&client->dev, "%s : charging status B(0x%02x)\n",
 126                 __func__, data_b);
 127         smb328_i2c_read(chg->client, SMB328A_BATTERY_CHARGING_STATUS_C, &data_c);
 128         dev_info(&client->dev, "%s : charging status C(0x%02x)\n",
 129                 __func__, data_c);
 130
 131         /* Is enabled ? */
 132         if (data_c & 0x01) {
 133                 if(!(data_a & 0x02))    /* Input current is NOT OK */
 134                         health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
 135         }
 136
 137         return (int)health;
 138 }
 139
 140 static void smb328a_allow_volatile_writes(struct i2c_client *client)
 141 {
 142         int val, reg;
 143         u8 data;
 144
 145         reg = SMB328A_COMMAND;
 146         val = smb328_i2c_read(client, reg, &data);
 147         if ((val >= 0) && !(val&0x80)) {
 148                 data = (u8)val;
 149                 dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 150                         __func__, reg, data);
 151                 data |= (0x1 << 7);
 152                 if (smb328_i2c_write(client, reg, data) < 0)
 153                         pr_err("%s : error!\n", __func__);
 154                 val = smb328_i2c_read(client, reg, &data);
 155                 if (val >= 0) {
 156                         data = (u8)data;
 157                         pr_info("%s : => reg (0x%x) = 0x%x\n", __func__, reg, data);
 158                 }
 159         }
 160 }
 161
 162 static void smb328a_charger_function_conrol(struct i2c_client *client)
 163 {
 164         struct smb328_chip *chip = i2c_get_clientdata(client);
 165         int val, reg;
 166         u8 data, set_data;
 167
 168         if (chip->is_otg) {
 169                 dev_info(&client->dev, "%s : OTG is activated. Ignore command! (type:%d, enable:%s)\n",
 170                         __func__, chip->cable_type, chip->is_enable?"true":"false");
 171                 return;
 172         }
 173
 174         smb328a_allow_volatile_writes(client);
 175
 176         if(!chip->is_enable) {
 177                 reg = SMB328A_FUNCTION_CONTROL_B;
 178                 val = smb328_i2c_read(client, reg, &data);
 179                 if (val >= 0) {
 180                         data = (u8)val;
 181                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 182                                 __func__, reg, data);
 183                         if (data != 0x0) {
 184                                 data = 0x0;
 185                                 if (smb328_i2c_write(client, reg, data) < 0)
 186                                         pr_err("%s : error!\n", __func__);
 187                                 val = smb328_i2c_read(client, reg, &data);
 188                                 if (val >= 0) {
 189                                         data = (u8)val;
 190                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 191                                                 __func__, reg, data);
 192                                 }
 193                         }
 194                 }
 195
 196                 reg = SMB328A_COMMAND;
 197                 val = smb328_i2c_read(client, reg, &data);
 198                 if (val >= 0) {
 199                         data = (u8)val;
 200                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 201                                 __func__, reg, data);
 202                         data = 0x98;    /* turn off charger */
 203                         if (smb328_i2c_write(client, reg, data) < 0)
 204                                 pr_err("%s : error!\n", __func__);
 205                         val = smb328_i2c_read(client, reg, &data);
 206                         if (val >= 0) {
 207                                 data = (u8)val;
 208                                 dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 209                                         __func__, reg, data);
 210                         }
 211                 }
 212         }else {
 213                 reg = SMB328A_INPUT_AND_CHARGE_CURRENTS;
 214                 val = smb328_i2c_read(client, reg, &data);
 215                 if (val >= 0) {
 216                         data = (u8)val;
 217                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 218                                 __func__, reg, data);
 219                         if (chip->cable_type == CABLE_TYPE_AC) {
 220                                 set_data = 0xb7; /* fast 1000mA, termination 200mA */
 221                         } else if (chip->cable_type == CABLE_TYPE_MISC) {
 222                                 set_data = 0x57; /* fast 700mA, termination 200mA */
 223                         } else
 224                                 set_data = 0x17; /* fast 500mA, termination 200mA */
 225                         if (data != set_data) { /* this can be changed with top-off setting */
 226                                 data = set_data;
 227                                 if (smb328_i2c_write(client, reg, data) < 0)
 228                                         pr_err("%s : error!\n", __func__);
 229                                 val = smb328_i2c_read(client, reg, &data);
 230                                 if (val >= 0) {
 231                                         data = (u8)val;
 232                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 233                                                 __func__, reg, data);
 234                                 }
 235                         }
 236                 }
 237
 238                 reg = SMB328A_CURRENT_TERMINATION;
 239                 val = smb328_i2c_read(client, reg, &data);
 240                 if (val >= 0) {
 241                         data = (u8)val;
 242                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 243                                 __func__, reg, data);
 244                         if (chip->cable_type == CABLE_TYPE_AC) {
 245                                 set_data = 0xb0; /* input 1A, threshold 4.25V */
 246                         } else if (chip->cable_type == CABLE_TYPE_MISC) {
 247                                 set_data = 0x50; /* input 700mA, threshold 4.25V */
 248                         } else
 249                                 set_data = 0x10; /* input 450mA, threshold 4.25V */
 250                         if (data != set_data) { /* AICL enable */
 251                                 data = set_data;
 252                                 if (smb328_i2c_write(client, reg, data) < 0)
 253                                         pr_err("%s : error!\n", __func__);
 254                                 val = smb328_i2c_read(client, reg, &data);
 255                                 if (val >= 0) {
 256                                         data = (u8)val;
 257                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 258                                                 __func__, reg, data);
 259                                 }
 260                         }
 261                 }
 262
 263                 reg = SMB328A_FLOAT_VOLTAGE;
 264                 val = smb328_i2c_read(client, reg, &data);
 265                 if (val >= 0) {
 266                         data = (u8)val;
 267                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 268                                 __func__, reg, data);
 269                         if (data != 0xca) {
 270                                 data = 0xca; /* 4.2V float voltage */
 271                                 if (smb328_i2c_write(client, reg, data) < 0)
 272                                         pr_err("%s : error!\n", __func__);
 273                                 val = smb328_i2c_read(client, reg, &data);
 274                                 if (val >= 0) {
 275                                         data = (u8)val;
 276                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 277                                                 __func__, reg, data);
 278                                 }
 279                         }
 280                 }
 281
 282                 reg = SMB328A_FUNCTION_CONTROL_A1;
 283                 val = smb328_i2c_read(client, reg, &data);
 284                 if (val >= 0) {
 285                         data = (u8)val;
 286                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 287                                 __func__, reg, data);
 288 #if 1
 289                         if (data != 0xda) {
 290                                 data = 0xda;    /* top-off by ADC */
 291 #else
 292                         if (data != 0x9a) {
 293                                 data = 0x9a;    /* top-off by charger */
 294 #endif
 295                                 if (smb328_i2c_write(client, reg, data) < 0)
 296                                         pr_err("%s : error!\n", __func__);
 297                                 val = smb328_i2c_read(client, reg, &data);
 298                                 if (val >= 0) {
 299                                         data = (u8)val;
 300                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 301                                                 __func__, reg, data);
 302                                 }
 303                         }
 304                 }
 305
 306                 reg = SMB328A_FUNCTION_CONTROL_A2;
 307                 val = smb328_i2c_read(client, reg, &data);
 308                 if (val >= 0) {
 309                         data = (u8)val;
 310                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 311                                 __func__, reg, data);
 312                         if (data != 0x4c) {
 313                                 data = 0x4c;
 314                                 if (smb328_i2c_write(client, reg, data) < 0)
 315                                         pr_err("%s : error!\n", __func__);
 316                                 val = smb328_i2c_read(client, reg, &data);
 317                                 if (val >= 0) {
 318                                         data = (u8)val;
 319                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 320                                                 __func__, reg, data);
 321                                 }
 322                         }
 323                 }
 324
 325                 reg = SMB328A_FUNCTION_CONTROL_B;
 326                 val = smb328_i2c_read(client, reg, &data);
 327                 if (val >= 0) {
 328                         data = (u8)val;
 329                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 330                                 __func__, reg, data);
 331                         if (data != 0x0) {
 332                                 data = 0x0;
 333                                 if (smb328_i2c_write(client, reg, data) < 0)
 334                                         pr_err("%s : error!\n", __func__);
 335                                 val = smb328_i2c_read(client, reg, &data);
 336                                 if (val >= 0) {
 337                                         data = (u8)val;
 338                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 339                                                 __func__, reg, data);
 340                                 }
 341                         }
 342                 }
 343
 344                 reg = SMB328A_OTG_PWR_AND_LDO_CONTROL;
 345                 val = smb328_i2c_read(client, reg, &data);
 346                 if (val >= 0) {
 347                         data = (u8)val;
 348                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 349                                 __func__, reg, data);
 350                         set_data = 0xf5;
 351                         if (chip->cable_type == CABLE_TYPE_AC) {
 352                                 set_data = 0xf5;
 353                         } else if (chip->cable_type == CABLE_TYPE_MISC) {
 354                                 set_data = 0xf5;
 355                         } else
 356                                 set_data = 0xd5;
 357                         if (data != set_data) {
 358                                 data = set_data;
 359                                 if (smb328_i2c_write(client, reg, data) < 0)
 360                                         pr_err("%s : error!\n", __func__);
 361                                 val = smb328_i2c_read(client, reg, &data);
 362                                 if (val >= 0) {
 363                                         data = (u8)val;
 364                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 365                                                 __func__, reg, data);
 366                                 }
 367                         }
 368                 }
 369
 370                 reg = SMB328A_VARIOUS_CONTROL_FUNCTION_A;
 371                 val = smb328_i2c_read(client, reg, &data);
 372                 if (val >= 0) {
 373                         data = (u8)val;
 374                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 375                                 __func__, reg, data);
 376                         if (data != 0xf6) { /* this can be changed with top-off setting */
 377                                 data = 0xf6;
 378                                 if (smb328_i2c_write(client, reg, data) < 0)
 379                                         pr_err("%s : error!\n", __func__);
 380                                 val = smb328_i2c_read(client, reg, &data);
 381                                 if (val >= 0) {
 382                                         data = (u8)val;
 383                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 384                                                 __func__, reg, data);
 385                                 }
 386                         }
 387                 }
 388
 389                 reg = SMB328A_CELL_TEMPERATURE_MONITOR;
 390                 val = smb328_i2c_read(client, reg, &data);
 391                 if (val >= 0) {
 392                         data = (u8)val;
 393                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 394                                 __func__, reg, data);
 395                         if (data != 0x0) {
 396                                 data = 0x0;
 397                                 if (smb328_i2c_write(client, reg, data) < 0)
 398                                         pr_err("%s : error!\n", __func__);
 399                                 val = smb328_i2c_read(client, reg, &data);
 400                                 if (val >= 0) {
 401                                         data = (u8)val;
 402                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 403                                                 __func__, reg, data);
 404                                 }
 405                         }
 406                 }
 407
 408                 reg = SMB328A_INTERRUPT_SIGNAL_SELECTION;
 409                 val = smb328_i2c_read(client, reg, &data);
 410                 if (val >= 0) {
 411                         data = (u8)val;
 412                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 413                                 __func__, reg, data);
 414                         if (data != 0x0) {
 415                                 data = 0x0;
 416                                 if (smb328_i2c_write(client, reg, data) < 0)
 417                                         pr_err("%s : error!\n", __func__);
 418                                 val = smb328_i2c_read(client, reg, &data);
 419                                 if (val >= 0) {
 420                                         data = (u8)val;
 421                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 422                                                 __func__, reg, data);
 423                                 }
 424                         }
 425                 }
 426
 427                 reg = SMB328A_COMMAND;
 428                 val = smb328_i2c_read(client, reg, &data);
 429                 if (val >= 0) {
 430                         data = (u8)val;
 431                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 432                                 __func__, reg, data);
 433                         if (chip->cable_type == CABLE_TYPE_AC) {                /* turn on charger */
 434                                 data = 0x8c;
 435                         } else if (chip->cable_type == CABLE_TYPE_MISC) {
 436                                 data = 0x88;
 437                         } else
 438                                 data = 0x88; /* USB */
 439                         if (smb328_i2c_write(client, reg, data) < 0)
 440                                 pr_err("%s : error!\n", __func__);
 441                         val = smb328_i2c_read(client, reg, &data);
 442                         if (val >= 0) {
 443                                 data = (u8)val;
 444                                 dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 445                                         __func__, reg, data);
 446                         }
 447                 }
 448         }
 449 }
 450
 451 static void smb328a_charger_otg_conrol(struct i2c_client *client)
 452 {
 453         struct smb328_chip *chip = i2c_get_clientdata(client);
 454         int val, reg;
 455         u8 data;
 456
 457         smb328a_allow_volatile_writes(client);
 458
 459         if(chip->is_otg) {
 460                 reg = SMB328A_FUNCTION_CONTROL_B;
 461                 val = smb328_i2c_read(client, reg, &data);
 462                 if (val >= 0) {
 463                         data = (u8)val;
 464                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 465                                 __func__, reg, data);
 466                         if (data != 0x0) {
 467                                 data = 0x0;
 468                                 if (smb328_i2c_write(client, reg, data) < 0)
 469                                         pr_err("%s : error!\n", __func__);
 470                                 val = smb328_i2c_read(client, reg, &data);
 471                                 if (val >= 0) {
 472                                         data = (u8)val;
 473                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 474                                                 __func__, reg, data);
 475                                 }
 476                         }
 477                 }
 478
 479                 /* delay for reset of charger */
 480                 mdelay(150);
 481
 482                 reg = SMB328A_COMMAND;
 483                 val = smb328_i2c_read(client, reg, &data);
 484                 if (val >= 0) {
 485                         data = (u8)val;
 486                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 487                                 __func__, reg, data);
 488                         data = 0x9a;    /* turn on OTG */
 489                         if (smb328_i2c_write(client, reg, data) < 0)
 490                                 pr_err("%s : error!\n", __func__);
 491                         val = smb328_i2c_read(client, reg, &data);
 492                         if (val >= 0) {
 493                                 data = (u8)val;
 494                                 dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 495                                         __func__, reg, data);
 496                         }
 497                 }
 498         } else {
 499                 reg = SMB328A_FUNCTION_CONTROL_B;
 500                 val = smb328_i2c_read(client, reg, &data);
 501                 if (val >= 0) {
 502                         data = (u8)val;
 503                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 504                                 __func__, reg, data);
 505                         if (data != 0x0) {
 506                                 data = 0x0c;    /* turn off charger */
 507                                 if (smb328_i2c_write(client, reg, data) < 0)
 508                                         pr_err("%s : error!\n", __func__);
 509                                 val = smb328_i2c_read(client, reg, &data);
 510                                 if (val >= 0) {
 511                                         data = (u8)val;
 512                                         dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 513                                                 __func__, reg, data);
 514                                 }
 515                         }
 516                 }
 517
 518                 /* delay for reset of charger */
 519                 mdelay(150);
 520
 521                 reg = SMB328A_COMMAND;
 522                 val = smb328_i2c_read(client, reg, &data);
 523                 if (val >= 0) {
 524                         data = (u8)val;
 525                         dev_info(&client->dev, "%s : reg (0x%x) = 0x%x\n",
 526                                 __func__, reg, data);
 527                         data = 0x98;    /* turn off OTG */
 528                         if (smb328_i2c_write(client, reg, data) < 0)
 529                                 pr_err("%s : error!\n", __func__);
 530                         val = smb328_i2c_read(client, reg, &data);
 531                         if (val >= 0) {
 532                                 data = (u8)val;
 533                                 dev_info(&client->dev, "%s : => reg (0x%x) = 0x%x\n",
 534                                         __func__, reg, data);
 535                         }
 536                 }
 537         }
 538 }
 539
 540 static int smb328_get_property(struct power_supply *psy,
 541                             enum power_supply_property psp,
 542                             union power_supply_propval *val)
 543 {
 544         struct smb328_chip *chip = container_of(psy,
 545                                                   struct smb328_chip,
 546                                                   charger);
 547         u8 data;
 548
 549         switch (psp) {
 550         case POWER_SUPPLY_PROP_STATUS:
 551                 val->intval = smb328_get_charging_status(chip->client);
 552                 break;
 553         case POWER_SUPPLY_PROP_CHARGE_TYPE:
 554                 val->intval = chip->cable_type;
 555                 break;
 556         case POWER_SUPPLY_PROP_HEALTH:
 557                 val->intval = smb328_get_charging_health(chip->client);
 558                 break;
 559         case POWER_SUPPLY_PROP_ONLINE:
 560                 val->intval = chip->is_enable;
 561                 break;
 562         case POWER_SUPPLY_PROP_CURRENT_NOW:
 563                 if (chip->is_enable) {
 564                         smb328_i2c_read(chip->client, SMB328A_INPUT_AND_CHARGE_CURRENTS, &data);
 565                         switch (data >> 5) {
 566                         case 0:
 567                                 val->intval = 450;
 568                                 break;
 569                         case 1:
 570                                 val->intval = 600;
 571                                 break;
 572                         case 2:
 573                                 val->intval = 700;
 574                                 break;
 575                         case 3:
 576                                 val->intval = 800;
 577                                 break;
 578                         case 4:
 579                                 val->intval = 900;
 580                                 break;
 581                         case 5:
 582                                 val->intval = 1000;
 583                                 break;
 584                         case 6:
 585                                 val->intval = 1100;
 586                                 break;
 587                         case 7:
 588                                 val->intval = 1200;
 589                                 break;
 590                         }
 591                 } else
 592                         val->intval = 0;
 593                 break;
 594         default:
 595                 return -EINVAL;
 596         }
 597
 598         dev_info(&chip->client->dev, "%s: smb328_get_property (%d,%d)\n",
 599                 __func__, psp, val->intval);
 600
 601         return 0;
 602 }
 603
 604 static int smb328_set_property(struct power_supply *psy,
 605                             enum power_supply_property psp,
 606                             const union power_supply_propval *val)
 607 {
 608         struct smb328_chip *chip = container_of(psy,
 609                                                   struct smb328_chip,
 610                                                   charger);
 611
 612         dev_info(&chip->client->dev, "%s: smb328_set_property (%d,%d)\n",
 613                 __func__, psp, val->intval);
 614
 615         switch (psp) {
 616         case POWER_SUPPLY_PROP_STATUS:
 617                 chip->is_enable = (val->intval == POWER_SUPPLY_STATUS_CHARGING);
 618                 smb328a_charger_function_conrol(chip->client);
 619                 break;
 620         case POWER_SUPPLY_PROP_CHARGE_TYPE:     /* only for OTG support */
 621                 chip->is_otg = val->intval;
 622                 smb328a_charger_otg_conrol(chip->client);
 623                 smb328_test_read(chip->client);
 624                 break;
 625         case POWER_SUPPLY_PROP_HEALTH:
 626                 break;
 627         case POWER_SUPPLY_PROP_ONLINE:
 628                 chip->is_enable = (bool)val->intval;
 629                 smb328a_charger_function_conrol(chip->client);
 630                 break;
 631         case POWER_SUPPLY_PROP_CURRENT_NOW:
 632                 if (val->intval <= 450)
 633                         chip->cable_type = CABLE_TYPE_USB;      /* USB */
 634                 else
 635                         chip->cable_type = CABLE_TYPE_AC;       /* TA */
 636                 break;
 637         default:
 638                 return -EINVAL;
 639         }
 640         return 0;
 641 }
 642
 643 static irqreturn_t smb328_irq_thread(int irq, void *data)
 644 {
 645         struct smb328_chip *chip = data;
 646         int ret = 0;
 647
 648         dev_info(&chip->client->dev, "%s: chg_ing IRQ occurred!\n", __func__);
 649
 650         if (chip->pdata->topoff_cb)
 651                 ret = chip->pdata->topoff_cb();
 652
 653         if (ret) {
 654                 dev_err(&chip->client->dev, "%s: error from topoff_cb(%d)\n",
 655                         __func__, ret);
 656                 return IRQ_HANDLED;
 657         }
 658
 659         return IRQ_HANDLED;
 660 }
 661
 662 static int smb328_irq_init(struct smb328_chip *chip)
 663 {
 664         struct i2c_client *client = chip->client;
 665         int ret;
 666
 667         if (client->irq) {
 668                 ret = request_threaded_irq(client->irq, NULL,
 669                         smb328_irq_thread,
 670                         IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 671                         "SMB328 charger", chip);
 672                 if (ret) {
 673                         dev_err(&client->dev, "failed to reqeust IRQ\n");
 674                         return ret;
 675                 }
 676
 677                 ret = enable_irq_wake(client->irq);
 678                 if (ret < 0)
 679                         dev_err(&client->dev,
 680                                 "failed to enable wakeup src %d\n", ret);
 681         }
 682
 683         return 0;
 684 }
 685
 686 static int smb328_is_enabled(struct regulator_dev *rdev)
 687 {
 688         struct smb328_chip *smb328 = rdev_get_drvdata(rdev);
 689
 690         return smb328->is_enable;
 691 }
 692
 693 static int smb328_enable(struct regulator_dev *rdev)
 694 {
 695         struct smb328_chip *smb328 = rdev_get_drvdata(rdev);
 696
 697         smb328->is_enable = 1;
 698 //      smb328a_charger_function_conrol(smb328->client);
 699
 700         return 0;
 701 }
 702
 703 static int smb328_disable(struct regulator_dev *rdev)
 704 {
 705         struct smb328_chip *smb328 = rdev_get_drvdata(rdev);
 706
 707         smb328->is_enable = 0;
 708 //      smb328a_charger_function_conrol(smb328->client);
 709
 710         return 0;
 711 }
 712
 713 static int smb328_get_current_limit(struct regulator_dev *rdev)
 714 {
 715         struct smb328_chip *smb328 = rdev_get_drvdata(rdev);
 716
 717         return smb328->max_uA;
 718 }
 719
 720 static int smb328_set_current_limit(struct regulator_dev *rdev,
 721                                 int min_uA, int max_uA)
 722 {
 723         struct smb328_chip *smb328 = rdev_get_drvdata(rdev);
 724
 725         if (smb328->max_uA != max_uA) {
 726                 smb328->max_uA = max_uA;
 727
 728 #if 0
 729                 /* Reset charger if it was already enabled */
 730                 if (smb328->is_enable) {
 731                         smb328->is_enable  = 0;
 732                         smb328a_charger_function_conrol(smb328->client);
 733                         smb328->is_enable  = 1;
 734                         smb328a_charger_function_conrol(smb328->client);
 735
 736                 }
 737 #endif
 738         }
 739
 740         return 0;
 741 }
 742
 743 static struct regulator_ops smb328_ops = {
 744         .is_enabled             = smb328_is_enabled,
 745         .enable                 = smb328_enable,
 746         .disable                = smb328_disable,
 747         .get_current_limit      = smb328_get_current_limit,
 748         .set_current_limit      = smb328_set_current_limit,
 749 };
 750
 751 static struct regulator_desc regulator = {
 752         .name           = "SMB328_CHARGER",
 753         .id             = 0,
 754         .ops            = &smb328_ops,
 755         .type           = REGULATOR_CURRENT,
 756         .owner          = THIS_MODULE,
 757 };
 758
 759 static int smb328_charger_notifier(struct notifier_block *self,
 760                 unsigned long event, void *ptr)
 761 {
 762         struct smb328_chip *chip =
 763                 container_of(self, struct smb328_chip, nb);
 764         bool charger_enable = false;
 765         int cable_type = CABLE_TYPE_NONE;
 766
 767         if (chip->event_code_ta > 0) {
 768                 if (event & chip->event_code_ta) {
 769                         cable_type = CABLE_TYPE_AC;
 770                         chip->max_uA = SMB328_TA_TYP_CURRENT;
 771                         charger_enable = true;
 772                 }
 773         }
 774
 775         if (chip->event_code_usb > 0) {
 776                 if (event & chip->event_code_usb) {
 777                         cable_type = CABLE_TYPE_USB;
 778                         chip->max_uA = SMB328_USB_MAX_CURRENT;
 779                         charger_enable = true;
 780                 }
 781         }
 782
 783 //      if (charger_enable)
 784 //              smb328a_charger_function_conrol(chip->client);
 785
 786         chip->cable_type = cable_type;
 787
 788         return NOTIFY_DONE;
 789 }
 790
 791 static struct notifier_block smb328_charger_nb = {
 792         .notifier_call = smb328_charger_notifier,
 793 };
 794
 795 static int smb328_probe(struct i2c_client *client, const struct i2c_device_id *id)
 796 {
 797         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
 798         struct smb328_chip *chip;
 799         int ret = 0;
 800         int gpio = 0;
 801         u8 data;
 802
 803         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE))
 804                 return -EIO;
 805
 806         if (smb328_i2c_read(client, 0x36, &data)<0)     /* check HW */
 807                 return -EIO;
 808
 809         dev_info(&client->dev, "%s : SMB328 Charger Driver Loading\n", __func__);
 810
 811         chip = kzalloc(sizeof(struct smb328_chip), GFP_KERNEL);
 812         if (!chip)
 813                 return -ENOMEM;
 814
 815         chip->client = client;
 816         chip->pdata = client->dev.platform_data;
 817
 818         i2c_set_clientdata(client, chip);
 819
 820         if (!chip->pdata) {
 821                 dev_err(&client->dev, "%s : No platform data supplied\n", __func__);
 822                 ret = -EINVAL;
 823                 goto err_pdata;
 824         }
 825
 826         if (chip->pdata->set_charger_name)
 827                 chip->pdata->set_charger_name();
 828
 829         chip->is_otg = false;
 830         chip->is_enable = false;
 831         chip->cable_type = CABLE_TYPE_NONE;
 832
 833         chip->charger.name              = "smb328-charger";
 834         chip->charger.type              = POWER_SUPPLY_TYPE_BATTERY;
 835         chip->charger.get_property      = smb328_get_property;
 836         chip->charger.set_property      = smb328_set_property;
 837         chip->charger.properties        = smb328_charger_props;
 838         chip->charger.num_properties    = ARRAY_SIZE(smb328_charger_props);
 839
 840         ret = power_supply_register(&client->dev, &chip->charger);
 841         if (ret) {
 842                 dev_err(&client->dev, "failed: power supply register\n");
 843                 kfree(chip);
 844                 return ret;
 845         }
 846
 847         /* CHG_EN pin control - active low */
 848         if (chip->pdata->gpio_chg_en) {
 849                 s3c_gpio_cfgpin(chip->pdata->gpio_chg_en, S3C_GPIO_OUTPUT);
 850                 s3c_gpio_setpull(chip->pdata->gpio_chg_en, S3C_GPIO_PULL_NONE);
 851
 852                 gpio = gpio_request(chip->pdata->gpio_chg_en, "CHG_EN");
 853                 if (!gpio) {
 854                         gpio_direction_output(chip->pdata->gpio_chg_en, GPIO_LEVEL_HIGH);
 855                         gpio_free(chip->pdata->gpio_chg_en);
 856                 } else
 857                         dev_err(&client->dev,
 858                         "faile to request gpio(CHG_EN)\n");
 859         }
 860
 861         if (chip->pdata->gpio_otg_en) {
 862                 s3c_gpio_cfgpin(chip->pdata->gpio_otg_en, S3C_GPIO_OUTPUT);
 863                 s3c_gpio_setpull(chip->pdata->gpio_otg_en, S3C_GPIO_PULL_NONE);
 864
 865                 gpio = gpio_request(chip->pdata->gpio_otg_en, "OTG_EN");
 866                 if (!gpio) {
 867                         gpio_direction_output(chip->pdata->gpio_otg_en, GPIO_LEVEL_LOW);
 868                         gpio_free(chip->pdata->gpio_otg_en);
 869                 } else
 870                         dev_err(&client->dev,
 871                         "faile to request gpio(OTG_EN)\n");
 872         }
 873
 874         if (chip->pdata->gpio_ta_nconnected) {
 875                 s3c_gpio_cfgpin(chip->pdata->gpio_ta_nconnected, S3C_GPIO_INPUT);
 876                 s3c_gpio_setpull(chip->pdata->gpio_ta_nconnected, S3C_GPIO_PULL_NONE);
 877         }
 878
 879         if (chip->pdata->gpio_chg_ing) {
 880 #if 0
 881                 client->irq = gpio_to_irq(chip->pdata->gpio_chg_ing);
 882                 ret = smb328_irq_init(chip);
 883                 if (ret)
 884                         goto err_pdata;
 885 #else
 886                 s3c_gpio_cfgpin(chip->pdata->gpio_chg_ing, S3C_GPIO_INPUT);
 887                 s3c_gpio_setpull(chip->pdata->gpio_chg_ing, S3C_GPIO_PULL_NONE);
 888 #endif
 889         }
 890
 891         chip->rdev = regulator_register(&regulator, chip->pdata->dev,
 892                         chip->pdata->init_data, chip);
 893
 894         if (IS_ERR(chip->rdev)) {
 895                 ret = PTR_ERR(chip->rdev);
 896                 dev_err(chip->pdata->dev, "regulator init failed (%d)\n", ret);
 897                 goto err_pdata;
 898         }
 899
 900         chip->nb = smb328_charger_nb;
 901         chip->switch_dev = switch_get_switch_dev("switch-usb");
 902         if (chip->switch_dev) {
 903                 switch_register_notifier(chip->switch_dev, &chip->nb);
 904                 chip->event_code_ta =
 905                     switch_get_event_code(chip->switch_dev, "TA");
 906                 chip->event_code_usb =
 907                     switch_get_event_code(chip->switch_dev, "USB");
 908         }
 909
 910         chip->cable_type = CABLE_TYPE_NONE;
 911
 912         smb328_test_read(client);
 913
 914         return 0;
 915
 916 err_pdata:
 917         kfree(chip);
 918         return ret;
 919 }
 920
 921 static int __devexit smb328_remove(struct i2c_client *client)
 922 {
 923         struct smb328_chip *chip = i2c_get_clientdata(client);
 924
 925         kfree(chip);
 926         return 0;
 927 }
 928
 929 static const struct i2c_device_id smb328_id[] = {
 930         {"smb328-charger", 0},
 931         {}
 932 };
 933
 934 MODULE_DEVICE_TABLE(i2c, smb328_id);
 935
 936 static struct i2c_driver smb328_i2c_driver = {
 937         .driver = {
 938                 .owner  = THIS_MODULE,
 939                 .name   = "smb328-charger",
 940         },
 941         .probe  = smb328_probe,
 942         .remove = __devexit_p(smb328_remove),
 943         .command = NULL,
 944         .id_table       = smb328_id,
 945 };
 946
 947 static int __init smb328_init(void)
 948 {
 949         return i2c_add_driver(&smb328_i2c_driver);
 950 }
 951
 952 static void __exit smb328_exit(void)
 953 {
 954         i2c_del_driver(&smb328_i2c_driver);
 955 }
 956
 957 module_init(smb328_init);
 958 module_exit(smb328_exit);
 959
 960 MODULE_AUTHOR("Ikkeun Kim <iks.kim@samsung.com>");
 961 MODULE_DESCRIPTION("smb328 charger driver");
 962 MODULE_LICENSE("GPL");