drivers/irqchip/irq-metag-ext.c

   1 /*
   2  * Meta External interrupt code.
   3  *
   4  * Copyright (C) 2005-2012 Imagination Technologies Ltd.
   5  *
   6  * External interrupts on Meta are configured at two-levels, in the CPU core and
   7  * in the external trigger block. Interrupts from SoC peripherals are
   8  * multiplexed onto a single Meta CPU "trigger" - traditionally it has always
   9  * been trigger 2 (TR2). For info on how de-multiplexing happens check out
  10  * meta_intc_irq_demux().
  11  */
  12
  13 #include <linux/interrupt.h>
  14 #include <linux/irqchip/metag-ext.h>
  15 #include <linux/irqdomain.h>
  16 #include <linux/io.h>
  17 #include <linux/of.h>
  18 #include <linux/slab.h>
  19 #include <linux/syscore_ops.h>
  20
  21 #include <asm/irq.h>
  22 #include <asm/hwthread.h>
  23
  24 #define HWSTAT_STRIDE 8
  25 #define HWVEC_BLK_STRIDE 0x1000
  26
  27 /**
  28  * struct meta_intc_priv - private meta external interrupt data
  29  * @nr_banks:           Number of interrupt banks
  30  * @domain:             IRQ domain for all banks of external IRQs
  31  * @unmasked:           Record of unmasked IRQs
  32  * @levels_altered:     Record of altered level bits
  33  */
  34 struct meta_intc_priv {
  35         unsigned int            nr_banks;
  36         struct irq_domain       *domain;
  37
  38         unsigned long           unmasked[4];
  39
  40 #ifdef CONFIG_METAG_SUSPEND_MEM
  41         unsigned long           levels_altered[4];
  42 #endif
  43 };
  44
  45 /* Private data for the one and only external interrupt controller */
  46 static struct meta_intc_priv meta_intc_priv;
  47
  48 /**
  49  * meta_intc_offset() - Get the offset into the bank of a hardware IRQ number
  50  * @hw:         Hardware IRQ number (within external trigger block)
  51  *
  52  * Returns:     Bit offset into the IRQ's bank registers
  53  */
  54 static unsigned int meta_intc_offset(irq_hw_number_t hw)
  55 {
  56         return hw & 0x1f;
  57 }
  58
  59 /**
  60  * meta_intc_bank() - Get the bank number of a hardware IRQ number
  61  * @hw:         Hardware IRQ number (within external trigger block)
  62  *
  63  * Returns:     Bank number indicating which register the IRQ's bits are
  64  */
  65 static unsigned int meta_intc_bank(irq_hw_number_t hw)
  66 {
  67         return hw >> 5;
  68 }
  69
  70 /**
  71  * meta_intc_stat_addr() - Get the address of a HWSTATEXT register
  72  * @hw:         Hardware IRQ number (within external trigger block)
  73  *
  74  * Returns:     Address of a HWSTATEXT register containing the status bit for
  75  *              the specified hardware IRQ number
  76  */
  77 static void __iomem *meta_intc_stat_addr(irq_hw_number_t hw)
  78 {
  79         return (void __iomem *)(HWSTATEXT +
  80                                 HWSTAT_STRIDE * meta_intc_bank(hw));
  81 }
  82
  83 /**
  84  * meta_intc_level_addr() - Get the address of a HWLEVELEXT register
  85  * @hw:         Hardware IRQ number (within external trigger block)
  86  *
  87  * Returns:     Address of a HWLEVELEXT register containing the sense bit for
  88  *              the specified hardware IRQ number
  89  */
  90 static void __iomem *meta_intc_level_addr(irq_hw_number_t hw)
  91 {
  92         return (void __iomem *)(HWLEVELEXT +
  93                                 HWSTAT_STRIDE * meta_intc_bank(hw));
  94 }
  95
  96 /**
  97  * meta_intc_mask_addr() - Get the address of a HWMASKEXT register
  98  * @hw:         Hardware IRQ number (within external trigger block)
  99  *
 100  * Returns:     Address of a HWMASKEXT register containing the mask bit for the
 101  *              specified hardware IRQ number
 102  */
 103 static void __iomem *meta_intc_mask_addr(irq_hw_number_t hw)
 104 {
 105         return (void __iomem *)(HWMASKEXT +
 106                                 HWSTAT_STRIDE * meta_intc_bank(hw));
 107 }
 108
 109 /**
 110  * meta_intc_vec_addr() - Get the vector address of a hardware interrupt
 111  * @hw:         Hardware IRQ number (within external trigger block)
 112  *
 113  * Returns:     Address of a HWVECEXT register controlling the core trigger to
 114  *              vector the IRQ onto
 115  */
 116 static inline void __iomem *meta_intc_vec_addr(irq_hw_number_t hw)
 117 {
 118         return (void __iomem *)(HWVEC0EXT +
 119                                 HWVEC_BLK_STRIDE * meta_intc_bank(hw) +
 120                                 HWVECnEXT_STRIDE * meta_intc_offset(hw));
 121 }
 122
 123 /**
 124  * meta_intc_startup_irq() - set up an external irq
 125  * @data:       data for the external irq to start up
 126  *
 127  * Multiplex interrupts for irq onto TR2. Clear any pending interrupts and
 128  * unmask irq, both using the appropriate callbacks.
 129  */
 130 static unsigned int meta_intc_startup_irq(struct irq_data *data)
 131 {
 132         irq_hw_number_t hw = data->hwirq;
 133         void __iomem *vec_addr = meta_intc_vec_addr(hw);
 134         int thread = hard_processor_id();
 135
 136         /* Perform any necessary acking. */
 137         if (data->chip->irq_ack)
 138                 data->chip->irq_ack(data);
 139
 140         /* Wire up this interrupt to the core with HWVECxEXT. */
 141         metag_out32(TBI_TRIG_VEC(TBID_SIGNUM_TR2(thread)), vec_addr);
 142
 143         /* Perform any necessary unmasking. */
 144         data->chip->irq_unmask(data);
 145
 146         return 0;
 147 }
 148
 149 /**
 150  * meta_intc_shutdown_irq() - turn off an external irq
 151  * @data:       data for the external irq to turn off
 152  *
 153  * Mask irq using the appropriate callback and stop muxing it onto TR2.
 154  */
 155 static void meta_intc_shutdown_irq(struct irq_data *data)
 156 {
 157         irq_hw_number_t hw = data->hwirq;
 158         void __iomem *vec_addr = meta_intc_vec_addr(hw);
 159
 160         /* Mask the IRQ */
 161         data->chip->irq_mask(data);
 162
 163         /*
 164          * Disable the IRQ at the core by removing the interrupt from
 165          * the HW vector mapping.
 166          */
 167         metag_out32(0, vec_addr);
 168 }
 169
 170 /**
 171  * meta_intc_ack_irq() - acknowledge an external irq
 172  * @data:       data for the external irq to ack
 173  *
 174  * Clear down an edge interrupt in the status register.
 175  */
 176 static void meta_intc_ack_irq(struct irq_data *data)
 177 {
 178         irq_hw_number_t hw = data->hwirq;
 179         unsigned int bit = 1 << meta_intc_offset(hw);
 180         void __iomem *stat_addr = meta_intc_stat_addr(hw);
 181
 182         /* Ack the int, if it is still 'on'.
 183          * NOTE - this only works for edge triggered interrupts.
 184          */
 185         if (metag_in32(stat_addr) & bit)
 186                 metag_out32(bit, stat_addr);
 187 }
 188
 189 /**
 190  * record_irq_is_masked() - record the IRQ masked so it doesn't get handled
 191  * @data:       data for the external irq to record
 192  *
 193  * This should get called whenever an external IRQ is masked (by whichever
 194  * callback is used). It records the IRQ masked so that it doesn't get handled
 195  * if it still shows up in the status register.
 196  */
 197 static void record_irq_is_masked(struct irq_data *data)
 198 {
 199         struct meta_intc_priv *priv = &meta_intc_priv;
 200         irq_hw_number_t hw = data->hwirq;
 201
 202         clear_bit(meta_intc_offset(hw), &priv->unmasked[meta_intc_bank(hw)]);
 203 }
 204
 205 /**
 206  * record_irq_is_unmasked() - record the IRQ unmasked so it can be handled
 207  * @data:       data for the external irq to record
 208  *
 209  * This should get called whenever an external IRQ is unmasked (by whichever
 210  * callback is used). It records the IRQ unmasked so that it gets handled if it
 211  * shows up in the status register.
 212  */
 213 static void record_irq_is_unmasked(struct irq_data *data)
 214 {
 215         struct meta_intc_priv *priv = &meta_intc_priv;
 216         irq_hw_number_t hw = data->hwirq;
 217
 218         set_bit(meta_intc_offset(hw), &priv->unmasked[meta_intc_bank(hw)]);
 219 }
 220
 221 /*
 222  * For use by wrapper IRQ drivers
 223  */
 224
 225 /**
 226  * meta_intc_mask_irq_simple() - minimal mask used by wrapper IRQ drivers
 227  * @data:       data for the external irq being masked
 228  *
 229  * This should be called by any wrapper IRQ driver mask functions. it doesn't do
 230  * any masking but records the IRQ as masked so that the core code knows the
 231  * mask has taken place. It is the callers responsibility to ensure that the IRQ
 232  * won't trigger an interrupt to the core.
 233  */
 234 void meta_intc_mask_irq_simple(struct irq_data *data)
 235 {
 236         record_irq_is_masked(data);
 237 }
 238
 239 /**
 240  * meta_intc_unmask_irq_simple() - minimal unmask used by wrapper IRQ drivers
 241  * @data:       data for the external irq being unmasked
 242  *
 243  * This should be called by any wrapper IRQ driver unmask functions. it doesn't
 244  * do any unmasking but records the IRQ as unmasked so that the core code knows
 245  * the unmask has taken place. It is the callers responsibility to ensure that
 246  * the IRQ can now trigger an interrupt to the core.
 247  */
 248 void meta_intc_unmask_irq_simple(struct irq_data *data)
 249 {
 250         record_irq_is_unmasked(data);
 251 }
 252
 253
 254 /**
 255  * meta_intc_mask_irq() - mask an external irq using HWMASKEXT
 256  * @data:       data for the external irq to mask
 257  *
 258  * This is a default implementation of a mask function which makes use of the
 259  * HWMASKEXT registers available in newer versions.
 260  *
 261  * Earlier versions without these registers should use SoC level IRQ masking
 262  * which call the meta_intc_*_simple() functions above, or if that isn't
 263  * available should use the fallback meta_intc_*_nomask() functions below.
 264  */
 265 static void meta_intc_mask_irq(struct irq_data *data)
 266 {
 267         irq_hw_number_t hw = data->hwirq;
 268         unsigned int bit = 1 << meta_intc_offset(hw);
 269         void __iomem *mask_addr = meta_intc_mask_addr(hw);
 270         unsigned long flags;
 271
 272         record_irq_is_masked(data);
 273
 274         /* update the interrupt mask */
 275         __global_lock2(flags);
 276         metag_out32(metag_in32(mask_addr) & ~bit, mask_addr);
 277         __global_unlock2(flags);
 278 }
 279
 280 /**
 281  * meta_intc_unmask_irq() - unmask an external irq using HWMASKEXT
 282  * @data:       data for the external irq to unmask
 283  *
 284  * This is a default implementation of an unmask function which makes use of the
 285  * HWMASKEXT registers available on new versions. It should be paired with
 286  * meta_intc_mask_irq() above.
 287  */
 288 static void meta_intc_unmask_irq(struct irq_data *data)
 289 {
 290         irq_hw_number_t hw = data->hwirq;
 291         unsigned int bit = 1 << meta_intc_offset(hw);
 292         void __iomem *mask_addr = meta_intc_mask_addr(hw);
 293         unsigned long flags;
 294
 295         record_irq_is_unmasked(data);
 296
 297         /* update the interrupt mask */
 298         __global_lock2(flags);
 299         metag_out32(metag_in32(mask_addr) | bit, mask_addr);
 300         __global_unlock2(flags);
 301 }
 302
 303 /**
 304  * meta_intc_mask_irq_nomask() - mask an external irq by unvectoring
 305  * @data:       data for the external irq to mask
 306  *
 307  * This is the version of the mask function for older versions which don't have
 308  * HWMASKEXT registers, or a SoC level means of masking IRQs. Instead the IRQ is
 309  * unvectored from the core and retriggered if necessary later.
 310  */
 311 static void meta_intc_mask_irq_nomask(struct irq_data *data)
 312 {
 313         irq_hw_number_t hw = data->hwirq;
 314         void __iomem *vec_addr = meta_intc_vec_addr(hw);
 315
 316         record_irq_is_masked(data);
 317
 318         /* there is no interrupt mask, so unvector the interrupt */
 319         metag_out32(0, vec_addr);
 320 }
 321
 322 /**
 323  * meta_intc_unmask_edge_irq_nomask() - unmask an edge irq by revectoring
 324  * @data:       data for the external irq to unmask
 325  *
 326  * This is the version of the unmask function for older versions which don't
 327  * have HWMASKEXT registers, or a SoC level means of masking IRQs. Instead the
 328  * IRQ is revectored back to the core and retriggered if necessary.
 329  *
 330  * The retriggering done by this function is specific to edge interrupts.
 331  */
 332 static void meta_intc_unmask_edge_irq_nomask(struct irq_data *data)
 333 {
 334         irq_hw_number_t hw = data->hwirq;
 335         unsigned int bit = 1 << meta_intc_offset(hw);
 336         void __iomem *stat_addr = meta_intc_stat_addr(hw);
 337         void __iomem *vec_addr = meta_intc_vec_addr(hw);
 338         unsigned int thread = hard_processor_id();
 339
 340         record_irq_is_unmasked(data);
 341
 342         /* there is no interrupt mask, so revector the interrupt */
 343         metag_out32(TBI_TRIG_VEC(TBID_SIGNUM_TR2(thread)), vec_addr);
 344
 345         /*
 346          * Re-trigger interrupt
 347          *
 348          * Writing a 1 toggles, and a 0->1 transition triggers. We only
 349          * retrigger if the status bit is already set, which means we
 350          * need to clear it first. Retriggering is fundamentally racy
 351          * because if the interrupt fires again after we clear it we
 352          * could end up clearing it again and the interrupt handler
 353          * thinking it hasn't fired. Therefore we need to keep trying to
 354          * retrigger until the bit is set.
 355          */
 356         if (metag_in32(stat_addr) & bit) {
 357                 metag_out32(bit, stat_addr);
 358                 while (!(metag_in32(stat_addr) & bit))
 359                         metag_out32(bit, stat_addr);
 360         }
 361 }
 362
 363 /**
 364  * meta_intc_unmask_level_irq_nomask() - unmask a level irq by revectoring
 365  * @data:       data for the external irq to unmask
 366  *
 367  * This is the version of the unmask function for older versions which don't
 368  * have HWMASKEXT registers, or a SoC level means of masking IRQs. Instead the
 369  * IRQ is revectored back to the core and retriggered if necessary.
 370  *
 371  * The retriggering done by this function is specific to level interrupts.
 372  */
 373 static void meta_intc_unmask_level_irq_nomask(struct irq_data *data)
 374 {
 375         irq_hw_number_t hw = data->hwirq;
 376         unsigned int bit = 1 << meta_intc_offset(hw);
 377         void __iomem *stat_addr = meta_intc_stat_addr(hw);
 378         void __iomem *vec_addr = meta_intc_vec_addr(hw);
 379         unsigned int thread = hard_processor_id();
 380
 381         record_irq_is_unmasked(data);
 382
 383         /* there is no interrupt mask, so revector the interrupt */
 384         metag_out32(TBI_TRIG_VEC(TBID_SIGNUM_TR2(thread)), vec_addr);
 385
 386         /* Re-trigger interrupt */
 387         /* Writing a 1 triggers interrupt */
 388         if (metag_in32(stat_addr) & bit)
 389                 metag_out32(bit, stat_addr);
 390 }
 391
 392 /**
 393  * meta_intc_irq_set_type() - set the type of an external irq
 394  * @data:       data for the external irq to set the type of
 395  * @flow_type:  new irq flow type
 396  *
 397  * Set the flow type of an external interrupt. This updates the irq chip and irq
 398  * handler depending on whether the irq is edge or level sensitive (the polarity
 399  * is ignored), and also sets up the bit in HWLEVELEXT so the hardware knows
 400  * when to trigger.
 401  */
 402 static int meta_intc_irq_set_type(struct irq_data *data, unsigned int flow_type)
 403 {
 404 #ifdef CONFIG_METAG_SUSPEND_MEM
 405         struct meta_intc_priv *priv = &meta_intc_priv;
 406 #endif
 407         irq_hw_number_t hw = data->hwirq;
 408         unsigned int bit = 1 << meta_intc_offset(hw);
 409         void __iomem *level_addr = meta_intc_level_addr(hw);
 410         unsigned long flags;
 411         unsigned int level;
 412
 413         /* update the chip/handler */
 414         if (flow_type & IRQ_TYPE_LEVEL_MASK)
 415                 irq_set_chip_handler_name_locked(data, &meta_intc_level_chip,
 416                                                  handle_level_irq, NULL);
 417         else
 418                 irq_set_chip_handler_name_locked(data, &meta_intc_edge_chip,
 419                                                  handle_edge_irq, NULL);
 420
 421         /* and clear/set the bit in HWLEVELEXT */
 422         __global_lock2(flags);
 423         level = metag_in32(level_addr);
 424         if (flow_type & IRQ_TYPE_LEVEL_MASK)
 425                 level |= bit;
 426         else
 427                 level &= ~bit;
 428         metag_out32(level, level_addr);
 429 #ifdef CONFIG_METAG_SUSPEND_MEM
 430         priv->levels_altered[meta_intc_bank(hw)] |= bit;
 431 #endif
 432         __global_unlock2(flags);
 433
 434         return 0;
 435 }
 436
 437 /**
 438  * meta_intc_irq_demux() - external irq de-multiplexer
 439  * @desc:       the interrupt description structure for this irq
 440  *
 441  * The cpu receives an interrupt on TR2 when a SoC interrupt has occurred. It is
 442  * this function's job to demux this irq and figure out exactly which external
 443  * irq needs servicing.
 444  *
 445  * Whilst using TR2 to detect external interrupts is a software convention it is
 446  * (hopefully) unlikely to change.
 447  */
 448 static void meta_intc_irq_demux(struct irq_desc *desc)
 449 {
 450         struct meta_intc_priv *priv = &meta_intc_priv;
 451         irq_hw_number_t hw;
 452         unsigned int bank, irq_no, status;
 453         void __iomem *stat_addr = meta_intc_stat_addr(0);
 454
 455         /*
 456          * Locate which interrupt has caused our handler to run.
 457          */
 458         for (bank = 0; bank < priv->nr_banks; ++bank) {
 459                 /* Which interrupts are currently pending in this bank? */
 460 recalculate:
 461                 status = metag_in32(stat_addr) & priv->unmasked[bank];
 462
 463                 for (hw = bank*32; status; status >>= 1, ++hw) {
 464                         if (status & 0x1) {
 465                                 /*
 466                                  * Map the hardware IRQ number to a virtual
 467                                  * Linux IRQ number.
 468                                  */
 469                                 irq_no = irq_linear_revmap(priv->domain, hw);
 470
 471                                 /*
 472                                  * Only fire off external interrupts that are
 473                                  * registered to be handled by the kernel.
 474                                  * Other external interrupts are probably being
 475                                  * handled by other Meta hardware threads.
 476                                  */
 477                                 generic_handle_irq(irq_no);
 478
 479                                 /*
 480                                  * The handler may have re-enabled interrupts
 481                                  * which could have caused a nested invocation
 482                                  * of this code and make the copy of the
 483                                  * status register we are using invalid.
 484                                  */
 485                                 goto recalculate;
 486                         }
 487                 }
 488                 stat_addr += HWSTAT_STRIDE;
 489         }
 490 }
 491
 492 #ifdef CONFIG_SMP
 493 /**
 494  * meta_intc_set_affinity() - set the affinity for an interrupt
 495  * @data:       data for the external irq to set the affinity of
 496  * @cpumask:    cpu mask representing cpus which can handle the interrupt
 497  * @force:      whether to force (ignored)
 498  *
 499  * Revector the specified external irq onto a specific cpu's TR2 trigger, so
 500  * that that cpu tends to be the one who handles it.
 501  */
 502 static int meta_intc_set_affinity(struct irq_data *data,
 503                                   const struct cpumask *cpumask, bool force)
 504 {
 505         irq_hw_number_t hw = data->hwirq;
 506         void __iomem *vec_addr = meta_intc_vec_addr(hw);
 507         unsigned int cpu, thread;
 508
 509         /*
 510          * Wire up this interrupt from HWVECxEXT to the Meta core.
 511          *
 512          * Note that we can't wire up HWVECxEXT to interrupt more than
 513          * one cpu (the interrupt code doesn't support it), so we just
 514          * pick the first cpu we find in 'cpumask'.
 515          */
 516         cpu = cpumask_any_and(cpumask, cpu_online_mask);
 517         thread = cpu_2_hwthread_id[cpu];
 518
 519         metag_out32(TBI_TRIG_VEC(TBID_SIGNUM_TR2(thread)), vec_addr);
 520
 521         irq_data_update_effective_affinity(data, cpumask_of(cpu));
 522
 523         return 0;
 524 }
 525 #else
 526 #define meta_intc_set_affinity  NULL
 527 #endif
 528
 529 #ifdef CONFIG_PM_SLEEP
 530 #define META_INTC_CHIP_FLAGS    (IRQCHIP_MASK_ON_SUSPEND \
 531                                 | IRQCHIP_SKIP_SET_WAKE)
 532 #else
 533 #define META_INTC_CHIP_FLAGS    0
 534 #endif
 535
 536 /* public edge/level irq chips which SoCs can override */
 537
 538 struct irq_chip meta_intc_edge_chip = {
 539         .irq_startup            = meta_intc_startup_irq,
 540         .irq_shutdown           = meta_intc_shutdown_irq,
 541         .irq_ack                = meta_intc_ack_irq,
 542         .irq_mask               = meta_intc_mask_irq,
 543         .irq_unmask             = meta_intc_unmask_irq,
 544         .irq_set_type           = meta_intc_irq_set_type,
 545         .irq_set_affinity       = meta_intc_set_affinity,
 546         .flags                  = META_INTC_CHIP_FLAGS,
 547 };
 548
 549 struct irq_chip meta_intc_level_chip = {
 550         .irq_startup            = meta_intc_startup_irq,
 551         .irq_shutdown           = meta_intc_shutdown_irq,
 552         .irq_set_type           = meta_intc_irq_set_type,
 553         .irq_mask               = meta_intc_mask_irq,
 554         .irq_unmask             = meta_intc_unmask_irq,
 555         .irq_set_affinity       = meta_intc_set_affinity,
 556         .flags                  = META_INTC_CHIP_FLAGS,
 557 };
 558
 559 /**
 560  * meta_intc_map() - map an external irq
 561  * @d:          irq domain of external trigger block
 562  * @irq:        virtual irq number
 563  * @hw:         hardware irq number within external trigger block
 564  *
 565  * This sets up a virtual irq for a specified hardware interrupt. The irq chip
 566  * and handler is configured, using the HWLEVELEXT registers to determine
 567  * edge/level flow type. These registers will have been set when the irq type is
 568  * set (or set to a default at init time).
 569  */
 570 static int meta_intc_map(struct irq_domain *d, unsigned int irq,
 571                          irq_hw_number_t hw)
 572 {
 573         unsigned int bit = 1 << meta_intc_offset(hw);
 574         void __iomem *level_addr = meta_intc_level_addr(hw);
 575
 576         /* Go by the current sense in the HWLEVELEXT register */
 577         if (metag_in32(level_addr) & bit)
 578                 irq_set_chip_and_handler(irq, &meta_intc_level_chip,
 579                                          handle_level_irq);
 580         else
 581                 irq_set_chip_and_handler(irq, &meta_intc_edge_chip,
 582                                          handle_edge_irq);
 583
 584         irqd_set_single_target(irq_desc_get_irq_data(irq_to_desc(irq)));
 585         return 0;
 586 }
 587
 588 static const struct irq_domain_ops meta_intc_domain_ops = {
 589         .map = meta_intc_map,
 590         .xlate = irq_domain_xlate_twocell,
 591 };
 592
 593 #ifdef CONFIG_METAG_SUSPEND_MEM
 594
 595 /**
 596  * struct meta_intc_context - suspend context
 597  * @levels:     State of HWLEVELEXT registers
 598  * @masks:      State of HWMASKEXT registers
 599  * @vectors:    State of HWVECEXT registers
 600  * @txvecint:   State of TxVECINT registers
 601  *
 602  * This structure stores the IRQ state across suspend.
 603  */
 604 struct meta_intc_context {
 605         u32 levels[4];
 606         u32 masks[4];
 607         u8 vectors[4*32];
 608
 609         u8 txvecint[4][4];
 610 };
 611
 612 /* suspend context */
 613 static struct meta_intc_context *meta_intc_context;
 614
 615 /**
 616  * meta_intc_suspend() - store irq state
 617  *
 618  * To avoid interfering with other threads we only save the IRQ state of IRQs in
 619  * use by Linux.
 620  */
 621 static int meta_intc_suspend(void)
 622 {
 623         struct meta_intc_priv *priv = &meta_intc_priv;
 624         int i, j;
 625         irq_hw_number_t hw;
 626         unsigned int bank;
 627         unsigned long flags;
 628         struct meta_intc_context *context;
 629         void __iomem *level_addr, *mask_addr, *vec_addr;
 630         u32 mask, bit;
 631
 632         context = kzalloc(sizeof(*context), GFP_ATOMIC);
 633         if (!context)
 634                 return -ENOMEM;
 635
 636         hw = 0;
 637         level_addr = meta_intc_level_addr(0);
 638         mask_addr = meta_intc_mask_addr(0);
 639         for (bank = 0; bank < priv->nr_banks; ++bank) {
 640                 vec_addr = meta_intc_vec_addr(hw);
 641
 642                 /* create mask of interrupts in use */
 643                 mask = 0;
 644                 for (bit = 1; bit; bit <<= 1) {
 645                         i = irq_linear_revmap(priv->domain, hw);
 646                         /* save mapped irqs which are enabled or have actions */
 647                         if (i && (!irqd_irq_disabled(irq_get_irq_data(i)) ||
 648                                   irq_has_action(i))) {
 649                                 mask |= bit;
 650
 651                                 /* save trigger vector */
 652                                 context->vectors[hw] = metag_in32(vec_addr);
 653                         }
 654
 655                         ++hw;
 656                         vec_addr += HWVECnEXT_STRIDE;
 657                 }
 658
 659                 /* save level state if any IRQ levels altered */
 660                 if (priv->levels_altered[bank])
 661                         context->levels[bank] = metag_in32(level_addr);
 662                 /* save mask state if any IRQs in use */
 663                 if (mask)
 664                         context->masks[bank] = metag_in32(mask_addr);
 665
 666                 level_addr += HWSTAT_STRIDE;
 667                 mask_addr += HWSTAT_STRIDE;
 668         }
 669
 670         /* save trigger matrixing */
 671         __global_lock2(flags);
 672         for (i = 0; i < 4; ++i)
 673                 for (j = 0; j < 4; ++j)
 674                         context->txvecint[i][j] = metag_in32(T0VECINT_BHALT +
 675                                                              TnVECINT_STRIDE*i +
 676                                                              8*j);
 677         __global_unlock2(flags);
 678
 679         meta_intc_context = context;
 680         return 0;
 681 }
 682
 683 /**
 684  * meta_intc_resume() - restore saved irq state
 685  *
 686  * Restore the saved IRQ state and drop it.
 687  */
 688 static void meta_intc_resume(void)
 689 {
 690         struct meta_intc_priv *priv = &meta_intc_priv;
 691         int i, j;
 692         irq_hw_number_t hw;
 693         unsigned int bank;
 694         unsigned long flags;
 695         struct meta_intc_context *context = meta_intc_context;
 696         void __iomem *level_addr, *mask_addr, *vec_addr;
 697         u32 mask, bit, tmp;
 698
 699         meta_intc_context = NULL;
 700
 701         hw = 0;
 702         level_addr = meta_intc_level_addr(0);
 703         mask_addr = meta_intc_mask_addr(0);
 704         for (bank = 0; bank < priv->nr_banks; ++bank) {
 705                 vec_addr = meta_intc_vec_addr(hw);
 706
 707                 /* create mask of interrupts in use */
 708                 mask = 0;
 709                 for (bit = 1; bit; bit <<= 1) {
 710                         i = irq_linear_revmap(priv->domain, hw);
 711                         /* restore mapped irqs, enabled or with actions */
 712                         if (i && (!irqd_irq_disabled(irq_get_irq_data(i)) ||
 713                                   irq_has_action(i))) {
 714                                 mask |= bit;
 715
 716                                 /* restore trigger vector */
 717                                 metag_out32(context->vectors[hw], vec_addr);
 718                         }
 719
 720                         ++hw;
 721                         vec_addr += HWVECnEXT_STRIDE;
 722                 }
 723
 724                 if (mask) {
 725                         /* restore mask state */
 726                         __global_lock2(flags);
 727                         tmp = metag_in32(mask_addr);
 728                         tmp = (tmp & ~mask) | (context->masks[bank] & mask);
 729                         metag_out32(tmp, mask_addr);
 730                         __global_unlock2(flags);
 731                 }
 732
 733                 mask = priv->levels_altered[bank];
 734                 if (mask) {
 735                         /* restore level state */
 736                         __global_lock2(flags);
 737                         tmp = metag_in32(level_addr);
 738                         tmp = (tmp & ~mask) | (context->levels[bank] & mask);
 739                         metag_out32(tmp, level_addr);
 740                         __global_unlock2(flags);
 741                 }
 742
 743                 level_addr += HWSTAT_STRIDE;
 744                 mask_addr += HWSTAT_STRIDE;
 745         }
 746
 747         /* restore trigger matrixing */
 748         __global_lock2(flags);
 749         for (i = 0; i < 4; ++i) {
 750                 for (j = 0; j < 4; ++j) {
 751                         metag_out32(context->txvecint[i][j],
 752                                     T0VECINT_BHALT +
 753                                     TnVECINT_STRIDE*i +
 754                                     8*j);
 755                 }
 756         }
 757         __global_unlock2(flags);
 758
 759         kfree(context);
 760 }
 761
 762 static struct syscore_ops meta_intc_syscore_ops = {
 763         .suspend = meta_intc_suspend,
 764         .resume = meta_intc_resume,
 765 };
 766
 767 static void __init meta_intc_init_syscore_ops(struct meta_intc_priv *priv)
 768 {
 769         register_syscore_ops(&meta_intc_syscore_ops);
 770 }
 771 #else
 772 #define meta_intc_init_syscore_ops(priv) do {} while (0)
 773 #endif
 774
 775 /**
 776  * meta_intc_init_cpu() - register with a Meta cpu
 777  * @priv:       private interrupt controller data
 778  * @cpu:        the CPU to register on
 779  *
 780  * Configure @cpu's TR2 irq so that we can demux external irqs.
 781  */
 782 static void __init meta_intc_init_cpu(struct meta_intc_priv *priv, int cpu)
 783 {
 784         unsigned int thread = cpu_2_hwthread_id[cpu];
 785         unsigned int signum = TBID_SIGNUM_TR2(thread);
 786         int irq = tbisig_map(signum);
 787
 788         /* Register the multiplexed IRQ handler */
 789         irq_set_chained_handler(irq, meta_intc_irq_demux);
 790         irq_set_irq_type(irq, IRQ_TYPE_LEVEL_LOW);
 791 }
 792
 793 /**
 794  * meta_intc_no_mask() - indicate lack of HWMASKEXT registers
 795  *
 796  * Called from SoC code (or init code below) to dynamically indicate the lack of
 797  * HWMASKEXT registers (for example depending on some SoC revision register).
 798  * This alters the irq mask and unmask callbacks to use the fallback
 799  * unvectoring/retriggering technique instead of using HWMASKEXT registers.
 800  */
 801 void __init meta_intc_no_mask(void)
 802 {
 803         meta_intc_edge_chip.irq_mask    = meta_intc_mask_irq_nomask;
 804         meta_intc_edge_chip.irq_unmask  = meta_intc_unmask_edge_irq_nomask;
 805         meta_intc_level_chip.irq_mask   = meta_intc_mask_irq_nomask;
 806         meta_intc_level_chip.irq_unmask = meta_intc_unmask_level_irq_nomask;
 807 }
 808
 809 /**
 810  * init_external_IRQ() - initialise the external irq controller
 811  *
 812  * Set up the external irq controller using device tree properties. This is
 813  * called from init_IRQ().
 814  */
 815 int __init init_external_IRQ(void)
 816 {
 817         struct meta_intc_priv *priv = &meta_intc_priv;
 818         struct device_node *node;
 819         int ret, cpu;
 820         u32 val;
 821         bool no_masks = false;
 822
 823         node = of_find_compatible_node(NULL, NULL, "img,meta-intc");
 824         if (!node)
 825                 return -ENOENT;
 826
 827         /* Get number of banks */
 828         ret = of_property_read_u32(node, "num-banks", &val);
 829         if (ret) {
 830                 pr_err("meta-intc: No num-banks property found\n");
 831                 return ret;
 832         }
 833         if (val < 1 || val > 4) {
 834                 pr_err("meta-intc: num-banks (%u) out of range\n", val);
 835                 return -EINVAL;
 836         }
 837         priv->nr_banks = val;
 838
 839         /* Are any mask registers present? */
 840         if (of_get_property(node, "no-mask", NULL))
 841                 no_masks = true;
 842
 843         /* No HWMASKEXT registers present? */
 844         if (no_masks)
 845                 meta_intc_no_mask();
 846
 847         /* Set up an IRQ domain */
 848         /*
 849          * This is a legacy IRQ domain for now until all the platform setup code
 850          * has been converted to devicetree.
 851          */
 852         priv->domain = irq_domain_add_linear(node, priv->nr_banks*32,
 853                                              &meta_intc_domain_ops, priv);
 854         if (unlikely(!priv->domain)) {
 855                 pr_err("meta-intc: cannot add IRQ domain\n");
 856                 return -ENOMEM;
 857         }
 858
 859         /* Setup TR2 for all cpus. */
 860         for_each_possible_cpu(cpu)
 861                 meta_intc_init_cpu(priv, cpu);
 862
 863         /* Set up system suspend/resume callbacks */
 864         meta_intc_init_syscore_ops(priv);
 865
 866         pr_info("meta-intc: External IRQ controller initialised (%u IRQs)\n",
 867                 priv->nr_banks*32);
 868
 869         return 0;
 870 }