package main

import (
	"delay"
	"fmt"

	"stm32/hal/display"
	"stm32/hal/gpio"
	"stm32/hal/system"
	"stm32/hal/system/timer/systick"
)

var green, orange, red, blue gpio.Pin

func init() {
	system.Setup168(8)
	systick.Setup(2e6)

	gpio.D.EnableClock(false)
	gpio.G.EnableClock(false)
	gpio.K.EnableClock(false)
	green = gpio.G.Pin(6)
	orange = gpio.D.Pin(4)
	red = gpio.D.Pin(5)
	blue = gpio.K.Pin(3)

	cfg := gpio.Config{Mode: gpio.Out, Speed: gpio.Low}

	green.Setup(&cfg)
	orange.Setup(&cfg)
	red.Setup(&cfg)
	blue.Setup(&cfg)
}

func wait() {
	delay.Millisec(500)
}

func main() {
	for {
		blue.Clear()
		green.Clear()
		orange.Set()
		red.Set()

		wait()
		red.Clear()
		blue.Set()
		orange.Clear()
		green.Set()
		wait()
	}
}

// +build f40_41xxx f469xx f746xx

package gpio

import (
	"unsafe"

	"stm32/hal/raw/mmap"
)

//emgo:const
var (
	A = (*Port)(unsafe.Pointer(mmap.GPIOA_BASE))
	B = (*Port)(unsafe.Pointer(mmap.GPIOB_BASE))
	C = (*Port)(unsafe.Pointer(mmap.GPIOC_BASE))
	D = (*Port)(unsafe.Pointer(mmap.GPIOD_BASE))
	E = (*Port)(unsafe.Pointer(mmap.GPIOE_BASE))
	F = (*Port)(unsafe.Pointer(mmap.GPIOF_BASE))
	G = (*Port)(unsafe.Pointer(mmap.GPIOG_BASE))
	H = (*Port)(unsafe.Pointer(mmap.GPIOH_BASE))
	I = (*Port)(unsafe.Pointer(mmap.GPIOI_BASE))
	J = (*Port)(unsafe.Pointer(mmap.GPIOJ_BASE))
	K = (*Port)(unsafe.Pointer(mmap.GPIOK_BASE))
)

package gpio

import (
	"unsafe"

	"stm32/hal/internal"
	"stm32/hal/system"
)

// Port represents GPIO port.
type Port struct {
	registers
}

// Bus returns a bus to which p is connected.
func (p *Port) Bus() system.Bus {
	return internal.Bus(unsafe.Pointer(p))
}

// Num returns port number: A.Num() == 0, B.Num() = 1, ...
func (p *Port) Num() int {
	return int(portnum(p))
}

// EnableClock enables clock for port p.
// lp determines whether the clock remains on in low power (sleep) mode.
func (p *Port) EnableClock(lp bool) {
	enableClock(p, lp)
}

// DisableClock disables clock for port p.
func (p *Port) DisableClock() {
	disableClock(p)
}

// Reset resets port p.
func (p *Port) Reset() {
	reset(p)
}

// Pins is a bitmask which represents the pins of GPIO port.
type Pins uint16

const (
	Pin0 Pins = 1 << iota
	Pin1
	Pin2
	Pin3
	Pin4
	Pin5
	Pin6
	Pin7
	Pin8
	Pin9
	Pin10
	Pin11
	Pin12
	Pin13
	Pin14
	Pin15
)

func (p *Port) Pin(id int) Pin {
	ptr := uintptr(unsafe.Pointer(p))
	return Pin{ptr | uintptr(id&0xf)}
}

// +build f030x6 f030x8 f303xe f40_41xxx f411xe f469xx f746xx l1xx_md l1xx_mdp l1xx_hd l1xx_xl l476xx

package gpio

import (
	"mmio"

	"stm32/hal/raw/rcc"
)

type registers struct {
	moder   mmio.U32
	otyper  mmio.U32
	ospeedr mmio.U32
	pupdr   mmio.U32
	idr     mmio.U16
	_       uint16
	odr     mmio.U16
	_       uint16
	bsrr    mmio.U32
	lckr    mmio.U32
	afr     [2]mmio.U32
}

const (
	// Mode
	out   = 1
	alt   = 2
	altIn = 2
	ana   = 3

	// Pull
	pullUp   = 1
	pullDown = 2

	// Driver
	openDrain = 1
)

func enableClock(p *Port, lp bool) {
	pnum := portnum(p)
	enreg().U32.AtomicSetBits(uint32(rcc.GPIOAEN << pnum))
	if lp {
		lpenaclk(pnum)
	} else {
		lpdisclk(pnum)
	}
	enreg().Load() // RCC delay (workaround for silicon bugs).
}

func disableClock(p *Port) {
	enreg().U32.AtomicClearBits(uint32(rcc.GPIOAEN << portnum(p)))
}

func reset(p *Port) {
	pnum := portnum(p)
	rstreg().U32.AtomicSetBits(uint32(rcc.GPIOARST << pnum))
	rstreg().U32.AtomicClearBits(uint32(rcc.GPIOARST << pnum))
}

func setup(p *Port, n int, cfg *Config) {
	pos := uint(n * 2)
	p.otyper.StoreBit(n, int(cfg.Driver))
	p.ospeedr.StoreBits(3<<pos, uint32(int(cfg.Speed)-veryLow)<<pos)
	p.pupdr.StoreBits(3<<pos, uint32(cfg.Pull)<<pos)
	p.moder.StoreBits(3<<pos, uint32(cfg.Mode)<<pos)
}

type AltFunc byte

const (
	AF0 AltFunc = iota
	AF1
	AF2
	AF3
	AF4
	AF5
	AF6
	AF7
	AF8
	AF9
	AF10
	AF11
	AF12
	AF13
	AF14
	AF15

	System   = AF0  // System function.
	EventOut = AF15 // Pulse generated by SEV instruction.
)

// SetPinAltFunc sets alternate function for n-th pin.
func (p *Port) SetPinAltFunc(n int, af AltFunc) {
	m := n >> 3 & 1
	o := uint(n) & 7 * 4
	p.afr[m].StoreBits(0xf<<o, uint32(af)<<o)
}

// SetAltFunc sets alternate function for pins.
func (p *Port) SetAltFunc(pins Pins, af AltFunc) {
	for n := 0; n < 16; n++ {
		if pins&(1<<uint(n)) != 0 {
			p.SetPinAltFunc(n, af)
		}
	}
}

// SetAltFunc sets alternate function for pin.
func (p Pin) SetAltFunc(af AltFunc) {
	p.Port().SetPinAltFunc(p.Index(), af)
}

// +build f40_41xxx f411xe f469xx

package gpio

import (
	"stm32/hal/raw/rcc"
)

const (
	MCO      = AF0
	RTC_50HZ = AF0
	TRACE    = AF0

	TIM1 = AF1
	TIM2 = AF1

	TIM3 = AF2
	TIM4 = AF2
	TIM5 = AF2

	TIM8  = AF3
	TIM9  = AF3
	TIM10 = AF3
	TIM11 = AF3

	I2C1 = AF4
	I2C2 = AF4
	I2C3 = AF4

	SPI1 = AF5
	SPI2 = AF5
	SPI4 = AF5
	SPI5 = AF5
	SPI6 = AF5

	SPI3 = AF6
	SAI1 = AF6

	USART1 = AF7
	USART2 = AF7
	USART3 = AF7

	UART4  = AF8
	UART5  = AF8
	USART6 = AF8
	UART7  = AF8
	UART8  = AF8

	CAN1  = AF9
	CAN2  = AF9
	TIM12 = AF9
	TIM13 = AF9
	TIM14 = AF9

	OTGFS = AF10
	OTGHS = AF10

	ETH = AF11

	FSMC    = AF12
	FMC     = AF12
	SDIO    = AF12
	OTGHSFS = AF12

	DCMI = AF13

	LTDC = AF14
)

const (
	veryLow  = -1 // Not supported.
	low      = -1 //   2 MHz (CL = 50 pF, VDD > 2.7 V)
	_        = 0  //  25 MHz (CL = 50 pF, VDD > 2.7 V)
	high     = 1  //  50 MHz (CL = 40 pF, VDD > 2.7 V)
	veryHigh = 2  // 100 MHz (CL = 30 pF, VDD > 2.7 V)
)

func enreg() *rcc.RAHB1ENR   { return &rcc.RCC.AHB1ENR }
func rstreg() *rcc.RAHB1RSTR { return &rcc.RCC.AHB1RSTR }

func lpenaclk(pnum uint) {
	rcc.RCC.AHB1LPENR.AtomicSetBits(rcc.GPIOALPEN << pnum)
}
func lpdisclk(pnum uint) {
	rcc.RCC.AHB1LPENR.AtomicClearBits(rcc.GPIOALPEN << pnum)
}