2 * File: arch/blackfin/mach-common/ints-priority.c
4 * Description: Set up the interrupt priorities
8 * 1999 D. Jeff Dionne <jeff@uclinux.org>
9 * 2000-2001 Lineo, Inc. D. Jefff Dionne <jeff@lineo.ca>
10 * 2002 Arcturus Networks Inc. MaTed <mated@sympatico.ca>
11 * 2003 Metrowerks/Motorola
12 * 2003 Bas Vermeulen <bas@buyways.nl>
13 * Copyright 2004-2008 Analog Devices Inc.
15 * Bugs: Enter bugs at http://blackfin.uclinux.org/
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License as published by
19 * the Free Software Foundation; either version 2 of the License, or
20 * (at your option) any later version.
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
27 * You should have received a copy of the GNU General Public License
28 * along with this program; if not, see the file COPYING, or write
29 * to the Free Software Foundation, Inc.,
30 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
33 #include <linux/module.h>
34 #include <linux/kernel_stat.h>
35 #include <linux/seq_file.h>
36 #include <linux/irq.h>
38 #include <linux/ipipe.h>
41 #include <linux/kgdb.h>
43 #include <asm/traps.h>
44 #include <asm/blackfin.h>
46 #include <asm/irq_handler.h>
48 #define SIC_SYSIRQ(irq) (irq - (IRQ_CORETMR + 1))
51 # define BF537_GENERIC_ERROR_INT_DEMUX
53 # undef BF537_GENERIC_ERROR_INT_DEMUX
58 * - we have separated the physical Hardware interrupt from the
59 * levels that the LINUX kernel sees (see the description in irq.h)
64 /* Initialize this to an actual value to force it into the .data
65 * section so that we know it is properly initialized at entry into
66 * the kernel but before bss is initialized to zero (which is where
67 * it would live otherwise). The 0x1f magic represents the IRQs we
68 * cannot actually mask out in hardware.
70 unsigned long bfin_irq_flags
= 0x1f;
71 EXPORT_SYMBOL(bfin_irq_flags
);
74 /* The number of spurious interrupts */
75 atomic_t num_spurious
;
78 unsigned long bfin_sic_iwr
[3]; /* Up to 3 SIC_IWRx registers */
83 /* irq number for request_irq, available in mach-bf5xx/irq.h */
85 /* corresponding bit in the SIC_ISR register */
87 } ivg_table
[NR_PERI_INTS
];
90 /* position of first irq in ivg_table for given ivg */
93 } ivg7_13
[IVG13
- IVG7
+ 1];
97 * Search SIC_IAR and fill tables with the irqvalues
98 * and their positions in the SIC_ISR register.
100 static void __init
search_IAR(void)
102 unsigned ivg
, irq_pos
= 0;
103 for (ivg
= 0; ivg
<= IVG13
- IVG7
; ivg
++) {
106 ivg7_13
[ivg
].istop
= ivg7_13
[ivg
].ifirst
= &ivg_table
[irq_pos
];
108 for (irqn
= 0; irqn
< NR_PERI_INTS
; irqn
++) {
109 int iar_shift
= (irqn
& 7) * 4;
111 #if defined(CONFIG_BF52x) || defined(CONFIG_BF538) \
112 || defined(CONFIG_BF539) || defined(CONFIG_BF51x)
113 bfin_read32((unsigned long *)SIC_IAR0
+
114 ((irqn
% 32) >> 3) + ((irqn
/ 32) *
115 ((SIC_IAR4
- SIC_IAR0
) / 4))) >> iar_shift
)) {
117 bfin_read32((unsigned long *)SIC_IAR0
+
118 (irqn
>> 3)) >> iar_shift
)) {
120 ivg_table
[irq_pos
].irqno
= IVG7
+ irqn
;
121 ivg_table
[irq_pos
].isrflag
= 1 << (irqn
% 32);
122 ivg7_13
[ivg
].istop
++;
130 * This is for core internal IRQs
133 static void bfin_ack_noop(unsigned int irq
)
135 /* Dummy function. */
138 static void bfin_core_mask_irq(unsigned int irq
)
140 bfin_irq_flags
&= ~(1 << irq
);
141 if (!irqs_disabled_hw())
142 local_irq_enable_hw();
145 static void bfin_core_unmask_irq(unsigned int irq
)
147 bfin_irq_flags
|= 1 << irq
;
149 * If interrupts are enabled, IMASK must contain the same value
150 * as bfin_irq_flags. Make sure that invariant holds. If interrupts
151 * are currently disabled we need not do anything; one of the
152 * callers will take care of setting IMASK to the proper value
153 * when reenabling interrupts.
154 * local_irq_enable just does "STI bfin_irq_flags", so it's exactly
157 if (!irqs_disabled_hw())
158 local_irq_enable_hw();
162 static void bfin_internal_mask_irq(unsigned int irq
)
165 bfin_write_SIC_IMASK(bfin_read_SIC_IMASK() &
166 ~(1 << SIC_SYSIRQ(irq
)));
168 unsigned mask_bank
, mask_bit
;
169 mask_bank
= SIC_SYSIRQ(irq
) / 32;
170 mask_bit
= SIC_SYSIRQ(irq
) % 32;
171 bfin_write_SIC_IMASK(mask_bank
, bfin_read_SIC_IMASK(mask_bank
) &
174 bfin_write_SICB_IMASK(mask_bank
, bfin_read_SICB_IMASK(mask_bank
) &
180 static void bfin_internal_unmask_irq(unsigned int irq
)
183 bfin_write_SIC_IMASK(bfin_read_SIC_IMASK() |
184 (1 << SIC_SYSIRQ(irq
)));
186 unsigned mask_bank
, mask_bit
;
187 mask_bank
= SIC_SYSIRQ(irq
) / 32;
188 mask_bit
= SIC_SYSIRQ(irq
) % 32;
189 bfin_write_SIC_IMASK(mask_bank
, bfin_read_SIC_IMASK(mask_bank
) |
192 bfin_write_SICB_IMASK(mask_bank
, bfin_read_SICB_IMASK(mask_bank
) |
199 int bfin_internal_set_wake(unsigned int irq
, unsigned int state
)
201 u32 bank
, bit
, wakeup
= 0;
203 bank
= SIC_SYSIRQ(irq
) / 32;
204 bit
= SIC_SYSIRQ(irq
) % 32;
241 local_irq_save_hw(flags
);
244 bfin_sic_iwr
[bank
] |= (1 << bit
);
248 bfin_sic_iwr
[bank
] &= ~(1 << bit
);
249 vr_wakeup
&= ~wakeup
;
252 local_irq_restore_hw(flags
);
258 static struct irq_chip bfin_core_irqchip
= {
260 .ack
= bfin_ack_noop
,
261 .mask
= bfin_core_mask_irq
,
262 .unmask
= bfin_core_unmask_irq
,
265 static struct irq_chip bfin_internal_irqchip
= {
267 .ack
= bfin_ack_noop
,
268 .mask
= bfin_internal_mask_irq
,
269 .unmask
= bfin_internal_unmask_irq
,
270 .mask_ack
= bfin_internal_mask_irq
,
271 .disable
= bfin_internal_mask_irq
,
272 .enable
= bfin_internal_unmask_irq
,
274 .set_wake
= bfin_internal_set_wake
,
278 static void bfin_handle_irq(unsigned irq
)
281 struct pt_regs regs
; /* Contents not used. */
282 ipipe_trace_irq_entry(irq
);
283 __ipipe_handle_irq(irq
, ®s
);
284 ipipe_trace_irq_exit(irq
);
285 #else /* !CONFIG_IPIPE */
286 struct irq_desc
*desc
= irq_desc
+ irq
;
287 desc
->handle_irq(irq
, desc
);
288 #endif /* !CONFIG_IPIPE */
291 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
292 static int error_int_mask
;
294 static void bfin_generic_error_mask_irq(unsigned int irq
)
296 error_int_mask
&= ~(1L << (irq
- IRQ_PPI_ERROR
));
299 bfin_internal_mask_irq(IRQ_GENERIC_ERROR
);
302 static void bfin_generic_error_unmask_irq(unsigned int irq
)
304 bfin_internal_unmask_irq(IRQ_GENERIC_ERROR
);
305 error_int_mask
|= 1L << (irq
- IRQ_PPI_ERROR
);
308 static struct irq_chip bfin_generic_error_irqchip
= {
310 .ack
= bfin_ack_noop
,
311 .mask_ack
= bfin_generic_error_mask_irq
,
312 .mask
= bfin_generic_error_mask_irq
,
313 .unmask
= bfin_generic_error_unmask_irq
,
316 static void bfin_demux_error_irq(unsigned int int_err_irq
,
317 struct irq_desc
*inta_desc
)
321 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
322 if (bfin_read_EMAC_SYSTAT() & EMAC_ERR_MASK
)
326 if (bfin_read_SPORT0_STAT() & SPORT_ERR_MASK
)
327 irq
= IRQ_SPORT0_ERROR
;
328 else if (bfin_read_SPORT1_STAT() & SPORT_ERR_MASK
)
329 irq
= IRQ_SPORT1_ERROR
;
330 else if (bfin_read_PPI_STATUS() & PPI_ERR_MASK
)
332 else if (bfin_read_CAN_GIF() & CAN_ERR_MASK
)
334 else if (bfin_read_SPI_STAT() & SPI_ERR_MASK
)
336 else if ((bfin_read_UART0_IIR() & UART_ERR_MASK_STAT1
) &&
337 (bfin_read_UART0_IIR() & UART_ERR_MASK_STAT0
))
338 irq
= IRQ_UART0_ERROR
;
339 else if ((bfin_read_UART1_IIR() & UART_ERR_MASK_STAT1
) &&
340 (bfin_read_UART1_IIR() & UART_ERR_MASK_STAT0
))
341 irq
= IRQ_UART1_ERROR
;
344 if (error_int_mask
& (1L << (irq
- IRQ_PPI_ERROR
)))
345 bfin_handle_irq(irq
);
350 bfin_write_PPI_STATUS(PPI_ERR_MASK
);
352 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
354 bfin_write_EMAC_SYSTAT(EMAC_ERR_MASK
);
357 case IRQ_SPORT0_ERROR
:
358 bfin_write_SPORT0_STAT(SPORT_ERR_MASK
);
361 case IRQ_SPORT1_ERROR
:
362 bfin_write_SPORT1_STAT(SPORT_ERR_MASK
);
366 bfin_write_CAN_GIS(CAN_ERR_MASK
);
370 bfin_write_SPI_STAT(SPI_ERR_MASK
);
378 " MASKED PERIPHERAL ERROR INTERRUPT ASSERTED\n",
383 "%s : %s : LINE %d :\nIRQ ?: PERIPHERAL ERROR"
384 " INTERRUPT ASSERTED BUT NO SOURCE FOUND\n",
385 __func__
, __FILE__
, __LINE__
);
388 #endif /* BF537_GENERIC_ERROR_INT_DEMUX */
390 static inline void bfin_set_irq_handler(unsigned irq
, irq_flow_handler_t handle
)
393 _set_irq_handler(irq
, handle_edge_irq
);
395 struct irq_desc
*desc
= irq_desc
+ irq
;
396 /* May not call generic set_irq_handler() due to spinlock
398 desc
->handle_irq
= handle
;
402 static DECLARE_BITMAP(gpio_enabled
, MAX_BLACKFIN_GPIOS
);
403 extern void bfin_gpio_irq_prepare(unsigned gpio
);
405 #if !defined(CONFIG_BF54x)
407 static void bfin_gpio_ack_irq(unsigned int irq
)
409 /* AFAIK ack_irq in case mask_ack is provided
410 * get's only called for edge sense irqs
412 set_gpio_data(irq_to_gpio(irq
), 0);
415 static void bfin_gpio_mask_ack_irq(unsigned int irq
)
417 struct irq_desc
*desc
= irq_desc
+ irq
;
418 u32 gpionr
= irq_to_gpio(irq
);
420 if (desc
->handle_irq
== handle_edge_irq
)
421 set_gpio_data(gpionr
, 0);
423 set_gpio_maska(gpionr
, 0);
426 static void bfin_gpio_mask_irq(unsigned int irq
)
428 set_gpio_maska(irq_to_gpio(irq
), 0);
431 static void bfin_gpio_unmask_irq(unsigned int irq
)
433 set_gpio_maska(irq_to_gpio(irq
), 1);
436 static unsigned int bfin_gpio_irq_startup(unsigned int irq
)
438 u32 gpionr
= irq_to_gpio(irq
);
440 if (__test_and_set_bit(gpionr
, gpio_enabled
))
441 bfin_gpio_irq_prepare(gpionr
);
443 bfin_gpio_unmask_irq(irq
);
448 static void bfin_gpio_irq_shutdown(unsigned int irq
)
450 u32 gpionr
= irq_to_gpio(irq
);
452 bfin_gpio_mask_irq(irq
);
453 __clear_bit(gpionr
, gpio_enabled
);
454 bfin_gpio_irq_free(gpionr
);
457 static int bfin_gpio_irq_type(unsigned int irq
, unsigned int type
)
461 u32 gpionr
= irq_to_gpio(irq
);
463 if (type
== IRQ_TYPE_PROBE
) {
464 /* only probe unenabled GPIO interrupt lines */
465 if (__test_bit(gpionr
, gpio_enabled
))
467 type
= IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
;
470 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
|
471 IRQ_TYPE_LEVEL_HIGH
| IRQ_TYPE_LEVEL_LOW
)) {
473 snprintf(buf
, 16, "gpio-irq%d", irq
);
474 ret
= bfin_gpio_irq_request(gpionr
, buf
);
478 if (__test_and_set_bit(gpionr
, gpio_enabled
))
479 bfin_gpio_irq_prepare(gpionr
);
482 __clear_bit(gpionr
, gpio_enabled
);
486 set_gpio_inen(gpionr
, 0);
487 set_gpio_dir(gpionr
, 0);
489 if ((type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
490 == (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
491 set_gpio_both(gpionr
, 1);
493 set_gpio_both(gpionr
, 0);
495 if ((type
& (IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_LEVEL_LOW
)))
496 set_gpio_polar(gpionr
, 1); /* low or falling edge denoted by one */
498 set_gpio_polar(gpionr
, 0); /* high or rising edge denoted by zero */
500 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
)) {
501 set_gpio_edge(gpionr
, 1);
502 set_gpio_inen(gpionr
, 1);
503 set_gpio_data(gpionr
, 0);
506 set_gpio_edge(gpionr
, 0);
507 set_gpio_inen(gpionr
, 1);
510 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
511 bfin_set_irq_handler(irq
, handle_edge_irq
);
513 bfin_set_irq_handler(irq
, handle_level_irq
);
519 int bfin_gpio_set_wake(unsigned int irq
, unsigned int state
)
521 unsigned gpio
= irq_to_gpio(irq
);
524 gpio_pm_wakeup_request(gpio
, PM_WAKE_IGNORE
);
526 gpio_pm_wakeup_free(gpio
);
532 static void bfin_demux_gpio_irq(unsigned int inta_irq
,
533 struct irq_desc
*desc
)
535 unsigned int i
, gpio
, mask
, irq
, search
= 0;
538 #if defined(CONFIG_BF53x)
543 # if defined(BF537_FAMILY) && !(defined(CONFIG_BFIN_MAC) || defined(CONFIG_BFIN_MAC_MODULE))
548 #elif defined(CONFIG_BF538) || defined(CONFIG_BF539)
552 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
562 #elif defined(CONFIG_BF561)
579 for (i
= 0; i
< MAX_BLACKFIN_GPIOS
; i
+= GPIO_BANKSIZE
) {
582 mask
= get_gpiop_data(i
) & get_gpiop_maska(i
);
586 bfin_handle_irq(irq
);
592 gpio
= irq_to_gpio(irq
);
593 mask
= get_gpiop_data(gpio
) & get_gpiop_maska(gpio
);
597 bfin_handle_irq(irq
);
605 #else /* CONFIG_BF54x */
607 #define NR_PINT_SYS_IRQS 4
608 #define NR_PINT_BITS 32
610 #define IRQ_NOT_AVAIL 0xFF
612 #define PINT_2_BANK(x) ((x) >> 5)
613 #define PINT_2_BIT(x) ((x) & 0x1F)
614 #define PINT_BIT(x) (1 << (PINT_2_BIT(x)))
616 static unsigned char irq2pint_lut
[NR_PINTS
];
617 static unsigned char pint2irq_lut
[NR_PINT_SYS_IRQS
* NR_PINT_BITS
];
620 unsigned int mask_set
;
621 unsigned int mask_clear
;
622 unsigned int request
;
624 unsigned int edge_set
;
625 unsigned int edge_clear
;
626 unsigned int invert_set
;
627 unsigned int invert_clear
;
628 unsigned int pinstate
;
632 static struct pin_int_t
*pint
[NR_PINT_SYS_IRQS
] = {
633 (struct pin_int_t
*)PINT0_MASK_SET
,
634 (struct pin_int_t
*)PINT1_MASK_SET
,
635 (struct pin_int_t
*)PINT2_MASK_SET
,
636 (struct pin_int_t
*)PINT3_MASK_SET
,
639 inline unsigned int get_irq_base(u32 bank
, u8 bmap
)
641 unsigned int irq_base
;
643 if (bank
< 2) { /*PA-PB */
644 irq_base
= IRQ_PA0
+ bmap
* 16;
646 irq_base
= IRQ_PC0
+ bmap
* 16;
652 /* Whenever PINTx_ASSIGN is altered init_pint_lut() must be executed! */
653 void init_pint_lut(void)
655 u16 bank
, bit
, irq_base
, bit_pos
;
659 memset(irq2pint_lut
, IRQ_NOT_AVAIL
, sizeof(irq2pint_lut
));
661 for (bank
= 0; bank
< NR_PINT_SYS_IRQS
; bank
++) {
663 pint_assign
= pint
[bank
]->assign
;
665 for (bit
= 0; bit
< NR_PINT_BITS
; bit
++) {
667 bmap
= (pint_assign
>> ((bit
/ 8) * 8)) & 0xFF;
669 irq_base
= get_irq_base(bank
, bmap
);
671 irq_base
+= (bit
% 8) + ((bit
/ 8) & 1 ? 8 : 0);
672 bit_pos
= bit
+ bank
* NR_PINT_BITS
;
674 pint2irq_lut
[bit_pos
] = irq_base
- SYS_IRQS
;
675 irq2pint_lut
[irq_base
- SYS_IRQS
] = bit_pos
;
680 static void bfin_gpio_ack_irq(unsigned int irq
)
682 struct irq_desc
*desc
= irq_desc
+ irq
;
683 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
684 u32 pintbit
= PINT_BIT(pint_val
);
685 u32 bank
= PINT_2_BANK(pint_val
);
687 if ((desc
->status
& IRQ_TYPE_SENSE_MASK
) == IRQ_TYPE_EDGE_BOTH
) {
688 if (pint
[bank
]->invert_set
& pintbit
)
689 pint
[bank
]->invert_clear
= pintbit
;
691 pint
[bank
]->invert_set
= pintbit
;
693 pint
[bank
]->request
= pintbit
;
697 static void bfin_gpio_mask_ack_irq(unsigned int irq
)
699 struct irq_desc
*desc
= irq_desc
+ irq
;
700 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
701 u32 pintbit
= PINT_BIT(pint_val
);
702 u32 bank
= PINT_2_BANK(pint_val
);
704 if ((desc
->status
& IRQ_TYPE_SENSE_MASK
) == IRQ_TYPE_EDGE_BOTH
) {
705 if (pint
[bank
]->invert_set
& pintbit
)
706 pint
[bank
]->invert_clear
= pintbit
;
708 pint
[bank
]->invert_set
= pintbit
;
711 pint
[bank
]->request
= pintbit
;
712 pint
[bank
]->mask_clear
= pintbit
;
715 static void bfin_gpio_mask_irq(unsigned int irq
)
717 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
719 pint
[PINT_2_BANK(pint_val
)]->mask_clear
= PINT_BIT(pint_val
);
722 static void bfin_gpio_unmask_irq(unsigned int irq
)
724 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
725 u32 pintbit
= PINT_BIT(pint_val
);
726 u32 bank
= PINT_2_BANK(pint_val
);
728 pint
[bank
]->request
= pintbit
;
729 pint
[bank
]->mask_set
= pintbit
;
732 static unsigned int bfin_gpio_irq_startup(unsigned int irq
)
734 u32 gpionr
= irq_to_gpio(irq
);
735 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
737 if (pint_val
== IRQ_NOT_AVAIL
) {
739 "GPIO IRQ %d :Not in PINT Assign table "
740 "Reconfigure Interrupt to Port Assignemt\n", irq
);
744 if (__test_and_set_bit(gpionr
, gpio_enabled
))
745 bfin_gpio_irq_prepare(gpionr
);
747 bfin_gpio_unmask_irq(irq
);
752 static void bfin_gpio_irq_shutdown(unsigned int irq
)
754 u32 gpionr
= irq_to_gpio(irq
);
756 bfin_gpio_mask_irq(irq
);
757 __clear_bit(gpionr
, gpio_enabled
);
758 bfin_gpio_irq_free(gpionr
);
761 static int bfin_gpio_irq_type(unsigned int irq
, unsigned int type
)
765 u32 gpionr
= irq_to_gpio(irq
);
766 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
767 u32 pintbit
= PINT_BIT(pint_val
);
768 u32 bank
= PINT_2_BANK(pint_val
);
770 if (pint_val
== IRQ_NOT_AVAIL
)
773 if (type
== IRQ_TYPE_PROBE
) {
774 /* only probe unenabled GPIO interrupt lines */
775 if (__test_bit(gpionr
, gpio_enabled
))
777 type
= IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
;
780 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
|
781 IRQ_TYPE_LEVEL_HIGH
| IRQ_TYPE_LEVEL_LOW
)) {
783 snprintf(buf
, 16, "gpio-irq%d", irq
);
784 ret
= bfin_gpio_irq_request(gpionr
, buf
);
788 if (__test_and_set_bit(gpionr
, gpio_enabled
))
789 bfin_gpio_irq_prepare(gpionr
);
792 __clear_bit(gpionr
, gpio_enabled
);
796 if ((type
& (IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_LEVEL_LOW
)))
797 pint
[bank
]->invert_set
= pintbit
; /* low or falling edge denoted by one */
799 pint
[bank
]->invert_clear
= pintbit
; /* high or rising edge denoted by zero */
801 if ((type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
802 == (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
)) {
803 if (gpio_get_value(gpionr
))
804 pint
[bank
]->invert_set
= pintbit
;
806 pint
[bank
]->invert_clear
= pintbit
;
809 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
)) {
810 pint
[bank
]->edge_set
= pintbit
;
811 bfin_set_irq_handler(irq
, handle_edge_irq
);
813 pint
[bank
]->edge_clear
= pintbit
;
814 bfin_set_irq_handler(irq
, handle_level_irq
);
821 u32 pint_saved_masks
[NR_PINT_SYS_IRQS
];
822 u32 pint_wakeup_masks
[NR_PINT_SYS_IRQS
];
824 int bfin_gpio_set_wake(unsigned int irq
, unsigned int state
)
827 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
828 u32 bank
= PINT_2_BANK(pint_val
);
829 u32 pintbit
= PINT_BIT(pint_val
);
833 pint_irq
= IRQ_PINT0
;
836 pint_irq
= IRQ_PINT2
;
839 pint_irq
= IRQ_PINT3
;
842 pint_irq
= IRQ_PINT1
;
848 bfin_internal_set_wake(pint_irq
, state
);
851 pint_wakeup_masks
[bank
] |= pintbit
;
853 pint_wakeup_masks
[bank
] &= ~pintbit
;
858 u32
bfin_pm_setup(void)
862 for (i
= 0; i
< NR_PINT_SYS_IRQS
; i
++) {
863 val
= pint
[i
]->mask_clear
;
864 pint_saved_masks
[i
] = val
;
865 if (val
^ pint_wakeup_masks
[i
]) {
866 pint
[i
]->mask_clear
= val
;
867 pint
[i
]->mask_set
= pint_wakeup_masks
[i
];
874 void bfin_pm_restore(void)
878 for (i
= 0; i
< NR_PINT_SYS_IRQS
; i
++) {
879 val
= pint_saved_masks
[i
];
880 if (val
^ pint_wakeup_masks
[i
]) {
881 pint
[i
]->mask_clear
= pint
[i
]->mask_clear
;
882 pint
[i
]->mask_set
= val
;
888 static void bfin_demux_gpio_irq(unsigned int inta_irq
,
889 struct irq_desc
*desc
)
911 pint_val
= bank
* NR_PINT_BITS
;
913 request
= pint
[bank
]->request
;
917 irq
= pint2irq_lut
[pint_val
] + SYS_IRQS
;
918 bfin_handle_irq(irq
);
927 static struct irq_chip bfin_gpio_irqchip
= {
929 .ack
= bfin_gpio_ack_irq
,
930 .mask
= bfin_gpio_mask_irq
,
931 .mask_ack
= bfin_gpio_mask_ack_irq
,
932 .unmask
= bfin_gpio_unmask_irq
,
933 .disable
= bfin_gpio_mask_irq
,
934 .enable
= bfin_gpio_unmask_irq
,
935 .set_type
= bfin_gpio_irq_type
,
936 .startup
= bfin_gpio_irq_startup
,
937 .shutdown
= bfin_gpio_irq_shutdown
,
939 .set_wake
= bfin_gpio_set_wake
,
943 void __cpuinit
init_exception_vectors(void)
945 /* cannot program in software:
946 * evt0 - emulation (jtag)
949 bfin_write_EVT2(evt_nmi
);
950 bfin_write_EVT3(trap
);
951 bfin_write_EVT5(evt_ivhw
);
952 bfin_write_EVT6(evt_timer
);
953 bfin_write_EVT7(evt_evt7
);
954 bfin_write_EVT8(evt_evt8
);
955 bfin_write_EVT9(evt_evt9
);
956 bfin_write_EVT10(evt_evt10
);
957 bfin_write_EVT11(evt_evt11
);
958 bfin_write_EVT12(evt_evt12
);
959 bfin_write_EVT13(evt_evt13
);
960 bfin_write_EVT14(evt14_softirq
);
961 bfin_write_EVT15(evt_system_call
);
966 * This function should be called during kernel startup to initialize
967 * the BFin IRQ handling routines.
970 int __init
init_arch_irq(void)
973 unsigned long ilat
= 0;
974 /* Disable all the peripheral intrs - page 4-29 HW Ref manual */
975 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561) \
976 || defined(BF538_FAMILY) || defined(CONFIG_BF51x)
977 bfin_write_SIC_IMASK0(SIC_UNMASK_ALL
);
978 bfin_write_SIC_IMASK1(SIC_UNMASK_ALL
);
980 bfin_write_SIC_IMASK2(SIC_UNMASK_ALL
);
983 bfin_write_SICB_IMASK0(SIC_UNMASK_ALL
);
984 bfin_write_SICB_IMASK1(SIC_UNMASK_ALL
);
987 bfin_write_SIC_IMASK(SIC_UNMASK_ALL
);
992 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
993 /* Clear EMAC Interrupt Status bits so we can demux it later */
994 bfin_write_EMAC_SYSTAT(-1);
998 # ifdef CONFIG_PINTx_REASSIGN
999 pint
[0]->assign
= CONFIG_PINT0_ASSIGN
;
1000 pint
[1]->assign
= CONFIG_PINT1_ASSIGN
;
1001 pint
[2]->assign
= CONFIG_PINT2_ASSIGN
;
1002 pint
[3]->assign
= CONFIG_PINT3_ASSIGN
;
1004 /* Whenever PINTx_ASSIGN is altered init_pint_lut() must be executed! */
1008 for (irq
= 0; irq
<= SYS_IRQS
; irq
++) {
1009 if (irq
<= IRQ_CORETMR
)
1010 set_irq_chip(irq
, &bfin_core_irqchip
);
1012 set_irq_chip(irq
, &bfin_internal_irqchip
);
1015 #if defined(CONFIG_BF53x)
1017 # if defined(BF537_FAMILY) && !(defined(CONFIG_BFIN_MAC) || defined(CONFIG_BFIN_MAC_MODULE))
1020 #elif defined(CONFIG_BF54x)
1025 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
1026 case IRQ_PORTF_INTA
:
1027 case IRQ_PORTG_INTA
:
1028 case IRQ_PORTH_INTA
:
1029 #elif defined(CONFIG_BF561)
1030 case IRQ_PROG0_INTA
:
1031 case IRQ_PROG1_INTA
:
1032 case IRQ_PROG2_INTA
:
1033 #elif defined(CONFIG_BF538) || defined(CONFIG_BF539)
1034 case IRQ_PORTF_INTA
:
1037 set_irq_chained_handler(irq
,
1038 bfin_demux_gpio_irq
);
1040 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
1041 case IRQ_GENERIC_ERROR
:
1042 set_irq_chained_handler(irq
, bfin_demux_error_irq
);
1045 #if defined(CONFIG_TICK_SOURCE_SYSTMR0) || defined(CONFIG_IPIPE)
1047 set_irq_handler(irq
, handle_percpu_irq
);
1053 set_irq_handler(irq
, handle_percpu_irq
);
1059 * We want internal interrupt sources to be masked, because
1060 * ISRs may trigger interrupts recursively (e.g. DMA), but
1061 * interrupts are _not_ masked at CPU level. So let's handle
1062 * them as level interrupts.
1064 set_irq_handler(irq
, handle_level_irq
);
1065 #else /* !CONFIG_IPIPE */
1066 set_irq_handler(irq
, handle_simple_irq
);
1067 #endif /* !CONFIG_IPIPE */
1072 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
1073 for (irq
= IRQ_PPI_ERROR
; irq
<= IRQ_UART1_ERROR
; irq
++)
1074 set_irq_chip_and_handler(irq
, &bfin_generic_error_irqchip
,
1078 /* if configured as edge, then will be changed to do_edge_IRQ */
1079 for (irq
= GPIO_IRQ_BASE
; irq
< NR_IRQS
; irq
++)
1080 set_irq_chip_and_handler(irq
, &bfin_gpio_irqchip
,
1084 bfin_write_IMASK(0);
1086 ilat
= bfin_read_ILAT();
1088 bfin_write_ILAT(ilat
);
1091 printk(KERN_INFO
"Configuring Blackfin Priority Driven Interrupts\n");
1092 /* IMASK=xxx is equivalent to STI xx or bfin_irq_flags=xx,
1093 * local_irq_enable()
1096 /* Therefore it's better to setup IARs before interrupts enabled */
1099 /* Enable interrupts IVG7-15 */
1100 bfin_irq_flags
|= IMASK_IVG15
|
1101 IMASK_IVG14
| IMASK_IVG13
| IMASK_IVG12
| IMASK_IVG11
|
1102 IMASK_IVG10
| IMASK_IVG9
| IMASK_IVG8
| IMASK_IVG7
| IMASK_IVGHW
;
1104 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561) \
1105 || defined(BF538_FAMILY) || defined(CONFIG_BF51x)
1106 bfin_write_SIC_IWR0(IWR_DISABLE_ALL
);
1107 #if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
1108 /* BF52x/BF51x system reset does not properly reset SIC_IWR1 which
1109 * will screw up the bootrom as it relies on MDMA0/1 waking it
1110 * up from IDLE instructions. See this report for more info:
1111 * http://blackfin.uclinux.org/gf/tracker/4323
1113 if (ANOMALY_05000435
)
1114 bfin_write_SIC_IWR1(IWR_ENABLE(10) | IWR_ENABLE(11));
1116 bfin_write_SIC_IWR1(IWR_DISABLE_ALL
);
1118 bfin_write_SIC_IWR1(IWR_DISABLE_ALL
);
1120 # ifdef CONFIG_BF54x
1121 bfin_write_SIC_IWR2(IWR_DISABLE_ALL
);
1124 bfin_write_SIC_IWR(IWR_DISABLE_ALL
);
1128 for (irq
= 0; irq
< NR_IRQS
; irq
++) {
1129 struct irq_desc
*desc
= irq_desc
+ irq
;
1130 desc
->ic_prio
= __ipipe_get_irq_priority(irq
);
1131 desc
->thr_prio
= __ipipe_get_irqthread_priority(irq
);
1133 #endif /* CONFIG_IPIPE */
1138 #ifdef CONFIG_DO_IRQ_L1
1139 __attribute__((l1_text
))
1141 void do_irq(int vec
, struct pt_regs
*fp
)
1143 if (vec
== EVT_IVTMR_P
) {
1146 struct ivgx
*ivg
= ivg7_13
[vec
- IVG7
].ifirst
;
1147 struct ivgx
*ivg_stop
= ivg7_13
[vec
- IVG7
].istop
;
1148 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561) \
1149 || defined(BF538_FAMILY) || defined(CONFIG_BF51x)
1150 unsigned long sic_status
[3];
1152 if (smp_processor_id()) {
1154 /* This will be optimized out in UP mode. */
1155 sic_status
[0] = bfin_read_SICB_ISR0() & bfin_read_SICB_IMASK0();
1156 sic_status
[1] = bfin_read_SICB_ISR1() & bfin_read_SICB_IMASK1();
1159 sic_status
[0] = bfin_read_SIC_ISR0() & bfin_read_SIC_IMASK0();
1160 sic_status
[1] = bfin_read_SIC_ISR1() & bfin_read_SIC_IMASK1();
1163 sic_status
[2] = bfin_read_SIC_ISR2() & bfin_read_SIC_IMASK2();
1166 if (ivg
>= ivg_stop
) {
1167 atomic_inc(&num_spurious
);
1170 if (sic_status
[(ivg
->irqno
- IVG7
) / 32] & ivg
->isrflag
)
1174 unsigned long sic_status
;
1176 sic_status
= bfin_read_SIC_IMASK() & bfin_read_SIC_ISR();
1179 if (ivg
>= ivg_stop
) {
1180 atomic_inc(&num_spurious
);
1182 } else if (sic_status
& ivg
->isrflag
)
1188 asm_do_IRQ(vec
, fp
);
1193 int __ipipe_get_irq_priority(unsigned irq
)
1197 if (irq
<= IRQ_CORETMR
)
1200 for (ient
= 0; ient
< NR_PERI_INTS
; ient
++) {
1201 struct ivgx
*ivg
= ivg_table
+ ient
;
1202 if (ivg
->irqno
== irq
) {
1203 for (prio
= 0; prio
<= IVG13
-IVG7
; prio
++) {
1204 if (ivg7_13
[prio
].ifirst
<= ivg
&&
1205 ivg7_13
[prio
].istop
> ivg
)
1214 int __ipipe_get_irqthread_priority(unsigned irq
)
1219 /* The returned priority value is rescaled to [0..IVG13+1]
1220 * with 0 being the lowest effective priority level. */
1222 if (irq
<= IRQ_CORETMR
)
1223 return IVG13
- irq
+ 1;
1225 /* GPIO IRQs are given the priority of the demux
1227 if (IS_GPIOIRQ(irq
)) {
1228 #if defined(CONFIG_BF54x)
1229 u32 bank
= PINT_2_BANK(irq2pint_lut
[irq
- SYS_IRQS
]);
1230 demux_irq
= (bank
== 0 ? IRQ_PINT0
:
1231 bank
== 1 ? IRQ_PINT1
:
1232 bank
== 2 ? IRQ_PINT2
:
1234 #elif defined(CONFIG_BF561)
1235 demux_irq
= (irq
>= IRQ_PF32
? IRQ_PROG2_INTA
:
1236 irq
>= IRQ_PF16
? IRQ_PROG1_INTA
:
1238 #elif defined(CONFIG_BF52x)
1239 demux_irq
= (irq
>= IRQ_PH0
? IRQ_PORTH_INTA
:
1240 irq
>= IRQ_PG0
? IRQ_PORTG_INTA
:
1245 return IVG13
- PRIO_GPIODEMUX(demux_irq
) + 1;
1248 /* The GPIO demux interrupt is given a lower priority
1249 * than the GPIO IRQs, so that its threaded handler
1250 * unmasks the interrupt line after the decoded IRQs
1251 * have been processed. */
1252 prio
= PRIO_GPIODEMUX(irq
);
1255 return IVG13
- prio
;
1257 for (ient
= 0; ient
< NR_PERI_INTS
; ient
++) {
1258 struct ivgx
*ivg
= ivg_table
+ ient
;
1259 if (ivg
->irqno
== irq
) {
1260 for (prio
= 0; prio
<= IVG13
-IVG7
; prio
++) {
1261 if (ivg7_13
[prio
].ifirst
<= ivg
&&
1262 ivg7_13
[prio
].istop
> ivg
)
1271 /* Hw interrupts are disabled on entry (check SAVE_CONTEXT). */
1272 #ifdef CONFIG_DO_IRQ_L1
1273 __attribute__((l1_text
))
1275 asmlinkage
int __ipipe_grab_irq(int vec
, struct pt_regs
*regs
)
1277 struct ivgx
*ivg_stop
= ivg7_13
[vec
-IVG7
].istop
;
1278 struct ivgx
*ivg
= ivg7_13
[vec
-IVG7
].ifirst
;
1281 if (likely(vec
== EVT_IVTMR_P
)) {
1288 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561)
1290 unsigned long sic_status
[3];
1292 sic_status
[0] = bfin_read_SIC_ISR0() & bfin_read_SIC_IMASK0();
1293 sic_status
[1] = bfin_read_SIC_ISR1() & bfin_read_SIC_IMASK1();
1295 sic_status
[2] = bfin_read_SIC_ISR2() & bfin_read_SIC_IMASK2();
1298 if (ivg
>= ivg_stop
) {
1299 atomic_inc(&num_spurious
);
1302 if (sic_status
[(ivg
->irqno
- IVG7
) / 32] & ivg
->isrflag
)
1308 unsigned long sic_status
;
1310 sic_status
= bfin_read_SIC_IMASK() & bfin_read_SIC_ISR();
1313 if (ivg
>= ivg_stop
) {
1314 atomic_inc(&num_spurious
);
1316 } else if (sic_status
& ivg
->isrflag
)
1324 if (irq
== IRQ_SYSTMR
) {
1325 bfin_write_TIMER_STATUS(1); /* Latch TIMIL0 */
1326 /* This is basically what we need from the register frame. */
1327 __raw_get_cpu_var(__ipipe_tick_regs
).ipend
= regs
->ipend
;
1328 __raw_get_cpu_var(__ipipe_tick_regs
).pc
= regs
->pc
;
1329 if (!ipipe_root_domain_p
)
1330 __raw_get_cpu_var(__ipipe_tick_regs
).ipend
|= 0x10;
1332 __raw_get_cpu_var(__ipipe_tick_regs
).ipend
&= ~0x10;
1337 ipipe_trace_irq_entry(irq
);
1338 __ipipe_handle_irq(irq
, regs
);
1339 ipipe_trace_irq_exit(irq
);
1341 if (ipipe_root_domain_p
)
1342 return !test_bit(IPIPE_STALL_FLAG
, &ipipe_root_cpudom_var(status
));
1347 #endif /* CONFIG_IPIPE */