drivers/mfd/rt5025-irq.c

   1 /*
   2  *  drivers/mfd/rt5025-irq.c
   3  *  Driver foo Richtek RT5025 PMIC irq
   4  *
   5  *  Copyright (C) 2013 Richtek Electronics
   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.
  11  */
  12
  13 #include <linux/module.h>
  14 #include <linux/kernel.h>
  15 #include <linux/err.h>
  16 #include <linux/i2c.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/slab.h>
  19 #include <linux/wakelock.h>
  20 #include <linux/delay.h>
  21
  22 #include <linux/gpio.h>
  23 #include <linux/irq.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/workqueue.h>
  26
  27 #include <linux/mfd/rt5025.h>
  28 #include <linux/mfd/rt5025-irq.h>
  29
  30 struct rt5025_irq_info {
  31         struct i2c_client *i2c;
  32         struct device *dev;
  33         struct rt5025_chip *chip;
  34         struct workqueue_struct *wq;
  35         struct rt5025_event_callback *event_cb;
  36         struct delayed_work delayed_work;
  37         struct wake_lock irq_wake_lock;
  38         int intr_pin;
  39         int irq;
  40         int suspend;
  41         int acin_cnt;
  42         int usbin_cnt;
  43 };
  44
  45 static void rt5025_work_func(struct work_struct *work)
  46 {
  47         struct delayed_work *delayed_work = (struct delayed_work *)container_of(work, struct delayed_work, work);
  48         struct rt5025_irq_info *ii = (struct rt5025_irq_info *)container_of(delayed_work, struct rt5025_irq_info, delayed_work);
  49         unsigned char irq_stat[6] = {0};
  50         unsigned char irq_enable[6] = {0};
  51         uint32_t chg_event = 0, pwr_event = 0;
  52
  53         //Add this to prevent i2c xfer before i2c chip is in suspend mode
  54         if (ii->suspend)
  55         {
  56                 queue_delayed_work(ii->wq, &ii->delayed_work, msecs_to_jiffies(1));
  57                 return;
  58         }
  59
  60         #ifdef CONFIG_POWER_RT5025
  61         if (!ii->chip->power_info || !ii->chip->jeita_info || !ii->chip->battery_info)
  62         {
  63                 queue_delayed_work(ii->wq, &ii->delayed_work, msecs_to_jiffies(1));
  64                 return;
  65         }
  66         #endif
  67
  68         #if 0
  69         if (rt5025_reg_block_read(ii->i2c, RT5025_REG_IRQEN1, 10, irq_stat) >= 0)
  70         {
  71         #endif
  72                 /* backup the irq enable bit */
  73                 irq_enable[0] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN1);
  74                 irq_enable[1] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN2);
  75                 irq_enable[2] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN3);
  76                 irq_enable[3] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN4);
  77                 irq_enable[4] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQEN5);
  78                 irq_enable[5] = rt5025_reg_read(ii->i2c, RT5025_REG_GAUGEIRQEN);
  79                 #if 1
  80                 rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, irq_enable[1]&(~RT5025_CHTERMI_MASK));
  81                 #else
  82                 /* disable all irq enable bit first */
  83                 rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN1, irq_enable[0]&RT5025_ADAPIRQ_MASK);
  84                 rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, 0x00);
  85                 rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN3, 0x00);
  86                 rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN4, 0x00);
  87                 rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN5, 0x00);
  88                 rt5025_reg_write(ii->i2c, RT5025_REG_GAUGEIRQEN, 0x00);
  89                 #endif //#if 0
  90                 /* read irq status bit */
  91                 irq_stat[0] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS1);
  92                 irq_stat[1] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS2);
  93                 irq_stat[2] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS3);
  94                 irq_stat[3] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS4);
  95                 irq_stat[4] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS5);
  96                 irq_stat[5] = rt5025_reg_read(ii->i2c, RT5025_REG_GAUGEIRQFLG);
  97                 RTINFO("irq1->0x%02x, irq2->0x%02x, irq3->0x%02x\n", irq_stat[0], irq_stat[1], irq_stat[2]);
  98                 RTINFO("irq4->0x%02x, irq5->0x%02x, irq6->0x%02x\n", irq_stat[3], irq_stat[4], irq_stat[5]);
  99                 RTINFO("stat value = %02x\n", rt5025_reg_read(ii->i2c, RT5025_REG_CHGSTAT));
 100
 101                 chg_event = irq_stat[0]<<16 | irq_stat[1]<<8 | irq_stat[2];
 102                 pwr_event = irq_stat[3]<<8 | irq_stat[4];
 103                 #ifdef CONFIG_POWER_RT5025
 104                 if ((chg_event & CHARGER_DETECT_MASK))
 105                 {
 106                         if (chg_event & CHG_EVENT_CHTERMI)
 107                         {
 108                                 ii->chip->power_info->chg_term++;
 109                                 if (ii->chip->power_info->chg_term > 3)
 110                                         ii->chip->power_info->chg_term = 4;
 111                         }
 112
 113                         if (chg_event & CHG_EVENT_CHRCHGI)
 114                                 ii->chip->power_info->chg_term = 0;
 115
 116                         if (chg_event & (CHG_EVENT_CHSLPI_INAC | CHG_EVENT_CHSLPI_INUSB))
 117                         {
 118                                 ii->chip->power_info->chg_term = 0;
 119                                 if (chg_event & CHG_EVENT_CHSLPI_INAC)
 120                                         ii->acin_cnt = 0;
 121                                 if (chg_event & CHG_EVENT_CHSLPI_INUSB)
 122                                         ii->usbin_cnt = 0;
 123
 124                         }
 125
 126                         if (chg_event & (CHG_EVENT_INAC_PLUGIN | CHG_EVENT_INUSB_PLUGIN))
 127                         {
 128                                 RTINFO("acin_cnt %d, usbin_cnt %d\n", ii->acin_cnt, ii->usbin_cnt);
 129                                 if (ii->acin_cnt == 0 && ii->usbin_cnt == 0)
 130                                 {
 131                                         #if 1
 132                                         rt5025_charger_reset_and_reinit(ii->chip->power_info);
 133                                         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN1, irq_enable[0]);
 134                                         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, irq_enable[1]&(~RT5025_CHTERMI_MASK));
 135                                         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN3, irq_enable[2]);
 136                                         #else
 137                                         rt5025_set_charging_buck(ii->i2c, 0);
 138                                         mdelay(50);
 139                                         rt5025_set_charging_buck(ii->i2c, 1);
 140                                         mdelay(100);
 141                                         rt5025_set_charging_buck(ii->i2c, 0);
 142                                         mdelay(50);
 143                                         rt5025_set_charging_buck(ii->i2c, 1);
 144                                         mdelay(400);
 145                                         #endif /* #if 1 */
 146                                 }
 147
 148                                 if (chg_event & CHG_EVENT_INAC_PLUGIN)
 149                                         ii->acin_cnt = 1;
 150                                 if (chg_event & CHG_EVENT_INUSB_PLUGIN)
 151                                         ii->usbin_cnt = 1;
 152                                 RTINFO("acin_cnt %d, usbin_cnt %d\n", ii->acin_cnt, ii->usbin_cnt);
 153                         }
 154
 155                         if (ii->chip->power_info->chg_term <= 3)
 156                                 rt5025_power_charge_detect(ii->chip->power_info);
 157
 158                 }
 159                 #endif /* CONFIG_POWER_RT5025 */
 160                 if (ii->event_cb)
 161                 {
 162                         if (chg_event)
 163                                 ii->event_cb->charger_event_callback(chg_event);
 164                         if (pwr_event)
 165                                 ii->event_cb->power_event_callkback(pwr_event);
 166                 }
 167         #if 0
 168         }
 169         else
 170                 dev_err(ii->dev, "read irq stat io fail\n");
 171         #endif
 172
 173
 174         #ifdef CONFIG_POWER_RT5025
 175         if (irq_stat[5] & RT5025_FLG_TEMP)
 176                 rt5025_swjeita_irq_handler(ii->chip->jeita_info, irq_stat[5] & RT5025_FLG_TEMP);
 177         if (irq_stat[5] & RT5025_FLG_VOLT)
 178                 rt5025_gauge_irq_handler(ii->chip->battery_info, irq_stat[5] & RT5025_FLG_VOLT);
 179         #endif /* CONFIG_POWER_RT5025 */
 180
 181         #if 1
 182         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, irq_enable[1]);
 183         #else
 184         /* restore all irq enable bit */
 185         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN1, irq_enable[0]);
 186         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, irq_enable[1]);
 187         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN3, irq_enable[2]);
 188         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN4, irq_enable[3]);
 189         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN5, irq_enable[4]);
 190         if (rt5025_reg_read(ii->i2c, RT5025_REG_GAUGEIRQEN) == 0)
 191                 rt5025_reg_write(ii->i2c, RT5025_REG_GAUGEIRQEN, irq_enable[5]);
 192         #endif //#if 0
 193
 194         //enable_irq(ii->irq);
 195 }
 196
 197 static irqreturn_t rt5025_interrupt(int irqno, void *param)
 198 {
 199         struct rt5025_irq_info *ii = (struct rt5025_irq_info *)param;
 200
 201         //disable_irq_nosync(ii->irq);
 202         wake_lock_timeout(&ii->irq_wake_lock, 1*HZ);
 203         queue_delayed_work(ii->wq, &ii->delayed_work, 0);
 204         return IRQ_HANDLED;
 205 }
 206
 207 static int __devinit rt5025_interrupt_init(struct rt5025_irq_info* ii)
 208 {
 209         int ret = 0;
 210
 211         RTINFO("\n");
 212         ii->wq = create_workqueue("rt5025_wq");
 213         INIT_DELAYED_WORK(&ii->delayed_work, rt5025_work_func);
 214
 215         #if 0
 216         if (gpio_is_valid(ii->intr_pin))
 217         {
 218                 ret = gpio_request(ii->intr_pin, "rt5025_interrupt");
 219                 if (ret)
 220                         return ret;
 221
 222                 ret = gpio_direction_input(ii->intr_pin);
 223                 if (ret)
 224                         return ret;
 225         #endif
 226
 227                 if (request_irq(ii->irq, rt5025_interrupt, IRQ_TYPE_EDGE_FALLING|IRQF_DISABLED, "RT5025_IRQ", ii))
 228                 {
 229                         dev_err(ii->dev, "couldn't allocate IRQ_NO(%d) !\n", ii->irq);
 230                         return -EINVAL;
 231                 }
 232                 enable_irq_wake(ii->irq);
 233                 queue_delayed_work(ii->wq, &ii->delayed_work, msecs_to_jiffies(100));
 234         #if 0
 235
 236                 if (!gpio_get_value(ii->intr_pin))
 237                 {
 238                         //disable_irq_nosync(ii->irq);
 239                         queue_delayed_work(ii->wq, &ii->delayed_work, 0);
 240                 }
 241         }
 242         else
 243                 return -EINVAL;
 244         #endif
 245
 246         return ret;
 247 }
 248
 249 static void __devexit rt5025_interrupt_deinit(struct rt5025_irq_info* ii)
 250 {
 251         if (ii->irq)
 252                 free_irq(ii->irq, ii);
 253
 254         if (ii->wq)
 255         {
 256                 cancel_delayed_work_sync(&ii->delayed_work);
 257                 flush_workqueue(ii->wq);
 258                 destroy_workqueue(ii->wq);
 259         }
 260 }
 261
 262 static int __devinit rt5025_irq_reg_init(struct rt5025_irq_info* ii, struct rt5025_irq_data* irq_data)
 263 {
 264         RTINFO("\n");
 265         // will just enable the interrupt that we want
 266         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN1, irq_data->irq_enable1.val);
 267         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, irq_data->irq_enable2.val);
 268         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN3, irq_data->irq_enable3.val);
 269         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN4, irq_data->irq_enable4.val);
 270         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN5, irq_data->irq_enable5.val);
 271         return 0;
 272 }
 273
 274 static int __devinit rt5025_irq_probe(struct platform_device *pdev)
 275 {
 276         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
 277         struct rt5025_platform_data *pdata = chip->dev->platform_data;
 278         struct rt5025_irq_info *ii;
 279
 280         RTINFO("\n");
 281         ii = kzalloc(sizeof(*ii), GFP_KERNEL);
 282         if (!ii)
 283                 return -ENOMEM;
 284
 285         ii->i2c = chip->i2c;
 286         ii->dev = &pdev->dev;
 287         ii->chip = chip;
 288         ii->intr_pin = pdata->intr_pin;
 289         ii->irq = chip->irq;//gpio_to_irq(pdata->intr_pin);
 290         if (pdata->cb)
 291                 ii->event_cb = pdata->cb;
 292         wake_lock_init(&ii->irq_wake_lock, WAKE_LOCK_SUSPEND, "rt_irq_wake");
 293
 294         rt5025_irq_reg_init(ii, pdata->irq_data);
 295         rt5025_interrupt_init(ii);
 296
 297         platform_set_drvdata(pdev, ii);
 298         RTINFO("\n");
 299         return 0;
 300 }
 301
 302 static int __devexit rt5025_irq_remove(struct platform_device *pdev)
 303 {
 304         struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
 305
 306         wake_lock_destroy(&ii->irq_wake_lock);
 307         rt5025_interrupt_deinit(ii);
 308         platform_set_drvdata(pdev, NULL);
 309         kfree(ii);
 310         RTINFO("\n");
 311         return 0;
 312 }
 313
 314 static void rt5025_irq_shutdown(struct platform_device *pdev)
 315 {
 316         struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
 317
 318         if (ii->irq)
 319                 free_irq(ii->irq, ii);
 320
 321         if (ii->wq)
 322         {
 323                 cancel_delayed_work_sync(&ii->delayed_work);
 324                 flush_workqueue(ii->wq);
 325         }
 326         RTINFO("\n");
 327 }
 328
 329 static int rt5025_irq_suspend(struct platform_device *pdev, pm_message_t state)
 330 {
 331         struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
 332
 333         RTINFO("\n");
 334         ii->suspend = 1;
 335         return 0;
 336 }
 337
 338 static int rt5025_irq_resume(struct platform_device *pdev)
 339 {
 340         struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
 341
 342         RTINFO("\n");
 343         ii->suspend = 0;
 344         return 0;
 345 }
 346
 347 static struct platform_driver rt5025_irq_driver =
 348 {
 349         .driver = {
 350                 .name = RT5025_DEVICE_NAME "-irq",
 351                 .owner = THIS_MODULE,
 352         },
 353         .probe = rt5025_irq_probe,
 354         .remove = __devexit_p(rt5025_irq_remove),
 355         .shutdown = rt5025_irq_shutdown,
 356         .suspend = rt5025_irq_suspend,
 357         .resume = rt5025_irq_resume,
 358 };
 359
 360 static int __init rt5025_irq_init(void)
 361 {
 362         return platform_driver_register(&rt5025_irq_driver);
 363 }
 364 module_init(rt5025_irq_init);
 365
 366 static void __exit rt5025_irq_exit(void)
 367 {
 368         platform_driver_unregister(&rt5025_irq_driver);
 369 }
 370 module_exit(rt5025_irq_exit);
 371
 372 MODULE_LICENSE("GPL v2");
 373 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 374 MODULE_DESCRIPTION("IRQ driver for RT5025");
 375 MODULE_ALIAS("platform:" RT5025_DEVICE_NAME "-irq");
 376 MODULE_VERSION(RT5025_DRV_VER);