/*
    Prototype fast inline I/O for AVR
    Copyright (C) 2014 Jeff Epler <jepler@unpythonic.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library 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
    Library General Public License for more details.

    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#include <avr/io.h>

// BLACK MAGIC STARTS HERE
template<int port_, int pin_, int ddr_>
struct IOPORT
{
    enum { port = port_, pin = pin_, ddr = ddr_ };
};

#pragma push_macro("_MMIO_BYTE")
#undef _MMIO_BYTE
#define _MMIO_BYTE(x) (x)
#ifdef PORTA
typedef IOPORT<PORTA, PINA, DDRA> PORT_A;
#endif
#ifdef PORTB
typedef IOPORT<PORTB, PINB, DDRB> PORT_B;
#endif
#ifdef PORTC
typedef IOPORT<PORTC, PINC, DDRC> PORT_C;
#endif
#ifdef PORTD
typedef IOPORT<PORTD, PIND, DDRD> PORT_D;
#endif
#ifdef PORTE
typedef IOPORT<PORTE, PINE, DDRE> PORT_E;
#endif
#ifdef PORTF
typedef IOPORT<PORTF, PINF, DDRF> PORT_F;
#endif
#ifdef PORTG
typedef IOPORT<PORTG, PING, DDRG> PORT_G;
#endif
#ifdef PORTH
typedef IOPORT<PORTH, PINH, DDRH> PORT_H;
#endif
#ifdef PORTI
typedef IOPORT<PORTI, PINI, DDRI> PORT_I;
#endif
#ifdef PORTJ
typedef IOPORT<PORTJ, PINJ, DDRJ> PORT_J;
#endif
#ifdef PORTK
typedef IOPORT<PORTK, PINK, DDRK> PORT_K;
#endif
#ifdef PORTL
typedef IOPORT<PORTL, PINL, DDRL> PORT_L;
#endif
#pragma pop_macro("_MMIO_BYTE")

#define FNORD __attribute__((always_inline, flatten, optimize("Ofast")))

template<class ioport, int off>
struct IOPIN
{
    enum { mask = (1<<off) };

    static bool read() FNORD;
    static void input() FNORD;
    static void output() FNORD;
    static void set() FNORD;
    static void clear() FNORD;
    static void write(bool val) FNORD;
    static void toggle() FNORD;

};

template<class ioport, int off>
inline bool IOPIN<ioport,off>::read() { return _MMIO_BYTE(ioport::pin) & mask; }
template<class ioport, int off>
inline void IOPIN<ioport, off>::input() { _MMIO_BYTE(ioport::ddr) &= ~mask; }
template<class ioport, int off>
inline void IOPIN<ioport, off>::output() { _MMIO_BYTE(ioport::ddr) |= mask; }
template<class ioport, int off>
inline void IOPIN<ioport, off>::set() { _MMIO_BYTE(ioport::port) |= mask; }
template<class ioport, int off>
inline void IOPIN<ioport, off>::clear() { _MMIO_BYTE(ioport::port) &= ~mask; }
template<class ioport, int off>
inline void IOPIN<ioport, off>::write(bool val) { if(val) set(); else clear(); }
template<class ioport, int off>
inline void IOPIN<ioport, off>::toggle() { _MMIO_BYTE(ioport::pin) |= mask; }

// we can also provide some support for open collector pins, where 
// the PORT and DDR bit are manipulated in tandem to emulate an open collector
template<class ioport, int off, bool pu>
struct OCPIN
{
    typedef IOPIN<ioport, off> io;
    enum { mask = (1<<off) };

    static bool read() FNORD;
    static void set() FNORD;
    static void clear() FNORD;
    static void write(bool val) FNORD;

};

template<class ioport, int off, bool pu>
inline bool OCPIN<ioport, off, pu>::read() { return io::read(); }
template<class ioport, int off, bool pu>
inline void OCPIN<ioport, off, pu>::set() { io::input(); if(pu) io::set(); }
template<class ioport, int off, bool pu>
inline void OCPIN<ioport, off, pu>::clear() { io::clear(); io::output(); }
template<class ioport, int off, bool pu>
inline void OCPIN<ioport, off, pu>::write(bool val) {
    if(val) set(); else clear(); }

// from wiring or something
extern int digitalWrite(int8_t i, int8_t v);

// show how digitalWrite can be turned into an efficient inline when the 
// arguments are constant, a quite good inline when the pin is constant but
// the value isn't, and a call when the pin is variable
inline void fastDigitalWrite(int8_t i, int8_t v) __attribute__((always_inline, flatten, optimize("Ofast")));
inline void fastDigitalWrite(int8_t i, int8_t v) {
    if(__builtin_constant_p(i)) {
        // n.b. check this to match Arduino silkscreen for all pins
        if(i == 0) {
            if(v) IOPIN<PORT_B, 0>::set();
            else IOPIN<PORT_B, 0>::clear();
            return;
        }
        else if(i == 1) {
            if(v) IOPIN<PORT_B, 1>::set();
            else IOPIN<PORT_B, 1>::clear();
            return;
        }
    } else {
        digitalWrite(i, v);
    }
}

// force functions to be visible so we can disassemble them

int en() __attribute__((externally_visible));
int fn() __attribute__((externally_visible));
int gn() __attribute__((externally_visible));
int hn() __attribute__((externally_visible));
int jn(bool b) __attribute__((externally_visible));
int kn() __attribute__((externally_visible));
int a(int i, int j) __attribute__((externally_visible));
int b(int i) __attribute__((externally_visible));
int c(int i) __attribute__((externally_visible));
int d() __attribute__((externally_visible));

// BLACK MAGIC ENDS -- resume comprehensible code below

// You can declare a port (it uses no RAM)
typedef IOPIN<PORT_B, 0> iob0;
typedef IOPIN<PORT_B, 1> iob1;
typedef OCPIN<PORT_B, 1, true> ocb1;

// .. and use it efficiently (instruction counts never include ret)
int en() { iob0::output(); }                // 1 instruction
int fn() { iob0::toggle(); }                // 1 instruction
int gn() { ocb1::set(); }                   // 2 instructions
int hn() { ocb1::clear(); }                 // 2 instructions
int jn(bool b) { iob0::write(b); }          // 5 instructions
int kn() { iob0::write(1); }                // 1 instruction

// you can use fastDigitalWrite just like digitalWrite
int c(int i) { fastDigitalWrite(1, i); }    // 5 instructions
int d() { fastDigitalWrite(1, 1); }         // 1 instruction

// these have a variable port so they still turn into calls to digitalWrite
int a(int i, int j) { fastDigitalWrite(i, j); } // call
int b(int i) { fastDigitalWrite(i, 1); } // call