1 import qemu

     2 

     3 class syborg_timer(qemu.devclass):

     4   REG_ID            = 0

     5   REG_RUNNING       = 1

     6   REG_ONESHOT       = 2

     7   REG_LIMIT         = 3

     8   REG_VALUE         = 4

     9   REG_INT_ENABLE    = 5

    10   REG_INT_STATUS    = 6

    11   REG_FREQ          = 7

    12 

    13   def update(self):

    14     self.set_irq_level(0, (self.int_status & self.int_enable) != 0)

    15 

    16   def timer_tick(self):

    17     self.int_status |= 1

    18     if (self.oneshot):

    19       self.running = False

    20     self.update()

    21 

    22   def create(self):

    23     self.freq = self.properties["frequency"]

    24     if self.freq == 0:

    25       raise ValueError, "Zero/unset frequency"

    26     self.timer = qemu.ptimer(self.timer_tick, self.freq)

    27     self.running = False

    28     self.oneshot = False

    29     self.int_status = 0

    30     self.int_enable = 0

    31     self.limit = 0

    32 

    33   def read_reg(self, offset):

    34     offset >>= 2

    35     if offset == self.REG_ID:

    36       return 0xc51d0003

    37     elif offset == self.REG_RUNNING:

    38       return 1 if self.running else 0

    39     elif offset == self.REG_ONESHOT:

    40       return 1 if self.oneshot else 0

    41     elif offset == self.REG_LIMIT:

    42       return self.limit

    43     elif offset == self.REG_VALUE:

    44       return self.timer.count

    45     elif offset == self.REG_INT_ENABLE:

    46       return self.int_enable

    47     elif offset == self.REG_INT_STATUS:

    48       return self.int_status

    49     elif offset == self.REG_FREQ:

    50       return self.freq

    51     return 0

    52 

    53   def write_reg(self, offset, value):

    54     offset >>= 2

    55     if offset == self.REG_RUNNING:

    56       if self.running != (value != 0):

    57         self.running = (value != 0)

    58         if self.running:

    59           self.timer.run(self.oneshot)

    60         else:

    61           self.timer.stop()

    62     elif offset == self.REG_ONESHOT:

    63       if self.running:

    64         self.timer.stop()

    65       self.oneshot = (value != 0)

    66       if self.running:

    67         self.timer.run(self.oneshot);

    68     elif offset == self.REG_LIMIT:

    69       self.limit = value

    70       self.timer.set_limit(value, True)

    71     elif offset == self.REG_VALUE:

    72       self.timer.count = value

    73     elif offset == self.REG_INT_ENABLE:

    74       self.int_enable = value & 1

    75       self.update()

    76     elif offset == self.REG_INT_STATUS:

    77       self.int_status &= ~value

    78       self.update()

    79 

    80   def save(self, f):

    81     f.put_u32(self.running)

    82     f.put_u32(self.oneshot)

    83     f.put_u32(self.limit)

    84     f.put_u32(self.int_status)

    85     f.put_u32(self.int_enable)

    86     self.timer.put(f)

    87 

    88   def load(self, f):

    89     self.running = (f.get_u32() != 0)

    90     self.oneshot = (f.get_u32() != 0)

    91     self.limit = f.get_u32()

    92     self.int_status = f.get_u32()

    93     self.int_enable = f.get_u32()

    94     self.timer.get(f)

    95 

    96   # Device class properties

    97   regions = [qemu.ioregion(0x1000, readl=read_reg, writel=write_reg)]

    98   irqs = 1

    99   name = "syborg,timer"

   100   properties = {"frequency":0}

   101 

   102 qemu.register_device(syborg_timer)