drivers/mfd/twl4030-irq.c

   1 /*
   2  * twl4030-irq.c - TWL4030/TPS659x0 irq support
   3  *
   4  * Copyright (C) 2005-2006 Texas Instruments, Inc.
   5  *
   6  * Modifications to defer interrupt handling to a kernel thread:
   7  * Copyright (C) 2006 MontaVista Software, Inc.
   8  *
   9  * Based on tlv320aic23.c:
  10  * Copyright (c) by Kai Svahn <kai.svahn@nokia.com>
  11  *
  12  * Code cleanup and modifications to IRQ handler.
  13  * by syed khasim <x0khasim@ti.com>
  14  *
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  28  */
  29
  30 #include <linux/init.h>
  31 #include <linux/export.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/irq.h>
  34 #include <linux/slab.h>
  35 #include <linux/of.h>
  36 #include <linux/irqdomain.h>
  37 #include <linux/i2c/twl.h>
  38
  39 #include "twl-core.h"
  40
  41 /*
  42  * TWL4030 IRQ handling has two stages in hardware, and thus in software.
  43  * The Primary Interrupt Handler (PIH) stage exposes status bits saying
  44  * which Secondary Interrupt Handler (SIH) stage is raising an interrupt.
  45  * SIH modules are more traditional IRQ components, which support per-IRQ
  46  * enable/disable and trigger controls; they do most of the work.
  47  *
  48  * These chips are designed to support IRQ handling from two different
  49  * I2C masters.  Each has a dedicated IRQ line, and dedicated IRQ status
  50  * and mask registers in the PIH and SIH modules.
  51  *
  52  * We set up IRQs starting at a platform-specified base, always starting
  53  * with PIH and the SIH for PWR_INT and then usually adding GPIO:
  54  *      base + 0  .. base + 7   PIH
  55  *      base + 8  .. base + 15  SIH for PWR_INT
  56  *      base + 16 .. base + 33  SIH for GPIO
  57  */
  58 #define TWL4030_CORE_NR_IRQS    8
  59 #define TWL4030_PWR_NR_IRQS     8
  60
  61 /* PIH register offsets */
  62 #define REG_PIH_ISR_P1                  0x01
  63 #define REG_PIH_ISR_P2                  0x02
  64 #define REG_PIH_SIR                     0x03    /* for testing */
  65
  66 /* Linux could (eventually) use either IRQ line */
  67 static int irq_line;
  68
  69 struct sih {
  70         char    name[8];
  71         u8      module;                 /* module id */
  72         u8      control_offset;         /* for SIH_CTRL */
  73         bool    set_cor;
  74
  75         u8      bits;                   /* valid in isr/imr */
  76         u8      bytes_ixr;              /* bytelen of ISR/IMR/SIR */
  77
  78         u8      edr_offset;
  79         u8      bytes_edr;              /* bytelen of EDR */
  80
  81         u8      irq_lines;              /* number of supported irq lines */
  82
  83         /* SIR ignored -- set interrupt, for testing only */
  84         struct sih_irq_data {
  85                 u8      isr_offset;
  86                 u8      imr_offset;
  87         } mask[2];
  88         /* + 2 bytes padding */
  89 };
  90
  91 static const struct sih *sih_modules;
  92 static int nr_sih_modules;
  93
  94 #define SIH_INITIALIZER(modname, nbits) \
  95         .module         = TWL4030_MODULE_ ## modname, \
  96         .control_offset = TWL4030_ ## modname ## _SIH_CTRL, \
  97         .bits           = nbits, \
  98         .bytes_ixr      = DIV_ROUND_UP(nbits, 8), \
  99         .edr_offset     = TWL4030_ ## modname ## _EDR, \
 100         .bytes_edr      = DIV_ROUND_UP((2*(nbits)), 8), \
 101         .irq_lines      = 2, \
 102         .mask = { { \
 103                 .isr_offset     = TWL4030_ ## modname ## _ISR1, \
 104                 .imr_offset     = TWL4030_ ## modname ## _IMR1, \
 105         }, \
 106         { \
 107                 .isr_offset     = TWL4030_ ## modname ## _ISR2, \
 108                 .imr_offset     = TWL4030_ ## modname ## _IMR2, \
 109         }, },
 110
 111 /* register naming policies are inconsistent ... */
 112 #define TWL4030_INT_PWR_EDR             TWL4030_INT_PWR_EDR1
 113 #define TWL4030_MODULE_KEYPAD_KEYP      TWL4030_MODULE_KEYPAD
 114 #define TWL4030_MODULE_INT_PWR          TWL4030_MODULE_INT
 115
 116
 117 /*
 118  * Order in this table matches order in PIH_ISR.  That is,
 119  * BIT(n) in PIH_ISR is sih_modules[n].
 120  */
 121 /* sih_modules_twl4030 is used both in twl4030 and twl5030 */
 122 static const struct sih sih_modules_twl4030[6] = {
 123         [0] = {
 124                 .name           = "gpio",
 125                 .module         = TWL4030_MODULE_GPIO,
 126                 .control_offset = REG_GPIO_SIH_CTRL,
 127                 .set_cor        = true,
 128                 .bits           = TWL4030_GPIO_MAX,
 129                 .bytes_ixr      = 3,
 130                 /* Note: *all* of these IRQs default to no-trigger */
 131                 .edr_offset     = REG_GPIO_EDR1,
 132                 .bytes_edr      = 5,
 133                 .irq_lines      = 2,
 134                 .mask = { {
 135                         .isr_offset     = REG_GPIO_ISR1A,
 136                         .imr_offset     = REG_GPIO_IMR1A,
 137                 }, {
 138                         .isr_offset     = REG_GPIO_ISR1B,
 139                         .imr_offset     = REG_GPIO_IMR1B,
 140                 }, },
 141         },
 142         [1] = {
 143                 .name           = "keypad",
 144                 .set_cor        = true,
 145                 SIH_INITIALIZER(KEYPAD_KEYP, 4)
 146         },
 147         [2] = {
 148                 .name           = "bci",
 149                 .module         = TWL4030_MODULE_INTERRUPTS,
 150                 .control_offset = TWL4030_INTERRUPTS_BCISIHCTRL,
 151                 .set_cor        = true,
 152                 .bits           = 12,
 153                 .bytes_ixr      = 2,
 154                 .edr_offset     = TWL4030_INTERRUPTS_BCIEDR1,
 155                 /* Note: most of these IRQs default to no-trigger */
 156                 .bytes_edr      = 3,
 157                 .irq_lines      = 2,
 158                 .mask = { {
 159                         .isr_offset     = TWL4030_INTERRUPTS_BCIISR1A,
 160                         .imr_offset     = TWL4030_INTERRUPTS_BCIIMR1A,
 161                 }, {
 162                         .isr_offset     = TWL4030_INTERRUPTS_BCIISR1B,
 163                         .imr_offset     = TWL4030_INTERRUPTS_BCIIMR1B,
 164                 }, },
 165         },
 166         [3] = {
 167                 .name           = "madc",
 168                 SIH_INITIALIZER(MADC, 4)
 169         },
 170         [4] = {
 171                 /* USB doesn't use the same SIH organization */
 172                 .name           = "usb",
 173         },
 174         [5] = {
 175                 .name           = "power",
 176                 .set_cor        = true,
 177                 SIH_INITIALIZER(INT_PWR, 8)
 178         },
 179                 /* there are no SIH modules #6 or #7 ... */
 180 };
 181
 182 static const struct sih sih_modules_twl5031[8] = {
 183         [0] = {
 184                 .name           = "gpio",
 185                 .module         = TWL4030_MODULE_GPIO,
 186                 .control_offset = REG_GPIO_SIH_CTRL,
 187                 .set_cor        = true,
 188                 .bits           = TWL4030_GPIO_MAX,
 189                 .bytes_ixr      = 3,
 190                 /* Note: *all* of these IRQs default to no-trigger */
 191                 .edr_offset     = REG_GPIO_EDR1,
 192                 .bytes_edr      = 5,
 193                 .irq_lines      = 2,
 194                 .mask = { {
 195                         .isr_offset     = REG_GPIO_ISR1A,
 196                         .imr_offset     = REG_GPIO_IMR1A,
 197                 }, {
 198                         .isr_offset     = REG_GPIO_ISR1B,
 199                         .imr_offset     = REG_GPIO_IMR1B,
 200                 }, },
 201         },
 202         [1] = {
 203                 .name           = "keypad",
 204                 .set_cor        = true,
 205                 SIH_INITIALIZER(KEYPAD_KEYP, 4)
 206         },
 207         [2] = {
 208                 .name           = "bci",
 209                 .module         = TWL5031_MODULE_INTERRUPTS,
 210                 .control_offset = TWL5031_INTERRUPTS_BCISIHCTRL,
 211                 .bits           = 7,
 212                 .bytes_ixr      = 1,
 213                 .edr_offset     = TWL5031_INTERRUPTS_BCIEDR1,
 214                 /* Note: most of these IRQs default to no-trigger */
 215                 .bytes_edr      = 2,
 216                 .irq_lines      = 2,
 217                 .mask = { {
 218                         .isr_offset     = TWL5031_INTERRUPTS_BCIISR1,
 219                         .imr_offset     = TWL5031_INTERRUPTS_BCIIMR1,
 220                 }, {
 221                         .isr_offset     = TWL5031_INTERRUPTS_BCIISR2,
 222                         .imr_offset     = TWL5031_INTERRUPTS_BCIIMR2,
 223                 }, },
 224         },
 225         [3] = {
 226                 .name           = "madc",
 227                 SIH_INITIALIZER(MADC, 4)
 228         },
 229         [4] = {
 230                 /* USB doesn't use the same SIH organization */
 231                 .name           = "usb",
 232         },
 233         [5] = {
 234                 .name           = "power",
 235                 .set_cor        = true,
 236                 SIH_INITIALIZER(INT_PWR, 8)
 237         },
 238         [6] = {
 239                 /*
 240                  * ECI/DBI doesn't use the same SIH organization.
 241                  * For example, it supports only one interrupt output line.
 242                  * That is, the interrupts are seen on both INT1 and INT2 lines.
 243                  */
 244                 .name           = "eci_dbi",
 245                 .module         = TWL5031_MODULE_ACCESSORY,
 246                 .bits           = 9,
 247                 .bytes_ixr      = 2,
 248                 .irq_lines      = 1,
 249                 .mask = { {
 250                         .isr_offset     = TWL5031_ACIIDR_LSB,
 251                         .imr_offset     = TWL5031_ACIIMR_LSB,
 252                 }, },
 253
 254         },
 255         [7] = {
 256                 /* Audio accessory */
 257                 .name           = "audio",
 258                 .module         = TWL5031_MODULE_ACCESSORY,
 259                 .control_offset = TWL5031_ACCSIHCTRL,
 260                 .bits           = 2,
 261                 .bytes_ixr      = 1,
 262                 .edr_offset     = TWL5031_ACCEDR1,
 263                 /* Note: most of these IRQs default to no-trigger */
 264                 .bytes_edr      = 1,
 265                 .irq_lines      = 2,
 266                 .mask = { {
 267                         .isr_offset     = TWL5031_ACCISR1,
 268                         .imr_offset     = TWL5031_ACCIMR1,
 269                 }, {
 270                         .isr_offset     = TWL5031_ACCISR2,
 271                         .imr_offset     = TWL5031_ACCIMR2,
 272                 }, },
 273         },
 274 };
 275
 276 #undef TWL4030_MODULE_KEYPAD_KEYP
 277 #undef TWL4030_MODULE_INT_PWR
 278 #undef TWL4030_INT_PWR_EDR
 279
 280 /*----------------------------------------------------------------------*/
 281
 282 static unsigned twl4030_irq_base;
 283
 284 /*
 285  * handle_twl4030_pih() is the desc->handle method for the twl4030 interrupt.
 286  * This is a chained interrupt, so there is no desc->action method for it.
 287  * Now we need to query the interrupt controller in the twl4030 to determine
 288  * which module is generating the interrupt request.  However, we can't do i2c
 289  * transactions in interrupt context, so we must defer that work to a kernel
 290  * thread.  All we do here is acknowledge and mask the interrupt and wakeup
 291  * the kernel thread.
 292  */
 293 static irqreturn_t handle_twl4030_pih(int irq, void *devid)
 294 {
 295         irqreturn_t     ret;
 296         u8              pih_isr;
 297
 298         ret = twl_i2c_read_u8(TWL_MODULE_PIH, &pih_isr,
 299                               REG_PIH_ISR_P1);
 300         if (ret) {
 301                 pr_warning("twl4030: I2C error %d reading PIH ISR\n", ret);
 302                 return IRQ_NONE;
 303         }
 304
 305         while (pih_isr) {
 306                 unsigned long   pending = __ffs(pih_isr);
 307                 unsigned int    irq;
 308
 309                 pih_isr &= ~BIT(pending);
 310                 irq = pending + twl4030_irq_base;
 311                 handle_nested_irq(irq);
 312         }
 313
 314         return IRQ_HANDLED;
 315 }
 316
 317 /*----------------------------------------------------------------------*/
 318
 319 /*
 320  * twl4030_init_sih_modules() ... start from a known state where no
 321  * IRQs will be coming in, and where we can quickly enable them then
 322  * handle them as they arrive.  Mask all IRQs: maybe init SIH_CTRL.
 323  *
 324  * NOTE:  we don't touch EDR registers here; they stay with hardware
 325  * defaults or whatever the last value was.  Note that when both EDR
 326  * bits for an IRQ are clear, that's as if its IMR bit is set...
 327  */
 328 static int twl4030_init_sih_modules(unsigned line)
 329 {
 330         const struct sih *sih;
 331         u8 buf[4];
 332         int i;
 333         int status;
 334
 335         /* line 0 == int1_n signal; line 1 == int2_n signal */
 336         if (line > 1)
 337                 return -EINVAL;
 338
 339         irq_line = line;
 340
 341         /* disable all interrupts on our line */
 342         memset(buf, 0xff, sizeof buf);
 343         sih = sih_modules;
 344         for (i = 0; i < nr_sih_modules; i++, sih++) {
 345                 /* skip USB -- it's funky */
 346                 if (!sih->bytes_ixr)
 347                         continue;
 348
 349                 /* Not all the SIH modules support multiple interrupt lines */
 350                 if (sih->irq_lines <= line)
 351                         continue;
 352
 353                 status = twl_i2c_write(sih->module, buf,
 354                                 sih->mask[line].imr_offset, sih->bytes_ixr);
 355                 if (status < 0)
 356                         pr_err("twl4030: err %d initializing %s %s\n",
 357                                         status, sih->name, "IMR");
 358
 359                 /*
 360                  * Maybe disable "exclusive" mode; buffer second pending irq;
 361                  * set Clear-On-Read (COR) bit.
 362                  *
 363                  * NOTE that sometimes COR polarity is documented as being
 364                  * inverted:  for MADC, COR=1 means "clear on write".
 365                  * And for PWR_INT it's not documented...
 366                  */
 367                 if (sih->set_cor) {
 368                         status = twl_i2c_write_u8(sih->module,
 369                                         TWL4030_SIH_CTRL_COR_MASK,
 370                                         sih->control_offset);
 371                         if (status < 0)
 372                                 pr_err("twl4030: err %d initializing %s %s\n",
 373                                                 status, sih->name, "SIH_CTRL");
 374                 }
 375         }
 376
 377         sih = sih_modules;
 378         for (i = 0; i < nr_sih_modules; i++, sih++) {
 379                 u8 rxbuf[4];
 380                 int j;
 381
 382                 /* skip USB */
 383                 if (!sih->bytes_ixr)
 384                         continue;
 385
 386                 /* Not all the SIH modules support multiple interrupt lines */
 387                 if (sih->irq_lines <= line)
 388                         continue;
 389
 390                 /*
 391                  * Clear pending interrupt status.  Either the read was
 392                  * enough, or we need to write those bits.  Repeat, in
 393                  * case an IRQ is pending (PENDDIS=0) ... that's not
 394                  * uncommon with PWR_INT.PWRON.
 395                  */
 396                 for (j = 0; j < 2; j++) {
 397                         status = twl_i2c_read(sih->module, rxbuf,
 398                                 sih->mask[line].isr_offset, sih->bytes_ixr);
 399                         if (status < 0)
 400                                 pr_err("twl4030: err %d initializing %s %s\n",
 401                                         status, sih->name, "ISR");
 402
 403                         if (!sih->set_cor)
 404                                 status = twl_i2c_write(sih->module, buf,
 405                                         sih->mask[line].isr_offset,
 406                                         sih->bytes_ixr);
 407                         /*
 408                          * else COR=1 means read sufficed.
 409                          * (for most SIH modules...)
 410                          */
 411                 }
 412         }
 413
 414         return 0;
 415 }
 416
 417 static inline void activate_irq(int irq)
 418 {
 419 #ifdef CONFIG_ARM
 420         /*
 421          * ARM requires an extra step to clear IRQ_NOREQUEST, which it
 422          * sets on behalf of every irq_chip.  Also sets IRQ_NOPROBE.
 423          */
 424         set_irq_flags(irq, IRQF_VALID);
 425 #else
 426         /* same effect on other architectures */
 427         irq_set_noprobe(irq);
 428 #endif
 429 }
 430
 431 /*----------------------------------------------------------------------*/
 432
 433 struct sih_agent {
 434         int                     irq_base;
 435         const struct sih        *sih;
 436
 437         u32                     imr;
 438         bool                    imr_change_pending;
 439
 440         u32                     edge_change;
 441
 442         struct mutex            irq_lock;
 443         char                    *irq_name;
 444 };
 445
 446 /*----------------------------------------------------------------------*/
 447
 448 /*
 449  * All irq_chip methods get issued from code holding irq_desc[irq].lock,
 450  * which can't perform the underlying I2C operations (because they sleep).
 451  * So we must hand them off to a thread (workqueue) and cope with asynch
 452  * completion, potentially including some re-ordering, of these requests.
 453  */
 454
 455 static void twl4030_sih_mask(struct irq_data *data)
 456 {
 457         struct sih_agent *agent = irq_data_get_irq_chip_data(data);
 458
 459         agent->imr |= BIT(data->irq - agent->irq_base);
 460         agent->imr_change_pending = true;
 461 }
 462
 463 static void twl4030_sih_unmask(struct irq_data *data)
 464 {
 465         struct sih_agent *agent = irq_data_get_irq_chip_data(data);
 466
 467         agent->imr &= ~BIT(data->irq - agent->irq_base);
 468         agent->imr_change_pending = true;
 469 }
 470
 471 static int twl4030_sih_set_type(struct irq_data *data, unsigned trigger)
 472 {
 473         struct sih_agent *agent = irq_data_get_irq_chip_data(data);
 474
 475         if (trigger & ~(IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING))
 476                 return -EINVAL;
 477
 478         if (irqd_get_trigger_type(data) != trigger)
 479                 agent->edge_change |= BIT(data->irq - agent->irq_base);
 480
 481         return 0;
 482 }
 483
 484 static void twl4030_sih_bus_lock(struct irq_data *data)
 485 {
 486         struct sih_agent        *agent = irq_data_get_irq_chip_data(data);
 487
 488         mutex_lock(&agent->irq_lock);
 489 }
 490
 491 static void twl4030_sih_bus_sync_unlock(struct irq_data *data)
 492 {
 493         struct sih_agent        *agent = irq_data_get_irq_chip_data(data);
 494         const struct sih        *sih = agent->sih;
 495         int                     status;
 496
 497         if (agent->imr_change_pending) {
 498                 union {
 499                         u32     word;
 500                         u8      bytes[4];
 501                 } imr;
 502
 503                 /* byte[0] gets overwritten as we write ... */
 504                 imr.word = cpu_to_le32(agent->imr);
 505                 agent->imr_change_pending = false;
 506
 507                 /* write the whole mask ... simpler than subsetting it */
 508                 status = twl_i2c_write(sih->module, imr.bytes,
 509                                 sih->mask[irq_line].imr_offset,
 510                                 sih->bytes_ixr);
 511                 if (status)
 512                         pr_err("twl4030: %s, %s --> %d\n", __func__,
 513                                         "write", status);
 514         }
 515
 516         if (agent->edge_change) {
 517                 u32             edge_change;
 518                 u8              bytes[6];
 519
 520                 edge_change = agent->edge_change;
 521                 agent->edge_change = 0;
 522
 523                 /*
 524                  * Read, reserving first byte for write scratch.  Yes, this
 525                  * could be cached for some speedup ... but be careful about
 526                  * any processor on the other IRQ line, EDR registers are
 527                  * shared.
 528                  */
 529                 status = twl_i2c_read(sih->module, bytes,
 530                                 sih->edr_offset, sih->bytes_edr);
 531                 if (status) {
 532                         pr_err("twl4030: %s, %s --> %d\n", __func__,
 533                                         "read", status);
 534                         return;
 535                 }
 536
 537                 /* Modify only the bits we know must change */
 538                 while (edge_change) {
 539                         int             i = fls(edge_change) - 1;
 540                         int             byte = i >> 2;
 541                         int             off = (i & 0x3) * 2;
 542                         unsigned int    type;
 543
 544                         bytes[byte] &= ~(0x03 << off);
 545
 546                         type = irq_get_trigger_type(i + agent->irq_base);
 547                         if (type & IRQ_TYPE_EDGE_RISING)
 548                                 bytes[byte] |= BIT(off + 1);
 549                         if (type & IRQ_TYPE_EDGE_FALLING)
 550                                 bytes[byte] |= BIT(off + 0);
 551
 552                         edge_change &= ~BIT(i);
 553                 }
 554
 555                 /* Write */
 556                 status = twl_i2c_write(sih->module, bytes,
 557                                 sih->edr_offset, sih->bytes_edr);
 558                 if (status)
 559                         pr_err("twl4030: %s, %s --> %d\n", __func__,
 560                                         "write", status);
 561         }
 562
 563         mutex_unlock(&agent->irq_lock);
 564 }
 565
 566 static struct irq_chip twl4030_sih_irq_chip = {
 567         .name           = "twl4030",
 568         .irq_mask       = twl4030_sih_mask,
 569         .irq_unmask     = twl4030_sih_unmask,
 570         .irq_set_type   = twl4030_sih_set_type,
 571         .irq_bus_lock   = twl4030_sih_bus_lock,
 572         .irq_bus_sync_unlock = twl4030_sih_bus_sync_unlock,
 573         .flags          = IRQCHIP_SKIP_SET_WAKE,
 574 };
 575
 576 /*----------------------------------------------------------------------*/
 577
 578 static inline int sih_read_isr(const struct sih *sih)
 579 {
 580         int status;
 581         union {
 582                 u8 bytes[4];
 583                 u32 word;
 584         } isr;
 585
 586         /* FIXME need retry-on-error ... */
 587
 588         isr.word = 0;
 589         status = twl_i2c_read(sih->module, isr.bytes,
 590                         sih->mask[irq_line].isr_offset, sih->bytes_ixr);
 591
 592         return (status < 0) ? status : le32_to_cpu(isr.word);
 593 }
 594
 595 /*
 596  * Generic handler for SIH interrupts ... we "know" this is called
 597  * in task context, with IRQs enabled.
 598  */
 599 static irqreturn_t handle_twl4030_sih(int irq, void *data)
 600 {
 601         struct sih_agent *agent = irq_get_handler_data(irq);
 602         const struct sih *sih = agent->sih;
 603         int isr;
 604
 605         /* reading ISR acks the IRQs, using clear-on-read mode */
 606         isr = sih_read_isr(sih);
 607
 608         if (isr < 0) {
 609                 pr_err("twl4030: %s SIH, read ISR error %d\n",
 610                         sih->name, isr);
 611                 /* REVISIT:  recover; eventually mask it all, etc */
 612                 return IRQ_HANDLED;
 613         }
 614
 615         while (isr) {
 616                 irq = fls(isr);
 617                 irq--;
 618                 isr &= ~BIT(irq);
 619
 620                 if (irq < sih->bits)
 621                         handle_nested_irq(agent->irq_base + irq);
 622                 else
 623                         pr_err("twl4030: %s SIH, invalid ISR bit %d\n",
 624                                 sih->name, irq);
 625         }
 626         return IRQ_HANDLED;
 627 }
 628
 629 /* returns the first IRQ used by this SIH bank, or negative errno */
 630 int twl4030_sih_setup(struct device *dev, int module, int irq_base)
 631 {
 632         int                     sih_mod;
 633         const struct sih        *sih = NULL;
 634         struct sih_agent        *agent;
 635         int                     i, irq;
 636         int                     status = -EINVAL;
 637
 638         /* only support modules with standard clear-on-read for now */
 639         for (sih_mod = 0, sih = sih_modules; sih_mod < nr_sih_modules;
 640                         sih_mod++, sih++) {
 641                 if (sih->module == module && sih->set_cor) {
 642                         status = 0;
 643                         break;
 644                 }
 645         }
 646
 647         if (status < 0)
 648                 return status;
 649
 650         agent = kzalloc(sizeof *agent, GFP_KERNEL);
 651         if (!agent)
 652                 return -ENOMEM;
 653
 654         agent->irq_base = irq_base;
 655         agent->sih = sih;
 656         agent->imr = ~0;
 657         mutex_init(&agent->irq_lock);
 658
 659         for (i = 0; i < sih->bits; i++) {
 660                 irq = irq_base + i;
 661
 662                 irq_set_chip_data(irq, agent);
 663                 irq_set_chip_and_handler(irq, &twl4030_sih_irq_chip,
 664                                          handle_edge_irq);
 665                 irq_set_nested_thread(irq, 1);
 666                 activate_irq(irq);
 667         }
 668
 669         /* replace generic PIH handler (handle_simple_irq) */
 670         irq = sih_mod + twl4030_irq_base;
 671         irq_set_handler_data(irq, agent);
 672         agent->irq_name = kasprintf(GFP_KERNEL, "twl4030_%s", sih->name);
 673         status = request_threaded_irq(irq, NULL, handle_twl4030_sih,
 674                                       IRQF_EARLY_RESUME,
 675                                       agent->irq_name ?: sih->name, NULL);
 676
 677         dev_info(dev, "%s (irq %d) chaining IRQs %d..%d\n", sih->name,
 678                         irq, irq_base, irq_base + i - 1);
 679
 680         return status < 0 ? status : irq_base;
 681 }
 682
 683 /* FIXME need a call to reverse twl4030_sih_setup() ... */
 684
 685 /*----------------------------------------------------------------------*/
 686
 687 /* FIXME pass in which interrupt line we'll use ... */
 688 #define twl_irq_line    0
 689
 690 int twl4030_init_irq(struct device *dev, int irq_num)
 691 {
 692         static struct irq_chip  twl4030_irq_chip;
 693         int                     status, i;
 694         int                     irq_base, irq_end, nr_irqs;
 695         struct                  device_node *node = dev->of_node;
 696
 697         /*
 698          * TWL core and pwr interrupts must be contiguous because
 699          * the hwirqs numbers are defined contiguously from 1 to 15.
 700          * Create only one domain for both.
 701          */
 702         nr_irqs = TWL4030_PWR_NR_IRQS + TWL4030_CORE_NR_IRQS;
 703
 704         irq_base = irq_alloc_descs(-1, 0, nr_irqs, 0);
 705         if (IS_ERR_VALUE(irq_base)) {
 706                 dev_err(dev, "Fail to allocate IRQ descs\n");
 707                 return irq_base;
 708         }
 709
 710         irq_domain_add_legacy(node, nr_irqs, irq_base, 0,
 711                               &irq_domain_simple_ops, NULL);
 712
 713         irq_end = irq_base + TWL4030_CORE_NR_IRQS;
 714
 715         /*
 716          * Mask and clear all TWL4030 interrupts since initially we do
 717          * not have any TWL4030 module interrupt handlers present
 718          */
 719         status = twl4030_init_sih_modules(twl_irq_line);
 720         if (status < 0)
 721                 return status;
 722
 723         twl4030_irq_base = irq_base;
 724
 725         /*
 726          * Install an irq handler for each of the SIH modules;
 727          * clone dummy irq_chip since PIH can't *do* anything
 728          */
 729         twl4030_irq_chip = dummy_irq_chip;
 730         twl4030_irq_chip.name = "twl4030";
 731
 732         twl4030_sih_irq_chip.irq_ack = dummy_irq_chip.irq_ack;
 733
 734         for (i = irq_base; i < irq_end; i++) {
 735                 irq_set_chip_and_handler(i, &twl4030_irq_chip,
 736                                          handle_simple_irq);
 737                 irq_set_nested_thread(i, 1);
 738                 activate_irq(i);
 739         }
 740
 741         dev_info(dev, "%s (irq %d) chaining IRQs %d..%d\n", "PIH",
 742                         irq_num, irq_base, irq_end);
 743
 744         /* ... and the PWR_INT module ... */
 745         status = twl4030_sih_setup(dev, TWL4030_MODULE_INT, irq_end);
 746         if (status < 0) {
 747                 dev_err(dev, "sih_setup PWR INT --> %d\n", status);
 748                 goto fail;
 749         }
 750
 751         /* install an irq handler to demultiplex the TWL4030 interrupt */
 752         status = request_threaded_irq(irq_num, NULL, handle_twl4030_pih,
 753                                       IRQF_ONESHOT,
 754                                       "TWL4030-PIH", NULL);
 755         if (status < 0) {
 756                 dev_err(dev, "could not claim irq%d: %d\n", irq_num, status);
 757                 goto fail_rqirq;
 758         }
 759         enable_irq_wake(irq_num);
 760
 761         return irq_base;
 762 fail_rqirq:
 763         /* clean up twl4030_sih_setup */
 764 fail:
 765         for (i = irq_base; i < irq_end; i++) {
 766                 irq_set_nested_thread(i, 0);
 767                 irq_set_chip_and_handler(i, NULL, NULL);
 768         }
 769
 770         return status;
 771 }
 772
 773 int twl4030_exit_irq(void)
 774 {
 775         /* FIXME undo twl_init_irq() */
 776         if (twl4030_irq_base) {
 777                 pr_err("twl4030: can't yet clean up IRQs?\n");
 778                 return -ENOSYS;
 779         }
 780         return 0;
 781 }
 782
 783 int twl4030_init_chip_irq(const char *chip)
 784 {
 785         if (!strcmp(chip, "twl5031")) {
 786                 sih_modules = sih_modules_twl5031;
 787                 nr_sih_modules = ARRAY_SIZE(sih_modules_twl5031);
 788         } else {
 789                 sih_modules = sih_modules_twl4030;
 790                 nr_sih_modules = ARRAY_SIZE(sih_modules_twl4030);
 791         }
 792
 793         return 0;
 794 }