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/kgdb.h>
40 #include <asm/traps.h>
41 #include <asm/blackfin.h>
43 #include <asm/irq_handler.h>
45 #define SIC_SYSIRQ(irq) (irq - (IRQ_CORETMR + 1))
48 # define BF537_GENERIC_ERROR_INT_DEMUX
50 # undef BF537_GENERIC_ERROR_INT_DEMUX
55 * - we have separated the physical Hardware interrupt from the
56 * levels that the LINUX kernel sees (see the description in irq.h)
61 /* Initialize this to an actual value to force it into the .data
62 * section so that we know it is properly initialized at entry into
63 * the kernel but before bss is initialized to zero (which is where
64 * it would live otherwise). The 0x1f magic represents the IRQs we
65 * cannot actually mask out in hardware.
67 unsigned long bfin_irq_flags
= 0x1f;
68 EXPORT_SYMBOL(bfin_irq_flags
);
71 /* The number of spurious interrupts */
72 atomic_t num_spurious
;
75 unsigned long bfin_sic_iwr
[3]; /* Up to 3 SIC_IWRx registers */
80 /* irq number for request_irq, available in mach-bf5xx/irq.h */
82 /* corresponding bit in the SIC_ISR register */
84 } ivg_table
[NR_PERI_INTS
];
87 /* position of first irq in ivg_table for given ivg */
90 } ivg7_13
[IVG13
- IVG7
+ 1];
94 * Search SIC_IAR and fill tables with the irqvalues
95 * and their positions in the SIC_ISR register.
97 static void __init
search_IAR(void)
99 unsigned ivg
, irq_pos
= 0;
100 for (ivg
= 0; ivg
<= IVG13
- IVG7
; ivg
++) {
103 ivg7_13
[ivg
].istop
= ivg7_13
[ivg
].ifirst
= &ivg_table
[irq_pos
];
105 for (irqn
= 0; irqn
< NR_PERI_INTS
; irqn
++) {
106 int iar_shift
= (irqn
& 7) * 4;
108 #if defined(CONFIG_BF52x) || defined(CONFIG_BF538) \
109 || defined(CONFIG_BF539) || defined(CONFIG_BF51x)
110 bfin_read32((unsigned long *)SIC_IAR0
+
111 ((irqn
% 32) >> 3) + ((irqn
/ 32) *
112 ((SIC_IAR4
- SIC_IAR0
) / 4))) >> iar_shift
)) {
114 bfin_read32((unsigned long *)SIC_IAR0
+
115 (irqn
>> 3)) >> iar_shift
)) {
117 ivg_table
[irq_pos
].irqno
= IVG7
+ irqn
;
118 ivg_table
[irq_pos
].isrflag
= 1 << (irqn
% 32);
119 ivg7_13
[ivg
].istop
++;
127 * This is for core internal IRQs
130 static void bfin_ack_noop(unsigned int irq
)
132 /* Dummy function. */
135 static void bfin_core_mask_irq(unsigned int irq
)
137 bfin_irq_flags
&= ~(1 << irq
);
138 if (!irqs_disabled())
142 static void bfin_core_unmask_irq(unsigned int irq
)
144 bfin_irq_flags
|= 1 << irq
;
146 * If interrupts are enabled, IMASK must contain the same value
147 * as bfin_irq_flags. Make sure that invariant holds. If interrupts
148 * are currently disabled we need not do anything; one of the
149 * callers will take care of setting IMASK to the proper value
150 * when reenabling interrupts.
151 * local_irq_enable just does "STI bfin_irq_flags", so it's exactly
154 if (!irqs_disabled())
159 static void bfin_internal_mask_irq(unsigned int irq
)
162 bfin_write_SIC_IMASK(bfin_read_SIC_IMASK() &
163 ~(1 << SIC_SYSIRQ(irq
)));
165 unsigned mask_bank
, mask_bit
;
166 mask_bank
= SIC_SYSIRQ(irq
) / 32;
167 mask_bit
= SIC_SYSIRQ(irq
) % 32;
168 bfin_write_SIC_IMASK(mask_bank
, bfin_read_SIC_IMASK(mask_bank
) &
171 bfin_write_SICB_IMASK(mask_bank
, bfin_read_SICB_IMASK(mask_bank
) &
177 static void bfin_internal_unmask_irq(unsigned int irq
)
180 bfin_write_SIC_IMASK(bfin_read_SIC_IMASK() |
181 (1 << SIC_SYSIRQ(irq
)));
183 unsigned mask_bank
, mask_bit
;
184 mask_bank
= SIC_SYSIRQ(irq
) / 32;
185 mask_bit
= SIC_SYSIRQ(irq
) % 32;
186 bfin_write_SIC_IMASK(mask_bank
, bfin_read_SIC_IMASK(mask_bank
) |
189 bfin_write_SICB_IMASK(mask_bank
, bfin_read_SICB_IMASK(mask_bank
) |
196 int bfin_internal_set_wake(unsigned int irq
, unsigned int state
)
198 u32 bank
, bit
, wakeup
= 0;
200 bank
= SIC_SYSIRQ(irq
) / 32;
201 bit
= SIC_SYSIRQ(irq
) % 32;
238 local_irq_save(flags
);
241 bfin_sic_iwr
[bank
] |= (1 << bit
);
245 bfin_sic_iwr
[bank
] &= ~(1 << bit
);
246 vr_wakeup
&= ~wakeup
;
249 local_irq_restore(flags
);
255 static struct irq_chip bfin_core_irqchip
= {
257 .ack
= bfin_ack_noop
,
258 .mask
= bfin_core_mask_irq
,
259 .unmask
= bfin_core_unmask_irq
,
262 static struct irq_chip bfin_internal_irqchip
= {
264 .ack
= bfin_ack_noop
,
265 .mask
= bfin_internal_mask_irq
,
266 .unmask
= bfin_internal_unmask_irq
,
267 .mask_ack
= bfin_internal_mask_irq
,
268 .disable
= bfin_internal_mask_irq
,
269 .enable
= bfin_internal_unmask_irq
,
271 .set_wake
= bfin_internal_set_wake
,
275 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
276 static int error_int_mask
;
278 static void bfin_generic_error_mask_irq(unsigned int irq
)
280 error_int_mask
&= ~(1L << (irq
- IRQ_PPI_ERROR
));
283 bfin_internal_mask_irq(IRQ_GENERIC_ERROR
);
286 static void bfin_generic_error_unmask_irq(unsigned int irq
)
288 bfin_internal_unmask_irq(IRQ_GENERIC_ERROR
);
289 error_int_mask
|= 1L << (irq
- IRQ_PPI_ERROR
);
292 static struct irq_chip bfin_generic_error_irqchip
= {
294 .ack
= bfin_ack_noop
,
295 .mask_ack
= bfin_generic_error_mask_irq
,
296 .mask
= bfin_generic_error_mask_irq
,
297 .unmask
= bfin_generic_error_unmask_irq
,
300 static void bfin_demux_error_irq(unsigned int int_err_irq
,
301 struct irq_desc
*inta_desc
)
305 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
306 if (bfin_read_EMAC_SYSTAT() & EMAC_ERR_MASK
)
310 if (bfin_read_SPORT0_STAT() & SPORT_ERR_MASK
)
311 irq
= IRQ_SPORT0_ERROR
;
312 else if (bfin_read_SPORT1_STAT() & SPORT_ERR_MASK
)
313 irq
= IRQ_SPORT1_ERROR
;
314 else if (bfin_read_PPI_STATUS() & PPI_ERR_MASK
)
316 else if (bfin_read_CAN_GIF() & CAN_ERR_MASK
)
318 else if (bfin_read_SPI_STAT() & SPI_ERR_MASK
)
320 else if ((bfin_read_UART0_IIR() & UART_ERR_MASK_STAT1
) &&
321 (bfin_read_UART0_IIR() & UART_ERR_MASK_STAT0
))
322 irq
= IRQ_UART0_ERROR
;
323 else if ((bfin_read_UART1_IIR() & UART_ERR_MASK_STAT1
) &&
324 (bfin_read_UART1_IIR() & UART_ERR_MASK_STAT0
))
325 irq
= IRQ_UART1_ERROR
;
328 if (error_int_mask
& (1L << (irq
- IRQ_PPI_ERROR
))) {
329 struct irq_desc
*desc
= irq_desc
+ irq
;
330 desc
->handle_irq(irq
, desc
);
335 bfin_write_PPI_STATUS(PPI_ERR_MASK
);
337 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
339 bfin_write_EMAC_SYSTAT(EMAC_ERR_MASK
);
342 case IRQ_SPORT0_ERROR
:
343 bfin_write_SPORT0_STAT(SPORT_ERR_MASK
);
346 case IRQ_SPORT1_ERROR
:
347 bfin_write_SPORT1_STAT(SPORT_ERR_MASK
);
351 bfin_write_CAN_GIS(CAN_ERR_MASK
);
355 bfin_write_SPI_STAT(SPI_ERR_MASK
);
363 " MASKED PERIPHERAL ERROR INTERRUPT ASSERTED\n",
368 "%s : %s : LINE %d :\nIRQ ?: PERIPHERAL ERROR"
369 " INTERRUPT ASSERTED BUT NO SOURCE FOUND\n",
370 __func__
, __FILE__
, __LINE__
);
373 #endif /* BF537_GENERIC_ERROR_INT_DEMUX */
375 static inline void bfin_set_irq_handler(unsigned irq
, irq_flow_handler_t handle
)
377 struct irq_desc
*desc
= irq_desc
+ irq
;
378 /* May not call generic set_irq_handler() due to spinlock
380 desc
->handle_irq
= handle
;
383 static DECLARE_BITMAP(gpio_enabled
, MAX_BLACKFIN_GPIOS
);
384 extern void bfin_gpio_irq_prepare(unsigned gpio
);
386 #if !defined(CONFIG_BF54x)
388 static void bfin_gpio_ack_irq(unsigned int irq
)
390 /* AFAIK ack_irq in case mask_ack is provided
391 * get's only called for edge sense irqs
393 set_gpio_data(irq_to_gpio(irq
), 0);
396 static void bfin_gpio_mask_ack_irq(unsigned int irq
)
398 struct irq_desc
*desc
= irq_desc
+ irq
;
399 u32 gpionr
= irq_to_gpio(irq
);
401 if (desc
->handle_irq
== handle_edge_irq
)
402 set_gpio_data(gpionr
, 0);
404 set_gpio_maska(gpionr
, 0);
407 static void bfin_gpio_mask_irq(unsigned int irq
)
409 set_gpio_maska(irq_to_gpio(irq
), 0);
412 static void bfin_gpio_unmask_irq(unsigned int irq
)
414 set_gpio_maska(irq_to_gpio(irq
), 1);
417 static unsigned int bfin_gpio_irq_startup(unsigned int irq
)
419 u32 gpionr
= irq_to_gpio(irq
);
421 if (__test_and_set_bit(gpionr
, gpio_enabled
))
422 bfin_gpio_irq_prepare(gpionr
);
424 bfin_gpio_unmask_irq(irq
);
429 static void bfin_gpio_irq_shutdown(unsigned int irq
)
431 u32 gpionr
= irq_to_gpio(irq
);
433 bfin_gpio_mask_irq(irq
);
434 __clear_bit(gpionr
, gpio_enabled
);
435 bfin_gpio_irq_free(gpionr
);
438 static int bfin_gpio_irq_type(unsigned int irq
, unsigned int type
)
442 u32 gpionr
= irq_to_gpio(irq
);
444 if (type
== IRQ_TYPE_PROBE
) {
445 /* only probe unenabled GPIO interrupt lines */
446 if (__test_bit(gpionr
, gpio_enabled
))
448 type
= IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
;
451 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
|
452 IRQ_TYPE_LEVEL_HIGH
| IRQ_TYPE_LEVEL_LOW
)) {
454 snprintf(buf
, 16, "gpio-irq%d", irq
);
455 ret
= bfin_gpio_irq_request(gpionr
, buf
);
459 if (__test_and_set_bit(gpionr
, gpio_enabled
))
460 bfin_gpio_irq_prepare(gpionr
);
463 __clear_bit(gpionr
, gpio_enabled
);
467 set_gpio_inen(gpionr
, 0);
468 set_gpio_dir(gpionr
, 0);
470 if ((type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
471 == (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
472 set_gpio_both(gpionr
, 1);
474 set_gpio_both(gpionr
, 0);
476 if ((type
& (IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_LEVEL_LOW
)))
477 set_gpio_polar(gpionr
, 1); /* low or falling edge denoted by one */
479 set_gpio_polar(gpionr
, 0); /* high or rising edge denoted by zero */
481 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
)) {
482 set_gpio_edge(gpionr
, 1);
483 set_gpio_inen(gpionr
, 1);
484 set_gpio_data(gpionr
, 0);
487 set_gpio_edge(gpionr
, 0);
488 set_gpio_inen(gpionr
, 1);
491 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
492 bfin_set_irq_handler(irq
, handle_edge_irq
);
494 bfin_set_irq_handler(irq
, handle_level_irq
);
500 int bfin_gpio_set_wake(unsigned int irq
, unsigned int state
)
502 unsigned gpio
= irq_to_gpio(irq
);
505 gpio_pm_wakeup_request(gpio
, PM_WAKE_IGNORE
);
507 gpio_pm_wakeup_free(gpio
);
513 static void bfin_demux_gpio_irq(unsigned int inta_irq
,
514 struct irq_desc
*desc
)
516 unsigned int i
, gpio
, mask
, irq
, search
= 0;
519 #if defined(CONFIG_BF53x)
524 # if defined(BF537_FAMILY) && !(defined(CONFIG_BFIN_MAC) || defined(CONFIG_BFIN_MAC_MODULE))
529 #elif defined(CONFIG_BF538) || defined(CONFIG_BF539)
533 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
543 #elif defined(CONFIG_BF561)
560 for (i
= 0; i
< MAX_BLACKFIN_GPIOS
; i
+= GPIO_BANKSIZE
) {
563 mask
= get_gpiop_data(i
) & get_gpiop_maska(i
);
567 desc
= irq_desc
+ irq
;
568 desc
->handle_irq(irq
, desc
);
575 gpio
= irq_to_gpio(irq
);
576 mask
= get_gpiop_data(gpio
) & get_gpiop_maska(gpio
);
580 desc
= irq_desc
+ irq
;
581 desc
->handle_irq(irq
, desc
);
590 #else /* CONFIG_BF54x */
592 #define NR_PINT_SYS_IRQS 4
593 #define NR_PINT_BITS 32
595 #define IRQ_NOT_AVAIL 0xFF
597 #define PINT_2_BANK(x) ((x) >> 5)
598 #define PINT_2_BIT(x) ((x) & 0x1F)
599 #define PINT_BIT(x) (1 << (PINT_2_BIT(x)))
601 static unsigned char irq2pint_lut
[NR_PINTS
];
602 static unsigned char pint2irq_lut
[NR_PINT_SYS_IRQS
* NR_PINT_BITS
];
605 unsigned int mask_set
;
606 unsigned int mask_clear
;
607 unsigned int request
;
609 unsigned int edge_set
;
610 unsigned int edge_clear
;
611 unsigned int invert_set
;
612 unsigned int invert_clear
;
613 unsigned int pinstate
;
617 static struct pin_int_t
*pint
[NR_PINT_SYS_IRQS
] = {
618 (struct pin_int_t
*)PINT0_MASK_SET
,
619 (struct pin_int_t
*)PINT1_MASK_SET
,
620 (struct pin_int_t
*)PINT2_MASK_SET
,
621 (struct pin_int_t
*)PINT3_MASK_SET
,
624 inline unsigned int get_irq_base(u32 bank
, u8 bmap
)
626 unsigned int irq_base
;
628 if (bank
< 2) { /*PA-PB */
629 irq_base
= IRQ_PA0
+ bmap
* 16;
631 irq_base
= IRQ_PC0
+ bmap
* 16;
637 /* Whenever PINTx_ASSIGN is altered init_pint_lut() must be executed! */
638 void init_pint_lut(void)
640 u16 bank
, bit
, irq_base
, bit_pos
;
644 memset(irq2pint_lut
, IRQ_NOT_AVAIL
, sizeof(irq2pint_lut
));
646 for (bank
= 0; bank
< NR_PINT_SYS_IRQS
; bank
++) {
648 pint_assign
= pint
[bank
]->assign
;
650 for (bit
= 0; bit
< NR_PINT_BITS
; bit
++) {
652 bmap
= (pint_assign
>> ((bit
/ 8) * 8)) & 0xFF;
654 irq_base
= get_irq_base(bank
, bmap
);
656 irq_base
+= (bit
% 8) + ((bit
/ 8) & 1 ? 8 : 0);
657 bit_pos
= bit
+ bank
* NR_PINT_BITS
;
659 pint2irq_lut
[bit_pos
] = irq_base
- SYS_IRQS
;
660 irq2pint_lut
[irq_base
- SYS_IRQS
] = bit_pos
;
665 static void bfin_gpio_ack_irq(unsigned int irq
)
667 struct irq_desc
*desc
= irq_desc
+ irq
;
668 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
669 u32 pintbit
= PINT_BIT(pint_val
);
670 u32 bank
= PINT_2_BANK(pint_val
);
672 if ((desc
->status
& IRQ_TYPE_SENSE_MASK
) == IRQ_TYPE_EDGE_BOTH
) {
673 if (pint
[bank
]->invert_set
& pintbit
)
674 pint
[bank
]->invert_clear
= pintbit
;
676 pint
[bank
]->invert_set
= pintbit
;
678 pint
[bank
]->request
= pintbit
;
682 static void bfin_gpio_mask_ack_irq(unsigned int irq
)
684 struct irq_desc
*desc
= irq_desc
+ irq
;
685 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
686 u32 pintbit
= PINT_BIT(pint_val
);
687 u32 bank
= PINT_2_BANK(pint_val
);
689 if ((desc
->status
& IRQ_TYPE_SENSE_MASK
) == IRQ_TYPE_EDGE_BOTH
) {
690 if (pint
[bank
]->invert_set
& pintbit
)
691 pint
[bank
]->invert_clear
= pintbit
;
693 pint
[bank
]->invert_set
= pintbit
;
696 pint
[bank
]->request
= pintbit
;
697 pint
[bank
]->mask_clear
= pintbit
;
700 static void bfin_gpio_mask_irq(unsigned int irq
)
702 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
704 pint
[PINT_2_BANK(pint_val
)]->mask_clear
= PINT_BIT(pint_val
);
707 static void bfin_gpio_unmask_irq(unsigned int irq
)
709 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
710 u32 pintbit
= PINT_BIT(pint_val
);
711 u32 bank
= PINT_2_BANK(pint_val
);
713 pint
[bank
]->request
= pintbit
;
714 pint
[bank
]->mask_set
= pintbit
;
717 static unsigned int bfin_gpio_irq_startup(unsigned int irq
)
719 u32 gpionr
= irq_to_gpio(irq
);
720 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
722 if (pint_val
== IRQ_NOT_AVAIL
) {
724 "GPIO IRQ %d :Not in PINT Assign table "
725 "Reconfigure Interrupt to Port Assignemt\n", irq
);
729 if (__test_and_set_bit(gpionr
, gpio_enabled
))
730 bfin_gpio_irq_prepare(gpionr
);
732 bfin_gpio_unmask_irq(irq
);
737 static void bfin_gpio_irq_shutdown(unsigned int irq
)
739 u32 gpionr
= irq_to_gpio(irq
);
741 bfin_gpio_mask_irq(irq
);
742 __clear_bit(gpionr
, gpio_enabled
);
743 bfin_gpio_irq_free(gpionr
);
746 static int bfin_gpio_irq_type(unsigned int irq
, unsigned int type
)
750 u32 gpionr
= irq_to_gpio(irq
);
751 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
752 u32 pintbit
= PINT_BIT(pint_val
);
753 u32 bank
= PINT_2_BANK(pint_val
);
755 if (pint_val
== IRQ_NOT_AVAIL
)
758 if (type
== IRQ_TYPE_PROBE
) {
759 /* only probe unenabled GPIO interrupt lines */
760 if (__test_bit(gpionr
, gpio_enabled
))
762 type
= IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
;
765 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
|
766 IRQ_TYPE_LEVEL_HIGH
| IRQ_TYPE_LEVEL_LOW
)) {
768 snprintf(buf
, 16, "gpio-irq%d", irq
);
769 ret
= bfin_gpio_irq_request(gpionr
, buf
);
773 if (__test_and_set_bit(gpionr
, gpio_enabled
))
774 bfin_gpio_irq_prepare(gpionr
);
777 __clear_bit(gpionr
, gpio_enabled
);
781 if ((type
& (IRQ_TYPE_EDGE_FALLING
| IRQ_TYPE_LEVEL_LOW
)))
782 pint
[bank
]->invert_set
= pintbit
; /* low or falling edge denoted by one */
784 pint
[bank
]->invert_clear
= pintbit
; /* high or rising edge denoted by zero */
786 if ((type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
))
787 == (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
)) {
788 if (gpio_get_value(gpionr
))
789 pint
[bank
]->invert_set
= pintbit
;
791 pint
[bank
]->invert_clear
= pintbit
;
794 if (type
& (IRQ_TYPE_EDGE_RISING
| IRQ_TYPE_EDGE_FALLING
)) {
795 pint
[bank
]->edge_set
= pintbit
;
796 bfin_set_irq_handler(irq
, handle_edge_irq
);
798 pint
[bank
]->edge_clear
= pintbit
;
799 bfin_set_irq_handler(irq
, handle_level_irq
);
806 u32 pint_saved_masks
[NR_PINT_SYS_IRQS
];
807 u32 pint_wakeup_masks
[NR_PINT_SYS_IRQS
];
809 int bfin_gpio_set_wake(unsigned int irq
, unsigned int state
)
812 u32 pint_val
= irq2pint_lut
[irq
- SYS_IRQS
];
813 u32 bank
= PINT_2_BANK(pint_val
);
814 u32 pintbit
= PINT_BIT(pint_val
);
818 pint_irq
= IRQ_PINT0
;
821 pint_irq
= IRQ_PINT2
;
824 pint_irq
= IRQ_PINT3
;
827 pint_irq
= IRQ_PINT1
;
833 bfin_internal_set_wake(pint_irq
, state
);
836 pint_wakeup_masks
[bank
] |= pintbit
;
838 pint_wakeup_masks
[bank
] &= ~pintbit
;
843 u32
bfin_pm_setup(void)
847 for (i
= 0; i
< NR_PINT_SYS_IRQS
; i
++) {
848 val
= pint
[i
]->mask_clear
;
849 pint_saved_masks
[i
] = val
;
850 if (val
^ pint_wakeup_masks
[i
]) {
851 pint
[i
]->mask_clear
= val
;
852 pint
[i
]->mask_set
= pint_wakeup_masks
[i
];
859 void bfin_pm_restore(void)
863 for (i
= 0; i
< NR_PINT_SYS_IRQS
; i
++) {
864 val
= pint_saved_masks
[i
];
865 if (val
^ pint_wakeup_masks
[i
]) {
866 pint
[i
]->mask_clear
= pint
[i
]->mask_clear
;
867 pint
[i
]->mask_set
= val
;
873 static void bfin_demux_gpio_irq(unsigned int inta_irq
,
874 struct irq_desc
*desc
)
896 pint_val
= bank
* NR_PINT_BITS
;
898 request
= pint
[bank
]->request
;
902 irq
= pint2irq_lut
[pint_val
] + SYS_IRQS
;
903 desc
= irq_desc
+ irq
;
904 desc
->handle_irq(irq
, desc
);
913 static struct irq_chip bfin_gpio_irqchip
= {
915 .ack
= bfin_gpio_ack_irq
,
916 .mask
= bfin_gpio_mask_irq
,
917 .mask_ack
= bfin_gpio_mask_ack_irq
,
918 .unmask
= bfin_gpio_unmask_irq
,
919 .disable
= bfin_gpio_mask_irq
,
920 .enable
= bfin_gpio_unmask_irq
,
921 .set_type
= bfin_gpio_irq_type
,
922 .startup
= bfin_gpio_irq_startup
,
923 .shutdown
= bfin_gpio_irq_shutdown
,
925 .set_wake
= bfin_gpio_set_wake
,
929 void __cpuinit
init_exception_vectors(void)
931 /* cannot program in software:
932 * evt0 - emulation (jtag)
935 bfin_write_EVT2(evt_nmi
);
936 bfin_write_EVT3(trap
);
937 bfin_write_EVT5(evt_ivhw
);
938 bfin_write_EVT6(evt_timer
);
939 bfin_write_EVT7(evt_evt7
);
940 bfin_write_EVT8(evt_evt8
);
941 bfin_write_EVT9(evt_evt9
);
942 bfin_write_EVT10(evt_evt10
);
943 bfin_write_EVT11(evt_evt11
);
944 bfin_write_EVT12(evt_evt12
);
945 bfin_write_EVT13(evt_evt13
);
946 bfin_write_EVT14(evt14_softirq
);
947 bfin_write_EVT15(evt_system_call
);
952 * This function should be called during kernel startup to initialize
953 * the BFin IRQ handling routines.
956 int __init
init_arch_irq(void)
959 unsigned long ilat
= 0;
960 /* Disable all the peripheral intrs - page 4-29 HW Ref manual */
961 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561) \
962 || defined(BF538_FAMILY) || defined(CONFIG_BF51x)
963 bfin_write_SIC_IMASK0(SIC_UNMASK_ALL
);
964 bfin_write_SIC_IMASK1(SIC_UNMASK_ALL
);
966 bfin_write_SIC_IMASK2(SIC_UNMASK_ALL
);
969 bfin_write_SICB_IMASK0(SIC_UNMASK_ALL
);
970 bfin_write_SICB_IMASK1(SIC_UNMASK_ALL
);
973 bfin_write_SIC_IMASK(SIC_UNMASK_ALL
);
978 #if (defined(CONFIG_BF537) || defined(CONFIG_BF536))
979 /* Clear EMAC Interrupt Status bits so we can demux it later */
980 bfin_write_EMAC_SYSTAT(-1);
984 # ifdef CONFIG_PINTx_REASSIGN
985 pint
[0]->assign
= CONFIG_PINT0_ASSIGN
;
986 pint
[1]->assign
= CONFIG_PINT1_ASSIGN
;
987 pint
[2]->assign
= CONFIG_PINT2_ASSIGN
;
988 pint
[3]->assign
= CONFIG_PINT3_ASSIGN
;
990 /* Whenever PINTx_ASSIGN is altered init_pint_lut() must be executed! */
994 for (irq
= 0; irq
<= SYS_IRQS
; irq
++) {
995 if (irq
<= IRQ_CORETMR
)
996 set_irq_chip(irq
, &bfin_core_irqchip
);
998 set_irq_chip(irq
, &bfin_internal_irqchip
);
1001 #if defined(CONFIG_BF53x)
1003 # if defined(BF537_FAMILY) && !(defined(CONFIG_BFIN_MAC) || defined(CONFIG_BFIN_MAC_MODULE))
1006 #elif defined(CONFIG_BF54x)
1011 #elif defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
1012 case IRQ_PORTF_INTA
:
1013 case IRQ_PORTG_INTA
:
1014 case IRQ_PORTH_INTA
:
1015 #elif defined(CONFIG_BF561)
1016 case IRQ_PROG0_INTA
:
1017 case IRQ_PROG1_INTA
:
1018 case IRQ_PROG2_INTA
:
1019 #elif defined(CONFIG_BF538) || defined(CONFIG_BF539)
1020 case IRQ_PORTF_INTA
:
1023 set_irq_chained_handler(irq
,
1024 bfin_demux_gpio_irq
);
1026 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
1027 case IRQ_GENERIC_ERROR
:
1028 set_irq_handler(irq
, bfin_demux_error_irq
);
1032 #ifdef CONFIG_TICK_SOURCE_SYSTMR0
1034 set_irq_handler(irq
, handle_percpu_irq
);
1040 set_irq_handler(irq
, handle_percpu_irq
);
1044 set_irq_handler(irq
, handle_simple_irq
);
1049 #ifdef BF537_GENERIC_ERROR_INT_DEMUX
1050 for (irq
= IRQ_PPI_ERROR
; irq
<= IRQ_UART1_ERROR
; irq
++)
1051 set_irq_chip_and_handler(irq
, &bfin_generic_error_irqchip
,
1055 /* if configured as edge, then will be changed to do_edge_IRQ */
1056 for (irq
= GPIO_IRQ_BASE
; irq
< NR_IRQS
; irq
++)
1057 set_irq_chip_and_handler(irq
, &bfin_gpio_irqchip
,
1061 bfin_write_IMASK(0);
1063 ilat
= bfin_read_ILAT();
1065 bfin_write_ILAT(ilat
);
1068 printk(KERN_INFO
"Configuring Blackfin Priority Driven Interrupts\n");
1069 /* IMASK=xxx is equivalent to STI xx or bfin_irq_flags=xx,
1070 * local_irq_enable()
1073 /* Therefore it's better to setup IARs before interrupts enabled */
1076 /* Enable interrupts IVG7-15 */
1077 bfin_irq_flags
|= IMASK_IVG15
|
1078 IMASK_IVG14
| IMASK_IVG13
| IMASK_IVG12
| IMASK_IVG11
|
1079 IMASK_IVG10
| IMASK_IVG9
| IMASK_IVG8
| IMASK_IVG7
| IMASK_IVGHW
;
1081 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561) \
1082 || defined(BF538_FAMILY) || defined(CONFIG_BF51x)
1083 bfin_write_SIC_IWR0(IWR_DISABLE_ALL
);
1084 #if defined(CONFIG_BF52x) || defined(CONFIG_BF51x)
1085 /* BF52x/BF51x system reset does not properly reset SIC_IWR1 which
1086 * will screw up the bootrom as it relies on MDMA0/1 waking it
1087 * up from IDLE instructions. See this report for more info:
1088 * http://blackfin.uclinux.org/gf/tracker/4323
1090 if (ANOMALY_05000435
)
1091 bfin_write_SIC_IWR1(IWR_ENABLE(10) | IWR_ENABLE(11));
1093 bfin_write_SIC_IWR1(IWR_DISABLE_ALL
);
1095 bfin_write_SIC_IWR1(IWR_DISABLE_ALL
);
1097 # ifdef CONFIG_BF54x
1098 bfin_write_SIC_IWR2(IWR_DISABLE_ALL
);
1101 bfin_write_SIC_IWR(IWR_DISABLE_ALL
);
1107 #ifdef CONFIG_DO_IRQ_L1
1108 __attribute__((l1_text
))
1110 void do_irq(int vec
, struct pt_regs
*fp
)
1112 if (vec
== EVT_IVTMR_P
) {
1115 struct ivgx
*ivg
= ivg7_13
[vec
- IVG7
].ifirst
;
1116 struct ivgx
*ivg_stop
= ivg7_13
[vec
- IVG7
].istop
;
1117 #if defined(CONFIG_BF54x) || defined(CONFIG_BF52x) || defined(CONFIG_BF561) \
1118 || defined(BF538_FAMILY) || defined(CONFIG_BF51x)
1119 unsigned long sic_status
[3];
1121 if (smp_processor_id()) {
1123 /* This will be optimized out in UP mode. */
1124 sic_status
[0] = bfin_read_SICB_ISR0() & bfin_read_SICB_IMASK0();
1125 sic_status
[1] = bfin_read_SICB_ISR1() & bfin_read_SICB_IMASK1();
1128 sic_status
[0] = bfin_read_SIC_ISR0() & bfin_read_SIC_IMASK0();
1129 sic_status
[1] = bfin_read_SIC_ISR1() & bfin_read_SIC_IMASK1();
1132 sic_status
[2] = bfin_read_SIC_ISR2() & bfin_read_SIC_IMASK2();
1135 if (ivg
>= ivg_stop
) {
1136 atomic_inc(&num_spurious
);
1139 if (sic_status
[(ivg
->irqno
- IVG7
) / 32] & ivg
->isrflag
)
1143 unsigned long sic_status
;
1145 sic_status
= bfin_read_SIC_IMASK() & bfin_read_SIC_ISR();
1148 if (ivg
>= ivg_stop
) {
1149 atomic_inc(&num_spurious
);
1151 } else if (sic_status
& ivg
->isrflag
)
1157 asm_do_IRQ(vec
, fp
);