← Back to branch summary

~jderose/ubuntu/raring/qemu/vde-again

« back to all changes in this revision

Viewing changes to hw/slavio_intctl.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-07 06:20:34 UTC
  • mfrom: (1.1.9 upstream)
  • mto: This revision was merged to the branch mainline in revision 7.
  • Revision ID: james.westby@ubuntu.com-20090307062034-i3pead4mw653v2el
Tags: 0.10.0-1
http://bugs.debian.org/514462
http://bugs.debian.org/470231
http://bugs.debian.org/415996
http://bugs.debian.org/513210
http://bugs.debian.org/297572
[ Aurelien Jarno ]
* New upstream release:
  - Fix fr-be keyboard mapping (closes: bug#514462).
  - Fix stat64 structure on ppc-linux-user (closes: bug#470231).
  - Add a chroot option (closes: bug#415996).
  - Add evdev support (closes: bug#513210).
  - Fix loop on symlinks in user mode (closes: bug#297572).
  - Bump depends on openbios-sparc.
  - Depends on openbios-ppc.
  - Update 12_signal_powerpc_support.patch.
  - Update 21_net_soopts.patch.
  - Drop 44_socklen_t_check.patch (merged upstream).
  - Drop 49_null_check.patch (merged upstream).
  - Update 64_ppc_asm_constraints.patch.
  - Drop security/CVE-2008-0928-fedora.patch (merged upstream).
  - Drop security/CVE-2007-5730.patch (merged upstream).
* patches/80_stable-branch.patch: add patches from stable branch:
  - Fix race condition between signal handler/execution loop (closes:
    bug#474386, bug#501731).
* debian/copyright: update.
* Compile and install .dtb files:
  - debian/control: build-depends on device-tree-compiler.
  - debian/patches/81_compile_dtb.patch: new patch from upstream.
  - debian/rules: compile and install bamboo.dtb and mpc8544.dtb.

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/slavio_intctl.c
49
49
#define MAX_CPUS 16
50
50
#define MAX_PILS 16
51
51
 
 
52
struct SLAVIO_CPUINTCTLState;
 
53
 
52
54
typedef struct SLAVIO_INTCTLState {
53
 
    uint32_t intreg_pending[MAX_CPUS];
54
55
    uint32_t intregm_pending;
55
56
    uint32_t intregm_disabled;
56
57
    uint32_t target_cpu;
61
62
    const uint32_t *intbit_to_level;
62
63
    uint32_t cputimer_lbit, cputimer_mbit;
63
64
    uint32_t pil_out[MAX_CPUS];
 
65
    struct SLAVIO_CPUINTCTLState *slaves[MAX_CPUS];
64
66
} SLAVIO_INTCTLState;
65
67
 
 
68
typedef struct SLAVIO_CPUINTCTLState {
 
69
    uint32_t intreg_pending;
 
70
    SLAVIO_INTCTLState *master;
 
71
    uint32_t cpu;
 
72
} SLAVIO_CPUINTCTLState;
 
73
 
66
74
#define INTCTL_MAXADDR 0xf
67
75
#define INTCTL_SIZE (INTCTL_MAXADDR + 1)
68
 
#define INTCTLM_MAXADDR 0x13
69
 
#define INTCTLM_SIZE (INTCTLM_MAXADDR + 1)
70
 
#define INTCTLM_MASK 0x1f
 
76
#define INTCTLM_SIZE 0x14
71
77
#define MASTER_IRQ_MASK ~0x0fa2007f
72
78
#define MASTER_DISABLE 0x80000000
73
79
#define CPU_SOFTIRQ_MASK 0xfffe0000
75
81
#define CPU_IRQ_INT15_IN 0x0004000
76
82
#define CPU_IRQ_INT15_MASK 0x80000000
77
83
 
78
 
static void slavio_check_interrupts(void *opaque);
 
84
static void slavio_check_interrupts(SLAVIO_INTCTLState *s);
79
85
 
80
86
// per-cpu interrupt controller
81
87
static uint32_t slavio_intctl_mem_readl(void *opaque, target_phys_addr_t addr)
82
88
{
83
 
    SLAVIO_INTCTLState *s = opaque;
 
89
    SLAVIO_CPUINTCTLState *s = opaque;
84
90
    uint32_t saddr, ret;
85
 
    int cpu;
86
91
 
87
 
    cpu = (addr & (MAX_CPUS - 1) * TARGET_PAGE_SIZE) >> 12;
88
 
    saddr = (addr & INTCTL_MAXADDR) >> 2;
 
92
    saddr = addr >> 2;
89
93
    switch (saddr) {
90
94
    case 0:
91
 
        ret = s->intreg_pending[cpu];
 
95
        ret = s->intreg_pending;
92
96
        break;
93
97
    default:
94
98
        ret = 0;
95
99
        break;
96
100
    }
97
 
    DPRINTF("read cpu %d reg 0x" TARGET_FMT_plx " = %x\n", cpu, addr, ret);
 
101
    DPRINTF("read cpu %d reg 0x" TARGET_FMT_plx " = %x\n", s->cpu, addr, ret);
98
102
 
99
103
    return ret;
100
104
}
101
105
 
102
 
static void slavio_intctl_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
 
106
static void slavio_intctl_mem_writel(void *opaque, target_phys_addr_t addr,
 
107
                                     uint32_t val)
103
108
{
104
 
    SLAVIO_INTCTLState *s = opaque;
 
109
    SLAVIO_CPUINTCTLState *s = opaque;
105
110
    uint32_t saddr;
106
 
    int cpu;
107
111
 
108
 
    cpu = (addr & (MAX_CPUS - 1) * TARGET_PAGE_SIZE) >> 12;
109
 
    saddr = (addr & INTCTL_MAXADDR) >> 2;
110
 
    DPRINTF("write cpu %d reg 0x" TARGET_FMT_plx " = %x\n", cpu, addr, val);
 
112
    saddr = addr >> 2;
 
113
    DPRINTF("write cpu %d reg 0x" TARGET_FMT_plx " = %x\n", s->cpu, addr, val);
111
114
    switch (saddr) {
112
115
    case 1: // clear pending softints
113
116
        if (val & CPU_IRQ_INT15_IN)
114
117
            val |= CPU_IRQ_INT15_MASK;
115
118
        val &= CPU_SOFTIRQ_MASK;
116
 
        s->intreg_pending[cpu] &= ~val;
117
 
        slavio_check_interrupts(s);
118
 
        DPRINTF("Cleared cpu %d irq mask %x, curmask %x\n", cpu, val, s->intreg_pending[cpu]);
 
119
        s->intreg_pending &= ~val;
 
120
        slavio_check_interrupts(s->master);
 
121
        DPRINTF("Cleared cpu %d irq mask %x, curmask %x\n", s->cpu, val,
 
122
                s->intreg_pending);
119
123
        break;
120
124
    case 2: // set softint
121
125
        val &= CPU_SOFTIRQ_MASK;
122
 
        s->intreg_pending[cpu] |= val;
123
 
        slavio_check_interrupts(s);
124
 
        DPRINTF("Set cpu %d irq mask %x, curmask %x\n", cpu, val, s->intreg_pending[cpu]);
 
126
        s->intreg_pending |= val;
 
127
        slavio_check_interrupts(s->master);
 
128
        DPRINTF("Set cpu %d irq mask %x, curmask %x\n", s->cpu, val,
 
129
                s->intreg_pending);
125
130
        break;
126
131
    default:
127
132
        break;
146
151
    SLAVIO_INTCTLState *s = opaque;
147
152
    uint32_t saddr, ret;
148
153
 
149
 
    saddr = (addr & INTCTLM_MASK) >> 2;
 
154
    saddr = addr >> 2;
150
155
    switch (saddr) {
151
156
    case 0:
152
157
        ret = s->intregm_pending & ~MASTER_DISABLE;
166
171
    return ret;
167
172
}
168
173
 
169
 
static void slavio_intctlm_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
 
174
static void slavio_intctlm_mem_writel(void *opaque, target_phys_addr_t addr,
 
175
                                      uint32_t val)
170
176
{
171
177
    SLAVIO_INTCTLState *s = opaque;
172
178
    uint32_t saddr;
173
179
 
174
 
    saddr = (addr & INTCTLM_MASK) >> 2;
 
180
    saddr = addr >> 2;
175
181
    DPRINTF("write system reg 0x" TARGET_FMT_plx " = %x\n", addr, val);
176
182
    switch (saddr) {
177
183
    case 2: // clear (enable)
178
184
        // Force clear unused bits
179
185
        val &= MASTER_IRQ_MASK;
180
186
        s->intregm_disabled &= ~val;
181
 
        DPRINTF("Enabled master irq mask %x, curmask %x\n", val, s->intregm_disabled);
 
187
        DPRINTF("Enabled master irq mask %x, curmask %x\n", val,
 
188
                s->intregm_disabled);
182
189
        slavio_check_interrupts(s);
183
190
        break;
184
191
    case 3: // set (disable, clear pending)
187
194
        s->intregm_disabled |= val;
188
195
        s->intregm_pending &= ~val;
189
196
        slavio_check_interrupts(s);
190
 
        DPRINTF("Disabled master irq mask %x, curmask %x\n", val, s->intregm_disabled);
 
197
        DPRINTF("Disabled master irq mask %x, curmask %x\n", val,
 
198
                s->intregm_disabled);
191
199
        break;
192
200
    case 4:
193
201
        s->target_cpu = val & (MAX_CPUS - 1);
217
225
    int i;
218
226
 
219
227
    for (i = 0; i < MAX_CPUS; i++) {
220
 
        term_printf("per-cpu %d: pending 0x%08x\n", i, s->intreg_pending[i]);
 
228
        term_printf("per-cpu %d: pending 0x%08x\n", i,
 
229
                    s->slaves[i]->intreg_pending);
221
230
    }
222
 
    term_printf("master: pending 0x%08x, disabled 0x%08x\n", s->intregm_pending, s->intregm_disabled);
 
231
    term_printf("master: pending 0x%08x, disabled 0x%08x\n",
 
232
                s->intregm_pending, s->intregm_disabled);
223
233
}
224
234
 
225
235
void slavio_irq_info(void *opaque)
240
250
#endif
241
251
}
242
252
 
243
 
static void slavio_check_interrupts(void *opaque)
 
253
static void slavio_check_interrupts(SLAVIO_INTCTLState *s)
244
254
{
245
 
    SLAVIO_INTCTLState *s = opaque;
246
255
    uint32_t pending = s->intregm_pending, pil_pending;
247
256
    unsigned int i, j;
248
257
 
258
267
                    pil_pending |= 1 << s->intbit_to_level[j];
259
268
            }
260
269
        }
261
 
        pil_pending |= (s->intreg_pending[i] & CPU_SOFTIRQ_MASK) >> 16;
 
270
        pil_pending |= (s->slaves[i]->intreg_pending & CPU_SOFTIRQ_MASK) >> 16;
262
271
 
263
272
        for (j = 0; j < MAX_PILS; j++) {
264
273
            if (pil_pending & (1 << j)) {
291
300
            s->irq_count[pil]++;
292
301
#endif
293
302
            s->intregm_pending |= mask;
294
 
            s->intreg_pending[s->target_cpu] |= 1 << pil;
 
303
            s->slaves[s->target_cpu]->intreg_pending |= 1 << pil;
295
304
        } else {
296
305
            s->intregm_pending &= ~mask;
297
 
            s->intreg_pending[s->target_cpu] &= ~(1 << pil);
 
306
            s->slaves[s->target_cpu]->intreg_pending &= ~(1 << pil);
298
307
        }
299
308
        slavio_check_interrupts(s);
300
309
    }
308
317
 
309
318
    if (level) {
310
319
        s->intregm_pending |= s->cputimer_mbit;
311
 
        s->intreg_pending[cpu] |= s->cputimer_lbit;
 
320
        s->slaves[cpu]->intreg_pending |= s->cputimer_lbit;
312
321
    } else {
313
322
        s->intregm_pending &= ~s->cputimer_mbit;
314
 
        s->intreg_pending[cpu] &= ~s->cputimer_lbit;
 
323
        s->slaves[cpu]->intreg_pending &= ~s->cputimer_lbit;
315
324
    }
316
325
 
317
326
    slavio_check_interrupts(s);
323
332
    int i;
324
333
 
325
334
    for (i = 0; i < MAX_CPUS; i++) {
326
 
        qemu_put_be32s(f, &s->intreg_pending[i]);
 
335
        qemu_put_be32s(f, &s->slaves[i]->intreg_pending);
327
336
    }
328
337
    qemu_put_be32s(f, &s->intregm_pending);
329
338
    qemu_put_be32s(f, &s->intregm_disabled);
339
348
        return -EINVAL;
340
349
 
341
350
    for (i = 0; i < MAX_CPUS; i++) {
342
 
        qemu_get_be32s(f, &s->intreg_pending[i]);
 
351
        qemu_get_be32s(f, &s->slaves[i]->intreg_pending);
343
352
    }
344
353
    qemu_get_be32s(f, &s->intregm_pending);
345
354
    qemu_get_be32s(f, &s->intregm_disabled);
354
363
    int i;
355
364
 
356
365
    for (i = 0; i < MAX_CPUS; i++) {
357
 
        s->intreg_pending[i] = 0;
 
366
        s->slaves[i]->intreg_pending = 0;
358
367
    }
359
368
    s->intregm_disabled = ~MASTER_IRQ_MASK;
360
369
    s->intregm_pending = 0;
369
378
{
370
379
    int slavio_intctl_io_memory, slavio_intctlm_io_memory, i;
371
380
    SLAVIO_INTCTLState *s;
 
381
    SLAVIO_CPUINTCTLState *slave;
372
382
 
373
383
    s = qemu_mallocz(sizeof(SLAVIO_INTCTLState));
374
 
    if (!s)
375
 
        return NULL;
376
384
 
377
385
    s->intbit_to_level = intbit_to_level;
378
386
    for (i = 0; i < MAX_CPUS; i++) {
379
 
        slavio_intctl_io_memory = cpu_register_io_memory(0, slavio_intctl_mem_read, slavio_intctl_mem_write, s);
 
387
        slave = qemu_mallocz(sizeof(SLAVIO_CPUINTCTLState));
 
388
 
 
389
        slave->cpu = i;
 
390
        slave->master = s;
 
391
 
 
392
        slavio_intctl_io_memory = cpu_register_io_memory(0,
 
393
                                                         slavio_intctl_mem_read,
 
394
                                                         slavio_intctl_mem_write,
 
395
                                                         slave);
380
396
        cpu_register_physical_memory(addr + i * TARGET_PAGE_SIZE, INTCTL_SIZE,
381
397
                                     slavio_intctl_io_memory);
 
398
 
 
399
        s->slaves[i] = slave;
382
400
        s->cpu_irqs[i] = parent_irq[i];
383
401
    }
384
402
 
385
 
    slavio_intctlm_io_memory = cpu_register_io_memory(0, slavio_intctlm_mem_read, slavio_intctlm_mem_write, s);
 
403
    slavio_intctlm_io_memory = cpu_register_io_memory(0,
 
404
                                                      slavio_intctlm_mem_read,
 
405
                                                      slavio_intctlm_mem_write,
 
406
                                                      s);
386
407
    cpu_register_physical_memory(addrg, INTCTLM_SIZE, slavio_intctlm_io_memory);
387
408
 
388
 
    register_savevm("slavio_intctl", addr, 1, slavio_intctl_save, slavio_intctl_load, s);
 
409
    register_savevm("slavio_intctl", addr, 1, slavio_intctl_save,
 
410
                    slavio_intctl_load, s);
389
411
    qemu_register_reset(slavio_intctl_reset, s);
390
412
    *irq = qemu_allocate_irqs(slavio_set_irq, s, 32);
391
413
 
395
417
    slavio_intctl_reset(s);
396
418
    return s;
397
419
}
398