src/dev/intel_8254_timer.hh

   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 #ifndef __DEV_8254_HH__
  34 #define __DEV_8254_HH__
  35
  36 #include <string>
  37 #include <iostream>
  38
  39 #include "base/bitunion.hh"
  40 #include "base/types.hh"
  41 #include "sim/eventq.hh"
  42 #include "sim/serialize.hh"
  43
  44 /** Programmable Interval Timer (Intel 8254) */
  45 class Intel8254Timer : public EventManager
  46 {
  47   protected:
  48     BitUnion8(CtrlReg)
  49         Bitfield<7, 6> sel;
  50         Bitfield<5, 4> rw;
  51         Bitfield<3, 1> mode;
  52         Bitfield<0> bcd;
  53     EndBitUnion(CtrlReg)
  54
  55     enum SelectVal {
  56         SelectCounter0,
  57         SelectCounter1,
  58         SelectCounter2,
  59         ReadBackCommand
  60     };
  61
  62     enum ReadWriteVal {
  63         LatchCommand,
  64         LsbOnly,
  65         MsbOnly,
  66         TwoPhase
  67     };
  68
  69     enum ModeVal {
  70         InitTc,
  71         OneShot,
  72         RateGen,
  73         SquareWave,
  74         SoftwareStrobe,
  75         HardwareStrobe
  76     };
  77
  78     /** Counter element for PIT */
  79     class Counter
  80     {
  81         /** Event for counter interrupt */
  82         class CounterEvent : public Event
  83         {
  84           private:
  85             /** Pointer back to Counter */
  86             Counter* counter;
  87             Tick interval;
  88
  89           public:
  90             CounterEvent(Counter*);
  91
  92             /** Event process */
  93             void process();
  94
  95             /** Event description */
  96             virtual const char *description() const;
  97
  98             friend class Counter;
  99
 100             void setTo(int clocks);
 101
 102             int clocksLeft();
 103         };
 104
 105       private:
 106         std::string _name;
 107         const std::string &name() const { return _name; }
 108
 109         unsigned int num;
 110
 111         CounterEvent event;
 112
 113         /** Initial count value */
 114         uint16_t initial_count;
 115
 116         /** Latched count */
 117         uint16_t latched_count;
 118
 119         /** Interrupt period */
 120         uint16_t period;
 121
 122         /** Current mode of operation */
 123         uint8_t mode;
 124
 125         /** Output goes high when the counter reaches zero */
 126         bool output_high;
 127
 128         /** State of the count latch */
 129         bool latch_on;
 130
 131         /** Set of values for read_byte and write_byte */
 132         enum {LSB, MSB};
 133
 134         /** Determine which byte of a 16-bit count value to read/write */
 135         uint8_t read_byte, write_byte;
 136
 137         /** Pointer to container */
 138         Intel8254Timer *parent;
 139
 140         /** if non-zero, the scheduled tick of an event used for drain
 141             serialization coordination */
 142         Tick event_tick;
 143
 144       public:
 145         Counter(Intel8254Timer *p, const std::string &name, unsigned int num);
 146
 147         /** Latch the current count (if one is not already latched) */
 148         void latchCount();
 149
 150         /** Get the current count for this counter */
 151         int currentCount();
 152
 153         /** Set the read/write mode */
 154         void setRW(int rw_val);
 155
 156         /** Set operational mode */
 157         void setMode(int mode_val);
 158
 159         /** Set count encoding */
 160         void setBCD(int bcd_val);
 161
 162         /** Read a count byte */
 163         uint8_t read();
 164
 165         /** Write a count byte */
 166         void write(const uint8_t data);
 167
 168         /** Is the output high? */
 169         bool outputHigh();
 170
 171         /**
 172          * Drain all associated events.
 173          * @param drainEvent
 174          */
 175         unsigned int drain(Event *de);
 176
 177         /**
 178          * Serialize this object to the given output stream.
 179          * @param base The base name of the counter object.
 180          * @param os   The stream to serialize to.
 181          */
 182         void serialize(const std::string &base, std::ostream &os);
 183
 184         /**
 185          * Reconstruct the state of this object from a checkpoint.
 186          * @param base The base name of the counter object.
 187          * @param cp The checkpoint use.
 188          * @param section The section name of this object
 189          */
 190         void unserialize(const std::string &base, Checkpoint *cp,
 191                          const std::string &section);
 192     };
 193
 194   protected:
 195     std::string _name;
 196     const std::string &name() const { return _name; }
 197
 198     /** PIT has three seperate counters */
 199     Counter *counter[3];
 200
 201     virtual void
 202     counterInterrupt(unsigned int num)
 203     {
 204         DPRINTF(Intel8254Timer, "Timer interrupt from counter %d.\n", num);
 205     }
 206
 207   public:
 208
 209     virtual
 210     ~Intel8254Timer()
 211     {}
 212
 213     Intel8254Timer(EventManager *em, const std::string &name,
 214             Counter *counter0, Counter *counter1, Counter *counter2);
 215
 216     Intel8254Timer(EventManager *em, const std::string &name);
 217
 218     /** Write control word */
 219     void writeControl(const CtrlReg data);
 220
 221     uint8_t
 222     readCounter(unsigned int num)
 223     {
 224         assert(num < 3);
 225         return counter[num]->read();
 226     }
 227
 228     void
 229     writeCounter(unsigned int num, const uint8_t data)
 230     {
 231         assert(num < 3);
 232         counter[num]->write(data);
 233     }
 234
 235     bool
 236     outputHigh(unsigned int num)
 237     {
 238         assert(num < 3);
 239         return counter[num]->outputHigh();
 240     }
 241
 242     unsigned int drain(Event *de);
 243
 244     /**
 245      * Serialize this object to the given output stream.
 246      * @param base The base name of the counter object.
 247      * @param os The stream to serialize to.
 248      */
 249     void serialize(const std::string &base, std::ostream &os);
 250
 251     /**
 252      * Reconstruct the state of this object from a checkpoint.
 253      * @param base The base name of the counter object.
 254      * @param cp The checkpoint use.
 255      * @param section The section name of this object
 256      */
 257     void unserialize(const std::string &base, Checkpoint *cp,
 258                      const std::string &section);
 259 };
 260
 261 #endif // __DEV_8254_HH__