-- create the module's table
local swim = {}

-- import required modules
local dict = require "scripts.app.dict"
--local buffers = require "scripts.app.buffers"

-- file constants
-- firmware assembly return error code definitions
--.equ    NO_RESP, 0xFF device didn't appear to respond                              
--.equ    ACK,    0x01  transfer successful
--.equ    NAK,    0x00  device couldn't complete operation                                      
--.equ    HERR,   0x0E  header error
--.equ    PERR,   0x09  pairity error
local ECODE = {}
ECODE.NORESP = 0xFF
ECODE.ACK = 0x01
ECODE.NAK = 0x00
ECODE.PERR = 0x0E
ECODE.HERR = 0x09
--local NRESP = 0xFF
--local ACK = 0x01
--local NAK = 0x00
--local PERR = 0x0E
--local HERR = 0x09

local cur_CSR = 0x00
local SWIM_CSR = 0x7F80

-- local functions
local function get_key_for_value( t, value )
	for k,v in pairs(t) do
		if v==value then 
			return k
		end
	end
	return nil
end

local function system_reset()

	--TODO if cur_CSR has bit 2 set, SWIM must be reactivated 
	
	if dict.swim("SWIM_SRST") ~= ECODE.ACK then
		print("ERROR unable to reset STM8 core")
	else
--		print("reset stm8 core")
	end
end

local function reset_swim()
	--print("resetting SWIM")
      	dict.swim("SWIM_RESET")	

--	wotf(SWIM_CSR, cur_CSR)
	--must rewrite current value of SWIM_CSR register as HIGHSPEED is cleared during SWIM RESET
      	dict.swim("WOTF", SWIM_CSR, cur_CSR)	
end

local function rotf(addr, hspeed, debug)

	local result = ECODE.NAK
	local data
	local tries = 5
	local resets = 3

	local opcode = "ROTF"
	if hspeed then
		opcode = "ROTF_HS"
	end

	while result ~= "ACK" and tries > 0 do
		result, data = dict.swim(opcode, addr)
		--convert the value to the key string
		result = get_key_for_value( ECODE, result)
		if debug then print("rotf", string.format(" %X: %X, result ", addr, data), result) end
		if result == "NORESP" then
			reset_swim()
		end
		tries = tries - 1
		if tries == 0 then 
			print("ERROR max tries exceeded") 
			reset_swim()
			resets = resets - 1
			if resets > 0 then
				tries = 5
			end
		end
	end
	
	--return the result of the final transfer
	return result, data
end

local function wotf(addr, data, hspeed, debug)

	local result = ECODE.NAK
	local tries = 8
	local resets = 3

	local opcode = "WOTF"
	if hspeed then
		opcode = "WOTF_HS"
	end

	while result ~= "ACK" and tries > 0 do
		result = dict.swim(opcode, addr, data)
		result = get_key_for_value( ECODE, result)
		if debug then print("wotf", string.format(" %X: %X, result ", addr, data), result) end
		if result == "NORESP" then
			reset_swim()
		end
		if tries == 0 then 
			print("ERROR max tries exceeded") 
			reset_swim()
			resets = resets - 1
			if resets > 0 then
				tries = 5
			end
		end
		tries = tries - 1
	end

	--return the result of the final transfer
	return result
end

local function unlock_eeprom(hspeed)
	--Write 0xAE then 56h in
	--FLASH_DUKR (0x00 5064)(1)(2)
	wotf(0x5064, 0xAE, hspeed) 
	wotf(0x5064, 0x56, hspeed) 
end

local function unlock_flash(hspeed)
	--write 0x56 then 0xae in
	--flash_pukr (0x00 5062)(3)
	wotf(0x5062, 0x56, hspeed) 
	wotf(0x5062, 0xAE, hspeed) 
end

local function lock_flash_eeprom(hspeed)
	--lock eeprom:
	--Reset bit 3 (DUL)
	--in FLASH_IAPSR (0x00 505F)
	--lock flash:
        --Reset bit 1 (PUL)
	--in FLASH_IAPSR (0x00 505F)
	--just lock em both
	wotf(0x505F, 0x00, hspeed) 
end

local function swim_test()
	--print("rotf :", string.format("%X  %X", dict.swim("ROTF_HS", 0x8028)))
	--print("wotf :", dict.swim("WOTF_HS", 0x8028, 0x49))
	--print("rotf :", string.format("%X  %X", dict.swim("ROTF_HS", 0x8028)))

--read then write to SRAM
--	print("rotf :", string.format("%X  %X", dict.swim("ROTF_HS", 0x0000)))

      	--print("wotf :", dict.swim("WOTF_HS", 0x0000, 0x00))
	--high speed now, enable flag with true
--	wotf(0x0000, 0x00, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	rotf(0x0000, true) 
--	wotf(0x0000, 0xEE, true) 
--	rotf(0x0000, true) 
--	wotf(0x0000, 0xAA, true) 
--	rotf(0x0000, true) 
--	wotf(0x0000, 0x55, true) 
--	rotf(0x0000, true) 

--	print("rotf :", string.format("%X  %X", dict.swim("ROTF_HS", 0x0000)))

--read then write to eeprom
--	print("rotf :", string.format("%X  %X", dict.swim("ROTF_HS", 0x4000)))
--
--      --need to unlock the eeprom first!
	unlock_eeprom(true)
--	--Write 0xAE then 56h in
--	--FLASH_DUKR (0x00 5064)(1)(2)
--      	print("wotf :", dict.swim("WOTF_HS", 0x5064, 0xAE))
--      	print("wotf :", dict.swim("WOTF_HS", 0x5064, 0x56))
--	--write data
	rotf(0x4000, true)
	wotf(0x4000, 0xDE, true)
	wotf(0x4001, 0xAD, true)
	wotf(0x4002, 0xBE, true)
	wotf(0x4003, 0xEF, true)
--      	print("wotf :", dict.swim("WOTF_HS", 0x4000, 0x00))
--
--	--lock eeprom
--	--Reset bit 3 (DUL)
	lock_flash_eeprom(true)
--	--in FLASH_IAPSR (0x00 505F)
--      	print("wotf :", dict.swim("WOTF_HS", 0x505F, 0x00))
--
--	print("rotf :", string.format("%X  %X", dict.swim("ROTF_HS", 0x4000)))
	rotf(0x4000, true)
	rotf(0x4001, true)
	rotf(0x4002, true)
	rotf(0x4003, true)

--read then write to flash
--	print("rotf :", string.format("%X  %X", dict.swim("ROTF_HS", 0x8028)))

	--need to unlock the flash first!
	unlock_flash(true)
	--write data
	print("WRITE DATA")
	local byte_addr = 0x8028
	local data = 0xFF
	while byte_addr < 0x8030 do
		wotf(byte_addr, data, true, true) 
	
		byte_addr = byte_addr + 1
--		data = data + 0x11

	end
	--lock flash/eeprom
	lock_flash_eeprom(true)
	--read it back
	print("READ BACK DATA")
	local byte_addr = 0x8028
	while byte_addr < 0x8030 do
		rotf(byte_addr, true, true)
	
		byte_addr = byte_addr + 1
	end

	--test by blinking LED via periph register access
	--v2 board has LED on hi_lo_sel PA2
--	print("wotf LED PA_CR1:", dict.swim("WOTF", 0x5003, 0xFF))	--default is input w/o pullup, now pullups enabled
--	--LED should be dimly lit
--	--set pin to pushpull
--	print("wotf LED PA_DDR:", dict.swim("WOTF", 0x5002, 0x04))	--PA2 is output CR1 set above makes pushpull
--	--LED is push/pull, ODR default to 0, so LED OFF
--	print("wotf LED PA_ODR:", dict.swim("WOTF", 0x5000, 0x04))	--PA2 output set LED ON!
--	print("wotf LED PA_ODR:", dict.swim("WOTF", 0x5000, 0x00))	--PA2 output set LED OFF!
--HIGH SPEED
--	print("wotf LED PA_CR1:", dict.swim("WOTF_HS", 0x5003, 0xFF))	--default is input w/o pullup, now pullups enabled
--	--LED should be dimly lit
--	--set pin to pushpull
--	print("wotf LED PA_DDR:", dict.swim("WOTF_HS", 0x5002, 0x04))	--PA2 is output CR1 set above makes pushpull
--	--LED is push/pull, ODR default to 0, so LED OFF
--	print("wotf LED PA_ODR:", dict.swim("WOTF_HS", 0x5000, 0x04))	--PA2 output set LED ON!
--	print("wotf LED PA_ODR:", dict.swim("WOTF_HS", 0x5000, 0x00))	--PA2 output set LED OFF!


	--holds SWIM pin low for 16usec+ to reset SWIM comms incase of error
--	dict.swim("SWIM_RESET")	

	--reset the chip, if bit2 set in CSR the SWIM exits active mode with this reset
--	print("wotf SRST:", dict.swim("SWIM_SRST"))	
	--SWIM is now inactive chip is executing it's program code

	--indicate to logic analyzer that test sequence above is complete
--	dict.pinport("CTL_SET_LO", "EXP0")
	dict.io("IO_RESET")	

end


local function start()

	dict.io("IO_RESET")	

	dict.io("SNES_INIT")	
	dict.io("SWIM_INIT", "SWIM_ON_EXP0")	
	dict.swim("SWIM_ACTIVATE")	

	--holds SWIM pin low for 16usec+ to reset SWIM comms incase of error
	--also verifies that device has SWIM active
      	dict.swim("SWIM_RESET")	

	--write 0A0h to SWIM_CSR
	--bit 5: allows entire memory range to be read & swim reset to be accessed
	--bit 7: masks internal reset sources (like WDT..?)
	cur_CSR = 0xA0
	if wotf(SWIM_CSR, cur_CSR) == "ACK" then
		print("Successfully established SWIM comms")
	else
		print("Unable to establish SWIM comms")
		return false
	end


	--read SWIM_CSR
      	--dict.swim("SWIM_RESET")	

	--print("wotf SRST:", dict.swim("SWIM_SRST"))	
	--print("wotf SWIM_CSR:", dict.swim("WOTF", 0x7F80, 0xA0))	

	--now the SRST command is available, whole memory range available, and internal resets disabled
	--by default there is now a breakpoint set at reset vector
	
	--reset the STM8 core
--	dict.swim("SWIM_SRST")
	system_reset()

	--the STM8 core is now stalled @ reset vector
	--can read/write to any address on STM8 core
	--if CIC ROP bit is set, we can only r/w to periph & SRAM

	--bit 2: SWIM is reset (exits active mode) when chip reset
	--this forces successful SWIM entry on each execution of script
--	cur_CSR = cur_CSR | 0x04
--	wotf(SWIM_CSR, cur_CSR)

	--print("switch to HS")
	--bit 4: SWIM HIGH SPEED (set for high speed)  SWIM RESET will set back to low speed
	--print("wotf SWIM_CSR:", dict.swim("WOTF", 0x7F80, 0xB4))	
	cur_CSR = cur_CSR | 0x10
	wotf(SWIM_CSR, cur_CSR)
	
--	swim_test()

	return true
end

local function printCSR()
	print(cur_CSR)
end

local function write_optn_bytes(debug)

	local toprint = nil--debug
	if debug then print("programming option bytes") end
	unlock_eeprom(true)

	--FLASH_CR2 and FLASH_NCR2 must be enabled to permit option byte writing
	--DEF_8BIT_REG_AT(FLASH_CR2,0x505b);  default 0x00
	--DEF_8BIT_REG_AT(FLASH_NCR2,0x505c); default 0xFF
	--BIT 7: OPT/NOPT
	wotf(0x505B, 0x80, true, toprint)
	wotf(0x505C, 0x7F, true, toprint)

	--need to enable AFR0 for TIM1 timer input pins
	--AFR0 Alternate function remapping option 0(2)
	--0: AFR0 remapping option inactive: Default alternate functions(1)
	--1: Port C5 alternate function = TIM2_CH1; port C6 alternate function =
	--TIM1_CH1; port C7 alternate function = TIM1_CH2.
	--0x4803 Alternate function remapping (AFR)
	--	 OPT2 AFR7 AFR6 AFR5 AFR4 AFR3 AFR2 AFR1 AFR0 0x00
	--0x4804 NOPT2 NAFR7 NAFR6 NAFR5 NAFR4 NAFR3 NAFR2 NAFR1 NAFR0 0xFF
	if debug then print("ENABLING AFR0 for TIM1") end
	wotf(0x4803, 0x01, true, toprint)
	wotf(0x4804, 0xFE, true, toprint)

	--disable option byte writing
	wotf(0x505B, 0x00, true, toprint)
	wotf(0x505C, 0xFF, true, toprint)

	lock_flash_eeprom(true)
	if debug then print("done with option byte programming") end
end

local function write_flash(file, debug)

	unlock_flash(true)

	local toprint = debug
	local buff_size = 1
	local byte_num = 0
	local readdata = 0
	local readresult = 0
	print("Programming STM8 CIC flash")
	for byte in file:lines(buff_size) do
		local data = string.unpack("B", byte, 1)
	--	print(data)
		wotf(0x8000+byte_num, data, true, toprint)
		--wotf(0x8000+byte_num, 0xFF, true, true)
		readresult, readdata = rotf(0x8000+byte_num, true, toprint )
		if readdata ~= data then
			print("ERROR flashing byte number", byte_num, "to STM8 CIC", data, readdata)
		end
		--if byte_num == 0x4C0 then
		--if byte_num == 0x020 then
		----if byte_num == 0x1FFF then
		--	return
		--end
		byte_num = byte_num + 1
	end

	print("Done with STM8 CIC flash")
	lock_flash_eeprom(true)
end


-- global variables so other modules can use them


-- call functions desired to run when script is called/imported


-- functions other modules are able to call
swim.start = start
swim.write_flash = write_flash
swim.write_optn_bytes = write_optn_bytes
swim.printCSR = printCSR
swim.wotf = wotf
swim.rotf = rotf

-- return the module's table
return swim