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