drivers/power/rt5025-swjeita.c

   1 /* drivers/power/rt5025-swjeita.c
   2  * swjeita Driver for Richtek RT5025 PMIC
   3  * Multi function device - multi functional baseband PMIC swjeita part
   4  *
   5  * Copyright (C) 2013
   6  * Author: CY Huang <cy_huang@richtek.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/init.h>
  16 #include <linux/i2c.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/err.h>
  19 #include <linux/slab.h>
  20 #include <linux/delay.h>
  21
  22 #include <linux/mfd/rt5025.h>
  23 #include <linux/power/rt5025-swjeita.h>
  24
  25 #define TEMP_TOLERANCE  30  // 'c*10 gap for tolerance
  26
  27 static int rt5025_set_charging_cc_switch (struct i2c_client *i2c, int onoff)
  28 {
  29         int ret;
  30         RTINFO("onoff = %d\n", onoff);
  31         if (onoff)
  32                 ret = rt5025_set_bits(i2c, RT5025_REG_CHGCTL7, RT5025_CHGCCEN_MASK);
  33         else
  34                 ret = rt5025_clr_bits(i2c, RT5025_REG_CHGCTL7, RT5025_CHGCCEN_MASK);
  35         return ret;
  36 }
  37
  38 static int rt5025_set_charging_cc(struct i2c_client *i2c, int cur_value)
  39 {
  40         int ret;
  41         u8 data;
  42
  43         RTINFO("current value = %d\n", cur_value);
  44         if (cur_value < 500)
  45                 data = 0;
  46         else if (cur_value > 2000)
  47                 data = 0xf<<RT5025_CHGICC_SHIFT;
  48         else
  49                 data = ((cur_value-500)/100)<<RT5025_CHGICC_SHIFT;
  50
  51         ret = rt5025_assign_bits(i2c, RT5025_REG_CHGCTL4, RT5025_CHGICC_MASK, data);
  52
  53         if (cur_value < 500)
  54                 rt5025_set_charging_cc_switch(i2c, 0);
  55         else
  56                 rt5025_set_charging_cc_switch(i2c, 1);
  57
  58         return ret;
  59 }
  60
  61 static int rt5025_set_charging_cv(struct i2c_client *i2c, int voltage)
  62 {
  63         int ret;
  64         u8 data;
  65
  66         RTINFO("voltage = %d\n", voltage);
  67         if (voltage < 3500)
  68                 data = 0;
  69         else if (voltage > 4440)
  70                 data = 0x2f<<RT5025_CHGCV_SHIFT;
  71         else
  72                 data = ((voltage-3500)/20)<<RT5025_CHGCV_SHIFT;
  73
  74         ret = rt5025_assign_bits(i2c, RT5025_REG_CHGCTL3, RT5025_CHGCV_MASK, data);
  75         return ret;
  76 }
  77
  78 static int rt5025_sel_external_temp_index(struct rt5025_swjeita_info *swji)
  79 {
  80         int temp = swji->cur_temp;
  81         int sect_index;
  82
  83         RTINFO("\n");
  84         if (temp < swji->temp[0])
  85                 sect_index = 0;
  86         else if (temp >= swji->temp[0] && temp < swji->temp[1])
  87                 sect_index = 1;
  88         else if (temp >= swji->temp[1] && temp < swji->temp[2])
  89                 sect_index = 2;
  90         else if (temp >= swji->temp[2] && temp < swji->temp[3])
  91                 sect_index = 3;
  92         else if (temp >= swji->temp[3])
  93                 sect_index = 4;
  94
  95         RTINFO("sect_index = %d\n", sect_index);
  96         return sect_index;
  97 }
  98
  99 static int rt5025_get_external_temp_index(struct rt5025_swjeita_info *swji)
 100 {
 101         u8 data[2];
 102         long int temp;
 103         int sect_index;
 104
 105         RTINFO("\n");
 106         if (rt5025_reg_block_read(swji->i2c, RT5025_REG_AINH, 2, data) < 0)
 107                 pr_err("%s: failed to read ext_temp register\n", __func__);
 108
 109         temp = (data[0]*256+data[1])*61/100;
 110         temp = (temp * (-91738) +81521000)/100000;
 111
 112         swji->cur_temp = temp;
 113
 114         RTINFO("cur_section = %d, cur_temp = %d\n", swji->cur_section, swji->cur_temp);
 115
 116         switch (swji->cur_section)
 117         {
 118                 case 0:
 119                         if (temp < swji->temp[0]+TEMP_TOLERANCE)
 120                                 sect_index = rt5025_sel_external_temp_index(swji);
 121                         else
 122                                 sect_index = swji->cur_section;
 123                         break;
 124                 case 1:
 125                         if (temp <= swji->temp[0]-TEMP_TOLERANCE || temp >= swji->temp[1]+TEMP_TOLERANCE)
 126                                 sect_index = rt5025_sel_external_temp_index(swji);
 127                         else
 128                                 sect_index = swji->cur_section;
 129                         break;
 130                 case 2:
 131                         if (temp <= swji->temp[1]-TEMP_TOLERANCE || temp >= swji->temp[2]+TEMP_TOLERANCE)
 132                                 sect_index = rt5025_sel_external_temp_index(swji);
 133                         else
 134                                 sect_index = swji->cur_section;
 135                         break;
 136                 case 3:
 137                         if (temp <= swji->temp[2]-TEMP_TOLERANCE || temp >= swji->temp[3]+TEMP_TOLERANCE)
 138                                 sect_index = rt5025_sel_external_temp_index(swji);
 139                         else
 140                                 sect_index = swji->cur_section;
 141                         break;
 142                 case 4:
 143                         if (temp <= swji->temp[3]-TEMP_TOLERANCE)
 144                                 sect_index = rt5025_sel_external_temp_index(swji);
 145                         else
 146                                 sect_index = swji->cur_section;
 147                         break;
 148                 default:
 149                                 sect_index = swji->cur_section;
 150                         break;
 151         }
 152         RTINFO("sect_index = %d\n", sect_index);
 153         return sect_index;
 154 }
 155
 156 static inline int rt5025_set_ainadc_onoff(struct rt5025_swjeita_info *swji, int enable)
 157 {
 158         int ret;
 159
 160         RTINFO("enable = %d\n", enable);
 161         if (enable)
 162                 ret = rt5025_set_bits(swji->i2c, RT5025_REG_CHANNELL, RT5025_AINEN_MASK);
 163         else
 164                 ret = rt5025_clr_bits(swji->i2c, RT5025_REG_CHANNELL, RT5025_AINEN_MASK);
 165
 166         return ret;
 167 }
 168
 169 static inline int rt5025_set_intadc_onoff(struct rt5025_swjeita_info *swji, int enable)
 170 {
 171         int ret;
 172
 173         RTINFO("enable = %d\n", enable);
 174         if (enable)
 175                 ret = rt5025_set_bits(swji->i2c, RT5025_REG_CHANNELL, RT5025_INTEN_MASK);
 176         else
 177                 ret = rt5025_clr_bits(swji->i2c, RT5025_REG_CHANNELL, RT5025_INTEN_MASK);
 178
 179         return ret;
 180 }
 181
 182 static int rt5025_set_exttemp_alert(struct rt5025_swjeita_info *swji, int index)
 183 {
 184         int ret = 0;
 185
 186         RTINFO("index = %d\n", index);
 187
 188         switch (index)
 189         {
 190                 case 0:
 191                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMIN, swji->temp_scalar[1]);
 192                         break;
 193                 case 1:
 194                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMAX, swji->temp_scalar[0]);
 195                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMIN, swji->temp_scalar[3]);
 196                         break;
 197                 case 2:
 198                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMAX, swji->temp_scalar[2]);
 199                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMIN, swji->temp_scalar[5]);
 200                         break;
 201                 case 3:
 202                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMAX, swji->temp_scalar[4]);
 203                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMIN, swji->temp_scalar[7]);
 204                         break;
 205                 case 4:
 206                         rt5025_reg_write(swji->i2c, RT5025_REG_TALRTMAX, swji->temp_scalar[6]);
 207                         break;
 208         }
 209
 210         return ret;
 211 }
 212
 213 static int rt5025_exttemp_alert_switch(struct rt5025_swjeita_info *swji, int onoff)
 214 {
 215         if (!onoff)
 216         {
 217                 rt5025_clr_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMXEN_MASK);
 218                 rt5025_clr_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMNEN_MASK);
 219         }
 220         else
 221         {
 222                 switch (swji->cur_section)
 223                 {
 224                         case 0:
 225                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMNEN_MASK);
 226                                 break;
 227                         case 1:
 228                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMXEN_MASK);
 229                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMNEN_MASK);
 230                                 break;
 231                         case 2:
 232                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMXEN_MASK);
 233                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMNEN_MASK);
 234                                 break;
 235                         case 3:
 236                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMXEN_MASK);
 237                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMNEN_MASK);
 238                                 break;
 239                         case 4:
 240                                 rt5025_set_bits(swji->i2c, RT5025_REG_IRQCTL, RT5025_TMXEN_MASK);
 241                                 break;
 242                 }
 243         }
 244
 245         RTINFO("index=%d, onoff=%d\n", swji->cur_section, onoff);
 246         return 0;
 247 }
 248
 249 int rt5025_notify_charging_cable(struct rt5025_swjeita_info *swji, int cable_type)
 250 {
 251         int sect_index;
 252         int ret = 0;
 253
 254         RTINFO("cable_type = %d\n", cable_type);
 255
 256         rt5025_exttemp_alert_switch(swji, 0);
 257
 258         sect_index = rt5025_get_external_temp_index(swji);
 259         if (swji->cur_section != sect_index || swji->init_once == 0)
 260         {
 261                 rt5025_set_exttemp_alert(swji, sect_index);
 262                 swji->cur_section = sect_index;
 263                 swji->init_once = 1;
 264         }
 265
 266         switch (cable_type)
 267         {
 268                 case JEITA_NORMAL_USB:
 269                         rt5025_set_charging_cc(swji->i2c, swji->temp_cc[cable_type][swji->cur_section]\
 270                                 - swji->dec_current);
 271                         rt5025_set_charging_cv(swji->i2c, swji->temp_cv[cable_type][swji->cur_section]);
 272                         break;
 273                 case JEITA_USB_TA:
 274                         rt5025_set_charging_cc(swji->i2c, swji->temp_cc[cable_type][swji->cur_section]\
 275                                 - swji->dec_current);
 276                         rt5025_set_charging_cv(swji->i2c, swji->temp_cv[cable_type][swji->cur_section]);
 277                         break;
 278                 case JEITA_AC_ADAPTER:
 279                         rt5025_set_charging_cc(swji->i2c, swji->temp_cc[cable_type][swji->cur_section]\
 280                                 - swji->dec_current);
 281                         rt5025_set_charging_cv(swji->i2c, swji->temp_cv[cable_type][swji->cur_section]);
 282                         break;
 283                 case JEITA_NO_CHARGE:
 284                         rt5025_set_charging_cc(swji->i2c, swji->temp_cc[cable_type][swji->cur_section]);
 285                         rt5025_set_charging_cv(swji->i2c, swji->temp_cv[cable_type][swji->cur_section]);
 286                         break;
 287         }
 288         swji->cur_cable = cable_type;
 289
 290         rt5025_exttemp_alert_switch(swji, 1);
 291
 292         return ret;
 293 }
 294 EXPORT_SYMBOL(rt5025_notify_charging_cable);
 295
 296 int rt5025_swjeita_irq_handler(struct rt5025_swjeita_info *swji, unsigned char event)
 297 {
 298         int ret = 0;
 299         RTINFO("event = 0x%02x\n", event);
 300
 301         if (event&(RT5025_TMXEN_MASK|RT5025_TMNEN_MASK))
 302                 rt5025_notify_charging_cable(swji, swji->cur_cable);
 303
 304         return ret;
 305 }
 306 EXPORT_SYMBOL(rt5025_swjeita_irq_handler);
 307
 308 static void rt5025_get_internal_temp(struct rt5025_swjeita_info *swji)
 309 {
 310         u8 data[2];
 311         s32 temp;
 312         if (rt5025_reg_block_read(swji->i2c, RT5025_REG_INTTEMP_MSB, 2, data) < 0){
 313                 pr_err("%s: Failed to read internal TEMPERATURE\n", __func__);
 314         }
 315
 316         temp = ((data[0]&0x1F)<<8) + data[1];
 317         temp *= 15625;
 318         temp /= 100000;
 319
 320         temp = (data[0]&0x20)?-temp:temp;
 321         swji->cur_inttemp = temp;
 322
 323         RTINFO("internal temperature: %d\n", temp);
 324 }
 325
 326 static void thermal_reg_work_func(struct work_struct *work)
 327 {
 328         struct delayed_work *delayed_work = (struct delayed_work *)container_of(work, struct delayed_work, work);
 329         struct rt5025_swjeita_info *swji = (struct rt5025_swjeita_info *)container_of(delayed_work, struct rt5025_swjeita_info, thermal_reg_work);
 330         int therm_region = 0;
 331
 332         RTINFO("%s ++", __func__);
 333         rt5025_get_internal_temp(swji);
 334
 335         #if 1
 336         switch (swji->cur_therm_region)
 337         {
 338                 case 0:
 339                         if (swji->cur_inttemp >=820)
 340                                 therm_region = 1;
 341                         else
 342                                 therm_region = 0;
 343                         break;
 344                 case 1:
 345                         if (swji->cur_inttemp <= 780)
 346                                 therm_region = 0;
 347                         else if (swji->cur_inttemp >= 1020)
 348                                 therm_region = 2;
 349                         else
 350                                 therm_region = 1;
 351                         break;
 352                 case 2:
 353                         if (swji->cur_inttemp <= 980)
 354                                 therm_region = 1;
 355                         else
 356                                 therm_region = 2;
 357                         break;
 358
 359         }
 360         #else
 361         if (swji->cur_inttemp < 800)
 362                 therm_region = 0;
 363         else if (swji->cur_inttemp >= 800 && swji->cur_inttemp < 1000)
 364                 therm_region = 1;
 365         else
 366                 therm_region = 2;
 367         #endif /* #if 1*/
 368
 369         if (therm_region != swji->cur_therm_region)
 370         {
 371                 switch (therm_region)
 372                 {
 373                         case 0:
 374                                 swji->dec_current = 0;
 375                                 break;
 376                         case 1:
 377                                 swji->dec_current = 300;
 378                                 break;
 379                         case 2:
 380                                 swji->dec_current = 800;
 381                                 break;
 382                 }
 383                 swji->cur_therm_region = therm_region;
 384                 rt5025_notify_charging_cable(swji, swji->cur_cable);
 385         }
 386
 387         if (!swji->suspend)
 388                 schedule_delayed_work(&swji->thermal_reg_work, 5*HZ);
 389
 390         RTINFO("%s --", __func__);
 391 }
 392
 393 static int __devinit rt5025_swjeita_probe(struct platform_device *pdev)
 394 {
 395         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
 396         struct rt5025_platform_data *pdata = chip->dev->platform_data;
 397         struct rt5025_swjeita_info *swji;
 398         int ret = 0;
 399
 400         swji = kzalloc(sizeof(*swji), GFP_KERNEL);
 401         if (!swji)
 402                 return -ENOMEM;
 403
 404         #if 0 // for debug pdata->jeita_data
 405         for (ret=0; ret<4; ret++)
 406                 RTINFO("jeita temp value %d\n", pdata->jeita_data->temp[ret]);
 407         for (ret=0; ret<4; ret++)
 408         {
 409                 RTINFO("jeita temp_cc value %d, %d, %d, %d, %d\n", pdata->jeita_data->temp_cc[ret][0], \
 410                 pdata->jeita_data->temp_cc[ret][1], pdata->jeita_data->temp_cc[ret][2], \
 411                 pdata->jeita_data->temp_cc[ret][3], pdata->jeita_data->temp_cc[ret][4]);
 412         }
 413         for (ret=0; ret<4; ret++)
 414         {
 415                 RTINFO("jeita temp_cv value %d, %d, %d, %d, %d\n", pdata->jeita_data->temp_cv[ret][0], \
 416                 pdata->jeita_data->temp_cv[ret][1], pdata->jeita_data->temp_cv[ret][2], \
 417                 pdata->jeita_data->temp_cv[ret][3], pdata->jeita_data->temp_cv[ret][4]);
 418         }
 419         for (ret=0; ret<8; ret++)
 420         {
 421                 RTINFO("temp_scalar[%d] = 0x%02x\n", ret, pdata->jeita_data->temp_scalar[ret]);
 422         }
 423         ret = 0;
 424         #endif /* #if 0 */
 425
 426         swji->i2c = chip->i2c;
 427         swji->chip = chip;
 428         swji->cur_section = 2; //initial as the normal temperature
 429         swji->cur_cable = JEITA_NO_CHARGE;
 430         swji->temp = pdata->jeita_data->temp;
 431         swji->temp_scalar = pdata->jeita_data->temp_scalar;
 432         swji->temp_cc = pdata->jeita_data->temp_cc;
 433         swji->temp_cv = pdata->jeita_data->temp_cv;
 434         INIT_DELAYED_WORK(&swji->thermal_reg_work, thermal_reg_work_func);
 435         platform_set_drvdata(pdev, swji);
 436
 437         rt5025_set_ainadc_onoff(swji, 1);
 438         rt5025_set_intadc_onoff(swji, 1);
 439         mdelay(100);
 440         rt5025_notify_charging_cable(swji, swji->cur_cable);
 441         schedule_delayed_work(&swji->thermal_reg_work, 1*HZ);
 442
 443         chip->jeita_info = swji;
 444         RTINFO("rt5025-swjeita driver is successfully loaded\n");
 445         return ret;
 446 }
 447
 448 static int __devexit rt5025_swjeita_remove(struct platform_device *pdev)
 449 {
 450         struct rt5025_swjeita_info *swji = platform_get_drvdata(pdev);
 451
 452         swji->chip->jeita_info = NULL;
 453         kfree(swji);
 454         RTINFO("\n");
 455         return 0;
 456 }
 457
 458 static int rt5025_swjeita_suspend(struct platform_device *pdev, pm_message_t state)
 459 {
 460         struct rt5025_swjeita_info *swji = platform_get_drvdata(pdev);
 461         swji->suspend = 1;
 462         cancel_delayed_work_sync(&swji->thermal_reg_work);
 463         swji->cur_therm_region = swji->dec_current = 0;
 464         rt5025_notify_charging_cable(swji, swji->cur_cable);
 465         RTINFO("\n");
 466         return 0;
 467 }
 468
 469 static int rt5025_swjeita_resume(struct platform_device *pdev)
 470 {
 471         struct rt5025_swjeita_info *swji = platform_get_drvdata(pdev);
 472
 473         swji->suspend = 0;
 474         schedule_delayed_work(&swji->thermal_reg_work, 0);
 475         RTINFO("\n");
 476         return 0;
 477 }
 478
 479 static struct platform_driver rt5025_swjeita_driver =
 480 {
 481         .driver = {
 482                 .name = RT5025_DEVICE_NAME "-swjeita",
 483                 .owner = THIS_MODULE,
 484         },
 485         .probe = rt5025_swjeita_probe,
 486         .remove = __devexit_p(rt5025_swjeita_remove),
 487         .suspend = rt5025_swjeita_suspend,
 488         .resume = rt5025_swjeita_resume,
 489 };
 490
 491 static int __init rt5025_swjeita_init(void)
 492 {
 493         return platform_driver_register(&rt5025_swjeita_driver);
 494 }
 495 module_init(rt5025_swjeita_init);
 496
 497 static void __exit rt5025_swjeita_exit(void)
 498 {
 499         platform_driver_unregister(&rt5025_swjeita_driver);
 500 }
 501 module_exit(rt5025_swjeita_exit);
 502
 503
 504 MODULE_LICENSE("GPL v2");
 505 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 506 MODULE_DESCRIPTION("Swjeita driver for RT5025");
 507 MODULE_ALIAS("platform:" RT5025_DEVICE_NAME "-swjeita");
 508 MODULE_VERSION(RT5025_DRV_VER);