avr: add attiny1616 support

This is just support for the chip, no boards are currently supported.
However, you can use this target on a custom board.

Notes:

  - This required a new runtime and machine implementation, because the
    hardware is actually very different (and much nicer than older
    AVRs!).
  - I had to update gen-device-avr to support this chip. This also
    affects the generated output of other AVRs, but I checked all chips
    we support and there shouldn't be any backwards incompatible
    changes.
  - I did not implement peripherals like UART, I2C, SPI, etc because I
    don't need them. That is left to do in the future.

You can flash these chips with only a UART and a 1kOhm resistor, which
is really nice (no special hardware needed). Here is the program I've
used for this purpose: https://pypi.org/project/pymcuprog/

src/machine/machine_attiny1616.go

@@ -0,0 +1,52 @@
+//go:build attiny1616
+
+package machine
+
+import (
+	"device/avr"
+)
+
+const (
+	portA Pin = iota * 8
+	portB
+	portC
+)
+
+const (
+	PA0 = portA + 0
+	PA1 = portA + 1
+	PA2 = portA + 2
+	PA3 = portA + 3
+	PA4 = portA + 4
+	PA5 = portA + 5
+	PA6 = portA + 6
+	PA7 = portA + 7
+	PB0 = portB + 0
+	PB1 = portB + 1
+	PB2 = portB + 2
+	PB3 = portB + 3
+	PB4 = portB + 4
+	PB5 = portB + 5
+	PB6 = portB + 6
+	PB7 = portB + 7
+	PC0 = portC + 0
+	PC1 = portC + 1
+	PC2 = portC + 2
+	PC3 = portC + 3
+	PC4 = portC + 4
+	PC5 = portC + 5
+	PC6 = portC + 6
+	PC7 = portC + 7
+)
+
+// getPortMask returns the PORT peripheral and mask for the pin.
+func (p Pin) getPortMask() (*avr.PORT_Type, uint8) {
+	switch {
+	case p >= PA0 && p <= PA7: // port A
+		return avr.PORTA, 1 << uint8(p-portA)
+	case p >= PB0 && p <= PB7: // port B
+		return avr.PORTB, 1 << uint8(p-portB)
+	default: // port C
+		return avr.PORTC, 1 << uint8(p-portC)
+	}
+}

src/machine/machine_avr.go

@@ -1,4 +1,4 @@
-//go:build avr
+//go:build avr && !avrtiny
 
 package machine
 

src/machine/machine_avrtiny.go

@@ -0,0 +1,60 @@
+//go:build avrtiny
+
+package machine
+
+import "device/avr"
+
+const deviceName = avr.DEVICE
+
+const (
+	PinInput PinMode = iota
+	PinInputPullup
+	PinOutput
+)
+
+// Configure sets the pin to input or output.
+func (p Pin) Configure(config PinConfig) {
+	port, mask := p.getPortMask()
+
+	if config.Mode == PinOutput {
+		// set output bit
+		port.DIRSET.Set(mask)
+
+		// Note: if the pin was PinInputPullup before, it'll now be high.
+		// Otherwise it will be low.
+	} else {
+		// configure input: clear output bit
+		port.DIRCLR.Set(mask)
+
+		if config.Mode == PinInput {
+			// No pullup (floating).
+			// The transition may be one of the following:
+			//   output high -> input pullup -> input (safe: output high and input pullup are similar)
+			//   output low  -> input        -> input (safe: no extra transition)
+			port.OUTCLR.Set(mask)
+		} else {
+			// Pullup.
+			// The transition may be one of the following:
+			//   output high -> input pullup -> input pullup (safe: no extra transition)
+			//   output low  -> input        -> input pullup (possibly problematic)
+			// For the last transition (output low -> input -> input pullup),
+			// the transition may be problematic in some cases because there is
+			// an intermediate floating state (which may cause irratic
+			// interrupts, for example). If this is a problem, the application
+			// should set the pin high before configuring it as PinInputPullup.
+			// We can't do that here because setting it to high as an
+			// intermediate state may have other problems.
+			port.OUTSET.Set(mask)
+		}
+	}
+}
+
+// Set changes the value of the GPIO pin. The pin must be configured as output.
+func (p Pin) Set(high bool) {
+	port, mask := p.getPortMask()
+	if high {
+		port.OUTSET.Set(mask)
+	} else {
+		port.OUTCLR.Set(mask)
+	}
+}