← Back to branch summary

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

« back to all changes in this revision

Viewing changes to hw/parallel.c

  • Committer: Bazaar Package Importer
  • Author(s): Aurelien Jarno, Aurelien Jarno
  • Date: 2009-03-22 10:13:17 UTC
  • mfrom: (1.2.1 upstream) (6.1.1 sid)
  • Revision ID: james.westby@ubuntu.com-20090322101317-iigjtnu5qil35dtb
Tags: 0.10.1-1
http://bugs.debian.org/501400
[ Aurelien Jarno ]
* New upstream stable release:
  - patches/80_stable-branch.patch: remove.
* debian/control: 
  - Remove depends on proll.
  - Move depends on device-tree-compiler to build-depends.
  - Bump Standards-Version to 3.8.1 (no changes).
* patches/82_qemu-img_decimal.patch: new patch from upstream to make
  qemu-img accept sizes with decimal values (closes: bug#501400).

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/parallel.c
75
75
    int epp_timeout;
76
76
    uint32_t last_read_offset; /* For debugging */
77
77
    /* Memory-mapped interface */
78
 
    target_phys_addr_t base;
79
78
    int it_shift;
80
79
};
81
80
 
101
100
        parallel_update_irq(s);
102
101
        break;
103
102
    case PARA_REG_CTR:
 
103
        val |= 0xc0;
104
104
        if ((val & PARA_CTR_INIT) == 0 ) {
105
105
            s->status = PARA_STS_BUSY;
106
106
            s->status |= PARA_STS_ACK;
128
128
{
129
129
    ParallelState *s = opaque;
130
130
    uint8_t parm = val;
 
131
    int dir;
131
132
 
132
133
    /* Sometimes programs do several writes for timing purposes on old
133
134
       HW. Take care not to waste time on writes that do nothing. */
153
154
        if (s->control == val)
154
155
            return;
155
156
        pdebug("wc%02x\n", val);
 
157
 
 
158
        if ((val & PARA_CTR_DIR) != (s->control & PARA_CTR_DIR)) {
 
159
            if (val & PARA_CTR_DIR) {
 
160
                dir = 1;
 
161
            } else {
 
162
                dir = 0;
 
163
            }
 
164
            qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_DATA_DIR, &dir);
 
165
            parm &= ~PARA_CTR_DIR;
 
166
        }
 
167
 
156
168
        qemu_chr_ioctl(s->chr, CHR_IOCTL_PP_WRITE_CONTROL, &parm);
157
169
        s->control = val;
158
170
        break;
406
418
    return ret;
407
419
}
408
420
 
409
 
static void parallel_reset(ParallelState *s, qemu_irq irq, CharDriverState *chr)
 
421
static void parallel_reset(void *opaque)
410
422
{
 
423
    ParallelState *s = opaque;
 
424
 
411
425
    s->datar = ~0;
412
426
    s->dataw = ~0;
413
427
    s->status = PARA_STS_BUSY;
414
428
    s->status |= PARA_STS_ACK;
415
429
    s->status |= PARA_STS_ONLINE;
416
430
    s->status |= PARA_STS_ERROR;
 
431
    s->status |= PARA_STS_TMOUT;
417
432
    s->control = PARA_CTR_SELECT;
418
433
    s->control |= PARA_CTR_INIT;
419
 
    s->irq = irq;
 
434
    s->control |= 0xc0;
420
435
    s->irq_pending = 0;
421
 
    s->chr = chr;
422
436
    s->hw_driver = 0;
423
437
    s->epp_timeout = 0;
424
438
    s->last_read_offset = ~0U;
431
445
    uint8_t dummy;
432
446
 
433
447
    s = qemu_mallocz(sizeof(ParallelState));
434
 
    if (!s)
435
 
        return NULL;
436
 
    parallel_reset(s, irq, chr);
 
448
    s->irq = irq;
 
449
    s->chr = chr;
 
450
    parallel_reset(s);
 
451
    qemu_register_reset(parallel_reset, s);
437
452
 
438
453
    if (qemu_chr_ioctl(chr, CHR_IOCTL_PP_READ_STATUS, &dummy) == 0) {
439
454
        s->hw_driver = 1;
462
477
{
463
478
    ParallelState *s = opaque;
464
479
 
465
 
    return parallel_ioport_read_sw(s, (addr - s->base) >> s->it_shift) & 0xFF;
 
480
    return parallel_ioport_read_sw(s, addr >> s->it_shift) & 0xFF;
466
481
}
467
482
 
468
483
static void parallel_mm_writeb (void *opaque,
470
485
{
471
486
    ParallelState *s = opaque;
472
487
 
473
 
    parallel_ioport_write_sw(s, (addr - s->base) >> s->it_shift, value & 0xFF);
 
488
    parallel_ioport_write_sw(s, addr >> s->it_shift, value & 0xFF);
474
489
}
475
490
 
476
491
static uint32_t parallel_mm_readw (void *opaque, target_phys_addr_t addr)
477
492
{
478
493
    ParallelState *s = opaque;
479
494
 
480
 
    return parallel_ioport_read_sw(s, (addr - s->base) >> s->it_shift) & 0xFFFF;
 
495
    return parallel_ioport_read_sw(s, addr >> s->it_shift) & 0xFFFF;
481
496
}
482
497
 
483
498
static void parallel_mm_writew (void *opaque,
485
500
{
486
501
    ParallelState *s = opaque;
487
502
 
488
 
    parallel_ioport_write_sw(s, (addr - s->base) >> s->it_shift, value & 0xFFFF);
 
503
    parallel_ioport_write_sw(s, addr >> s->it_shift, value & 0xFFFF);
489
504
}
490
505
 
491
506
static uint32_t parallel_mm_readl (void *opaque, target_phys_addr_t addr)
492
507
{
493
508
    ParallelState *s = opaque;
494
509
 
495
 
    return parallel_ioport_read_sw(s, (addr - s->base) >> s->it_shift);
 
510
    return parallel_ioport_read_sw(s, addr >> s->it_shift);
496
511
}
497
512
 
498
513
static void parallel_mm_writel (void *opaque,
500
515
{
501
516
    ParallelState *s = opaque;
502
517
 
503
 
    parallel_ioport_write_sw(s, (addr - s->base) >> s->it_shift, value);
 
518
    parallel_ioport_write_sw(s, addr >> s->it_shift, value);
504
519
}
505
520
 
506
521
static CPUReadMemoryFunc *parallel_mm_read_sw[] = {
522
537
    int io_sw;
523
538
 
524
539
    s = qemu_mallocz(sizeof(ParallelState));
525
 
    if (!s)
526
 
        return NULL;
527
 
    parallel_reset(s, irq, chr);
528
 
    s->base = base;
 
540
    s->irq = irq;
 
541
    s->chr = chr;
529
542
    s->it_shift = it_shift;
 
543
    parallel_reset(s);
 
544
    qemu_register_reset(parallel_reset, s);
530
545
 
531
546
    io_sw = cpu_register_io_memory(0, parallel_mm_read_sw, parallel_mm_write_sw, s);
532
547
    cpu_register_physical_memory(base, 8 << it_shift, io_sw);