drivers/mfd/max8997-irq.c

   1 /*
   2  * max8997-irq.c - Interrupt controller support for MAX8997
   3  *
   4  * Copyright (C) 2011 Samsung Electronics Co.Ltd
   5  * MyungJoo Ham <myungjoo.ham@samsung.com>
   6  *
   7  * This program is not provided / owned by Maxim Integrated Products.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  * This driver is based on max8998-irq.c
  24  */
  25
  26 #include <linux/err.h>
  27 #include <linux/irq.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/mfd/max8997.h>
  30 #include <linux/mfd/max8997-private.h>
  31 #include <linux/pm.h>
  32 #include <linux/pm_wakeup.h>
  33
  34 #define WAKEUP_TIMEOUT          (3000)          //ms
  35
  36 static u8 max8997_mask_reg[] = {
  37         [PMIC_INT1] = MAX8997_REG_INT1MSK,
  38         [PMIC_INT2] = MAX8997_REG_INT2MSK,
  39         [PMIC_INT3] = MAX8997_REG_INT3MSK,
  40         [PMIC_INT4] = MAX8997_REG_INT4MSK,
  41         [FUEL_GAUGE] = MAX8997_REG_INVALID,
  42         [MUIC_INT1] = MAX8997_MUIC_REG_INTMASK1,
  43         [MUIC_INT2] = MAX8997_MUIC_REG_INTMASK2,
  44         [MUIC_INT3] = MAX8997_MUIC_REG_INTMASK3,
  45         [GPIO_LOW] = MAX8997_REG_INVALID,
  46         [GPIO_HI] = MAX8997_REG_INVALID,
  47         [FLASH_STATUS] = MAX8997_REG_INVALID,
  48 };
  49
  50 static struct i2c_client *get_i2c(struct max8997_dev *max8997,
  51                 enum max8997_irq_source src)
  52 {
  53         switch (src) {
  54         case PMIC_INT1 ... PMIC_INT4:
  55                 return max8997->i2c;
  56         case FUEL_GAUGE:
  57                 return NULL;
  58         case MUIC_INT1 ... MUIC_INT3:
  59                 return max8997->muic;
  60         case GPIO_LOW ... GPIO_HI:
  61                 return max8997->i2c;
  62         case FLASH_STATUS:
  63                 return max8997->i2c;
  64         default:
  65                 return ERR_PTR(-EINVAL);
  66         }
  67
  68         return ERR_PTR(-EINVAL);
  69 }
  70
  71 struct max8997_irq_data {
  72         int mask;
  73         enum max8997_irq_source group;
  74 };
  75
  76 static struct max8997_irq_data max8997_irqs[] = {
  77         [MAX8997_PMICIRQ_PWRONR] = {
  78                 .group  = PMIC_INT1,
  79                 .mask   = 1 << 0,
  80         },
  81         [MAX8997_PMICIRQ_PWRONF] = {
  82                 .group  = PMIC_INT1,
  83                 .mask   = 1 << 1,
  84         },
  85         [MAX8997_PMICIRQ_PWRON1SEC] = {
  86                 .group  = PMIC_INT1,
  87                 .mask   = 1 << 3,
  88         },
  89         [MAX8997_PMICIRQ_JIGONR] = {
  90                 .group  = PMIC_INT1,
  91                 .mask   = 1 << 4,
  92         },
  93         [MAX8997_PMICIRQ_JIGONF] = {
  94                 .group  = PMIC_INT1,
  95                 .mask   = 1 << 5,
  96         },
  97         [MAX8997_PMICIRQ_LOWBAT2] = {
  98                 .group  = PMIC_INT1,
  99                 .mask   = 1 << 6,
 100         },
 101         [MAX8997_PMICIRQ_LOWBAT1] = {
 102                 .group  = PMIC_INT1,
 103                 .mask   = 1 << 7,
 104         },
 105
 106         [MAX8997_PMICIRQ_JIGR] = {
 107                 .group  = PMIC_INT2,
 108                 .mask   = 1 << 0,
 109         },
 110         [MAX8997_PMICIRQ_JIGF] = {
 111                 .group  = PMIC_INT2,
 112                 .mask   = 1 << 1,
 113         },
 114         [MAX8997_PMICIRQ_MR] = {
 115                 .group  = PMIC_INT2,
 116                 .mask   = 1 << 2,
 117         },
 118         [MAX8997_PMICIRQ_DVS1OK] = {
 119                 .group  = PMIC_INT2,
 120                 .mask   = 1 << 3,
 121         },
 122         [MAX8997_PMICIRQ_DVS2OK] = {
 123                 .group  = PMIC_INT2,
 124                 .mask   = 1 << 4,
 125         },
 126         [MAX8997_PMICIRQ_DVS3OK] = {
 127                 .group  = PMIC_INT2,
 128                 .mask   = 1 << 5,
 129         },
 130         [MAX8997_PMICIRQ_DVS4OK] = {
 131                 .group  = PMIC_INT2,
 132                 .mask   = 1 << 6,
 133         },
 134
 135         [MAX8997_PMICIRQ_CHGINS] = {
 136                 .group  = PMIC_INT3,
 137                 .mask   = 1 << 0,
 138         },
 139         [MAX8997_PMICIRQ_CHGRM] = {
 140                 .group  = PMIC_INT3,
 141                 .mask   = 1 << 1,
 142         },
 143         [MAX8997_PMICIRQ_DCINOVP] = {
 144                 .group  = PMIC_INT3,
 145                 .mask   = 1 << 2,
 146         },
 147         [MAX8997_PMICIRQ_TOPOFFR] = {
 148                 .group  = PMIC_INT3,
 149                 .mask   = 1 << 3,
 150         },
 151         [MAX8997_PMICIRQ_CHGRSTF] = {
 152                 .group  = PMIC_INT3,
 153                 .mask   = 1 << 5,
 154         },
 155         [MAX8997_PMICIRQ_MBCHGTMEXPD] = {
 156                 .group  = PMIC_INT3,
 157                 .mask   = 1 << 7,
 158         },
 159
 160         [MAX8997_PMICIRQ_RTC60S] = {
 161                 .group  = PMIC_INT4,
 162                 .mask   = 1 << 0,
 163         },
 164         [MAX8997_PMICIRQ_RTCA1] = {
 165                 .group  = PMIC_INT4,
 166                 .mask   = 1 << 1,
 167         },
 168         [MAX8997_PMICIRQ_RTCA2] = {
 169                 .group  = PMIC_INT4,
 170                 .mask   = 1 << 2,
 171         },
 172         [MAX8997_PMICIRQ_SMPL_INT] = {
 173                 .group  = PMIC_INT4,
 174                 .mask   = 1 << 3,
 175         },
 176         [MAX8997_PMICIRQ_RTC1S] = {
 177                 .group  = PMIC_INT4,
 178                 .mask   = 1 << 4,
 179         },
 180         [MAX8997_PMICIRQ_WTSR] = {
 181                 .group  = PMIC_INT4,
 182                 .mask   = 1 << 5,
 183         },
 184
 185         [MAX8997_MUICIRQ_ADCError] = {
 186                 .group  = MUIC_INT1,
 187                 .mask   = 1 << 2,
 188         },
 189         [MAX8997_MUICIRQ_ADCLow] = {
 190                 .group  = MUIC_INT1,
 191                 .mask   = 1 << 1,
 192         },
 193         [MAX8997_MUICIRQ_ADC] = {
 194                 .group  = MUIC_INT1,
 195                 .mask   = 1 << 0,
 196         },
 197
 198         [MAX8997_MUICIRQ_VBVolt] = {
 199                 .group  = MUIC_INT2,
 200                 .mask   = 1 << 4,
 201         },
 202         [MAX8997_MUICIRQ_DBChg] = {
 203                 .group  = MUIC_INT2,
 204                 .mask   = 1 << 3,
 205         },
 206         [MAX8997_MUICIRQ_DCDTmr] = {
 207                 .group  = MUIC_INT2,
 208                 .mask   = 1 << 2,
 209         },
 210         [MAX8997_MUICIRQ_ChgDetRun] = {
 211                 .group  = MUIC_INT2,
 212                 .mask   = 1 << 1,
 213         },
 214         [MAX8997_MUICIRQ_ChgTyp] = {
 215                 .group  = MUIC_INT2,
 216                 .mask   = 1 << 0,
 217         },
 218
 219         [MAX8997_MUICIRQ_OVP] = {
 220                 .group  = MUIC_INT3,
 221                 .mask   = 1 << 2,
 222         },
 223 };
 224
 225 static inline struct max8997_irq_data *
 226 irq_to_max8997_irq(struct max8997_dev *max8997, int irq)
 227 {
 228         return &max8997_irqs[irq - max8997->irq_base];
 229 }
 230
 231 static void max8997_irq_lock(unsigned int irq)
 232 {
 233         struct max8997_dev *max8997 = get_irq_chip_data(irq);
 234
 235         mutex_lock(&max8997->irqlock);
 236 }
 237
 238 static void max8997_irq_sync_unlock(unsigned int irq)
 239 {
 240         struct max8997_dev *max8997 = get_irq_chip_data(irq);
 241         int i;
 242
 243         for (i = 0; i < MAX8997_IRQ_GROUP_NR; i++) {
 244                 u8 mask_reg = max8997_mask_reg[i];
 245                 struct i2c_client *i2c = get_i2c(max8997, i);
 246
 247                 if (mask_reg == MAX8997_REG_INVALID ||
 248                                 IS_ERR_OR_NULL(i2c))
 249                         continue;
 250                 max8997->irq_masks_cache[i] = max8997->irq_masks_cur[i];
 251
 252                 max8997_write_reg(i2c, max8997_mask_reg[i],
 253                                 max8997->irq_masks_cur[i]);
 254         }
 255
 256         mutex_unlock(&max8997->irqlock);
 257 }
 258
 259 static void max8997_irq_mask(unsigned int irq)
 260 {
 261         struct max8997_dev *max8997 = get_irq_chip_data(irq);
 262         struct max8997_irq_data *irq_data = irq_to_max8997_irq(max8997, irq);
 263
 264         max8997->irq_masks_cur[irq_data->group] |= irq_data->mask;
 265 }
 266
 267 static void max8997_irq_unmask(unsigned int irq)
 268 {
 269         struct max8997_dev *max8997 = get_irq_chip_data(irq);
 270         struct max8997_irq_data *irq_data = irq_to_max8997_irq(max8997, irq);
 271
 272         max8997->irq_masks_cur[irq_data->group] &= ~irq_data->mask;
 273 }
 274
 275 static struct irq_chip max8997_irq_chip = {
 276         .name                   = "max8997",
 277         .bus_lock               = max8997_irq_lock,
 278         .bus_sync_unlock        = max8997_irq_sync_unlock,
 279         .mask                   = max8997_irq_mask,
 280         .unmask                 = max8997_irq_unmask,
 281 };
 282
 283 static irqreturn_t max8997_irq_thread(int irq, void *data)
 284 {
 285         struct max8997_dev *max8997 = data;
 286         u8 irq_reg[MAX8997_IRQ_GROUP_NR];
 287         u8 irq_src;
 288         int ret;
 289         int i;
 290
 291         ret = max8997_read_reg(max8997->i2c, MAX8997_REG_INTSRC, &irq_src);
 292         if (ret < 0) {
 293                 dev_err(max8997->dev, "Failed to read interrupt source: %d\n",
 294                                 ret);
 295                 return IRQ_NONE;
 296         }
 297
 298         for (i = 0; i < MAX8997_IRQ_GROUP_NR; i++)
 299                 irq_reg[i] = 0;
 300
 301         if (irq_src & (1 << 1)) {
 302                 /* PMIC INT1 ~ INT4 */
 303                 max8997_bulk_read(max8997->i2c, MAX8997_REG_INT1, 4, &irq_reg[PMIC_INT1]);
 304         }
 305         if (irq_src & (1 << 2)) {
 306                 /* FUEL GAUGE Interrupt */
 307                 /* Ignored */
 308                 irq_reg[FUEL_GAUGE] = 0;
 309         }
 310         if (irq_src & (1 << 3)) {
 311                 /* MUIC INT1 ~ INT3 */
 312                 max8997_bulk_read(max8997->muic, MAX8997_MUIC_REG_INT1, 3,
 313                                 &irq_reg[MUIC_INT1]);
 314         }
 315         if (irq_src & (1 << 4)) {
 316                 /* GPIO Interrupt */
 317                 u8 gpio_info[12];
 318                 int gpio;
 319
 320                 irq_reg[GPIO_LOW] = 0;
 321                 irq_reg[GPIO_HI] = 0;
 322
 323                 max8997_bulk_read(max8997->i2c, MAX8997_REG_GPIOCNTL1, 12,
 324                                 gpio_info);
 325                 for (gpio = 0; gpio < 8; gpio++) {
 326                         u8 val = gpio_info[gpio] & 0x34;
 327                         if (((val & 0x30) == 0x30) ||
 328                                         (val == 0x10) ||
 329                                         (val == 0x24))
 330                                 irq_reg[GPIO_LOW] |= (1 << gpio);
 331                 }
 332                 for (gpio = 8; gpio < 12; gpio++) {
 333                         u8 val = gpio_info[gpio] & 0x34;
 334                         if (((val & 0x30) == 0x30) ||
 335                                         (val == 0x10) ||
 336                                         (val == 0x24))
 337                                 irq_reg[GPIO_HI] |= (1 << (gpio - 8));
 338                 }
 339         }
 340         if (irq_src & (1 << 5)) {
 341                 /* Flash Status Interrupt */
 342                 ret = max8997_read_reg(max8997->i2c, MAX8997_REG_FLASHSTATUS,
 343                                 &irq_reg[FLASH_STATUS]);
 344         }
 345
 346         /* Apply masking */
 347         for (i = 0; i < MAX8997_IRQ_GROUP_NR; i++)
 348                 irq_reg[i] &= ~max8997->irq_masks_cur[i];
 349
 350         /* Report */
 351         for (i = 0; i < MAX8997_IRQ_NR; i++) {
 352                 if (irq_reg[max8997_irqs[i].group] & max8997_irqs[i].mask)
 353                         handle_nested_irq(max8997->irq_base + i);
 354         }
 355
 356         if(device_may_wakeup(max8997->dev))
 357                 pm_wakeup_event(max8997->dev, WAKEUP_TIMEOUT);
 358
 359         return IRQ_HANDLED;
 360 }
 361
 362 int max8997_irq_resume(struct max8997_dev *max8997)
 363 {
 364         if (max8997->irq && max8997->irq_base)
 365                 max8997_irq_thread(max8997->irq, max8997);
 366         return 0;
 367 }
 368
 369 int max8997_irq_init(struct max8997_dev *max8997)
 370 {
 371         int i;
 372         int cur_irq;
 373         int ret;
 374
 375         if (!max8997->irq) {
 376                 dev_warn(max8997->dev, "No interrupt specified.\n");
 377                 max8997->irq_base = 0;
 378                 return 0;
 379         }
 380
 381         if (!max8997->irq_base) {
 382                 dev_err(max8997->dev, "No interrupt base specified.\n");
 383                 return 0;
 384         }
 385
 386         mutex_init(&max8997->irqlock);
 387
 388         /* Mask individual interrupt sources */
 389         for (i = 0; i < MAX8997_IRQ_GROUP_NR; i++) {
 390                 struct i2c_client *i2c;
 391
 392                 max8997->irq_masks_cur[i] = 0xff;
 393                 max8997->irq_masks_cache[i] = 0xff;
 394                 i2c = get_i2c(max8997, i);
 395
 396                 if (IS_ERR_OR_NULL(i2c))
 397                         continue;
 398                 if (max8997_mask_reg[i] == MAX8997_REG_INVALID)
 399                         continue;
 400
 401                 max8997_write_reg(i2c, max8997_mask_reg[i], 0xff);
 402         }
 403
 404         /* Register with genirq */
 405         for (i = 0; i < MAX8997_IRQ_NR; i++) {
 406                 cur_irq = i + max8997->irq_base;
 407                 set_irq_chip_data(cur_irq, max8997);
 408                 set_irq_chip_and_handler(cur_irq, &max8997_irq_chip,
 409                                 handle_level_irq);
 410                 set_irq_nested_thread(cur_irq, 1);
 411 #ifdef CONFIG_ARM
 412                 set_irq_flags(cur_irq, IRQF_VALID);
 413 #else
 414                 set_irq_noprobe(cur_irq);
 415 #endif
 416         }
 417
 418         ret = request_threaded_irq(max8997->irq, NULL, max8997_irq_thread,
 419                         IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 420                         "max8997-irq", max8997);
 421
 422         if (ret) {
 423                 dev_err(max8997->dev, "Failed to request IRQ %d: %d\n",
 424                                 max8997->irq, ret);
 425                 return ret;
 426         }
 427
 428         device_init_wakeup(max8997->dev, max8997->wakeup);
 429
 430         if (!max8997->ono)
 431                 return 0;
 432
 433         ret = request_threaded_irq(max8997->ono, NULL, max8997_irq_thread,
 434                         IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING |
 435                         IRQF_ONESHOT, "max8997-ono", max8997);
 436
 437         if (ret)
 438                 dev_err(max8997->dev, "Failed to request ono-IRQ %d: %d\n",
 439                                 max8997->ono, ret);
 440
 441         return 0;
 442 }
 443
 444 void max8997_irq_exit(struct max8997_dev *max8997)
 445 {
 446         if (max8997->ono)
 447                 free_irq(max8997->ono, max8997);
 448
 449         if (max8997->irq)
 450                 free_irq(max8997->irq, max8997);
 451 }