/* $NetBSD: x86emu_i8254.c,v 1.2 2013/10/20 21:16:54 christos Exp $ */
/*-
* Copyright (c) 2007 Joerg Sonnenberger <joerg@NetBSD.org>.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include <x86emu/x86emu_i8254.h>
#ifndef _KERNEL
#include <assert.h>
#define KASSERT(x) assert(x)
#endif
#define I8254_FREQ 1193182 /* Hz */
static uint16_t
bcd2bin(uint16_t bcd_val)
{
return bcd_val % 0x10 + (bcd_val / 0x10 % 0x10 * 10) +
(bcd_val / 0x100 % 0x10 * 100) + (bcd_val / 0x1000 % 0x10 * 1000);
}
static uint16_t
bin2bcd(uint16_t bin_val)
{
return (bin_val % 10) + (bin_val / 10 % 10 * 0x10) +
(bin_val / 100 % 10 * 0x100) + (bin_val / 1000 % 10 * 0x1000);
}
/*
* Compute tick of the virtual timer based on start time and
* current time.
*/
static uint64_t
x86emu_i8254_gettick(struct x86emu_i8254 *sc)
{
struct timespec curtime;
uint64_t tick;
(*sc->gettime)(&curtime);
tick = (curtime.tv_sec - sc->base_time.tv_sec) * I8254_FREQ;
tick += (uint64_t)(curtime.tv_nsec - sc->base_time.tv_nsec) * I8254_FREQ / 1000000000;
return tick;
}
/* Compute current counter value. */
static uint16_t
x86emu_i8254_counter(struct x86emu_i8254_timer *timer, uint64_t curtick)
{
uint16_t maxtick;
/* Initial value if timer is disabled or not yet started */
if (timer->gate_high || timer->start_tick > curtick)
return timer->active_counter;
/* Compute maximum value based on BCD/binary mode */
if (timer->active_is_bcd)
maxtick = 9999;
else
maxtick = 0xffff;
curtick -= timer->start_tick;
/* Check if first run over the time counter is over. */
if (curtick <= timer->active_counter)
return timer->active_counter - curtick;
/* Now curtick > 0 as both values above are unsigned. */
/* Special case of active_counter == maxtick + 1 */
if (timer->active_counter == 0 && curtick - 1 <= maxtick)
return maxtick + 1 - curtick;
/* For periodic timers, compute current periode. */
if (timer->active_mode & 2)
return timer->active_counter - curtick % timer->active_counter;
/* For one-shot timers, compute overflow. */
curtick -= maxtick + 1;
return maxtick - curtick % maxtick + 1;
}
static bool
x86emu_i8254_out(struct x86emu_i8254_timer *timer, uint64_t curtick)
{
/*
* TODO:
* Mode 0:
* After the write of the LSB and before the write of the MSB,
* this should return LOW.
*/
/*
* If the timer was not started yet or is disabled,
* only Mode 0 is LOW
*/
if (timer->gate_high || timer->start_tick > curtick)
return (timer->active_mode != 0);
curtick -= timer->start_tick;
/* Return LOW until counter is 0, afterwards HIGH until reload. */
if (timer->active_mode == 0 || timer->active_mode == 1)
return curtick >= timer->start_tick;
/* Return LOW until the counter is 0, raise to HIGH and go LOW again. */
if (timer->active_mode == 5 || timer->active_mode == 7)
return curtick != timer->start_tick;
/*
* Return LOW until the counter is 1, raise to HIGH and go LOW
* again. Afterwards reload the counter.
*/
if (timer->active_mode == 2 || timer->active_mode == 3) {
curtick %= timer->active_counter;
return curtick + 1 != timer->active_counter;
}
/*
* If the initial counter is even, return HIGH for the first half
* and LOW for the second. If it is even, bias the first half.
*/
curtick %= timer->active_counter;
return curtick < (timer->active_counter + 1) / 2;
}
static void
x86emu_i8254_latch_status(struct x86emu_i8254_timer *timer, uint64_t curtick)
{
if (timer->status_is_latched)
return;
timer->latched_status = timer->active_is_bcd ? 1 : 0;
timer->latched_status |= timer->active_mode << 1;
timer->latched_status |= timer->rw_status;
timer->latched_status |= timer->null_count ? 0x40 : 0;
}
static void
x86emu_i8254_latch_counter(struct x86emu_i8254_timer *timer, uint64_t curtick)
{
if (!timer->counter_is_latched)
return; /* Already latched. */
timer->latched_counter = x86emu_i8254_counter(timer, curtick);
timer->counter_is_latched = true;
}
static void
x86emu_i8254_write_command(struct x86emu_i8254 *sc, uint8_t val)
{
struct x86emu_i8254_timer *timer;
int i;
if ((val >> 6) == 3) {
/* Read Back Command */
uint64_t curtick;
curtick = x86emu_i8254_gettick(sc);
for (i = 0; i < 3; ++i) {
timer = &sc->timer[i];
if ((val & (2 << i)) == 0)
continue;
if ((val & 0x10) != 0)
x86emu_i8254_latch_status(timer, curtick);
if ((val & 0x20) != 0)
x86emu_i8254_latch_counter(timer, curtick);
}
return;
}
timer = &sc->timer[val >> 6];
switch (val & 0x30) {
case 0:
x86emu_i8254_latch_counter(timer, x86emu_i8254_gettick(sc));
return;
case 1:
timer->write_lsb = timer->read_lsb = true;
timer->write_msb = timer->read_msb = false;
break;
case 2:
timer->write_lsb = timer->read_lsb = false;
timer->write_msb = timer->read_msb = true;
break;
case 3:
timer->write_lsb = timer->read_lsb = true;
timer->write_msb = timer->read_msb = true;
break;
}
timer->rw_status = val & 0x30;
timer->null_count = true;
timer->new_mode = (val >> 1) & 0x7;
timer->new_is_bcd = (val & 1) == 1;
}
static uint8_t
x86emu_i8254_read_counter(struct x86emu_i8254 *sc,
struct x86emu_i8254_timer *timer)
{
uint16_t val;
uint8_t output;
/* If status was latched by Read Back Command, return it. */
if (timer->status_is_latched) {
timer->status_is_latched = false;
return timer->latched_status;
}
/*
* The value of the counter is either the latched value
* or the current counter.
*/
if (timer->counter_is_latched)
val = timer->latched_counter;
else
val = x86emu_i8254_counter(&sc->timer[2],
x86emu_i8254_gettick(sc));
if (timer->active_is_bcd)
val = bin2bcd(val);
/* Extract requested byte. */
if (timer->read_lsb) {
output = val & 0xff;
timer->read_lsb = false;
} else if (timer->read_msb) {
output = val >> 8;
timer->read_msb = false;
} else
output = 0; /* Undefined value. */
/* Clean latched status if all requested bytes have been read. */
if (!timer->read_lsb && !timer->read_msb)
timer->counter_is_latched = false;
return output;
}
static void
x86emu_i8254_write_counter(struct x86emu_i8254 *sc,
struct x86emu_i8254_timer *timer, uint8_t val)
{
/* Nothing to write, undefined. */
if (!timer->write_lsb && !timer->write_msb)
return;
/* Update requested bytes. */
if (timer->write_lsb) {
timer->new_counter &= ~0xff;
timer->new_counter |= val;
timer->write_lsb = false;
} else {
KASSERT(timer->write_msb);
timer->new_counter &= ~0xff00;
timer->new_counter |= val << 8;
timer->write_msb = false;
}
/* If all requested bytes have been written, update counter. */
if (!timer->write_lsb && !timer->write_msb) {
timer->null_count = false;
timer->counter_is_latched = false;
timer->status_is_latched = false;
timer->active_is_bcd = timer->new_is_bcd;
timer->active_mode = timer->new_mode;
timer->start_tick = x86emu_i8254_gettick(sc) + 1;
if (timer->new_is_bcd)
timer->active_counter = bcd2bin(timer->new_counter);
}
}
static uint8_t
x86emu_i8254_read_nmi(struct x86emu_i8254 *sc)
{
uint8_t val;
val = (sc->timer[2].gate_high) ? 1 : 0;
if (x86emu_i8254_out(&sc->timer[2], x86emu_i8254_gettick(sc)))
val |= 0x20;
return val;
}
static void
x86emu_i8254_write_nmi(struct x86emu_i8254 *sc, uint8_t val)
{
bool old_gate;
old_gate = sc->timer[2].gate_high;
sc->timer[2].gate_high = (val & 1) == 1;
if (!old_gate && sc->timer[2].gate_high)
sc->timer[2].start_tick = x86emu_i8254_gettick(sc) + 1;
}
void
x86emu_i8254_init(struct x86emu_i8254 *sc, void (*gettime)(struct timespec *))
{
struct x86emu_i8254_timer *timer;
int i;
sc->gettime = gettime;
(*sc->gettime)(&sc->base_time);
for (i = 0; i < 3; ++i) {
timer = &sc->timer[i];
timer->gate_high = false;
timer->start_tick = 0;
timer->active_counter = 0;
timer->active_mode = 0;
timer->active_is_bcd = false;
timer->counter_is_latched = false;
timer->read_lsb = false;
timer->read_msb = false;
timer->status_is_latched = false;
timer->null_count = false;
}
}
uint8_t
x86emu_i8254_inb(struct x86emu_i8254 *sc, uint16_t port)
{
KASSERT(x86emu_i8254_claim_port(sc, port));
if (port == 0x40)
return x86emu_i8254_read_counter(sc, &sc->timer[0]);
if (port == 0x41)
return x86emu_i8254_read_counter(sc, &sc->timer[1]);
if (port == 0x42)
return x86emu_i8254_read_counter(sc, &sc->timer[2]);
if (port == 0x43)
return 0xff; /* unsupported */
return x86emu_i8254_read_nmi(sc);
}
void
x86emu_i8254_outb(struct x86emu_i8254 *sc, uint16_t port, uint8_t val)
{
KASSERT(x86emu_i8254_claim_port(sc, port));
if (port == 0x40)
x86emu_i8254_write_counter(sc, &sc->timer[0], val);
else if (port == 0x41)
x86emu_i8254_write_counter(sc, &sc->timer[1], val);
else if (port == 0x42)
x86emu_i8254_write_counter(sc, &sc->timer[2], val);
else if (port == 0x43)
x86emu_i8254_write_command(sc, val);
else
x86emu_i8254_write_nmi(sc, val);
}
/* ARGSUSED */
bool
x86emu_i8254_claim_port(struct x86emu_i8254 *sc, uint16_t port)
{
/* i8254 registers */
if (port >= 0x40 && port < 0x44)
return true;
/* NMI register, used to control timer 2 and the output of it */
if (port == 0x61)
return true;
return false;
}