2 * Set up the interrupt priorities
4 * Copyright 2004-2009 Analog Devices Inc.
5 * 2003 Bas Vermeulen <bas@buyways.nl>
6 * 2002 Arcturus Networks Inc. MaTed <mated@sympatico.ca>
7 * 2000-2001 Lineo, Inc. D. Jefff Dionne <jeff@lineo.ca>
8 * 1999 D. Jeff Dionne <jeff@uclinux.org>
11 * Licensed under the GPL-2
14 #include <linux/module.h>
15 #include <linux/kernel_stat.h>
16 #include <linux/seq_file.h>
17 #include <linux/irq.h>
19 #include <linux/ipipe.h>
22 #include <linux/kgdb.h>
24 #include <asm/traps.h>
25 #include <asm/blackfin.h>
27 #include <asm/irq_handler.h>
30 #define SIC_SYSIRQ(irq) (irq - (IRQ_CORETMR + 1))
33 # define BF537_GENERIC_ERROR_INT_DEMUX
35 # undef BF537_GENERIC_ERROR_INT_DEMUX
40 * - we have separated the physical Hardware interrupt from the
41 * levels that the LINUX kernel sees (see the description in irq.h)
46 /* Initialize this to an actual value to force it into the .data
47 * section so that we know it is properly initialized at entry into
48 * the kernel but before bss is initialized to zero (which is where
49 * it would live otherwise). The 0x1f magic represents the IRQs we
50 * cannot actually mask out in hardware.
52 unsigned long bfin_irq_flags = 0x1f;
53 EXPORT_SYMBOL(bfin_irq_flags);
56 /* The number of spurious interrupts */
57 atomic_t num_spurious;
60 unsigned long bfin_sic_iwr[3]; /* Up to 3 SIC_IWRx registers */
65 /* irq number for request_irq, available in mach-bf5xx/irq.h */
67 /* corresponding bit in the SIC_ISR register */
69 } ivg_table[NR_PERI_INTS];
72 /* position of first irq in ivg_table for given ivg */
75 } ivg7_13[IVG13 - IVG7 + 1];
79 * Search SIC_IAR and fill tables with the irqvalues
80 * and their positions in the SIC_ISR register.
82 static void __init search_IAR(void)
84 unsigned ivg, irq_pos = 0;
85 for (ivg = 0; ivg <= IVG13 - IVG7; ivg++) {
88 ivg7_13[ivg].istop = ivg7_13[ivg].ifirst = &ivg_table[irq_pos];
90 for (irqn = 0; irqn < NR_PERI_INTS; irqn++) {
91 int iar_shift = (irqn & 7) * 4;
93 #if defined(CONFIG_BF52x) || defined(CONFIG_BF538) \
94 || defined(CONFIG_BF539) || defined(CONFIG_BF51x)
95 bfin_read32((unsigned long *)SIC_IAR0 +
96 ((irqn % 32) >> 3) + ((irqn / 32) *
97 ((SIC_IAR4 - SIC_IAR0) / 4))) >> iar_shift)) {
99 bfin_read32((unsigned long *)SIC_IAR0 +
100 (irqn >> 3)) >> iar_shift)) {
102 ivg_table[irq_pos].irqno = IVG7 + irqn;
103 ivg_table[irq_pos].isrflag = 1 << (irqn % 32);
104 ivg7_13[ivg].istop++;
112 * This is for core internal IRQs
115 static void bfin_ack_noop(unsigned int irq)
117 /* Dummy function. */
120 static void bfin_core_mask_irq(unsigned int irq)
122 bfin_irq_flags &= ~(1 << irq);
123 if (!irqs_disabled_hw())
124 local_irq_enable_hw();
127 static void bfin_core_unmask_irq(unsigned int irq)
129 bfin_irq_flags |= 1 << irq;
131 * If interrupts are enabled, IMASK must contain the same value
132 * as bfin_irq_flags. Make sure that invariant holds. If interrupts
133 * are currently disabled we need not do anything; one of the
134 * callers will take care of setting IMASK to the proper value
135 * when reenabling interrupts.
136 * local_irq_enable just does "STI bfin_irq_flags", so it's exactly
139 if (!irqs_disabled_hw())
140 local_irq_enable_hw();
144 static void bfin_internal_mask_irq(unsigned int irq)
149 local_irq_save_hw(flags);
150 bfin_write_SIC_IMASK(bfin_read_SIC_IMASK() &
151 ~(1 << SIC_SYSIRQ(irq)));
153 unsigned mask_bank, mask_bit;
154 local_irq_save_hw(flags);
155 mask_bank = SIC_SYSIRQ(irq) / 32;
156 mask_bit = SIC_SYSIRQ(irq) % 32;
157 bfin_write_SIC_IMASK(mask_bank, bfin_read_SIC_IMASK(mask_bank) &
160 bfin_write_SICB_IMASK(mask_bank, bfin_read_SICB_IMASK(mask_bank) &
164 local_irq_restore_hw(flags);
167 static void bfin_internal_unmask_irq(unsigned int irq)
172 local_irq_save_hw(flags);
173 bfin_write_SIC_IMASK(bfin_read_SIC_IMASK() |
174 (1 << SIC_SYSIRQ(irq)));
176 unsigned mask_bank, mask_bit;
177 local_irq_save_hw(flags);
178 mask_bank = SIC_SYSIRQ(irq) / 32;
179 mask_bit = SIC_SYSIRQ(irq) % 32;
180 bfin_write_SIC_IMASK(mask_bank, bfin_read_SIC_IMASK(mask_bank) |
183 bfin_write_SICB_IMASK(mask_bank, bfin_read_SICB_IMASK(mask_bank) |
187 local_irq_restore_hw(flags);
191 int bfin_internal_set_wake(unsigned int irq, unsigned int state)
193 u32 bank, bit, wakeup = 0;
195 bank = SIC_SYSIRQ(irq) / 32;
196 bit = SIC_SYSIRQ(irq) % 32;
233 local_irq_save_hw(flags);
236 bfin_sic_iwr[bank] |= (1 << bit);
240 bfin_sic_iwr[bank] &= ~(1 << bit);
241 vr_wakeup &= ~wakeup;
244 local_irq_restore_hw(flags);
250 static struct irq_chip bfin_core_irqchip = {
252 .ack = bfin_ack_noop,
253 .mask = bfin_core_mask_irq,
254 .unmask = bfin_core_unmask_irq,
257 static struct irq_chip bfin_internal_irqchip = {
259 .ack = bfin_ack_noop,
260 .mask = bfin_internal_mask_irq,
261 .unmask = bfin_internal_unmask_irq,
262 .mask_ack = bfin_internal_mask_irq,
263 .disable = bfin_internal_mask_irq,
264 .enable = bfin_internal_unmask_irq,
266 .set_wake = bfin_internal_set_wake,
270 static void bfin_handle_irq(unsigned irq)
273 struct pt_regs regs; /* Contents not used. */
274 ipipe_trace_irq_entry(irq);
275 __ipipe_handle_irq(irq, ®s);
276 ipipe_trace_irq_exit(irq);
277 #else /* !CONFIG_IPIPE */
278 struct irq_desc *desc = irq_desc + irq;
279 desc->handle_irq(irq, desc);
280 #endif /* !CONFIG_IPIPE */
283 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
284 static int error_int_mask;
286 static void bfin_generic_error_mask_irq(unsigned int irq)
288 error_int_mask &= ~(1L << (irq - IRQ_PPI_ERROR));
291 bfin_internal_mask_irq(IRQ_GENERIC_ERROR);
294 static void bfin_generic_error_unmask_irq(unsigned int irq)
296 bfin_internal_unmask_irq(IRQ_GENERIC_ERROR);
297 error_int_mask |= 1L << (irq - IRQ_PPI_ERROR);
300 static struct irq_chip bfin_generic_error_irqchip = {
302 .ack = bfin_ack_noop,
303 .mask_ack = bfin_generic_error_mask_irq,
304 .mask = bfin_generic_error_mask_irq,
305 .unmask = bfin_generic_error_unmask_irq,
308 static void bfin_demux_error_irq(unsigned int int_err_irq,
309 struct irq_desc *inta_desc)
313 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
314 if (bfin_read_EMAC_SYSTAT() & EMAC_ERR_MASK)
318 if (bfin_read_SPORT0_STAT() & SPORT_ERR_MASK)
319 irq = IRQ_SPORT0_ERROR;
320 else if (bfin_read_SPORT1_STAT() & SPORT_ERR_MASK)
321 irq = IRQ_SPORT1_ERROR;
322 else if (bfin_read_PPI_STATUS() & PPI_ERR_MASK)
324 else if (bfin_read_CAN_GIF() & CAN_ERR_MASK)
326 else if (bfin_read_SPI_STAT() & SPI_ERR_MASK)
328 else if ((bfin_read_UART0_IIR() & UART_ERR_MASK_STAT1) &&
329 (bfin_read_UART0_IIR() & UART_ERR_MASK_STAT0))
330 irq = IRQ_UART0_ERROR;
331 else if ((bfin_read_UART1_IIR() & UART_ERR_MASK_STAT1) &&
332 (bfin_read_UART1_IIR() & UART_ERR_MASK_STAT0))
333 irq = IRQ_UART1_ERROR;
336 if (error_int_mask & (1L << (irq - IRQ_PPI_ERROR)))
337 bfin_handle_irq(irq);
342 bfin_write_PPI_STATUS(PPI_ERR_MASK);
344 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
346 bfin_write_EMAC_SYSTAT(EMAC_ERR_MASK);
349 case IRQ_SPORT0_ERROR:
350 bfin_write_SPORT0_STAT(SPORT_ERR_MASK);
353 case IRQ_SPORT1_ERROR:
354 bfin_write_SPORT1_STAT(SPORT_ERR_MASK);
358 bfin_write_CAN_GIS(CAN_ERR_MASK);
362 bfin_write_SPI_STAT(SPI_ERR_MASK);
370 " MASKED PERIPHERAL ERROR INTERRUPT ASSERTED\n",
375 "%s : %s : LINE %d :\nIRQ ?: PERIPHERAL ERROR"
376 " INTERRUPT ASSERTED BUT NO SOURCE FOUND\n",
377 __func__, __FILE__, __LINE__);
380 #endif /* BF537_GENERIC_ERROR_INT_DEMUX */
382 static inline void bfin_set_irq_handler(unsigned irq, irq_flow_handler_t handle)
385 _set_irq_handler(irq, handle_level_irq);
387 struct irq_desc *desc = irq_desc + irq;
388 /* May not call generic set_irq_handler() due to spinlock
390 desc->handle_irq = handle;
394 static DECLARE_BITMAP(gpio_enabled, MAX_BLACKFIN_GPIOS);
395 extern void bfin_gpio_irq_prepare(unsigned gpio);
397 #if !defined(CONFIG_BF54x)
399 static void bfin_gpio_ack_irq(unsigned int irq)
401 /* AFAIK ack_irq in case mask_ack is provided
402 * get's only called for edge sense irqs
404 set_gpio_data(irq_to_gpio(irq), 0);
407 static void bfin_gpio_mask_ack_irq(unsigned int irq)
409 struct irq_desc *desc = irq_desc + irq;
410 u32 gpionr = irq_to_gpio(irq);
412 if (desc->handle_irq == handle_edge_irq)
413 set_gpio_data(gpionr, 0);
415 set_gpio_maska(gpionr, 0);
418 static void bfin_gpio_mask_irq(unsigned int irq)
420 set_gpio_maska(irq_to_gpio(irq), 0);
423 static void bfin_gpio_unmask_irq(unsigned int irq)
425 set_gpio_maska(irq_to_gpio(irq), 1);
428 static unsigned int bfin_gpio_irq_startup(unsigned int irq)
430 u32 gpionr = irq_to_gpio(irq);
432 if (__test_and_set_bit(gpionr, gpio_enabled))
433 bfin_gpio_irq_prepare(gpionr);
435 bfin_gpio_unmask_irq(irq);
440 static void bfin_gpio_irq_shutdown(unsigned int irq)
442 u32 gpionr = irq_to_gpio(irq);
444 bfin_gpio_mask_irq(irq);
445 __clear_bit(gpionr, gpio_enabled);
446 bfin_gpio_irq_free(gpionr);
449 static int bfin_gpio_irq_type(unsigned int irq, unsigned int type)
453 u32 gpionr = irq_to_gpio(irq);
455 if (type == IRQ_TYPE_PROBE) {
456 /* only probe unenabled GPIO interrupt lines */
457 if (test_bit(gpionr, gpio_enabled))
459 type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
462 if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING |
463 IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) {
465 snprintf(buf, 16, "gpio-irq%d", irq);
466 ret = bfin_gpio_irq_request(gpionr, buf);
470 if (__test_and_set_bit(gpionr, gpio_enabled))
471 bfin_gpio_irq_prepare(gpionr);
474 __clear_bit(gpionr, gpio_enabled);
478 set_gpio_inen(gpionr, 0);
479 set_gpio_dir(gpionr, 0);
481 if ((type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
482 == (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
483 set_gpio_both(gpionr, 1);
485 set_gpio_both(gpionr, 0);
487 if ((type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_LEVEL_LOW)))
488 set_gpio_polar(gpionr, 1); /* low or falling edge denoted by one */
490 set_gpio_polar(gpionr, 0); /* high or rising edge denoted by zero */
492 if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) {
493 set_gpio_edge(gpionr, 1);
494 set_gpio_inen(gpionr, 1);
495 set_gpio_data(gpionr, 0);
498 set_gpio_edge(gpionr, 0);
499 set_gpio_inen(gpionr, 1);
502 if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
503 bfin_set_irq_handler(irq, handle_edge_irq);
505 bfin_set_irq_handler(irq, handle_level_irq);
511 int bfin_gpio_set_wake(unsigned int irq, unsigned int state)
513 unsigned gpio = irq_to_gpio(irq);
516 gpio_pm_wakeup_request(gpio, PM_WAKE_IGNORE);
518 gpio_pm_wakeup_free(gpio);
524 static void bfin_demux_gpio_irq(unsigned int inta_irq,
525 struct irq_desc *desc)
527 unsigned int i, gpio, mask, irq, search = 0;
530 #if defined(CONFIG_BF53x)
535 # if defined(BF537_FAMILY) && !(defined(CONFIG_BFIN_MAC) || defined(CONFIG_BFIN_MAC_MODULE))
540 #elif defined(CONFIG_BF538) || defined(CONFIG_BF539)
544 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
554 #elif defined(CONFIG_BF561)
571 for (i = 0; i < MAX_BLACKFIN_GPIOS; i += GPIO_BANKSIZE) {
574 mask = get_gpiop_data(i) & get_gpiop_maska(i);
578 bfin_handle_irq(irq);
584 gpio = irq_to_gpio(irq);
585 mask = get_gpiop_data(gpio) & get_gpiop_maska(gpio);
589 bfin_handle_irq(irq);
597 #else /* CONFIG_BF54x */
599 #define NR_PINT_SYS_IRQS 4
600 #define NR_PINT_BITS 32
602 #define IRQ_NOT_AVAIL 0xFF
604 #define PINT_2_BANK(x) ((x) >> 5)
605 #define PINT_2_BIT(x) ((x) & 0x1F)
606 #define PINT_BIT(x) (1 << (PINT_2_BIT(x)))
608 static unsigned char irq2pint_lut[NR_PINTS];
609 static unsigned char pint2irq_lut[NR_PINT_SYS_IRQS * NR_PINT_BITS];
612 unsigned int mask_set;
613 unsigned int mask_clear;
614 unsigned int request;
616 unsigned int edge_set;
617 unsigned int edge_clear;
618 unsigned int invert_set;
619 unsigned int invert_clear;
620 unsigned int pinstate;
624 static struct pin_int_t *pint[NR_PINT_SYS_IRQS] = {
625 (struct pin_int_t *)PINT0_MASK_SET,
626 (struct pin_int_t *)PINT1_MASK_SET,
627 (struct pin_int_t *)PINT2_MASK_SET,
628 (struct pin_int_t *)PINT3_MASK_SET,
631 inline unsigned int get_irq_base(u32 bank, u8 bmap)
633 unsigned int irq_base;
635 if (bank < 2) { /*PA-PB */
636 irq_base = IRQ_PA0 + bmap * 16;
638 irq_base = IRQ_PC0 + bmap * 16;
644 /* Whenever PINTx_ASSIGN is altered init_pint_lut() must be executed! */
645 void init_pint_lut(void)
647 u16 bank, bit, irq_base, bit_pos;
651 memset(irq2pint_lut, IRQ_NOT_AVAIL, sizeof(irq2pint_lut));
653 for (bank = 0; bank < NR_PINT_SYS_IRQS; bank++) {
655 pint_assign = pint[bank]->assign;
657 for (bit = 0; bit < NR_PINT_BITS; bit++) {
659 bmap = (pint_assign >> ((bit / 8) * 8)) & 0xFF;
661 irq_base = get_irq_base(bank, bmap);
663 irq_base += (bit % 8) + ((bit / 8) & 1 ? 8 : 0);
664 bit_pos = bit + bank * NR_PINT_BITS;
666 pint2irq_lut[bit_pos] = irq_base - SYS_IRQS;
667 irq2pint_lut[irq_base - SYS_IRQS] = bit_pos;
672 static void bfin_gpio_ack_irq(unsigned int irq)
674 struct irq_desc *desc = irq_desc + irq;
675 u32 pint_val = irq2pint_lut[irq - SYS_IRQS];
676 u32 pintbit = PINT_BIT(pint_val);
677 u32 bank = PINT_2_BANK(pint_val);
679 if ((desc->status & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH) {
680 if (pint[bank]->invert_set & pintbit)
681 pint[bank]->invert_clear = pintbit;
683 pint[bank]->invert_set = pintbit;
685 pint[bank]->request = pintbit;
689 static void bfin_gpio_mask_ack_irq(unsigned int irq)
691 struct irq_desc *desc = irq_desc + irq;
692 u32 pint_val = irq2pint_lut[irq - SYS_IRQS];
693 u32 pintbit = PINT_BIT(pint_val);
694 u32 bank = PINT_2_BANK(pint_val);
696 if ((desc->status & IRQ_TYPE_SENSE_MASK) == IRQ_TYPE_EDGE_BOTH) {
697 if (pint[bank]->invert_set & pintbit)
698 pint[bank]->invert_clear = pintbit;
700 pint[bank]->invert_set = pintbit;
703 pint[bank]->request = pintbit;
704 pint[bank]->mask_clear = pintbit;
707 static void bfin_gpio_mask_irq(unsigned int irq)
709 u32 pint_val = irq2pint_lut[irq - SYS_IRQS];
711 pint[PINT_2_BANK(pint_val)]->mask_clear = PINT_BIT(pint_val);
714 static void bfin_gpio_unmask_irq(unsigned int irq)
716 u32 pint_val = irq2pint_lut[irq - SYS_IRQS];
717 u32 pintbit = PINT_BIT(pint_val);
718 u32 bank = PINT_2_BANK(pint_val);
720 pint[bank]->request = pintbit;
721 pint[bank]->mask_set = pintbit;
724 static unsigned int bfin_gpio_irq_startup(unsigned int irq)
726 u32 gpionr = irq_to_gpio(irq);
727 u32 pint_val = irq2pint_lut[irq - SYS_IRQS];
729 if (pint_val == IRQ_NOT_AVAIL) {
731 "GPIO IRQ %d :Not in PINT Assign table "
732 "Reconfigure Interrupt to Port Assignemt\n", irq);
736 if (__test_and_set_bit(gpionr, gpio_enabled))
737 bfin_gpio_irq_prepare(gpionr);
739 bfin_gpio_unmask_irq(irq);
744 static void bfin_gpio_irq_shutdown(unsigned int irq)
746 u32 gpionr = irq_to_gpio(irq);
748 bfin_gpio_mask_irq(irq);
749 __clear_bit(gpionr, gpio_enabled);
750 bfin_gpio_irq_free(gpionr);
753 static int bfin_gpio_irq_type(unsigned int irq, unsigned int type)
757 u32 gpionr = irq_to_gpio(irq);
758 u32 pint_val = irq2pint_lut[irq - SYS_IRQS];
759 u32 pintbit = PINT_BIT(pint_val);
760 u32 bank = PINT_2_BANK(pint_val);
762 if (pint_val == IRQ_NOT_AVAIL)
765 if (type == IRQ_TYPE_PROBE) {
766 /* only probe unenabled GPIO interrupt lines */
767 if (test_bit(gpionr, gpio_enabled))
769 type = IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING;
772 if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING |
773 IRQ_TYPE_LEVEL_HIGH | IRQ_TYPE_LEVEL_LOW)) {
775 snprintf(buf, 16, "gpio-irq%d", irq);
776 ret = bfin_gpio_irq_request(gpionr, buf);
780 if (__test_and_set_bit(gpionr, gpio_enabled))
781 bfin_gpio_irq_prepare(gpionr);
784 __clear_bit(gpionr, gpio_enabled);
788 if ((type & (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_LEVEL_LOW)))
789 pint[bank]->invert_set = pintbit; /* low or falling edge denoted by one */
791 pint[bank]->invert_clear = pintbit; /* high or rising edge denoted by zero */
793 if ((type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING))
794 == (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) {
795 if (gpio_get_value(gpionr))
796 pint[bank]->invert_set = pintbit;
798 pint[bank]->invert_clear = pintbit;
801 if (type & (IRQ_TYPE_EDGE_RISING | IRQ_TYPE_EDGE_FALLING)) {
802 pint[bank]->edge_set = pintbit;
803 bfin_set_irq_handler(irq, handle_edge_irq);
805 pint[bank]->edge_clear = pintbit;
806 bfin_set_irq_handler(irq, handle_level_irq);
813 u32 pint_saved_masks[NR_PINT_SYS_IRQS];
814 u32 pint_wakeup_masks[NR_PINT_SYS_IRQS];
816 int bfin_gpio_set_wake(unsigned int irq, unsigned int state)
819 u32 pint_val = irq2pint_lut[irq - SYS_IRQS];
820 u32 bank = PINT_2_BANK(pint_val);
821 u32 pintbit = PINT_BIT(pint_val);
825 pint_irq = IRQ_PINT0;
828 pint_irq = IRQ_PINT2;
831 pint_irq = IRQ_PINT3;
834 pint_irq = IRQ_PINT1;
840 bfin_internal_set_wake(pint_irq, state);
843 pint_wakeup_masks[bank] |= pintbit;
845 pint_wakeup_masks[bank] &= ~pintbit;
850 u32 bfin_pm_setup(void)
854 for (i = 0; i < NR_PINT_SYS_IRQS; i++) {
855 val = pint[i]->mask_clear;
856 pint_saved_masks[i] = val;
857 if (val ^ pint_wakeup_masks[i]) {
858 pint[i]->mask_clear = val;
859 pint[i]->mask_set = pint_wakeup_masks[i];
866 void bfin_pm_restore(void)
870 for (i = 0; i < NR_PINT_SYS_IRQS; i++) {
871 val = pint_saved_masks[i];
872 if (val ^ pint_wakeup_masks[i]) {
873 pint[i]->mask_clear = pint[i]->mask_clear;
874 pint[i]->mask_set = val;
880 static void bfin_demux_gpio_irq(unsigned int inta_irq,
881 struct irq_desc *desc)
903 pint_val = bank * NR_PINT_BITS;
905 request = pint[bank]->request;
909 irq = pint2irq_lut[pint_val] + SYS_IRQS;
910 bfin_handle_irq(irq);
919 static struct irq_chip bfin_gpio_irqchip = {
921 .ack = bfin_gpio_ack_irq,
922 .mask = bfin_gpio_mask_irq,
923 .mask_ack = bfin_gpio_mask_ack_irq,
924 .unmask = bfin_gpio_unmask_irq,
925 .disable = bfin_gpio_mask_irq,
926 .enable = bfin_gpio_unmask_irq,
927 .set_type = bfin_gpio_irq_type,
928 .startup = bfin_gpio_irq_startup,
929 .shutdown = bfin_gpio_irq_shutdown,
931 .set_wake = bfin_gpio_set_wake,
935 void __cpuinit init_exception_vectors(void)
937 /* cannot program in software:
938 * evt0 - emulation (jtag)
941 bfin_write_EVT2(evt_nmi);
942 bfin_write_EVT3(trap);
943 bfin_write_EVT5(evt_ivhw);
944 bfin_write_EVT6(evt_timer);
945 bfin_write_EVT7(evt_evt7);
946 bfin_write_EVT8(evt_evt8);
947 bfin_write_EVT9(evt_evt9);
948 bfin_write_EVT10(evt_evt10);
949 bfin_write_EVT11(evt_evt11);
950 bfin_write_EVT12(evt_evt12);
951 bfin_write_EVT13(evt_evt13);
952 bfin_write_EVT14(evt_evt14);
953 bfin_write_EVT15(evt_system_call);
958 * This function should be called during kernel startup to initialize
959 * the BFin IRQ handling routines.
962 int __init init_arch_irq(void)
965 unsigned long ilat = 0;
966 /* Disable all the peripheral intrs - page 4-29 HW Ref manual */
967 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561) \
968 || defined(BF538_FAMILY) || defined(CONFIG_BF51x)
969 bfin_write_SIC_IMASK0(SIC_UNMASK_ALL);
970 bfin_write_SIC_IMASK1(SIC_UNMASK_ALL);
972 bfin_write_SIC_IMASK2(SIC_UNMASK_ALL);
975 bfin_write_SICB_IMASK0(SIC_UNMASK_ALL);
976 bfin_write_SICB_IMASK1(SIC_UNMASK_ALL);
979 bfin_write_SIC_IMASK(SIC_UNMASK_ALL);
984 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
985 /* Clear EMAC Interrupt Status bits so we can demux it later */
986 bfin_write_EMAC_SYSTAT(-1);
990 # ifdef CONFIG_PINTx_REASSIGN
991 pint[0]->assign = CONFIG_PINT0_ASSIGN;
992 pint[1]->assign = CONFIG_PINT1_ASSIGN;
993 pint[2]->assign = CONFIG_PINT2_ASSIGN;
994 pint[3]->assign = CONFIG_PINT3_ASSIGN;
996 /* Whenever PINTx_ASSIGN is altered init_pint_lut() must be executed! */
1000 for (irq = 0; irq <= SYS_IRQS; irq++) {
1001 if (irq <= IRQ_CORETMR)
1002 set_irq_chip(irq, &bfin_core_irqchip);
1004 set_irq_chip(irq, &bfin_internal_irqchip);
1007 #if defined(CONFIG_BF53x)
1009 # if defined(BF537_FAMILY) && !(defined(CONFIG_BFIN_MAC) || defined(CONFIG_BFIN_MAC_MODULE))
1012 #elif defined(CONFIG_BF54x)
1017 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
1018 case IRQ_PORTF_INTA:
1019 case IRQ_PORTG_INTA:
1020 case IRQ_PORTH_INTA:
1021 #elif defined(CONFIG_BF561)
1022 case IRQ_PROG0_INTA:
1023 case IRQ_PROG1_INTA:
1024 case IRQ_PROG2_INTA:
1025 #elif defined(CONFIG_BF538) || defined(CONFIG_BF539)
1026 case IRQ_PORTF_INTA:
1029 set_irq_chained_handler(irq,
1030 bfin_demux_gpio_irq);
1032 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
1033 case IRQ_GENERIC_ERROR:
1034 set_irq_chained_handler(irq, bfin_demux_error_irq);
1039 #ifdef CONFIG_TICKSOURCE_GPTMR0
1042 #ifdef CONFIG_TICKSOURCE_CORETMR
1047 set_irq_handler(irq, handle_percpu_irq);
1052 #ifndef CONFIG_TICKSOURCE_CORETMR
1054 set_irq_handler(irq, handle_simple_irq);
1058 set_irq_handler(irq, handle_simple_irq);
1061 set_irq_handler(irq, handle_level_irq);
1063 #else /* !CONFIG_IPIPE */
1065 set_irq_handler(irq, handle_simple_irq);
1067 #endif /* !CONFIG_IPIPE */
1071 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
1072 for (irq = IRQ_PPI_ERROR; irq <= IRQ_UART1_ERROR; irq++)
1073 set_irq_chip_and_handler(irq, &bfin_generic_error_irqchip,
1077 /* if configured as edge, then will be changed to do_edge_IRQ */
1078 for (irq = GPIO_IRQ_BASE; irq < NR_IRQS; irq++)
1079 set_irq_chip_and_handler(irq, &bfin_gpio_irqchip,
1083 bfin_write_IMASK(0);
1085 ilat = bfin_read_ILAT();
1087 bfin_write_ILAT(ilat);
1090 printk(KERN_INFO "Configuring Blackfin Priority Driven Interrupts\n");
1091 /* IMASK=xxx is equivalent to STI xx or bfin_irq_flags=xx,
1092 * local_irq_enable()
1095 /* Therefore it's better to setup IARs before interrupts enabled */
1098 /* Enable interrupts IVG7-15 */
1099 bfin_irq_flags |= IMASK_IVG15 |
1100 IMASK_IVG14 | IMASK_IVG13 | IMASK_IVG12 | IMASK_IVG11 |
1101 IMASK_IVG10 | IMASK_IVG9 | IMASK_IVG8 | IMASK_IVG7 | IMASK_IVGHW;
1103 /* This implicitly covers ANOMALY_05000171
1104 * Boot-ROM code modifies SICA_IWRx wakeup registers
1107 bfin_write_SIC_IWR0(IWR_DISABLE_ALL);
1109 /* BF52x/BF51x system reset does not properly reset SIC_IWR1 which
1110 * will screw up the bootrom as it relies on MDMA0/1 waking it
1111 * up from IDLE instructions. See this report for more info:
1112 * http://blackfin.uclinux.org/gf/tracker/4323
1114 if (ANOMALY_05000435)
1115 bfin_write_SIC_IWR1(IWR_ENABLE(10) | IWR_ENABLE(11));
1117 bfin_write_SIC_IWR1(IWR_DISABLE_ALL);
1120 bfin_write_SIC_IWR2(IWR_DISABLE_ALL);
1123 bfin_write_SIC_IWR(IWR_DISABLE_ALL);
1129 #ifdef CONFIG_DO_IRQ_L1
1130 __attribute__((l1_text))
1132 void do_irq(int vec, struct pt_regs *fp)
1134 if (vec == EVT_IVTMR_P) {
1137 struct ivgx *ivg = ivg7_13[vec - IVG7].ifirst;
1138 struct ivgx *ivg_stop = ivg7_13[vec - IVG7].istop;
1139 #if defined(SIC_ISR0) || defined(SICA_ISR0)
1140 unsigned long sic_status[3];
1142 if (smp_processor_id()) {
1144 /* This will be optimized out in UP mode. */
1145 sic_status[0] = bfin_read_SICB_ISR0() & bfin_read_SICB_IMASK0();
1146 sic_status[1] = bfin_read_SICB_ISR1() & bfin_read_SICB_IMASK1();
1149 sic_status[0] = bfin_read_SIC_ISR0() & bfin_read_SIC_IMASK0();
1150 sic_status[1] = bfin_read_SIC_ISR1() & bfin_read_SIC_IMASK1();
1153 sic_status[2] = bfin_read_SIC_ISR2() & bfin_read_SIC_IMASK2();
1156 if (ivg >= ivg_stop) {
1157 atomic_inc(&num_spurious);
1160 if (sic_status[(ivg->irqno - IVG7) / 32] & ivg->isrflag)
1164 unsigned long sic_status;
1166 sic_status = bfin_read_SIC_IMASK() & bfin_read_SIC_ISR();
1169 if (ivg >= ivg_stop) {
1170 atomic_inc(&num_spurious);
1172 } else if (sic_status & ivg->isrflag)
1178 asm_do_IRQ(vec, fp);
1183 int __ipipe_get_irq_priority(unsigned irq)
1187 if (irq <= IRQ_CORETMR)
1190 for (ient = 0; ient < NR_PERI_INTS; ient++) {
1191 struct ivgx *ivg = ivg_table + ient;
1192 if (ivg->irqno == irq) {
1193 for (prio = 0; prio <= IVG13-IVG7; prio++) {
1194 if (ivg7_13[prio].ifirst <= ivg &&
1195 ivg7_13[prio].istop > ivg)
1204 /* Hw interrupts are disabled on entry (check SAVE_CONTEXT). */
1205 #ifdef CONFIG_DO_IRQ_L1
1206 __attribute__((l1_text))
1208 asmlinkage int __ipipe_grab_irq(int vec, struct pt_regs *regs)
1210 struct ipipe_percpu_domain_data *p = ipipe_root_cpudom_ptr();
1211 struct ipipe_domain *this_domain = __ipipe_current_domain;
1212 struct ivgx *ivg_stop = ivg7_13[vec-IVG7].istop;
1213 struct ivgx *ivg = ivg7_13[vec-IVG7].ifirst;
1216 if (likely(vec == EVT_IVTMR_P))
1219 #if defined(SIC_ISR0) || defined(SICA_ISR0)
1220 unsigned long sic_status[3];
1222 sic_status[0] = bfin_read_SIC_ISR0() & bfin_read_SIC_IMASK0();
1223 sic_status[1] = bfin_read_SIC_ISR1() & bfin_read_SIC_IMASK1();
1225 sic_status[2] = bfin_read_SIC_ISR2() & bfin_read_SIC_IMASK2();
1228 if (ivg >= ivg_stop) {
1229 atomic_inc(&num_spurious);
1232 if (sic_status[(ivg->irqno - IVG7) / 32] & ivg->isrflag)
1236 unsigned long sic_status;
1238 sic_status = bfin_read_SIC_IMASK() & bfin_read_SIC_ISR();
1241 if (ivg >= ivg_stop) {
1242 atomic_inc(&num_spurious);
1244 } else if (sic_status & ivg->isrflag)
1251 if (irq == IRQ_SYSTMR) {
1252 #if !defined(CONFIG_GENERIC_CLOCKEVENTS) || defined(CONFIG_TICKSOURCE_GPTMR0)
1253 bfin_write_TIMER_STATUS(1); /* Latch TIMIL0 */
1255 /* This is basically what we need from the register frame. */
1256 __raw_get_cpu_var(__ipipe_tick_regs).ipend = regs->ipend;
1257 __raw_get_cpu_var(__ipipe_tick_regs).pc = regs->pc;
1258 if (this_domain != ipipe_root_domain)
1259 __raw_get_cpu_var(__ipipe_tick_regs).ipend &= ~0x10;
1261 __raw_get_cpu_var(__ipipe_tick_regs).ipend |= 0x10;
1264 if (this_domain == ipipe_root_domain) {
1265 s = __test_and_set_bit(IPIPE_SYNCDEFER_FLAG, &p->status);
1269 ipipe_trace_irq_entry(irq);
1270 __ipipe_handle_irq(irq, regs);
1271 ipipe_trace_irq_exit(irq);
1273 if (this_domain == ipipe_root_domain) {
1274 set_thread_flag(TIF_IRQ_SYNC);
1276 __clear_bit(IPIPE_SYNCDEFER_FLAG, &p->status);
1277 return !test_bit(IPIPE_STALL_FLAG, &p->status);
1284 #endif /* CONFIG_IPIPE */