Blame view
arch/m68k/q40/q40ints.c
7.89 KB
1da177e4c
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
/* * arch/m68k/q40/q40ints.c * * Copyright (C) 1999,2001 Richard Zidlicky * * This file is subject to the terms and conditions of the GNU General Public * License. See the file COPYING in the main directory of this archive * for more details. * * .. used to be loosely based on bvme6000ints.c * */ #include <linux/types.h> #include <linux/kernel.h> #include <linux/errno.h> |
1da177e4c
|
17 |
#include <linux/interrupt.h> |
a03010ed9
|
18 |
#include <linux/irq.h> |
1da177e4c
|
19 |
|
1da177e4c
|
20 |
#include <asm/ptrace.h> |
1da177e4c
|
21 22 23 24 25 26 27 28 29 30 31 32 33 34 |
#include <asm/traps.h> #include <asm/q40_master.h> #include <asm/q40ints.h> /* * Q40 IRQs are defined as follows: * 3,4,5,6,7,10,11,14,15 : ISA dev IRQs * 16-31: reserved * 32 : keyboard int * 33 : frame int (50/200 Hz periodic timer) * 34 : sample int (10/20 KHz periodic timer) * */ |
77dda339e
|
35 |
static void q40_irq_handler(unsigned int, struct pt_regs *fp); |
e8abf5e73
|
36 37 |
static void q40_irq_enable(struct irq_data *data); static void q40_irq_disable(struct irq_data *data); |
1da177e4c
|
38 |
|
77dda339e
|
39 40 |
unsigned short q40_ablecount[35]; unsigned short q40_state[35]; |
1da177e4c
|
41 |
|
e8abf5e73
|
42 |
static unsigned int q40_irq_startup(struct irq_data *data) |
77dda339e
|
43 |
{ |
e8abf5e73
|
44 |
unsigned int irq = data->irq; |
77dda339e
|
45 46 47 48 |
/* test for ISA ints not implemented by HW */ switch (irq) { case 1: case 2: case 8: case 9: case 11: case 12: case 13: |
f85e7cdc3
|
49 50 |
printk("%s: ISA IRQ %d not implemented by HW ", __func__, irq); |
c288bf253
|
51 |
/* FIXME return -ENXIO; */ |
77dda339e
|
52 53 54 |
} return 0; } |
1da177e4c
|
55 |
|
e8abf5e73
|
56 |
static void q40_irq_shutdown(struct irq_data *data) |
77dda339e
|
57 58 |
{ } |
1da177e4c
|
59 |
|
c288bf253
|
60 |
static struct irq_chip q40_irq_chip = { |
77dda339e
|
61 |
.name = "q40", |
c288bf253
|
62 63 |
.irq_startup = q40_irq_startup, .irq_shutdown = q40_irq_shutdown, |
e8abf5e73
|
64 65 |
.irq_enable = q40_irq_enable, .irq_disable = q40_irq_disable, |
77dda339e
|
66 |
}; |
1da177e4c
|
67 68 69 70 71 72 73 74 75 76 77 |
/* * void q40_init_IRQ (void) * * Parameters: None * * Returns: Nothing * * This function is called during kernel startup to initialize * the q40 IRQ handling routines. */ |
77dda339e
|
78 |
static int disabled; |
1da177e4c
|
79 |
|
66a3f820c
|
80 |
void __init q40_init_IRQ(void) |
1da177e4c
|
81 |
{ |
edb347256
|
82 83 |
m68k_setup_irq_controller(&q40_irq_chip, handle_simple_irq, 1, Q40_IRQ_MAX); |
1da177e4c
|
84 85 |
/* setup handler for ISA ints */ |
77dda339e
|
86 |
m68k_setup_auto_interrupt(q40_irq_handler); |
e8abf5e73
|
87 88 |
m68k_irq_startup_irq(IRQ_AUTO_2); m68k_irq_startup_irq(IRQ_AUTO_4); |
1da177e4c
|
89 90 |
/* now enable some ints.. */ |
77dda339e
|
91 |
master_outb(1, EXT_ENABLE_REG); /* ISA IRQ 5-15 */ |
1da177e4c
|
92 93 |
/* make sure keyboard IRQ is disabled */ |
77dda339e
|
94 |
master_outb(0, KEY_IRQ_ENABLE_REG); |
1da177e4c
|
95 |
} |
1da177e4c
|
96 97 98 |
/* * this stuff doesn't really belong here.. |
77dda339e
|
99 |
*/ |
1da177e4c
|
100 101 102 103 104 105 106 107 |
int ql_ticks; /* 200Hz ticks since last jiffie */ static int sound_ticks; #define SVOL 45 void q40_mksound(unsigned int hz, unsigned int ticks) { |
77dda339e
|
108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 |
/* for now ignore hz, except that hz==0 switches off sound */ /* simply alternate the ampl (128-SVOL)-(128+SVOL)-..-.. at 200Hz */ if (hz == 0) { if (sound_ticks) sound_ticks = 1; *DAC_LEFT = 128; *DAC_RIGHT = 128; return; } /* sound itself is done in q40_timer_int */ if (sound_ticks == 0) sound_ticks = 1000; /* pretty long beep */ sound_ticks = ticks << 1; |
1da177e4c
|
123 |
} |
40220c1a1
|
124 |
static irq_handler_t q40_timer_routine; |
1da177e4c
|
125 |
|
2850bc273
|
126 |
static irqreturn_t q40_timer_int (int irq, void * dev) |
1da177e4c
|
127 |
{ |
77dda339e
|
128 129 130 131 132 133 134 135 136 |
ql_ticks = ql_ticks ? 0 : 1; if (sound_ticks) { unsigned char sval=(sound_ticks & 1) ? 128-SVOL : 128+SVOL; sound_ticks--; *DAC_LEFT=sval; *DAC_RIGHT=sval; } if (!ql_ticks) |
2850bc273
|
137 |
q40_timer_routine(irq, dev); |
77dda339e
|
138 |
return IRQ_HANDLED; |
1da177e4c
|
139 |
} |
40220c1a1
|
140 |
void q40_sched_init (irq_handler_t timer_routine) |
1da177e4c
|
141 |
{ |
77dda339e
|
142 |
int timer_irq; |
1da177e4c
|
143 |
|
77dda339e
|
144 145 |
q40_timer_routine = timer_routine; timer_irq = Q40_IRQ_FRAME; |
1da177e4c
|
146 |
|
77dda339e
|
147 |
if (request_irq(timer_irq, q40_timer_int, 0, |
1da177e4c
|
148 |
"timer", q40_timer_int)) |
77dda339e
|
149 |
panic("Couldn't register timer int"); |
1da177e4c
|
150 |
|
77dda339e
|
151 152 |
master_outb(-1, FRAME_CLEAR_REG); master_outb( 1, FRAME_RATE_REG); |
1da177e4c
|
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 |
} /* * tables to translate bits into IRQ numbers * it is a good idea to order the entries by priority * */ struct IRQ_TABLE{ unsigned mask; int irq ;}; #if 0 static struct IRQ_TABLE iirqs[]={ {Q40_IRQ_FRAME_MASK,Q40_IRQ_FRAME}, {Q40_IRQ_KEYB_MASK,Q40_IRQ_KEYBOARD}, {0,0}}; #endif static struct IRQ_TABLE eirqs[] = { { .mask = Q40_IRQ3_MASK, .irq = 3 }, /* ser 1 */ { .mask = Q40_IRQ4_MASK, .irq = 4 }, /* ser 2 */ { .mask = Q40_IRQ14_MASK, .irq = 14 }, /* IDE 1 */ { .mask = Q40_IRQ15_MASK, .irq = 15 }, /* IDE 2 */ { .mask = Q40_IRQ6_MASK, .irq = 6 }, /* floppy, handled elsewhere */ { .mask = Q40_IRQ7_MASK, .irq = 7 }, /* par */ { .mask = Q40_IRQ5_MASK, .irq = 5 }, { .mask = Q40_IRQ10_MASK, .irq = 10 }, {0,0} }; /* complain only this many times about spurious ints : */ |
0c79cf6af
|
182 |
static int ccleirq=60; /* ISA dev IRQs*/ |
1da177e4c
|
183 184 185 186 187 188 189 190 191 192 193 194 195 |
/*static int cclirq=60;*/ /* internal */ /* FIXME: add shared ints,mask,unmask,probing.... */ #define IRQ_INPROGRESS 1 /*static unsigned short saved_mask;*/ //static int do_tint=0; #define DEBUG_Q40INT /*#define IP_USE_DISABLE *//* would be nice, but crashes ???? */ static int mext_disabled=0; /* ext irq disabled by master chip? */ static int aliased_irq=0; /* how many times inside handler ?*/ |
77dda339e
|
196 197 |
/* got interrupt, dispatch to ISA or keyboard/timer IRQs */ static void q40_irq_handler(unsigned int irq, struct pt_regs *fp) |
1da177e4c
|
198 |
{ |
77dda339e
|
199 200 |
unsigned mir, mer; int i; |
1da177e4c
|
201 202 |
//repeat: |
77dda339e
|
203 204 205 206 207 208 209 210 211 212 213 |
mir = master_inb(IIRQ_REG); #ifdef CONFIG_BLK_DEV_FD if ((mir & Q40_IRQ_EXT_MASK) && (master_inb(EIRQ_REG) & Q40_IRQ6_MASK)) { floppy_hardint(); return; } #endif switch (irq) { case 4: case 6: |
1425df87c
|
214 |
do_IRQ(Q40_IRQ_SAMPLE, fp); |
77dda339e
|
215 216 217 |
return; } if (mir & Q40_IRQ_FRAME_MASK) { |
1425df87c
|
218 |
do_IRQ(Q40_IRQ_FRAME, fp); |
77dda339e
|
219 220 221 222 223 224 225 |
master_outb(-1, FRAME_CLEAR_REG); } if ((mir & Q40_IRQ_SER_MASK) || (mir & Q40_IRQ_EXT_MASK)) { mer = master_inb(EIRQ_REG); for (i = 0; eirqs[i].mask; i++) { if (mer & eirqs[i].mask) { irq = eirqs[i].irq; |
1da177e4c
|
226 227 228 229 |
/* * There is a little mess wrt which IRQ really caused this irq request. The * main problem is that IIRQ_REG and EIRQ_REG reflect the state when they * are read - which is long after the request came in. In theory IRQs should |
0c79cf6af
|
230 |
* not just go away but they occasionally do |
1da177e4c
|
231 |
*/ |
77dda339e
|
232 233 234 235 236 237 238 |
if (irq > 4 && irq <= 15 && mext_disabled) { /*aliased_irq++;*/ goto iirq; } if (q40_state[irq] & IRQ_INPROGRESS) { /* some handlers do local_irq_enable() for irq latency reasons, */ /* however reentering an active irq handler is not permitted */ |
1da177e4c
|
239 |
#ifdef IP_USE_DISABLE |
77dda339e
|
240 241 242 243 |
/* in theory this is the better way to do it because it still */ /* lets through eg the serial irqs, unfortunately it crashes */ disable_irq(irq); disabled = 1; |
1da177e4c
|
244 |
#else |
77dda339e
|
245 246 247 248 249 |
/*printk("IRQ_INPROGRESS detected for irq %d, disabling - %s disabled ", irq, disabled ? "already" : "not yet"); */ fp->sr = (((fp->sr) & (~0x700))+0x200); disabled = 1; |
1da177e4c
|
250 |
#endif |
77dda339e
|
251 252 253 |
goto iirq; } q40_state[irq] |= IRQ_INPROGRESS; |
1425df87c
|
254 |
do_IRQ(irq, fp); |
77dda339e
|
255 256 257 258 259 260 261 |
q40_state[irq] &= ~IRQ_INPROGRESS; /* naively enable everything, if that fails than */ /* this function will be reentered immediately thus */ /* getting another chance to disable the IRQ */ if (disabled) { |
1da177e4c
|
262 |
#ifdef IP_USE_DISABLE |
77dda339e
|
263 264 265 266 |
if (irq > 4) { disabled = 0; enable_irq(irq); } |
1da177e4c
|
267 |
#else |
77dda339e
|
268 269 270 |
disabled = 0; /*printk("reenabling irq %d ", irq); */ |
1da177e4c
|
271 |
#endif |
77dda339e
|
272 |
} |
1da177e4c
|
273 |
// used to do 'goto repeat;' here, this delayed bh processing too long |
77dda339e
|
274 275 276 277 278 279 280 281 |
return; } } if (mer && ccleirq > 0 && !aliased_irq) { printk("ISA interrupt from unknown source? EIRQ_REG = %x ",mer); ccleirq--; } |
1da177e4c
|
282 |
} |
77dda339e
|
283 284 285 286 |
iirq: mir = master_inb(IIRQ_REG); /* should test whether keyboard irq is really enabled, doing it in defhand */ if (mir & Q40_IRQ_KEYB_MASK) |
1425df87c
|
287 |
do_IRQ(Q40_IRQ_KEYBOARD, fp); |
1da177e4c
|
288 |
|
77dda339e
|
289 |
return; |
1da177e4c
|
290 |
} |
1da177e4c
|
291 |
|
e8abf5e73
|
292 |
void q40_irq_enable(struct irq_data *data) |
1da177e4c
|
293 |
{ |
e8abf5e73
|
294 |
unsigned int irq = data->irq; |
77dda339e
|
295 296 297 |
if (irq >= 5 && irq <= 15) { mext_disabled--; if (mext_disabled > 0) |
e8abf5e73
|
298 299 |
printk("q40_irq_enable : nested disable/enable "); |
77dda339e
|
300 301 302 |
if (mext_disabled == 0) master_outb(1, EXT_ENABLE_REG); } |
1da177e4c
|
303 |
} |
e8abf5e73
|
304 |
void q40_irq_disable(struct irq_data *data) |
1da177e4c
|
305 |
{ |
e8abf5e73
|
306 |
unsigned int irq = data->irq; |
77dda339e
|
307 308 309 310 311 312 313 314 315 316 317 318 |
/* disable ISA iqs : only do something if the driver has been * verified to be Q40 "compatible" - right now IDE, NE2K * Any driver should not attempt to sleep across disable_irq !! */ if (irq >= 5 && irq <= 15) { master_outb(0, EXT_ENABLE_REG); mext_disabled++; if (mext_disabled > 1) printk("disable_irq nesting count %d ",mext_disabled); } |
1da177e4c
|
319 |
} |