← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-ti-omap4/precise-security

« back to all changes in this revision

Viewing changes to arch/m68k/q40/q40ints.c

  • Committer: Package Import Robot
  • Author(s): Paolo Pisati, Paolo Pisati
  • Date: 2011-12-06 15:56:07 UTC
  • Revision ID: package-import@ubuntu.com-20111206155607-pcf44kv5fmhk564f
Tags: 3.2.0-1401.1
[ Paolo Pisati ]

* Rebased on top of Ubuntu-3.2.0-3.8
* Tilt-tracking @ ef2487af4bb15bdd0689631774b5a5e3a59f74e2
* Delete debian.ti-omap4/control, it shoudln't be tracked
* Fix architecture spelling (s/armel/armhf/)
* [Config] Update configs following 3.2 import
* [Config] Fix compilation: disable CODA and ARCH_OMAP3
* [Config] Fix compilation: disable Ethernet Faraday
* Update series to precise

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/m68k/q40/q40ints.c
15
15
#include <linux/kernel.h>
16
16
#include <linux/errno.h>
17
17
#include <linux/interrupt.h>
 
18
#include <linux/irq.h>
18
19
 
19
20
#include <asm/ptrace.h>
20
21
#include <asm/system.h>
21
 
#include <asm/irq.h>
22
22
#include <asm/traps.h>
23
23
 
24
24
#include <asm/q40_master.h>
35
35
*/
36
36
 
37
37
static void q40_irq_handler(unsigned int, struct pt_regs *fp);
38
 
static void q40_enable_irq(unsigned int);
39
 
static void q40_disable_irq(unsigned int);
 
38
static void q40_irq_enable(struct irq_data *data);
 
39
static void q40_irq_disable(struct irq_data *data);
40
40
 
41
41
unsigned short q40_ablecount[35];
42
42
unsigned short q40_state[35];
43
43
 
44
 
static int q40_irq_startup(unsigned int irq)
 
44
static unsigned int q40_irq_startup(struct irq_data *data)
45
45
{
 
46
        unsigned int irq = data->irq;
 
47
 
46
48
        /* test for ISA ints not implemented by HW */
47
49
        switch (irq) {
48
50
        case 1: case 2: case 8: case 9:
49
51
        case 11: case 12: case 13:
50
52
                printk("%s: ISA IRQ %d not implemented by HW\n", __func__, irq);
51
 
                return -ENXIO;
 
53
                /* FIXME return -ENXIO; */
52
54
        }
53
55
        return 0;
54
56
}
55
57
 
56
 
static void q40_irq_shutdown(unsigned int irq)
 
58
static void q40_irq_shutdown(struct irq_data *data)
57
59
{
58
60
}
59
61
 
60
 
static struct irq_controller q40_irq_controller = {
 
62
static struct irq_chip q40_irq_chip = {
61
63
        .name           = "q40",
62
 
        .lock           = __SPIN_LOCK_UNLOCKED(q40_irq_controller.lock),
63
 
        .startup        = q40_irq_startup,
64
 
        .shutdown       = q40_irq_shutdown,
65
 
        .enable         = q40_enable_irq,
66
 
        .disable        = q40_disable_irq,
 
64
        .irq_startup    = q40_irq_startup,
 
65
        .irq_shutdown   = q40_irq_shutdown,
 
66
        .irq_enable     = q40_irq_enable,
 
67
        .irq_disable    = q40_irq_disable,
67
68
};
68
69
 
69
70
/*
81
82
 
82
83
void __init q40_init_IRQ(void)
83
84
{
84
 
        m68k_setup_irq_controller(&q40_irq_controller, 1, Q40_IRQ_MAX);
 
85
        m68k_setup_irq_controller(&q40_irq_chip, handle_simple_irq, 1,
 
86
                                  Q40_IRQ_MAX);
85
87
 
86
88
        /* setup handler for ISA ints */
87
89
        m68k_setup_auto_interrupt(q40_irq_handler);
88
90
 
89
 
        m68k_irq_startup(IRQ_AUTO_2);
90
 
        m68k_irq_startup(IRQ_AUTO_4);
 
91
        m68k_irq_startup_irq(IRQ_AUTO_2);
 
92
        m68k_irq_startup_irq(IRQ_AUTO_4);
91
93
 
92
94
        /* now enable some ints.. */
93
95
        master_outb(1, EXT_ENABLE_REG);  /* ISA IRQ 5-15 */
218
220
        switch (irq) {
219
221
        case 4:
220
222
        case 6:
221
 
                __m68k_handle_int(Q40_IRQ_SAMPLE, fp);
 
223
                do_IRQ(Q40_IRQ_SAMPLE, fp);
222
224
                return;
223
225
        }
224
226
        if (mir & Q40_IRQ_FRAME_MASK) {
225
 
                __m68k_handle_int(Q40_IRQ_FRAME, fp);
 
227
                do_IRQ(Q40_IRQ_FRAME, fp);
226
228
                master_outb(-1, FRAME_CLEAR_REG);
227
229
        }
228
230
        if ((mir & Q40_IRQ_SER_MASK) || (mir & Q40_IRQ_EXT_MASK)) {
257
259
                                        goto iirq;
258
260
                                }
259
261
                                q40_state[irq] |= IRQ_INPROGRESS;
260
 
                                __m68k_handle_int(irq, fp);
 
262
                                do_IRQ(irq, fp);
261
263
                                q40_state[irq] &= ~IRQ_INPROGRESS;
262
264
 
263
265
                                /* naively enable everything, if that fails than    */
288
290
        mir = master_inb(IIRQ_REG);
289
291
        /* should test whether keyboard irq is really enabled, doing it in defhand */
290
292
        if (mir & Q40_IRQ_KEYB_MASK)
291
 
                __m68k_handle_int(Q40_IRQ_KEYBOARD, fp);
 
293
                do_IRQ(Q40_IRQ_KEYBOARD, fp);
292
294
 
293
295
        return;
294
296
}
295
297
 
296
 
void q40_enable_irq(unsigned int irq)
 
298
void q40_irq_enable(struct irq_data *data)
297
299
{
 
300
        unsigned int irq = data->irq;
 
301
 
298
302
        if (irq >= 5 && irq <= 15) {
299
303
                mext_disabled--;
300
304
                if (mext_disabled > 0)
301
 
                        printk("q40_enable_irq : nested disable/enable\n");
 
305
                        printk("q40_irq_enable : nested disable/enable\n");
302
306
                if (mext_disabled == 0)
303
307
                        master_outb(1, EXT_ENABLE_REG);
304
308
        }
305
309
}
306
310
 
307
311
 
308
 
void q40_disable_irq(unsigned int irq)
 
312
void q40_irq_disable(struct irq_data *data)
309
313
{
 
314
        unsigned int irq = data->irq;
 
315
 
310
316
        /* disable ISA iqs : only do something if the driver has been
311
317
         * verified to be Q40 "compatible" - right now IDE, NE2K
312
318
         * Any driver should not attempt to sleep across disable_irq !!
319
325
                        printk("disable_irq nesting count %d\n",mext_disabled);
320
326
        }
321
327
}
322
 
 
323
 
unsigned long q40_probe_irq_on(void)
324
 
{
325
 
        printk("irq probing not working - reconfigure the driver to avoid this\n");
326
 
        return -1;
327
 
}
328
 
int q40_probe_irq_off(unsigned long irqs)
329
 
{
330
 
        return -1;
331
 
}