drivers/mfd/rt5036-misc.c

   1 /*
   2  *  drivers/mfd/rt5036-misc.c
   3  *  Driver for Richtek RT5036 PMIC misc option
   4  *
   5  *  Copyright (C) 2014 Richtek Technology Corp.
   6  *  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; either version 2
  11  * of the License, or (at your option) any later version.
  12  */
  13
  14 #include <linux/module.h>
  15 #include <linux/kernel.h>
  16 #include <linux/init.h>
  17 #include <linux/err.h>
  18 #include <linux/platform_device.h>
  19 #include <linux/i2c.h>
  20 #include <linux/of.h>
  21 #include <linux/power_supply.h>
  22 #ifdef CONFIG_MISC_RT5036_PWRKEY
  23 #include <linux/input.h>
  24 #endif /* #ifdef CONFIG_MISC_RT5036_PWRKEY */
  25
  26 #include <linux/mfd/rt5036/rt5036.h>
  27 #include <linux/mfd/rt5036/rt5036-misc.h>
  28 #include <asm/system_misc.h>
  29
  30 static struct i2c_client *g_shdn;
  31
  32 static unsigned char misc_init_regval[] = {
  33         0xA8,                   /*REG 0x51*/
  34         0x96,                   /*REG 0x52*/
  35         0x48,                   /*REG 0x53*/
  36         0x00,                   /*REG 0x54*/
  37         0x06,                   /*REG 0x55*/
  38         0xA0,                   /*REG 0x65*/
  39         0xFF,                   /*REG 0x5A*/
  40         0xE0,                   /*REG 0x5B*/
  41 #ifdef CONFIG_MISC_RT5036_PWRKEY
  42         0x18,                   /*REG 0x5C*/
  43 #else
  44         0x78,                   /*REG 0x5C*/
  45 #endif /* #ifdef CONFIG_RT5036_PWRKEY */
  46 };
  47
  48 int rt5036_vin_exist(void)
  49 {
  50         int ret = 0;
  51 #ifdef CONFIG_CHARGER_RT5036
  52         union power_supply_propval pval;
  53         struct power_supply *psy = power_supply_get_by_name("rt-charger");
  54
  55         if (psy) {
  56                 ret = psy->get_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
  57                 if (ret < 0)
  58                         ret = 0;
  59                 else
  60                         ret = pval.intval;
  61         } else {
  62                 pr_err("couldn't get rt-charger psy\n");
  63         }
  64         return ret;
  65 #else
  66         if (g_shdn)
  67                 ret = rt5036_reg_read(g_shdn, RT5036_REG_CHGSTAT2);
  68         return ret < 0 ? 0 : ret & RT5036_PWRRDY_MASK;
  69 #endif /* #ifdef CONFIG_CHARGER_RT5036 */
  70 }
  71 EXPORT_SYMBOL(rt5036_vin_exist);
  72 static bool rt_pm_off;
  73 void rt5036_chip_shutdown(void)
  74 {
  75         pr_info("%s\n", __func__);
  76         if (rt5036_vin_exist()) {
  77                 arm_pm_restart('h', "charge");
  78         } else {
  79                 if (g_shdn) {
  80                         pr_info("chip enter shutdown process\n");
  81                         rt5036_set_bits(g_shdn, RT5036_REG_MISC3,
  82                                         RT5036_CHIPSHDN_MASK);
  83                         rt5036_clr_bits(g_shdn, RT5036_REG_MISC3,
  84                                         RT5036_CHIPSHDN_MASK);
  85                 }
  86         }
  87 }
  88 EXPORT_SYMBOL(rt5036_chip_shutdown);
  89
  90 static void rt5036_general_irq_handler(void *info, int eventno)
  91 {
  92         struct rt5036_misc_info *mi = info;
  93
  94         dev_info(mi->dev, "eventno=%02d\n", eventno);
  95 #ifdef CONFIG_MISC_RT5036_PWRKEY
  96         switch (eventno) {
  97         case MISCEVENT_PWRONF:
  98                 if (!mi->pwr_key_pressed) {
  99                         input_report_key(mi->pwr_key, KEY_POWER, 1);
 100                         input_sync(mi->pwr_key);
 101                         mi->pwr_key_pressed = 1;
 102                 }
 103                 break;
 104         case MISCEVENT_PWRONR:
 105                 if (mi->pwr_key_pressed) {
 106                         input_report_key(mi->pwr_key, KEY_POWER, 0);
 107                         input_sync(mi->pwr_key);
 108                         mi->pwr_key_pressed = 0;
 109                 }
 110                 break;
 111         default:
 112                 break;
 113         }
 114 #endif /* #ifdef CONFIG_MISC_RT5036_PWRKEY */
 115 }
 116
 117 static rt_irq_handler rt_miscirq_handler[MISCEVENT_MAX] = {
 118         [MISCEVENT_PWRONLP] = rt5036_general_irq_handler,
 119         [MISCEVENT_PWRONSP] = rt5036_general_irq_handler,
 120         [MISCEVENT_PWRONF] = rt5036_general_irq_handler,
 121         [MISCEVENT_PWRONR] = rt5036_general_irq_handler,
 122         [MISCEVENT_KPSHDN] = rt5036_general_irq_handler,
 123         [MISCEVENT_VDDALV] = rt5036_general_irq_handler,
 124         [MISCEVNET_OTM] = rt5036_general_irq_handler,
 125         [MISCEVENT_PMICSYSLV] = rt5036_general_irq_handler,
 126         [MISCEVENT_LSW2LV] = rt5036_general_irq_handler,
 127         [MISCEVENT_LSW1LV] = rt5036_general_irq_handler,
 128         [MISCEVENT_LDO4LV] = rt5036_general_irq_handler,
 129         [MISCEVENT_LDO3LV] = rt5036_general_irq_handler,
 130         [MISCEVENT_LDO2LV] = rt5036_general_irq_handler,
 131         [MISCEVENT_LDO1LV] = rt5036_general_irq_handler,
 132         [MISCEVENT_BUCK4LV] = rt5036_general_irq_handler,
 133         [MISCEVENT_BUCK3LV] = rt5036_general_irq_handler,
 134         [MISCEVENT_BUCK2LV] = rt5036_general_irq_handler,
 135         [MISCEVENT_BUCK1LV] = rt5036_general_irq_handler,
 136 };
 137
 138 void rt5036_misc_irq_handler(struct rt5036_misc_info *mi, unsigned int irqevent)
 139 {
 140         int i;
 141         unsigned int masked_irq_event =
 142             (misc_init_regval[6] << 16) | (misc_init_regval[7] << 8) |
 143             misc_init_regval[8];
 144         unsigned int final_irq_event = irqevent & (~masked_irq_event);
 145
 146         for (i = 0; i < MISCEVENT_MAX; i++) {
 147                 if ((final_irq_event & (1 << i)) && rt_miscirq_handler[i])
 148                         rt_miscirq_handler[i] (mi, i);
 149         }
 150 }
 151 EXPORT_SYMBOL(rt5036_misc_irq_handler);
 152
 153 static int rt5036_misc_reginit(struct i2c_client *i2c)
 154 {
 155         rt5036_reg_write(i2c, RT5036_REG_MISC6, misc_init_regval[5]);
 156         rt5036_reg_block_write(i2c, RT5036_REG_MISC1, 5, misc_init_regval);
 157         rt5036_reg_block_write(i2c, RT5036_REG_BUCKLDOIRQMASK,
 158                                3, &misc_init_regval[6]);
 159         /*always clear at the first time*/
 160         rt5036_reg_read(i2c, RT5036_REG_BUCKLDOIRQ);
 161         rt5036_reg_read(i2c, RT5036_REG_LSWBASEIRQ);
 162         rt5036_reg_read(i2c, RT5036_REG_PWRKEYIRQ);
 163         return 0;
 164 }
 165
 166 static int rt_parse_dt(struct rt5036_misc_info *mi,
 167                                  struct device *dev)
 168 {
 169 #ifdef CONFIG_OF
 170         struct device_node *np = dev->of_node;
 171         u32 val;
 172
 173         if (of_property_read_u32(np, "rt,shdn_press", &val)) {
 174                 dev_info(dev,
 175                          "no shut_lpress property, use the default value\n");
 176         } else {
 177                 if (val > RT5036_SHDNPRESS_MASK)
 178                         val = RT5036_SHDNPRESS_MAX;
 179                 misc_init_regval[1] &= (~RT5036_SHDNPRESS_MASK);
 180                 misc_init_regval[1] |= (val << RT5036_SHDNPRESS_SHIFT);
 181         }
 182
 183         if (of_property_read_u32(np, "rt,stb_en", &val)) {
 184                 dev_info(dev, "no stb_en prpperty , use the default value\n");
 185         } else {
 186                 if (val > RT5036_STB_MAX)
 187                         val = RT5036_STB_MAX;
 188                 misc_init_regval[2] &= (~RT5036_STBEN_MASK);
 189                 misc_init_regval[2] |= (val << RT5036_STBEN_SHIFT);
 190         }
 191
 192         if (of_property_read_bool(np, "rt,lp_enshdn"))
 193                 misc_init_regval[4] |= RT5036_LPSHDNEN_MASK;
 194         else
 195                 misc_init_regval[4] &= (~RT5036_LPSHDNEN_MASK);
 196
 197         if (of_property_read_u32(np, "rt,vsysuvlo", &val)) {
 198                 dev_info(dev, "no vsysuvlo prpperty , use the default value\n");
 199         } else {
 200                 if (val > RT5036_SYSLV_MAX)
 201                         val = RT5036_SYSLV_MAX;
 202                 misc_init_regval[5] &= (~RT5036_SYSUVLO_MASK);
 203                 misc_init_regval[5] |= (val << RT5036_SYSUVLO_SHIFT);
 204         }
 205
 206         if (of_property_read_bool(np, "rt,syslv_enshdn"))
 207                 misc_init_regval[4] |= RT5036_SYSLVENSHDN_MASK;
 208         else
 209                 misc_init_regval[4] &= (~RT5036_SYSLVENSHDN_MASK);
 210
 211         rt_pm_off = of_property_read_bool(np, "rt,system-power-controller");
 212 #endif /* #ifdef CONFIG_OF */
 213         rt5036_misc_reginit(mi->i2c);
 214         RTINFO("\n");
 215         return 0;
 216 }
 217
 218 static int rt_parse_pdata(struct rt5036_misc_info *mi,
 219                                     struct device *dev)
 220 {
 221         struct rt5036_misc_data *misc_pdata = dev->platform_data;
 222         /*SHDN_PRESS_TIME property*/
 223         misc_init_regval[1] &= (~RT5036_SHDNPRESS_MASK);
 224         misc_init_regval[1] |=
 225             (misc_pdata->shdn_press << RT5036_SHDNPRESS_SHIFT);
 226         /*STB_EN property*/
 227         misc_init_regval[2] &= (~RT5036_STBEN_MASK);
 228         misc_init_regval[2] |= (misc_pdata->stb_en << RT5036_STBEN_SHIFT);
 229         /*LP_ENSHEN property*/
 230         if (misc_pdata->lp_enshdn)
 231                 misc_init_regval[4] |= RT5036_LPSHDNEN_MASK;
 232         else
 233                 misc_init_regval[4] &= (~RT5036_LPSHDNEN_MASK);
 234
 235         misc_init_regval[5] &= (~RT5036_SYSUVLO_MASK);
 236         misc_init_regval[5] |= (misc_pdata->vsysuvlo << RT5036_SYSUVLO_SHIFT);
 237
 238         if (misc_pdata->syslv_enshdn)
 239                 misc_init_regval[4] |= RT5036_SYSLVENSHDN_MASK;
 240         else
 241                 misc_init_regval[4] &= (~RT5036_SYSLVENSHDN_MASK);
 242
 243         rt5036_misc_reginit(mi->i2c);
 244         RTINFO("\n");
 245         return 0;
 246 }
 247
 248 static int rt5036_misc_probe(struct platform_device *pdev)
 249 {
 250         struct rt5036_chip *chip = dev_get_drvdata(pdev->dev.parent);
 251         struct rt5036_platform_data *pdata = (pdev->dev.parent)->platform_data;
 252         struct rt5036_misc_info *mi;
 253         bool use_dt = pdev->dev.of_node;
 254
 255         mi = devm_kzalloc(&pdev->dev, sizeof(*mi), GFP_KERNEL);
 256         if (!mi)
 257                 return -ENOMEM;
 258
 259         mi->i2c = chip->i2c;
 260         if (use_dt) {
 261                 rt_parse_dt(mi, &pdev->dev);
 262         } else {
 263                 if (!pdata)
 264                         goto out_dev;
 265                 pdev->dev.platform_data = pdata->misc_pdata;
 266                 rt_parse_pdata(mi, &pdev->dev);
 267         }
 268 #ifdef CONFIG_MISC_RT5036_PWRKEY
 269         mi->pwr_key = input_allocate_device();
 270         if (!mi->pwr_key) {
 271                 dev_err(&pdev->dev, "Allocate pwr_key input fail\n");
 272                 goto out_dev;
 273         }
 274         input_set_capability(mi->pwr_key, EV_KEY, KEY_POWER);
 275         mi->pwr_key->name = "rt5036_pwr_key";
 276         mi->pwr_key->phys = "rt5036_pwr_key/input0";
 277         mi->pwr_key->dev.parent = &pdev->dev;
 278         if (input_register_device(mi->pwr_key)) {
 279                 dev_err(&pdev->dev, "register pwr key fail\n");
 280                 goto free_input;
 281         }
 282 #endif /* #ifdef CONFIG_MISC_RT5036_PWRKEY */
 283         mi->dev = &pdev->dev;
 284         g_shdn = mi->i2c;
 285         chip->misc_info = mi;
 286         platform_set_drvdata(pdev, mi);
 287
 288         if (rt_pm_off && !pm_power_off)
 289                 pm_power_off = rt5036_chip_shutdown;
 290
 291         dev_info(&pdev->dev, "driver successfully loaded\n");
 292         return 0;
 293 #ifdef CONFIG_MISC_RT5036_PWRKEY
 294 free_input:
 295         input_free_device(mi->pwr_key);
 296 #endif /* #ifdef CONFIG_MISC_RT5036_PWRKEY */
 297 out_dev:
 298         return -EINVAL;
 299 }
 300
 301 static int rt5036_misc_remove(struct platform_device *pdev)
 302 {
 303 #ifdef CONFIG_MISC_RT5036_PWRKEY
 304         struct rt5036_misc_info *mi = platform_get_drvdata(pdev);
 305
 306         input_unregister_device(mi->pwr_key);
 307         input_free_device(mi->pwr_key);
 308 #endif /* #ifdef CONFIG_MISC_RT5036_PWRKEY */
 309         return 0;
 310 }
 311
 312 static const struct of_device_id rt_match_table[] = {
 313         {.compatible = "rt,rt5036-misc",},
 314         {},
 315 };
 316
 317 static struct platform_driver rt5036_misc_driver = {
 318         .driver = {
 319                    .name = RT5036_DEV_NAME "-misc",
 320                    .owner = THIS_MODULE,
 321                    .of_match_table = rt_match_table,
 322                    },
 323         .probe = rt5036_misc_probe,
 324         .remove = rt5036_misc_remove,
 325 };
 326
 327 static int __init rt5036_misc_init(void)
 328 {
 329         return platform_driver_register(&rt5036_misc_driver);
 330 }
 331 subsys_initcall(rt5036_misc_init);
 332
 333 static void __exit rt5036_misc_exit(void)
 334 {
 335         platform_driver_unregister(&rt5036_misc_driver);
 336 }
 337 module_exit(rt5036_misc_exit);
 338
 339 MODULE_LICENSE("GPL");
 340 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 341 MODULE_DESCRIPTION("Misc driver for RT5036");
 342 MODULE_ALIAS("platform:" RT5036_DEV_NAME "-misc");
 343 MODULE_VERSION(RT5036_DRV_VER);