src/dev/intel_8254_timer.cc

   1 /*
   2  * Copyright (c) 2004, 2005
   3  * The Regents of The University of Michigan
   4  * All Rights Reserved
   5  *
   6  * This code is part of the M5 simulator.
   7  *
   8  * Permission is granted to use, copy, create derivative works and
   9  * redistribute this software and such derivative works for any
  10  * purpose, so long as the copyright notice above, this grant of
  11  * permission, and the disclaimer below appear in all copies made; and
  12  * so long as the name of The University of Michigan is not used in
  13  * any advertising or publicity pertaining to the use or distribution
  14  * of this software without specific, written prior authorization.
  15  *
  16  * THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION FROM THE
  17  * UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY PURPOSE, AND
  18  * WITHOUT WARRANTY BY THE UNIVERSITY OF MICHIGAN OF ANY KIND, EITHER
  19  * EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED
  20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  21  * PURPOSE. THE REGENTS OF THE UNIVERSITY OF MICHIGAN SHALL NOT BE
  22  * LIABLE FOR ANY DAMAGES, INCLUDING DIRECT, SPECIAL, INDIRECT,
  23  * INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY CLAIM
  24  * ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN
  25  * IF IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH
  26  * DAMAGES.
  27  *
  28  * Authors: Ali G. Saidi
  29  *          Andrew L. Schultz
  30  *          Miguel J. Serrano
  31  */
  32
  33 #include "dev/intel_8254_timer.hh"
  34
  35 #include "base/logging.hh"
  36 #include "debug/Intel8254Timer.hh"
  37
  38 using namespace std;
  39
  40 Intel8254Timer::Intel8254Timer(EventManager *em, const string &name,
  41     Counter *counter0, Counter *counter1, Counter *counter2) :
  42     EventManager(em), _name(name)
  43 {
  44     counter[0] = counter0;
  45     counter[1] = counter1;
  46     counter[2] = counter2;
  47 }
  48
  49 Intel8254Timer::Intel8254Timer(EventManager *em, const string &name) :
  50     EventManager(em), _name(name)
  51 {
  52     counter[0] = new Counter(this, name + ".counter0", 0);
  53     counter[1] = new Counter(this, name + ".counter1", 1);
  54     counter[2] = new Counter(this, name + ".counter2", 2);
  55 }
  56
  57 void
  58 Intel8254Timer::writeControl(const CtrlReg data)
  59 {
  60     int sel = data.sel;
  61
  62     if (sel == ReadBackCommand)
  63        panic("PITimer Read-Back Command is not implemented.\n");
  64
  65     if (data.rw == LatchCommand)
  66         counter[sel]->latchCount();
  67     else {
  68         counter[sel]->setRW(data.rw);
  69         counter[sel]->setMode(data.mode);
  70         counter[sel]->setBCD(data.bcd);
  71     }
  72 }
  73
  74 void
  75 Intel8254Timer::serialize(const string &base, CheckpointOut &cp) const
  76 {
  77     // serialize the counters
  78     counter[0]->serialize(base + ".counter0", cp);
  79     counter[1]->serialize(base + ".counter1", cp);
  80     counter[2]->serialize(base + ".counter2", cp);
  81 }
  82
  83 void
  84 Intel8254Timer::unserialize(const string &base, CheckpointIn &cp)
  85 {
  86     // unserialze the counters
  87     counter[0]->unserialize(base + ".counter0", cp);
  88     counter[1]->unserialize(base + ".counter1", cp);
  89     counter[2]->unserialize(base + ".counter2", cp);
  90 }
  91
  92 void
  93 Intel8254Timer::startup()
  94 {
  95     counter[0]->startup();
  96     counter[1]->startup();
  97     counter[2]->startup();
  98 }
  99
 100 Intel8254Timer::Counter::Counter(Intel8254Timer *p,
 101         const string &name, unsigned int _num)
 102     : _name(name), num(_num), event(this), running(false),
 103       initial_count(0), latched_count(0), period(0), mode(0),
 104       output_high(false), latch_on(false), read_byte(LSB),
 105       write_byte(LSB), parent(p)
 106 {
 107     offset = period * event.getInterval();
 108 }
 109
 110 void
 111 Intel8254Timer::Counter::latchCount()
 112 {
 113     // behave like a real latch
 114     if (!latch_on) {
 115         latch_on = true;
 116         read_byte = LSB;
 117         latched_count = currentCount();
 118     }
 119 }
 120
 121 int
 122 Intel8254Timer::Counter::currentCount()
 123 {
 124     int clocks = event.clocksLeft();
 125     if (clocks == -1) {
 126         warn_once("Reading current count from inactive timer.\n");
 127         return 0;
 128     }
 129     if (mode == RateGen || mode == SquareWave)
 130         return clocks + 1;
 131     else
 132         return clocks;
 133 }
 134
 135 uint8_t
 136 Intel8254Timer::Counter::read()
 137 {
 138     if (latch_on) {
 139         switch (read_byte) {
 140           case LSB:
 141             read_byte = MSB;
 142             return (uint8_t)latched_count;
 143             break;
 144           case MSB:
 145             read_byte = LSB;
 146             latch_on = false;
 147             return latched_count >> 8;
 148             break;
 149           default:
 150             panic("Shouldn't be here");
 151         }
 152     } else {
 153         uint16_t count = currentCount();
 154         switch (read_byte) {
 155           case LSB:
 156             read_byte = MSB;
 157             return (uint8_t)count;
 158             break;
 159           case MSB:
 160             read_byte = LSB;
 161             return count >> 8;
 162             break;
 163           default:
 164             panic("Shouldn't be here");
 165         }
 166     }
 167 }
 168
 169 void
 170 Intel8254Timer::Counter::write(const uint8_t data)
 171 {
 172     switch (write_byte) {
 173       case LSB:
 174         initial_count = (initial_count & 0xFF00) | data;
 175
 176         if (event.scheduled())
 177             parent->deschedule(event);
 178         output_high = false;
 179         write_byte = MSB;
 180         break;
 181
 182       case MSB:
 183         initial_count = (initial_count & 0x00FF) | (data << 8);
 184         // In the RateGen or SquareWave modes, the timer wraps around and
 185         // triggers on a value of 1, not 0.
 186         if (mode == RateGen || mode == SquareWave)
 187             period = initial_count - 1;
 188         else
 189             period = initial_count;
 190
 191         offset = period * event.getInterval();
 192
 193         if (running && (period > 0))
 194             event.setTo(period);
 195
 196         write_byte = LSB;
 197         break;
 198     }
 199 }
 200
 201 void
 202 Intel8254Timer::Counter::setRW(int rw_val)
 203 {
 204     if (rw_val != TwoPhase)
 205         panic("Only LSB/MSB read/write is implemented.\n");
 206 }
 207
 208 void
 209 Intel8254Timer::Counter::setMode(int mode_val)
 210 {
 211     if (mode_val != InitTc && mode_val != RateGen &&
 212        mode_val != SquareWave)
 213         panic("PIT mode %#x is not implemented: \n", mode_val);
 214
 215     mode = mode_val;
 216 }
 217
 218 void
 219 Intel8254Timer::Counter::setBCD(int bcd_val)
 220 {
 221     if (bcd_val)
 222         panic("PITimer does not implement BCD counts.\n");
 223 }
 224
 225 bool
 226 Intel8254Timer::Counter::outputHigh()
 227 {
 228     return output_high;
 229 }
 230
 231 void
 232 Intel8254Timer::Counter::serialize(const string &base, CheckpointOut &cp) const
 233 {
 234     paramOut(cp, base + ".initial_count", initial_count);
 235     paramOut(cp, base + ".latched_count", latched_count);
 236     paramOut(cp, base + ".period", period);
 237     paramOut(cp, base + ".mode", mode);
 238     paramOut(cp, base + ".output_high", output_high);
 239     paramOut(cp, base + ".latch_on", latch_on);
 240     paramOut(cp, base + ".read_byte", read_byte);
 241     paramOut(cp, base + ".write_byte", write_byte);
 242
 243     Tick event_tick_offset = 0;
 244     if (event.scheduled())
 245         event_tick_offset = event.when() - curTick();
 246     paramOut(cp, base + ".event_tick_offset", event_tick_offset);
 247 }
 248
 249 void
 250 Intel8254Timer::Counter::unserialize(const string &base, CheckpointIn &cp)
 251 {
 252     paramIn(cp, base + ".initial_count", initial_count);
 253     paramIn(cp, base + ".latched_count", latched_count);
 254     paramIn(cp, base + ".period", period);
 255     paramIn(cp, base + ".mode", mode);
 256     paramIn(cp, base + ".output_high", output_high);
 257     paramIn(cp, base + ".latch_on", latch_on);
 258     paramIn(cp, base + ".read_byte", read_byte);
 259     paramIn(cp, base + ".write_byte", write_byte);
 260
 261     Tick event_tick_offset = 0;
 262     assert(!event.scheduled());
 263     paramIn(cp, base + ".event_tick_offset", event_tick_offset);
 264     offset = event_tick_offset;
 265 }
 266
 267 void
 268 Intel8254Timer::Counter::startup()
 269 {
 270     running = true;
 271     if ((period > 0) && (offset > 0))
 272     {
 273         parent->schedule(event, curTick() + offset);
 274     }
 275 }
 276
 277 Intel8254Timer::Counter::CounterEvent::CounterEvent(Counter* c_ptr)
 278 {
 279     interval = (Tick)(SimClock::Float::s / 1193180.0);
 280     counter = c_ptr;
 281 }
 282
 283 void
 284 Intel8254Timer::Counter::CounterEvent::process()
 285 {
 286     switch (counter->mode) {
 287       case InitTc:
 288         counter->output_high = true;
 289         break;
 290       case RateGen:
 291       case SquareWave:
 292         setTo(counter->period);
 293         break;
 294       default:
 295         panic("Unimplemented PITimer mode.\n");
 296     }
 297     counter->parent->counterInterrupt(counter->num);
 298 }
 299
 300 void
 301 Intel8254Timer::Counter::CounterEvent::setTo(int clocks)
 302 {
 303     if (clocks == 0)
 304         panic("Timer can't be set to go off instantly.\n");
 305     DPRINTF(Intel8254Timer, "Timer set to curTick() + %d\n",
 306             clocks * interval);
 307     counter->parent->schedule(this, curTick() + clocks * interval);
 308 }
 309
 310 int
 311 Intel8254Timer::Counter::CounterEvent::clocksLeft()
 312 {
 313     if (!scheduled())
 314         return -1;
 315     return (when() - curTick() + interval - 1) / interval;
 316 }
 317
 318 const char *
 319 Intel8254Timer::Counter::CounterEvent::description() const
 320 {
 321     return "Intel 8254 Interval timer";
 322 }
 323
 324 Tick
 325 Intel8254Timer::Counter::CounterEvent::getInterval()
 326 {
 327     return interval;
 328 }
 329