← Back to branch summary

~ubuntu-branches/debian/jessie/qemu/jessie

« back to all changes in this revision

Viewing changes to hw/i8254.c

  • Committer: Package Import Robot
  • Author(s): Vagrant Cascadian
  • Date: 2011-10-03 12:29:18 UTC
  • mfrom: (1.2.13) (10.2.6 experimental)
  • Revision ID: package-import@ubuntu.com-20111003122918-zc4kv6epchrbgdta
Tags: 0.15.0+dfsg-1
* New upstream version.
* Install new qemu-system, qemu-user and qemu-user-static variants: 
  lm32, microblazeel, s390x, unicore32
* Patch from upstream to set QEMU_INCLUDES before QEMU_CFLAGS.
* Update debian/watch to check http://qemu.org/download.

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/i8254.c
53
53
    qemu_irq irq;
54
54
} PITChannelState;
55
55
 
56
 
struct PITState {
 
56
typedef struct PITState {
 
57
    ISADevice dev;
 
58
    uint32_t irq;
 
59
    uint32_t iobase;
57
60
    PITChannelState channels[3];
58
 
};
 
61
} PITState;
59
62
 
60
63
static PITState pit_state;
61
64
 
66
69
    uint64_t d;
67
70
    int counter;
68
71
 
69
 
    d = muldiv64(qemu_get_clock(vm_clock) - s->count_load_time, PIT_FREQ,
 
72
    d = muldiv64(qemu_get_clock_ns(vm_clock) - s->count_load_time, PIT_FREQ,
70
73
                 get_ticks_per_sec());
71
74
    switch(s->mode) {
72
75
    case 0:
119
122
    return out;
120
123
}
121
124
 
122
 
int pit_get_out(PITState *pit, int channel, int64_t current_time)
 
125
int pit_get_out(ISADevice *dev, int channel, int64_t current_time)
123
126
{
 
127
    PITState *pit = DO_UPCAST(PITState, dev, dev);
124
128
    PITChannelState *s = &pit->channels[channel];
125
129
    return pit_get_out1(s, current_time);
126
130
}
179
183
}
180
184
 
181
185
/* val must be 0 or 1 */
182
 
void pit_set_gate(PITState *pit, int channel, int val)
 
186
void pit_set_gate(ISADevice *dev, int channel, int val)
183
187
{
 
188
    PITState *pit = DO_UPCAST(PITState, dev, dev);
184
189
    PITChannelState *s = &pit->channels[channel];
185
190
 
186
191
    switch(s->mode) {
193
198
    case 5:
194
199
        if (s->gate < val) {
195
200
            /* restart counting on rising edge */
196
 
            s->count_load_time = qemu_get_clock(vm_clock);
 
201
            s->count_load_time = qemu_get_clock_ns(vm_clock);
197
202
            pit_irq_timer_update(s, s->count_load_time);
198
203
        }
199
204
        break;
201
206
    case 3:
202
207
        if (s->gate < val) {
203
208
            /* restart counting on rising edge */
204
 
            s->count_load_time = qemu_get_clock(vm_clock);
 
209
            s->count_load_time = qemu_get_clock_ns(vm_clock);
205
210
            pit_irq_timer_update(s, s->count_load_time);
206
211
        }
207
212
        /* XXX: disable/enable counting */
210
215
    s->gate = val;
211
216
}
212
217
 
213
 
int pit_get_gate(PITState *pit, int channel)
 
218
int pit_get_gate(ISADevice *dev, int channel)
214
219
{
 
220
    PITState *pit = DO_UPCAST(PITState, dev, dev);
215
221
    PITChannelState *s = &pit->channels[channel];
216
222
    return s->gate;
217
223
}
218
224
 
219
 
int pit_get_initial_count(PITState *pit, int channel)
 
225
int pit_get_initial_count(ISADevice *dev, int channel)
220
226
{
 
227
    PITState *pit = DO_UPCAST(PITState, dev, dev);
221
228
    PITChannelState *s = &pit->channels[channel];
222
229
    return s->count;
223
230
}
224
231
 
225
 
int pit_get_mode(PITState *pit, int channel)
 
232
int pit_get_mode(ISADevice *dev, int channel)
226
233
{
 
234
    PITState *pit = DO_UPCAST(PITState, dev, dev);
227
235
    PITChannelState *s = &pit->channels[channel];
228
236
    return s->mode;
229
237
}
232
240
{
233
241
    if (val == 0)
234
242
        val = 0x10000;
235
 
    s->count_load_time = qemu_get_clock(vm_clock);
 
243
    s->count_load_time = qemu_get_clock_ns(vm_clock);
236
244
    s->count = val;
237
245
    pit_irq_timer_update(s, s->count_load_time);
238
246
}
266
274
                    if (!(val & 0x10) && !s->status_latched) {
267
275
                        /* status latch */
268
276
                        /* XXX: add BCD and null count */
269
 
                        s->status =  (pit_get_out1(s, qemu_get_clock(vm_clock)) << 7) |
 
277
                        s->status =  (pit_get_out1(s, qemu_get_clock_ns(vm_clock)) << 7) |
270
278
                            (s->rw_mode << 4) |
271
279
                            (s->mode << 1) |
272
280
                            s->bcd;
462
470
    }
463
471
};
464
472
 
465
 
static void pit_reset(void *opaque)
 
473
static void pit_reset(DeviceState *dev)
466
474
{
467
 
    PITState *pit = opaque;
 
475
    PITState *pit = container_of(dev, PITState, dev.qdev);
468
476
    PITChannelState *s;
469
477
    int i;
470
478
 
498
506
    pit_load_count(s, 0);
499
507
}
500
508
 
501
 
PITState *pit_init(int base, qemu_irq irq)
 
509
static int pit_initfn(ISADevice *dev)
502
510
{
503
 
    PITState *pit = &pit_state;
 
511
    PITState *pit = DO_UPCAST(PITState, dev, dev);
504
512
    PITChannelState *s;
505
513
 
506
514
    s = &pit->channels[0];
507
515
    /* the timer 0 is connected to an IRQ */
508
 
    s->irq_timer = qemu_new_timer(vm_clock, pit_irq_timer, s);
509
 
    s->irq = irq;
510
 
 
511
 
    vmstate_register(NULL, base, &vmstate_pit, pit);
512
 
    qemu_register_reset(pit_reset, pit);
513
 
    register_ioport_write(base, 4, 1, pit_ioport_write, pit);
514
 
    register_ioport_read(base, 3, 1, pit_ioport_read, pit);
515
 
 
516
 
    return pit;
517
 
}
 
516
    s->irq_timer = qemu_new_timer_ns(vm_clock, pit_irq_timer, s);
 
517
    s->irq = isa_get_irq(pit->irq);
 
518
 
 
519
    register_ioport_write(pit->iobase, 4, 1, pit_ioport_write, pit);
 
520
    register_ioport_read(pit->iobase, 3, 1, pit_ioport_read, pit);
 
521
    isa_init_ioport(dev, pit->iobase);
 
522
 
 
523
    qdev_set_legacy_instance_id(&dev->qdev, pit->iobase, 2);
 
524
 
 
525
    return 0;
 
526
}
 
527
 
 
528
static ISADeviceInfo pit_info = {
 
529
    .qdev.name     = "isa-pit",
 
530
    .qdev.size     = sizeof(PITState),
 
531
    .qdev.vmsd     = &vmstate_pit,
 
532
    .qdev.reset    = pit_reset,
 
533
    .qdev.no_user  = 1,
 
534
    .init          = pit_initfn,
 
535
    .qdev.props = (Property[]) {
 
536
        DEFINE_PROP_UINT32("irq", PITState, irq,  -1),
 
537
        DEFINE_PROP_HEX32("iobase", PITState, iobase,  -1),
 
538
        DEFINE_PROP_END_OF_LIST(),
 
539
    },
 
540
};
 
541
 
 
542
static void pit_register(void)
 
543
{
 
544
    isa_qdev_register(&pit_info);
 
545
}
 
546
device_init(pit_register)