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
  20 #include <linux/gpio.h>
  21 #include <linux/irq.h>
  22 #include <linux/interrupt.h>
  23 #include <linux/workqueue.h>
  24
  25 #include <linux/mfd/rt5025.h>
  26 #include <linux/mfd/rt5025-irq.h>
  27
  28 struct rt5025_irq_info {
  29         struct i2c_client *i2c;
  30         struct device *dev;
  31         struct rt5025_chip *chip;
  32         struct workqueue_struct *wq;
  33         struct rt5025_event_callback *event_cb;
  34         struct delayed_work delayed_work;
  35         int intr_pin;
  36         int irq;
  37 };
  38
  39 static void rt5025_work_func(struct work_struct *work)
  40 {
  41         struct delayed_work *delayed_work = (struct delayed_work *)container_of(work, struct delayed_work, work);
  42         struct rt5025_irq_info *ii = (struct rt5025_irq_info *)container_of(delayed_work, struct rt5025_irq_info, delayed_work);
  43         unsigned char irq_stat[6] = {0};
  44         uint32_t chg_event = 0, pwr_event = 0;
  45
  46         #ifdef CONFIG_POWER_RT5025
  47         if (!ii->chip->power_info || !ii->chip->jeita_info || !ii->chip->battery_info)
  48         {
  49                 queue_delayed_work(ii->wq, &ii->delayed_work, msecs_to_jiffies(1));
  50                 return;
  51         }
  52         #endif
  53
  54         #if 0
  55         if (rt5025_reg_block_read(ii->i2c, RT5025_REG_IRQEN1, 10, irq_stat) >= 0)
  56         {
  57         #endif
  58                 irq_stat[0] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS1);
  59                 irq_stat[1] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS2);
  60                 irq_stat[2] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS3);
  61                 irq_stat[3] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS4);
  62                 irq_stat[4] = rt5025_reg_read(ii->i2c, RT5025_REG_IRQSTATUS5);
  63                 irq_stat[5] = rt5025_reg_read(ii->i2c, RT5025_REG_GAUGEIRQFLG);
  64                 RTINFO("irq1->0x%02x, irq2->0x%02x, irq3->0x%02x\n", irq_stat[0], irq_stat[1], irq_stat[2]);
  65                 RTINFO("irq4->0x%02x, irq5->0x%02x, irq6->0x%02x\n", irq_stat[3], irq_stat[4], irq_stat[5]);
  66                 RTINFO("stat value = %02x\n", rt5025_reg_read(ii->i2c, RT5025_REG_CHGSTAT));
  67
  68                 chg_event = irq_stat[0]<<16 | irq_stat[1]<<8 | irq_stat[2];
  69                 pwr_event = irq_stat[3]<<8 | irq_stat[4];
  70                 #ifdef CONFIG_POWER_RT5025
  71                 if (chg_event & CHARGER_DETECT_MASK)
  72                 {
  73                         if (chg_event & CHG_EVENT_CHTERMI)
  74                                 ii->chip->power_info->chg_term++;
  75                         rt5025_power_charge_detect(ii->chip->power_info);
  76                 }
  77                 #endif /* CONFIG_POWER_RT5025 */
  78                 if (ii->event_cb)
  79                 {
  80                         if (chg_event)
  81                                 ii->event_cb->charger_event_callback(chg_event);
  82                         if (pwr_event)
  83                                 ii->event_cb->power_event_callkback(pwr_event);
  84                 }
  85         #if 0
  86         }
  87         else
  88                 dev_err(ii->dev, "read irq stat io fail\n");
  89         #endif
  90
  91
  92         #ifdef CONFIG_POWER_RT5025
  93         if (irq_stat[5] & RT5025_FLG_TEMP)
  94                 rt5025_swjeita_irq_handler(ii->chip->jeita_info, irq_stat[5] & RT5025_FLG_TEMP);
  95         if (irq_stat[5] & RT5025_FLG_VOLT)
  96                 rt5025_gauge_irq_handler(ii->chip->battery_info, irq_stat[5] & RT5025_FLG_VOLT);
  97         #endif /* CONFIG_POWER_RT5025 */
  98
  99         //enable_irq(ii->irq);
 100 }
 101
 102 static irqreturn_t rt5025_interrupt(int irqno, void *param)
 103 {
 104         struct rt5025_irq_info *ii = (struct rt5025_irq_info *)param;
 105
 106         //disable_irq_nosync(ii->irq);
 107         queue_delayed_work(ii->wq, &ii->delayed_work, 0);
 108         return IRQ_HANDLED;
 109 }
 110
 111 static int __devinit rt5025_interrupt_init(struct rt5025_irq_info* ii)
 112 {
 113         int ret = 0;
 114
 115         RTINFO("\n");
 116         ii->wq = create_workqueue("rt5025_wq");
 117         INIT_DELAYED_WORK(&ii->delayed_work, rt5025_work_func);
 118
 119         #if 0
 120         if (gpio_is_valid(ii->intr_pin))
 121         {
 122                 ret = gpio_request(ii->intr_pin, "rt5025_interrupt");
 123                 if (ret)
 124                         return ret;
 125
 126                 ret = gpio_direction_input(ii->intr_pin);
 127                 if (ret)
 128                         return ret;
 129         #endif
 130
 131                 if (request_irq(ii->irq, rt5025_interrupt, IRQ_TYPE_EDGE_FALLING|IRQF_DISABLED, "RT5025_IRQ", ii))
 132                 {
 133                         dev_err(ii->dev, "couldn't allocate IRQ_NO(%d) !\n", ii->irq);
 134                         return -EINVAL;
 135                 }
 136                 enable_irq_wake(ii->irq);
 137                 queue_delayed_work(ii->wq, &ii->delayed_work, msecs_to_jiffies(100));
 138         #if 0
 139
 140                 if (!gpio_get_value(ii->intr_pin))
 141                 {
 142                         //disable_irq_nosync(ii->irq);
 143                         queue_delayed_work(ii->wq, &ii->delayed_work, 0);
 144                 }
 145         }
 146         else
 147                 return -EINVAL;
 148         #endif
 149
 150         return ret;
 151 }
 152
 153 static void __devexit rt5025_interrupt_deinit(struct rt5025_irq_info* ii)
 154 {
 155         if (ii->irq)
 156                 free_irq(ii->irq, ii);
 157
 158         if (ii->wq)
 159         {
 160                 cancel_delayed_work_sync(&ii->delayed_work);
 161                 flush_workqueue(ii->wq);
 162                 destroy_workqueue(ii->wq);
 163         }
 164 }
 165
 166 static int __devinit rt5025_irq_reg_init(struct rt5025_irq_info* ii, struct rt5025_irq_data* irq_data)
 167 {
 168         RTINFO("\n");
 169         // will just enable the interrupt that we want
 170         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN1, irq_data->irq_enable1.val);
 171         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN2, irq_data->irq_enable2.val);
 172         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN3, irq_data->irq_enable3.val);
 173         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN4, irq_data->irq_enable4.val);
 174         rt5025_reg_write(ii->i2c, RT5025_REG_IRQEN5, irq_data->irq_enable5.val);
 175         return 0;
 176 }
 177
 178 static int __devinit rt5025_irq_probe(struct platform_device *pdev)
 179 {
 180         struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
 181         struct rt5025_platform_data *pdata = chip->dev->platform_data;
 182         struct rt5025_irq_info *ii;
 183
 184         RTINFO("\n");
 185         ii = kzalloc(sizeof(*ii), GFP_KERNEL);
 186         if (!ii)
 187                 return -ENOMEM;
 188
 189         ii->i2c = chip->i2c;
 190         ii->dev = &pdev->dev;
 191         ii->chip = chip;
 192         ii->intr_pin = pdata->intr_pin;
 193         ii->irq = chip->irq;//gpio_to_irq(pdata->intr_pin);
 194         if (pdata->cb)
 195                 ii->event_cb = pdata->cb;
 196
 197         rt5025_irq_reg_init(ii, pdata->irq_data);
 198         rt5025_interrupt_init(ii);
 199
 200         platform_set_drvdata(pdev, ii);
 201         return 0;
 202 }
 203
 204 static int __devexit rt5025_irq_remove(struct platform_device *pdev)
 205 {
 206         struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
 207
 208         rt5025_interrupt_deinit(ii);
 209         platform_set_drvdata(pdev, NULL);
 210         return 0;
 211 }
 212
 213 static void rt5025_irq_shutdown(struct platform_device *pdev)
 214 {
 215         struct rt5025_irq_info *ii = platform_get_drvdata(pdev);
 216
 217         if (ii->irq)
 218                 free_irq(ii->irq, ii);
 219
 220         if (ii->wq)
 221         {
 222                 cancel_delayed_work_sync(&ii->delayed_work);
 223                 flush_workqueue(ii->wq);
 224         }
 225 }
 226
 227 static struct platform_driver rt5025_irq_driver =
 228 {
 229         .driver = {
 230                 .name = RT5025_DEVICE_NAME "-irq",
 231                 .owner = THIS_MODULE,
 232         },
 233         .probe = rt5025_irq_probe,
 234         .remove = __devexit_p(rt5025_irq_remove),
 235         .shutdown = rt5025_irq_shutdown,
 236 };
 237
 238 static int __init rt5025_irq_init(void)
 239 {
 240         return platform_driver_register(&rt5025_irq_driver);
 241 }
 242 subsys_initcall_sync(rt5025_irq_init);
 243
 244 static void __exit rt5025_irq_exit(void)
 245 {
 246         platform_driver_unregister(&rt5025_irq_driver);
 247 }
 248 module_exit(rt5025_irq_exit);
 249
 250 MODULE_LICENSE("GPL v2");
 251 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com");
 252 MODULE_DESCRIPTION("IRQ driver for RT5025");
 253 MODULE_ALIAS("platform:" RT5025_DEVICE_NAME "-irq");