2 * QEMU 8259 interrupt controller emulation
4 * Copyright (c) 2003-2004 Fabrice Bellard
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 #include "qemu/osdep.h"
26 #include "hw/intc/i8259.h"
28 #include "hw/isa/isa.h"
29 #include "qemu/timer.h"
31 #include "hw/isa/i8259_internal.h"
33 #include "qom/object.h"
38 //#define DEBUG_IRQ_LATENCY
40 #define TYPE_I8259 "isa-i8259"
41 typedef struct PICClass PICClass
;
42 DECLARE_CLASS_CHECKERS(PICClass
, PIC
,
47 * @parent_realize: The parent's realizefn.
50 PICCommonClass parent_class
;
52 DeviceRealize parent_realize
;
55 #ifdef DEBUG_IRQ_LATENCY
56 static int64_t irq_time
[16];
58 PICCommonState
*isa_pic
;
59 static PICCommonState
*slave_pic
;
61 /* return the highest priority found in mask (highest = smallest
62 number). Return 8 if no irq */
63 static int get_priority(PICCommonState
*s
, int mask
)
71 while ((mask
& (1 << ((priority
+ s
->priority_add
) & 7))) == 0) {
77 /* return the pic wanted interrupt. return -1 if none */
78 static int pic_get_irq(PICCommonState
*s
)
80 int mask
, cur_priority
, priority
;
82 mask
= s
->irr
& ~s
->imr
;
83 priority
= get_priority(s
, mask
);
87 /* compute current priority. If special fully nested mode on the
88 master, the IRQ coming from the slave is not taken into account
89 for the priority computation. */
91 if (s
->special_mask
) {
94 if (s
->special_fully_nested_mode
&& s
->master
) {
97 cur_priority
= get_priority(s
, mask
);
98 if (priority
< cur_priority
) {
99 /* higher priority found: an irq should be generated */
100 return (priority
+ s
->priority_add
) & 7;
106 /* Update INT output. Must be called every time the output may have changed. */
107 static void pic_update_irq(PICCommonState
*s
)
111 irq
= pic_get_irq(s
);
113 trace_pic_update_irq(s
->master
, s
->imr
, s
->irr
, s
->priority_add
);
114 qemu_irq_raise(s
->int_out
[0]);
116 qemu_irq_lower(s
->int_out
[0]);
120 /* set irq level. If an edge is detected, then the IRR is set to 1 */
121 static void pic_set_irq(void *opaque
, int irq
, int level
)
123 PICCommonState
*s
= opaque
;
125 int irq_index
= s
->master
? irq
: irq
+ 8;
127 trace_pic_set_irq(s
->master
, irq
, level
);
128 pic_stat_update_irq(irq_index
, level
);
130 #ifdef DEBUG_IRQ_LATENCY
132 irq_time
[irq_index
] = qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
);
136 if (s
->ltim
|| (s
->elcr
& mask
)) {
137 /* level triggered */
143 s
->last_irr
&= ~mask
;
148 if ((s
->last_irr
& mask
) == 0) {
153 s
->last_irr
&= ~mask
;
159 /* acknowledge interrupt 'irq' */
160 static void pic_intack(PICCommonState
*s
, int irq
)
163 if (s
->rotate_on_auto_eoi
) {
164 s
->priority_add
= (irq
+ 1) & 7;
167 s
->isr
|= (1 << irq
);
169 /* We don't clear a level sensitive interrupt here */
170 if (!s
->ltim
&& !(s
->elcr
& (1 << irq
))) {
171 s
->irr
&= ~(1 << irq
);
176 int pic_read_irq(PICCommonState
*s
)
180 irq
= pic_get_irq(s
);
185 irq2
= pic_get_irq(slave_pic
);
187 pic_intack(slave_pic
, irq2
);
189 /* spurious IRQ on slave controller */
192 intno
= slave_pic
->irq_base
+ irq2
;
196 intno
= s
->irq_base
+ irq
;
200 /* spurious IRQ on host controller */
202 intno
= s
->irq_base
+ irq
;
205 #ifdef DEBUG_IRQ_LATENCY
206 printf("IRQ%d latency=%0.3fus\n",
208 (double)(qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL
) -
209 irq_time
[irq
]) * 1000000.0 / NANOSECONDS_PER_SECOND
);
212 trace_pic_interrupt(irq
, intno
);
216 static void pic_init_reset(PICCommonState
*s
)
222 static void pic_reset(DeviceState
*dev
)
224 PICCommonState
*s
= PIC_COMMON(dev
);
231 static void pic_ioport_write(void *opaque
, hwaddr addr64
,
232 uint64_t val64
, unsigned size
)
234 PICCommonState
*s
= opaque
;
235 uint32_t addr
= addr64
;
236 uint32_t val
= val64
;
237 int priority
, cmd
, irq
;
239 trace_pic_ioport_write(s
->master
, addr
, val
);
246 s
->single_mode
= val
& 2;
248 } else if (val
& 0x08) {
253 s
->read_reg_select
= val
& 1;
256 s
->special_mask
= (val
>> 5) & 1;
263 s
->rotate_on_auto_eoi
= cmd
>> 2;
265 case 1: /* end of interrupt */
267 priority
= get_priority(s
, s
->isr
);
269 irq
= (priority
+ s
->priority_add
) & 7;
270 s
->isr
&= ~(1 << irq
);
272 s
->priority_add
= (irq
+ 1) & 7;
279 s
->isr
&= ~(1 << irq
);
283 s
->priority_add
= (val
+ 1) & 7;
288 s
->isr
&= ~(1 << irq
);
289 s
->priority_add
= (irq
+ 1) & 7;
298 switch (s
->init_state
) {
305 s
->irq_base
= val
& 0xf8;
306 s
->init_state
= s
->single_mode
? (s
->init4
? 3 : 0) : 2;
316 s
->special_fully_nested_mode
= (val
>> 4) & 1;
317 s
->auto_eoi
= (val
>> 1) & 1;
324 static uint64_t pic_ioport_read(void *opaque
, hwaddr addr
,
327 PICCommonState
*s
= opaque
;
331 ret
= pic_get_irq(s
);
341 if (s
->read_reg_select
) {
350 trace_pic_ioport_read(s
->master
, addr
, ret
);
354 int pic_get_output(PICCommonState
*s
)
356 return (pic_get_irq(s
) >= 0);
359 static void elcr_ioport_write(void *opaque
, hwaddr addr
,
360 uint64_t val
, unsigned size
)
362 PICCommonState
*s
= opaque
;
363 s
->elcr
= val
& s
->elcr_mask
;
366 static uint64_t elcr_ioport_read(void *opaque
, hwaddr addr
,
369 PICCommonState
*s
= opaque
;
373 static const MemoryRegionOps pic_base_ioport_ops
= {
374 .read
= pic_ioport_read
,
375 .write
= pic_ioport_write
,
377 .min_access_size
= 1,
378 .max_access_size
= 1,
382 static const MemoryRegionOps pic_elcr_ioport_ops
= {
383 .read
= elcr_ioport_read
,
384 .write
= elcr_ioport_write
,
386 .min_access_size
= 1,
387 .max_access_size
= 1,
391 static void pic_realize(DeviceState
*dev
, Error
**errp
)
393 PICCommonState
*s
= PIC_COMMON(dev
);
394 PICClass
*pc
= PIC_GET_CLASS(dev
);
396 memory_region_init_io(&s
->base_io
, OBJECT(s
), &pic_base_ioport_ops
, s
,
398 memory_region_init_io(&s
->elcr_io
, OBJECT(s
), &pic_elcr_ioport_ops
, s
,
401 qdev_init_gpio_out(dev
, s
->int_out
, ARRAY_SIZE(s
->int_out
));
402 qdev_init_gpio_in(dev
, pic_set_irq
, 8);
404 pc
->parent_realize(dev
, errp
);
407 qemu_irq
*i8259_init(ISABus
*bus
, qemu_irq parent_irq_in
)
414 irq_set
= g_new0(qemu_irq
, ISA_NUM_IRQS
);
416 isadev
= i8259_init_chip(TYPE_I8259
, bus
, true);
417 dev
= DEVICE(isadev
);
419 qdev_connect_gpio_out(dev
, 0, parent_irq_in
);
420 for (i
= 0 ; i
< 8; i
++) {
421 irq_set
[i
] = qdev_get_gpio_in(dev
, i
);
424 isa_pic
= PIC_COMMON(dev
);
426 isadev
= i8259_init_chip(TYPE_I8259
, bus
, false);
427 dev
= DEVICE(isadev
);
429 qdev_connect_gpio_out(dev
, 0, irq_set
[2]);
430 for (i
= 0 ; i
< 8; i
++) {
431 irq_set
[i
+ 8] = qdev_get_gpio_in(dev
, i
);
434 slave_pic
= PIC_COMMON(dev
);
439 static void i8259_class_init(ObjectClass
*klass
, void *data
)
441 PICClass
*k
= PIC_CLASS(klass
);
442 DeviceClass
*dc
= DEVICE_CLASS(klass
);
444 device_class_set_parent_realize(dc
, pic_realize
, &k
->parent_realize
);
445 device_class_set_legacy_reset(dc
, pic_reset
);
448 static const TypeInfo i8259_info
= {
450 .instance_size
= sizeof(PICCommonState
),
451 .parent
= TYPE_PIC_COMMON
,
452 .class_init
= i8259_class_init
,
453 .class_size
= sizeof(PICClass
),
456 static void pic_register_types(void)
458 type_register_static(&i8259_info
);
461 type_init(pic_register_types
)