sim_regbit.h

Go to the documentation of this file.

/*
 * sim_regbit.h
 * 
 * Copyright 2008, 2009 Michel Pollet <buserror@gmail.com>
 * 
 * This file is part of simavr.
 * 
 * simavr is free software: you can redistribute it and/or modify it under the terms of the GNU
 * General Public License as published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 * 
 * simavr is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
 * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
 * Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License along with simavr.  If not, see
 * <http://www.gnu.org/licenses/>.
 */

#ifndef __SIM_REGBIT_H__
#define __SIM_REGBIT_H__

#include "sim_avr.h"

#ifdef __cplusplus
extern "C"
{
#endif

#define ARRAY_SIZE(_aa) \
  (sizeof(_aa) / sizeof((_aa)[0]))

  static inline uint8_t avr_regbit_set (avr_t * avr, avr_regbit_t rb)
  {
    uint16_t a = rb.reg;
    uint8_t m;

    if (!a)
      return 0;
    m = rb.mask << rb.bit;
    avr_core_watch_write (avr, a, avr->data[a] | m);
    return (avr->data[a] >> rb.bit) & rb.mask;
  }

  static inline uint8_t avr_regbit_setto (avr_t * avr, avr_regbit_t rb, uint8_t v)
  {
    uint16_t a = rb.reg;
    uint8_t m;

    if (!a)
      return 0;
    m = rb.mask << rb.bit;
    avr_core_watch_write (avr, a, (avr->data[a] & ~(m)) | ((v << rb.bit) & m));
    return (avr->data[a] >> rb.bit) & rb.mask;
  }

  static inline uint8_t avr_regbit_setto_raw (avr_t * avr, avr_regbit_t rb, uint8_t v)
  {
    uint16_t a = rb.reg;
    uint8_t m;

    if (!a)
      return 0;
    m = rb.mask << rb.bit;
    avr_core_watch_write (avr, a, (avr->data[a] & ~(m)) | ((v) & m));
    return (avr->data[a]) & (rb.mask << rb.bit);
  }

  static inline uint8_t avr_regbit_get (avr_t * avr, avr_regbit_t rb)
  {
    uint16_t a = rb.reg;
    if (!a)
      return 0;
    //uint8_t m = rb.mask << rb.bit;
    return (avr->data[a] >> rb.bit) & rb.mask;
  }

  static inline uint8_t avr_regbit_from_value (avr_t * avr, avr_regbit_t rb, uint8_t value)
  {
    uint16_t a = rb.reg;
    if (!a)
      return 0;
    return (value >> rb.bit) & rb.mask;
  }

  static inline uint8_t avr_regbit_get_raw (avr_t * avr, avr_regbit_t rb)
  {
    uint16_t a = rb.reg;
    if (!a)
      return 0;
    // uint8_t m = rb.mask << rb.bit;
    return (avr->data[a]) & (rb.mask << rb.bit);
  }

  static inline uint8_t avr_regbit_clear (avr_t * avr, avr_regbit_t rb)
  {
    uint16_t a = rb.reg;
    uint8_t m = rb.mask << rb.bit;
    avr_core_watch_write (avr, a, avr->data[a] & ~m);
    return avr->data[a];
  }

  static inline uint8_t avr_regbit_get_array (avr_t * avr, avr_regbit_t * rb, int count)
  {
    uint8_t res = 0;
    int i;

    for (i = 0; i < count; i++, rb++)
      if (rb->reg)
        {
          uint16_t a = rb->reg;
          res |= ((avr->data[a] >> rb->bit) & rb->mask) << i;
        }
    return res;
  }

  static inline void avr_regbit_set_array_from_value (avr_t * avr,
                                                      avr_regbit_t * rb,
                                                      uint8_t count, uint8_t value)
  {
    int i;
    for (i = 0; i < count; i++, rb++)
      if (rb->reg)
        {
          uint8_t rbv = (value >> (count - i)) & 1;
          avr_regbit_setto (avr, *rb, rbv);
        }
  }

#define AVR_IO_REGBIT(_io, _bit) \
  { . reg = (_io), .bit = (_bit), .mask = 1 }

#define AVR_IO_REGBITS(_io, _bit, _mask)        \
  { . reg = (_io), .bit = (_bit), .mask = (_mask) }

#ifdef __cplusplus
};
#endif

#endif /* __SIM_REGBIT_H__ */