Pull thinkpad-2.6.24 into release branch
[linux-2.6] / arch / ppc / syslib / i8259.c
1 /*
2  * i8259 interrupt controller driver.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version
7  * 2 of the License, or (at your option) any later version.
8  */
9 #include <linux/init.h>
10 #include <linux/ioport.h>
11 #include <linux/interrupt.h>
12 #include <asm/io.h>
13 #include <asm/i8259.h>
14
15 static volatile void __iomem *pci_intack; /* RO, gives us the irq vector */
16
17 static unsigned char cached_8259[2] = { 0xff, 0xff };
18 #define cached_A1 (cached_8259[0])
19 #define cached_21 (cached_8259[1])
20
21 static DEFINE_SPINLOCK(i8259_lock);
22
23 static int i8259_pic_irq_offset;
24
25 /*
26  * Acknowledge the IRQ using either the PCI host bridge's interrupt
27  * acknowledge feature or poll.  How i8259_init() is called determines
28  * which is called.  It should be noted that polling is broken on some
29  * IBM and Motorola PReP boxes so we must use the int-ack feature on them.
30  */
31 int i8259_irq(void)
32 {
33         int irq;
34
35         spin_lock(&i8259_lock);
36
37         /* Either int-ack or poll for the IRQ */
38         if (pci_intack)
39                 irq = readb(pci_intack);
40         else {
41                 /* Perform an interrupt acknowledge cycle on controller 1. */
42                 outb(0x0C, 0x20);               /* prepare for poll */
43                 irq = inb(0x20) & 7;
44                 if (irq == 2 ) {
45                         /*
46                          * Interrupt is cascaded so perform interrupt
47                          * acknowledge on controller 2.
48                          */
49                         outb(0x0C, 0xA0);       /* prepare for poll */
50                         irq = (inb(0xA0) & 7) + 8;
51                 }
52         }
53
54         if (irq == 7) {
55                 /*
56                  * This may be a spurious interrupt.
57                  *
58                  * Read the interrupt status register (ISR). If the most
59                  * significant bit is not set then there is no valid
60                  * interrupt.
61                  */
62                 if (!pci_intack)
63                         outb(0x0B, 0x20);       /* ISR register */
64                 if(~inb(0x20) & 0x80)
65                         irq = -1;
66         }
67
68         spin_unlock(&i8259_lock);
69         return irq + i8259_pic_irq_offset;
70 }
71
72 static void i8259_mask_and_ack_irq(unsigned int irq_nr)
73 {
74         unsigned long flags;
75
76         spin_lock_irqsave(&i8259_lock, flags);
77         irq_nr -= i8259_pic_irq_offset;
78         if (irq_nr > 7) {
79                 cached_A1 |= 1 << (irq_nr-8);
80                 inb(0xA1);      /* DUMMY */
81                 outb(cached_A1, 0xA1);
82                 outb(0x20, 0xA0);       /* Non-specific EOI */
83                 outb(0x20, 0x20);       /* Non-specific EOI to cascade */
84         } else {
85                 cached_21 |= 1 << irq_nr;
86                 inb(0x21);      /* DUMMY */
87                 outb(cached_21, 0x21);
88                 outb(0x20, 0x20);       /* Non-specific EOI */
89         }
90         spin_unlock_irqrestore(&i8259_lock, flags);
91 }
92
93 static void i8259_set_irq_mask(int irq_nr)
94 {
95         outb(cached_A1,0xA1);
96         outb(cached_21,0x21);
97 }
98
99 static void i8259_mask_irq(unsigned int irq_nr)
100 {
101         unsigned long flags;
102
103         spin_lock_irqsave(&i8259_lock, flags);
104         irq_nr -= i8259_pic_irq_offset;
105         if (irq_nr < 8)
106                 cached_21 |= 1 << irq_nr;
107         else
108                 cached_A1 |= 1 << (irq_nr-8);
109         i8259_set_irq_mask(irq_nr);
110         spin_unlock_irqrestore(&i8259_lock, flags);
111 }
112
113 static void i8259_unmask_irq(unsigned int irq_nr)
114 {
115         unsigned long flags;
116
117         spin_lock_irqsave(&i8259_lock, flags);
118         irq_nr -= i8259_pic_irq_offset;
119         if (irq_nr < 8)
120                 cached_21 &= ~(1 << irq_nr);
121         else
122                 cached_A1 &= ~(1 << (irq_nr-8));
123         i8259_set_irq_mask(irq_nr);
124         spin_unlock_irqrestore(&i8259_lock, flags);
125 }
126
127 static struct irq_chip i8259_pic = {
128         .typename       = " i8259    ",
129         .mask           = i8259_mask_irq,
130         .disable        = i8259_mask_irq,
131         .unmask         = i8259_unmask_irq,
132         .mask_ack       = i8259_mask_and_ack_irq,
133 };
134
135 static struct resource pic1_iores = {
136         .name = "8259 (master)",
137         .start = 0x20,
138         .end = 0x21,
139         .flags = IORESOURCE_BUSY,
140 };
141
142 static struct resource pic2_iores = {
143         .name = "8259 (slave)",
144         .start = 0xa0,
145         .end = 0xa1,
146         .flags = IORESOURCE_BUSY,
147 };
148
149 static struct resource pic_edgectrl_iores = {
150         .name = "8259 edge control",
151         .start = 0x4d0,
152         .end = 0x4d1,
153         .flags = IORESOURCE_BUSY,
154 };
155
156 static struct irqaction i8259_irqaction = {
157         .handler = no_action,
158         .flags = IRQF_DISABLED,
159         .mask = CPU_MASK_NONE,
160         .name = "82c59 secondary cascade",
161 };
162
163 /*
164  * i8259_init()
165  * intack_addr - PCI interrupt acknowledge (real) address which will return
166  *               the active irq from the 8259
167  */
168 void __init i8259_init(unsigned long intack_addr, int offset)
169 {
170         unsigned long flags;
171         int i;
172
173         spin_lock_irqsave(&i8259_lock, flags);
174         i8259_pic_irq_offset = offset;
175
176         /* init master interrupt controller */
177         outb(0x11, 0x20); /* Start init sequence */
178         outb(0x00, 0x21); /* Vector base */
179         outb(0x04, 0x21); /* edge tiggered, Cascade (slave) on IRQ2 */
180         outb(0x01, 0x21); /* Select 8086 mode */
181
182         /* init slave interrupt controller */
183         outb(0x11, 0xA0); /* Start init sequence */
184         outb(0x08, 0xA1); /* Vector base */
185         outb(0x02, 0xA1); /* edge triggered, Cascade (slave) on IRQ2 */
186         outb(0x01, 0xA1); /* Select 8086 mode */
187
188         /* always read ISR */
189         outb(0x0B, 0x20);
190         outb(0x0B, 0xA0);
191
192         /* Mask all interrupts */
193         outb(cached_A1, 0xA1);
194         outb(cached_21, 0x21);
195
196         spin_unlock_irqrestore(&i8259_lock, flags);
197
198         for (i = 0; i < NUM_ISA_INTERRUPTS; ++i) {
199                 set_irq_chip_and_handler(offset + i, &i8259_pic,
200                                          handle_level_irq);
201                 irq_desc[offset + i].status |= IRQ_LEVEL;
202         }
203
204         /* reserve our resources */
205         setup_irq(offset + 2, &i8259_irqaction);
206         request_resource(&ioport_resource, &pic1_iores);
207         request_resource(&ioport_resource, &pic2_iores);
208         request_resource(&ioport_resource, &pic_edgectrl_iores);
209
210         if (intack_addr != 0)
211                 pci_intack = ioremap(intack_addr, 1);
212
213 }