src/dev/intel_8254_timer.cc - arm/gem5 - Git at Google

 /*
  * Copyright (c) 2004, 2005
  * The Regents of The University of Michigan
  * All Rights Reserved
  *
  * This code is part of the M5 simulator.
  *
  * Permission is granted to use, copy, create derivative works and
  * redistribute this software and such derivative works for any
  * purpose, so long as the copyright notice above, this grant of
  * permission, and the disclaimer below appear in all copies made; and
  * so long as the name of The University of Michigan is not used in
  * any advertising or publicity pertaining to the use or distribution
  * of this software without specific, written prior authorization.
  *
  * THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION FROM THE
  * UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY PURPOSE, AND
  * WITHOUT WARRANTY BY THE UNIVERSITY OF MICHIGAN OF ANY KIND, EITHER
  * EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE. THE REGENTS OF THE UNIVERSITY OF MICHIGAN SHALL NOT BE
  * LIABLE FOR ANY DAMAGES, INCLUDING DIRECT, SPECIAL, INDIRECT,
  * INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY CLAIM
  * ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN
  * IF IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH
  * DAMAGES.
  *
  * Authors: Ali G. Saidi
  *          Andrew L. Schultz
  *          Miguel J. Serrano
  */

 #include "base/misc.hh"
 #include "debug/Intel8254Timer.hh"
 #include "dev/intel_8254_timer.hh"

 using namespace std;

 Intel8254Timer::Intel8254Timer(EventManager *em, const string &name,
     Counter *counter0, Counter *counter1, Counter *counter2) :
     EventManager(em), _name(name)
 {
     counter[0] = counter0;
     counter[1] = counter1;
     counter[2] = counter2;
 }

 Intel8254Timer::Intel8254Timer(EventManager *em, const string &name) :
     EventManager(em), _name(name)
 {
     counter[0] = new Counter(this, name + ".counter0", 0);
     counter[1] = new Counter(this, name + ".counter1", 1);
     counter[2] = new Counter(this, name + ".counter2", 2);
 }

 void
 Intel8254Timer::writeControl(const CtrlReg data)
 {
     int sel = data.sel;

     if (sel == ReadBackCommand)
        panic("PITimer Read-Back Command is not implemented.\n");

     if (data.rw == LatchCommand)
         counter[sel]->latchCount();
     else {
         counter[sel]->setRW(data.rw);
         counter[sel]->setMode(data.mode);
         counter[sel]->setBCD(data.bcd);
     }
 }

 void
 Intel8254Timer::serialize(const string &base, ostream &os)
 {
     // serialize the counters
     counter[0]->serialize(base + ".counter0", os);
     counter[1]->serialize(base + ".counter1", os);
     counter[2]->serialize(base + ".counter2", os);
 }

 void
 Intel8254Timer::unserialize(const string &base, Checkpoint *cp,
         const string &section)
 {
     // unserialze the counters
     counter[0]->unserialize(base + ".counter0", cp, section);
     counter[1]->unserialize(base + ".counter1", cp, section);
     counter[2]->unserialize(base + ".counter2", cp, section);
 }

 Intel8254Timer::Counter::Counter(Intel8254Timer *p,
         const string &name, unsigned int _num)
     : _name(name), num(_num), event(this), initial_count(0),
       latched_count(0), period(0), mode(0), output_high(false),
       latch_on(false), read_byte(LSB), write_byte(LSB), parent(p)
 {

 }

 void
 Intel8254Timer::Counter::latchCount()
 {
     // behave like a real latch
     if(!latch_on) {
         latch_on = true;
         read_byte = LSB;
         latched_count = currentCount();
     }
 }

 int
 Intel8254Timer::Counter::currentCount()
 {
     int clocks = event.clocksLeft();
     if (clocks == -1) {
         warn_once("Reading current count from inactive timer.\n");
         return 0;
     }
     if (mode == RateGen || mode == SquareWave)
         return clocks + 1;
     else
         return clocks;
 }

 uint8_t
 Intel8254Timer::Counter::read()
 {
     if (latch_on) {
         switch (read_byte) {
           case LSB:
             read_byte = MSB;
             return (uint8_t)latched_count;
             break;
           case MSB:
             read_byte = LSB;
             latch_on = false;
             return latched_count >> 8;
             break;
           default:
             panic("Shouldn't be here");
         }
     } else {
         uint16_t count = currentCount();
         switch (read_byte) {
           case LSB:
             read_byte = MSB;
             return (uint8_t)count;
             break;
           case MSB:
             read_byte = LSB;
             return count >> 8;
             break;
           default:
             panic("Shouldn't be here");
         }
     }
 }

 void
 Intel8254Timer::Counter::write(const uint8_t data)
 {
     switch (write_byte) {
       case LSB:
         initial_count = (initial_count & 0xFF00) | data;

         if (event.scheduled())
             parent->deschedule(event);
         output_high = false;
         write_byte = MSB;
         break;

       case MSB:
         initial_count = (initial_count & 0x00FF) | (data << 8);
         // In the RateGen or SquareWave modes, the timer wraps around and
         // triggers on a value of 1, not 0.
         if (mode == RateGen || mode == SquareWave)
             period = initial_count - 1;
         else
             period = initial_count;

         if (period > 0)
             event.setTo(period);

         write_byte = LSB;
         break;
     }
 }

 void
 Intel8254Timer::Counter::setRW(int rw_val)
 {
     if (rw_val != TwoPhase)
         panic("Only LSB/MSB read/write is implemented.\n");
 }

 void
 Intel8254Timer::Counter::setMode(int mode_val)
 {
     if(mode_val != InitTc && mode_val != RateGen &&
        mode_val != SquareWave)
         panic("PIT mode %#x is not implemented: \n", mode_val);

     mode = mode_val;
 }

 void
 Intel8254Timer::Counter::setBCD(int bcd_val)
 {
     if (bcd_val)
         panic("PITimer does not implement BCD counts.\n");
 }

 bool
 Intel8254Timer::Counter::outputHigh()
 {
     return output_high;
 }

 void
 Intel8254Timer::Counter::serialize(const string &base, ostream &os)
 {
     paramOut(os, base + ".initial_count", initial_count);
     paramOut(os, base + ".latched_count", latched_count);
     paramOut(os, base + ".period", period);
     paramOut(os, base + ".mode", mode);
     paramOut(os, base + ".output_high", output_high);
     paramOut(os, base + ".latch_on", latch_on);
     paramOut(os, base + ".read_byte", read_byte);
     paramOut(os, base + ".write_byte", write_byte);

     Tick event_tick = 0;
     if (event.scheduled())
         event_tick = event.when();
     paramOut(os, base + ".event_tick", event_tick);
 }

 void
 Intel8254Timer::Counter::unserialize(const string &base, Checkpoint *cp,
                                          const string &section)
 {
     paramIn(cp, section, base + ".initial_count", initial_count);
     paramIn(cp, section, base + ".latched_count", latched_count);
     paramIn(cp, section, base + ".period", period);
     paramIn(cp, section, base + ".mode", mode);
     paramIn(cp, section, base + ".output_high", output_high);
     paramIn(cp, section, base + ".latch_on", latch_on);
     paramIn(cp, section, base + ".read_byte", read_byte);
     paramIn(cp, section, base + ".write_byte", write_byte);

     Tick event_tick = 0;
     if (event.scheduled())
         parent->deschedule(event);
     paramIn(cp, section, base + ".event_tick", event_tick);
     if (event_tick)
         parent->schedule(event, event_tick);
 }

 Intel8254Timer::Counter::CounterEvent::CounterEvent(Counter* c_ptr)
 {
     interval = (Tick)(SimClock::Float::s / 1193180.0);
     counter = c_ptr;
 }

 void
 Intel8254Timer::Counter::CounterEvent::process()
 {
     switch (counter->mode) {
       case InitTc:
         counter->output_high = true;
         break;
       case RateGen:
       case SquareWave:
         setTo(counter->period);
         break;
       default:
         panic("Unimplemented PITimer mode.\n");
     }
     counter->parent->counterInterrupt(counter->num);
 }

 void
 Intel8254Timer::Counter::CounterEvent::setTo(int clocks)
 {
     if (clocks == 0)
         panic("Timer can't be set to go off instantly.\n");
     DPRINTF(Intel8254Timer, "Timer set to curTick() + %d\n",
             clocks * interval);
     counter->parent->schedule(this, curTick() + clocks * interval);
 }

 int
 Intel8254Timer::Counter::CounterEvent::clocksLeft()
 {
     if (!scheduled())
         return -1;
     return (when() - curTick() + interval - 1) / interval;
 }

 const char *
 Intel8254Timer::Counter::CounterEvent::description() const
 {
     return "Intel 8254 Interval timer";
 }
	/*
	* Copyright (c) 2004, 2005
	* The Regents of The University of Michigan
	* All Rights Reserved
	*
	* This code is part of the M5 simulator.
	*
	* Permission is granted to use, copy, create derivative works and
	* redistribute this software and such derivative works for any
	* purpose, so long as the copyright notice above, this grant of
	* permission, and the disclaimer below appear in all copies made; and
	* so long as the name of The University of Michigan is not used in
	* any advertising or publicity pertaining to the use or distribution
	* of this software without specific, written prior authorization.
	*
	* THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION FROM THE
	* UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY PURPOSE, AND
	* WITHOUT WARRANTY BY THE UNIVERSITY OF MICHIGAN OF ANY KIND, EITHER
	* EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
	* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
	* PURPOSE. THE REGENTS OF THE UNIVERSITY OF MICHIGAN SHALL NOT BE
	* LIABLE FOR ANY DAMAGES, INCLUDING DIRECT, SPECIAL, INDIRECT,
	* INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY CLAIM
	* ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN
	* IF IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH
	* DAMAGES.
	*
	* Authors: Ali G. Saidi
	* Andrew L. Schultz
	* Miguel J. Serrano
	*/

	#include "base/misc.hh"
	#include "debug/Intel8254Timer.hh"
	#include "dev/intel_8254_timer.hh"

	using namespace std;

	Intel8254Timer::Intel8254Timer(EventManager *em, const string &name,
	Counter counter0, Counter counter1, Counter *counter2) :
	EventManager(em), _name(name)
	{
	counter[0] = counter0;
	counter[1] = counter1;
	counter[2] = counter2;
	}

	Intel8254Timer::Intel8254Timer(EventManager *em, const string &name) :
	EventManager(em), _name(name)
	{
	counter[0] = new Counter(this, name + ".counter0", 0);
	counter[1] = new Counter(this, name + ".counter1", 1);
	counter[2] = new Counter(this, name + ".counter2", 2);
	}

	void
	Intel8254Timer::writeControl(const CtrlReg data)
	{
	int sel = data.sel;

	if (sel == ReadBackCommand)
	panic("PITimer Read-Back Command is not implemented.\n");

	if (data.rw == LatchCommand)
	counter[sel]->latchCount();
	else {
	counter[sel]->setRW(data.rw);
	counter[sel]->setMode(data.mode);
	counter[sel]->setBCD(data.bcd);
	}
	}

	void
	Intel8254Timer::serialize(const string &base, ostream &os)
	{
	// serialize the counters
	counter[0]->serialize(base + ".counter0", os);
	counter[1]->serialize(base + ".counter1", os);
	counter[2]->serialize(base + ".counter2", os);
	}

	void
	Intel8254Timer::unserialize(const string &base, Checkpoint *cp,
	const string &section)
	{
	// unserialze the counters
	counter[0]->unserialize(base + ".counter0", cp, section);
	counter[1]->unserialize(base + ".counter1", cp, section);
	counter[2]->unserialize(base + ".counter2", cp, section);
	}

	Intel8254Timer::Counter::Counter(Intel8254Timer *p,
	const string &name, unsigned int _num)
	: _name(name), num(_num), event(this), initial_count(0),
	latched_count(0), period(0), mode(0), output_high(false),
	latch_on(false), read_byte(LSB), write_byte(LSB), parent(p)
	{

	}

	void
	Intel8254Timer::Counter::latchCount()
	{
	// behave like a real latch
	if(!latch_on) {
	latch_on = true;
	read_byte = LSB;
	latched_count = currentCount();
	}
	}

	int
	Intel8254Timer::Counter::currentCount()
	{
	int clocks = event.clocksLeft();
	if (clocks == -1) {
	warn_once("Reading current count from inactive timer.\n");
	return 0;
	}
	if (mode == RateGen \|\| mode == SquareWave)
	return clocks + 1;
	else
	return clocks;
	}

	uint8_t
	Intel8254Timer::Counter::read()
	{
	if (latch_on) {
	switch (read_byte) {
	case LSB:
	read_byte = MSB;
	return (uint8_t)latched_count;
	break;
	case MSB:
	read_byte = LSB;
	latch_on = false;
	return latched_count >> 8;
	break;
	default:
	panic("Shouldn't be here");
	}
	} else {
	uint16_t count = currentCount();
	switch (read_byte) {
	case LSB:
	read_byte = MSB;
	return (uint8_t)count;
	break;
	case MSB:
	read_byte = LSB;
	return count >> 8;
	break;
	default:
	panic("Shouldn't be here");
	}
	}
	}

	void
	Intel8254Timer::Counter::write(const uint8_t data)
	{
	switch (write_byte) {
	case LSB:
	initial_count = (initial_count & 0xFF00) \| data;

	if (event.scheduled())
	parent->deschedule(event);
	output_high = false;
	write_byte = MSB;
	break;

	case MSB:
	initial_count = (initial_count & 0x00FF) \| (data << 8);
	// In the RateGen or SquareWave modes, the timer wraps around and
	// triggers on a value of 1, not 0.
	if (mode == RateGen \|\| mode == SquareWave)
	period = initial_count - 1;
	else
	period = initial_count;

	if (period > 0)
	event.setTo(period);

	write_byte = LSB;
	break;
	}
	}

	void
	Intel8254Timer::Counter::setRW(int rw_val)
	{
	if (rw_val != TwoPhase)
	panic("Only LSB/MSB read/write is implemented.\n");
	}

	void
	Intel8254Timer::Counter::setMode(int mode_val)
	{
	if(mode_val != InitTc && mode_val != RateGen &&
	mode_val != SquareWave)
	panic("PIT mode %#x is not implemented: \n", mode_val);

	mode = mode_val;
	}

	void
	Intel8254Timer::Counter::setBCD(int bcd_val)
	{
	if (bcd_val)
	panic("PITimer does not implement BCD counts.\n");
	}

	bool
	Intel8254Timer::Counter::outputHigh()
	{
	return output_high;
	}

	void
	Intel8254Timer::Counter::serialize(const string &base, ostream &os)
	{
	paramOut(os, base + ".initial_count", initial_count);
	paramOut(os, base + ".latched_count", latched_count);
	paramOut(os, base + ".period", period);
	paramOut(os, base + ".mode", mode);
	paramOut(os, base + ".output_high", output_high);
	paramOut(os, base + ".latch_on", latch_on);
	paramOut(os, base + ".read_byte", read_byte);
	paramOut(os, base + ".write_byte", write_byte);

	Tick event_tick = 0;
	if (event.scheduled())
	event_tick = event.when();
	paramOut(os, base + ".event_tick", event_tick);
	}

	void
	Intel8254Timer::Counter::unserialize(const string &base, Checkpoint *cp,
	const string &section)
	{
	paramIn(cp, section, base + ".initial_count", initial_count);
	paramIn(cp, section, base + ".latched_count", latched_count);
	paramIn(cp, section, base + ".period", period);
	paramIn(cp, section, base + ".mode", mode);
	paramIn(cp, section, base + ".output_high", output_high);
	paramIn(cp, section, base + ".latch_on", latch_on);
	paramIn(cp, section, base + ".read_byte", read_byte);
	paramIn(cp, section, base + ".write_byte", write_byte);

	Tick event_tick = 0;
	if (event.scheduled())
	parent->deschedule(event);
	paramIn(cp, section, base + ".event_tick", event_tick);
	if (event_tick)
	parent->schedule(event, event_tick);
	}

	Intel8254Timer::Counter::CounterEvent::CounterEvent(Counter* c_ptr)
	{
	interval = (Tick)(SimClock::Float::s / 1193180.0);
	counter = c_ptr;
	}

	void
	Intel8254Timer::Counter::CounterEvent::process()
	{
	switch (counter->mode) {
	case InitTc:
	counter->output_high = true;
	break;
	case RateGen:
	case SquareWave:
	setTo(counter->period);
	break;
	default:
	panic("Unimplemented PITimer mode.\n");
	}
	counter->parent->counterInterrupt(counter->num);
	}

	void
	Intel8254Timer::Counter::CounterEvent::setTo(int clocks)
	{
	if (clocks == 0)
	panic("Timer can't be set to go off instantly.\n");
	DPRINTF(Intel8254Timer, "Timer set to curTick() + %d\n",
	clocks * interval);
	counter->parent->schedule(this, curTick() + clocks * interval);
	}

	int
	Intel8254Timer::Counter::CounterEvent::clocksLeft()
	{
	if (!scheduled())
	return -1;
	return (when() - curTick() + interval - 1) / interval;
	}

	const char *
	Intel8254Timer::Counter::CounterEvent::description() const
	{
	return "Intel 8254 Interval timer";
	}